Project import
diff --git a/squashfs-tools/ACKNOWLEDGEMENTS b/squashfs-tools/ACKNOWLEDGEMENTS
new file mode 100644
index 0000000..2a80700
--- /dev/null
+++ b/squashfs-tools/ACKNOWLEDGEMENTS
@@ -0,0 +1,165 @@
+ ACKNOWLEDGEMENTS
+
+Thanks to everyone who have downloaded Squashfs. I appreciate people
+using it, and any feedback you have.
+
+The following have provided useful feedback, which has guided
+some of the extra features in squashfs. This is a randomly ordered
+(roughly in chronological order) list, which is updated when
+I remember...
+
+Acknowledgements for Squashfs 4.3
+---------------------------------
+
+Thanks to Bruno Wolff III and Andy Lutomirski for useful feedback
+during the long development process of Squashfs 4.3.
+
+Acknowledgements for Squashfs 4.2
+---------------------------------
+
+Thanks to Lasse Collin (http://tukaani.org/xz/) for mainlining XZ
+decompression support.
+
+Acknowledgements for Squashfs 4.1
+---------------------------------
+
+Thanks to Chan Jeong <chan.jeong@lge.com> and LG for the patches to support LZO
+compression.
+
+Acknowledgements for Squashfs 4.0
+---------------------------------
+
+Thanks to Tim Bird and CELF (Consumer Electronics Linux Forum) for helping
+fund mainstreaming of Squashfs into the 2.6.29 kernel and the
+changes to the Squashfs tools to support the new 4.0 file system layout.
+
+Acknowledgements for Squashfs-3.3
+------------------------------------
+
+Peter Korsgaard and others sent patches updating Squashfs to changes in the
+VFS interface for 2.6.22/2.6.23/2.6.24-rc1. Peter also sent some small patches
+for the Squashfs kernel code.
+
+Vito Di Leo sent a patch extending Mksquashfs to support regex filters.
+While his patched worked, it unfortunately made it easy to make Mksquashfs
+perform unpredictably with poorly choosen regex expressions. It, however,
+encouraged myself to add support for wildcard pattern matching and regex
+filters in a different way.
+
+Acknowledgements for Squashfs-3.2-r2
+------------------------------------
+
+Junjiro Okajima discovered a couple of SMP issues, thanks.
+
+Junjiro Okajima and Tomas Matejicek have produced some good LZMA patches
+for Squashfs.
+
+Acknowledgements for Squashfs-3.2
+---------------------------------
+
+Peter Korsgaard sent a patch updating Squashfs to changes in the VFS interface
+in Linux 2.6.20.
+
+Acknowledgements for Squashfs-3.1
+---------------------------------
+
+Kenneth Duda and Ed Swierk of Arastra Inc. identified numerous bugs with
+Squashfs, and provided patches which were the basis for some of the
+fixes. In particular they identified the fragment rounding bug, the
+NFS bug, the initrd bug, and helped identify the 4K stack overflow bug.
+
+Scott James Remnant (Ubuntu) also identified the fragment rounding bug,
+and he also provided a patch.
+
+Ming Zhang identified the Lseek bug in Mksquashfs. His tests on the
+performance of Mksquashfs on SMP systems encouraged the rewrite of
+Mksquashfs.
+
+Peter Korsgaard, Daniel Olivera and Zilvinas Valinskas noticed
+Squashfs 3.0 didn't compile on Linux-2.6.18-rc[1-4] due to changes
+in the Linux VFS interfaces, and provided patches.
+
+Tomas Matejicek (SLAX) suggested the -force option on Unsquashfs, and noticed
+Unsquashfs didn't return the correct exit status.
+
+Yann Le Doare reported a kernel oops and provided a Qemu image that led
+to the identification of the simultaneously accessing multiply mounted Squashfs
+filesystems bug.
+
+
+Older acknowledgements
+----------------------
+
+Mark Robson - pointed out early on that initrds didn't work
+
+Adam Warner - pointed out that greater than 2GB filesystems didn't work.
+
+John Sutton - raised the problem when archiving the entire filesystem
+(/) there was no way to prevent /proc being archived. This prompted
+exclude files.
+
+Martin Mueller (LinuxTV) - noticed that the filesystem length in the
+superblock doesn't match the output filesystem length. This is due to
+padding to a 4K boundary. This prompted the addition of the -nopad option.
+He also reported a problem where 32K block filesystems hung when used as
+initrds.
+
+Arkadiusz Patyk (Polish Linux Distribution - PLD) reported a problem where 32K
+block filesystems hung when used as a root filesystem mounted as a loopback
+device.
+
+Joe Blow emailed me that I'd forgotten to put anything in the README about
+mounting the squashfs filesystem.
+
+David Fox (Lindows) noticed that the exit codes returned by Mksquashfs were
+wrong. He also noticed that a lot of time was spent in the duplicate scan
+routine.
+
+Cameron Rich complained that Squashfs did not support FIFOs or sockets.
+
+Steve Chadsey and Thomas Weissmuller noticed that files larger than the
+available memory could not be compressed by Mksquashfs.
+
+"Ptwahyu" and "Hoan" (I have no full names and I don't like giving people's
+email addresses), noticed that Mksquashfs 1.3 SEGV'd occasionally. Even though
+I had already noticed this bug, it is useful to be informed by other people.
+
+Don Elwell, Murray Jensen and Cameron Rich, have all sent in patches. Thanks,
+I have not had time to do anything about them yet...
+
+Drew Scott Daniels has been a good advocate for Squashfs.
+
+Erik Andersen has made some nice suggestions, unfortunately, I have
+not had time to implement anything.
+
+Artemiy I. Pavlov has written a useful LDP mini-howto for Squashfs
+(http://linuxdoc.artemio.net/squashfs).
+
+Yves Combe reported the Apple G5 bug, when using Squashfs for
+his PPC Knoppix-mib livecd project.
+
+Jaco Greeff (mklivecd project, and maintainer of the Mandrake
+squashfs-tools package) suggested the new mksquashfs -ef option, and the
+standalone build for mksquashfs.
+
+Mike Schaudies made a donation.
+
+Arkadiusz Patyk from the Polish Linux Distribution reported that Squashfs
+didn't work on amd64 machines. He gave me an account on a PLD amd64 machine
+which allowed myself to track down these bugs.
+
+Miles Roper, Peter Kjellerstedt and Willy Tarreau reported that release 2.1 did
+not compile with gcc < 3.x.
+
+Marcel J.E. Mol reported lack of kernel memory issues when using Squashfs
+on small memory embedded systems. This prompted the addition of the embedded
+system kernel configuration options.
+
+Era Scarecrow noticed that Mksquashfs had not been updated to reflect that
+smaller than 4K blocks are no longer supported.
+
+Kenichi Shima reported the Kconfig file had not been updated to 2.2.
+
+Aaron Ten Clay made a donation!
+
+Tomas Matejicek (SLAX) made a donation!
diff --git a/squashfs-tools/Android.mk b/squashfs-tools/Android.mk
new file mode 100644
index 0000000..d81662e
--- /dev/null
+++ b/squashfs-tools/Android.mk
@@ -0,0 +1,5 @@
+# Copyright (C) 2015 The Android Open Source Project
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(call all-makefiles-under,$(LOCAL_PATH))
diff --git a/squashfs-tools/CHANGES b/squashfs-tools/CHANGES
new file mode 100644
index 0000000..30a06df
--- /dev/null
+++ b/squashfs-tools/CHANGES
@@ -0,0 +1,613 @@
+ SQUASHFS CHANGE LOG
+
+4.3 12 MAY 2014 New compressor options, new Mksquashfs/Unsquashfs
+ functionality, duplicate checking optimisations,
+ stability improvements (option/file parsing,
+ buffer/memory overflow checks, filesystem hardening
+ on corrupted filesystems), CVE fixes.
+
+ Too many changes to do the traditional custom changelog. But, this
+ is now unnecessary, so instead list most significant 15% of commits
+ from git changelog in chronological order.
+
+ - unsquashfs: add checks for corrupted data in opendir functions
+ - unsquashfs: completely empty filesystems incorrectly generate an error
+ - unsquashfs: fix open file limit
+ - mksquashfs: Use linked list to store directory entries rather
+ - mksquashfs: Remove qsort and add a bottom up linked list merge sort
+ - mksquashfs: optimise lookup_inode2() for dirs
+ - pseudo: fix handling of modify pseudo files
+ - pseudo: fix handling of directory pseudo files
+ - xattr: Fix ERROR() so that it is synchronised with the progress bar
+ - mksquashfs/sort: Fix INFO() so that it is synced with the progress bar
+ - mksquashfs: Add -progress to force progress bar when using -info
+ - error.h: consolidate the various error macros into one header file
+ - mksquashfs: fix stack overflow in write_fragment_table()
+ - mksquashfs: move list allocation from off the stack
+ - unsquashfs: fix oversight in directory permission setting
+ - mksquashfs: dynamically allocate recovery_file
+ - mksquashfs: dynamically allocate buffer in subpathname()
+ - mksquashfs: dynamically allocate buffer in pathname()
+ - unsquashfs: fix CVE-2012-4024
+ - unsquashfs: fix CVE-2012-4025
+ - mksquashfs: fix potential stack overflow in get_component()
+ - mksquashfs: add parse_number() helper for numeric command line options
+ - mksquasfs: check return value of fstat() in reader_read_file()
+ - mksquashfs: dynamically allocate filename in old_add_exclude()
+ - unsquashfs: dynamically allocate pathname in dir_scan()
+ - unsquashfs: dynamically allocate pathname in pre_scan()
+ - sort: dynamically allocate filename in add_sort_list()
+ - mksquashfs: fix dir_scan() exit if lstat of source directory fails
+ - pseudo: fix memory leak in read_pseudo_def() if exec_file() fails
+ - pseudo: dynamically allocate path in dump_pseudo()
+ - mksquashfs: dynamically allocate path in display_path2()
+ - mksquashfs: dynamically allocate b_buffer in getbase()
+ - pseudo: fix potential stack overflow in get_component()
+ - pseudo: avoid buffer overflow in read_pseudo_def() using sscanf()
+ - pseudo: dynamically allocate filename in exec_file()
+ - pseudo: avoid buffer overflow in read_sort_file() using fscanf()
+ - sort: tighten up sort file parsing
+ - unsquashfs: fix name under-allocation in process_extract_files()
+ - unsquashfs: avoid buffer overflow in print_filename() using sprintf()
+ - Fix some limits in the file parsing routines
+ - pseudo: Rewrite pseudo file processing
+ - read_fs: fix small memory leaks in read_filesystem()
+ - mksquashfs: fix fclose leak in reader_read_file() on I/O error
+ - mksquashfs: fix frag struct leak in write_file_{process|blocks|frag}
+ - unsquashfs_xattr: fix memory leak in write_xattr()
+ - read_xattrs: fix xattr free in get_xattr() in error path
+ - unsquashfs: add -user-xattrs option to only extract user.xxx xattrs
+ - unsquashfs: add code to only print "not superuser" error message once
+ - unsquashfs: check for integer overflow in user input
+ - mksquashfs: check for integer overflow in user input
+ - mksquashfs: fix "new" variable leak in dir_scan1()
+ - read_fs: prevent buffer {over|under}flow in read_block() with
+ corrupted filesystems
+ - read_fs: check metadata blocks are expected size in scan_inode_table()
+ - read_fs: check the root inode block is found in scan_inode_table()
+ - read_fs: Further harden scan_inode_table() against corrupted
+ filesystems
+ - unsquashfs: prevent buffer {over|under}flow in read_block() with
+ corrupted filesystems
+ - read_xattrs: harden xattr data reading against corrupted filesystems
+ - unsquash-[23]: harden frag table reading against corrupted filesystems
+ - unsquash-4.c: harden uid/gid & frag table reading against corruption
+ - unsquashfs: harden inode/directory table reading against corruption
+ - mksquashfs: improve out of space in output filesystem handling
+ - mksquashfs: flag lseek error in writer as probable out of space
+ - mksquashfs: flag lseek error in write_destination as probable out of
+ space
+ - mksquashfs: print file being squashed when ^\ (SIGQUIT) typed
+ - mksquashfs: make EXIT_MKSQUASHFS() etc restore via new restore thread
+ - mksquashfs: fix recursive restore failure check
+ - info: dump queue and cache status if ^\ hit twice within one second
+ - mksquashfs: fix rare race condition in "locked fragment" queueing
+ - lz4: add experimental support for lz4 compression
+ - lz4: add support for lz4 "high compression"
+ - lzo_wrapper: new implementation with compression options
+ - gzip_wrapper: add compression options
+ - mksquashfs: redo -comp <compressor> parsing
+ - mksquashfs: display compressor options when -X option isn't recognised
+ - mksquashfs: add -Xhelp option
+ - mksquashfs/unsquashfs: fix mtime signedness
+ - Mksquashfs: optimise duplicate checking when appending
+ - Mksquashfs: introduce additional per CPU fragment process threads
+ - Mksquashfs: significantly optimise fragment duplicate checking
+ - read_fs: scan_inode_table(), fix memory leak on filesystem corruption
+ - pseudo: add_pseudo(), fix use of freed variable
+ - mksquashfs/unsquashfs: exclude/extract/pseudo files, fix handling of
+ leaf name
+ - mksquashfs: rewrite default queue size so it's based on physical mem
+ - mksquashfs: add a new -mem <mbytes> option
+ - mksquashfs: fix limit on the number of dynamic pseudo files
+ - mksquashfs: make -mem take a normal byte value, optionally with a
+ K, M or G
+
+4.2 28 FEB 2011 XZ compression, and compression options support
+
+ 1. Filesystem improvements:
+
+ 1.1 Added XZ compression
+ 1.2 Added compression options support
+
+ 2. Miscellaneous improvements/bug fixes
+
+ 1.1 Add missing NO_XATTR filesystem flag to indicate no-xattrs
+ option was specified and no xattrs should be stored when
+ appending.
+ 1.2 Add suppport in Unquashfs -stat option for displaying
+ NO_XATTR flag.
+ 1.3 Remove checkdata entry from Unsquashfs -stat option if a 4.0
+ filesystem - checkdata is no longer supported.
+ 1.4 Fix appending bug when appending to an empty filesystem - this
+ would be incorrectly treated as an error.
+ 1.5 Use glibc sys/xattr.h include rather than using attr/xattr.h
+ which isn't present by default on some distributions.
+ 1.6 Unsquashfs, fix block calculation error with regular files when
+ file size is between 2^32-block_size+1 and 2^32-1.
+ 1.7 Unsquashfs, fix sparse file writing when holes are larger than
+ 2^31-1.
+ 1.8 Add external CFLAGS and LDFLAGS support to Makefile, and allow
+ build options to be specified on command line. Also don't
+ over-write passed in CFLAGS definition.
+
+
+4.1 19 SEPT 2010 Major filesystem and tools improvements
+
+ 1. Filesystem improvements:
+
+ 1.1 Extended attribute support
+ 1.2 New compression framework
+ 1.3 Support for LZO compression
+ 1.4 Support for LZMA compression (not yet in mainline)
+
+ 2. Mksquashfs improvements:
+
+ 1.1 Enhanced pseudo file support
+ 1.2 New options for choosing compression algorithm used
+ 1.3 New options for controlling extended attributes
+ 1.4 Fix misalignment issues with memcpy etc. seen on ARM
+ 1.5 Fix floating point error in progress_bar when max == 0
+ 1.6 Removed use of get_nproc() call unavailable in ulibc
+ 1.7 Reorganised help text
+
+ 3. Unsquashfs improvements:
+
+ 1.1 New options for controlling extended attributes
+ 1.2 Fix misalignment issues with memcpy etc. seen on ARM
+ 1.3 Fix floating point error in progress_bar when max == 0
+ 1.4 Removed use of get_nproc() call unavailable in ulibc
+
+
+4.0 5 APR 2009 Major filesystems improvements
+
+ 1. Kernel code improvements:
+
+ 1.1 Fixed little endian layout adopted. All swapping macros
+ removed, and in-line swapping added for big-endian
+ architectures.
+ 1.2 Kernel code substantially improved and restructured.
+ 1.3 Kernel code split into separate files along functional lines.
+ 1.4 Vmalloc usage removed, and code changed to use separately
+ allocated 4K buffers
+
+ 2. Unsquashfs improvements:
+
+ 2.1 Support for 4.0 filesystems added.
+ 2.2 Swapping macros rewritten.
+ 2.3 Unsquashfs code restructured and split into separate files.
+
+ 3. Mksquashfs improvements:
+
+ 3.1 Swapping macros rewritten. Fixed little-endian layout allows
+ code to be optimised and only added at compile time for
+ big endian systems.
+ 3.2 Support for pseudo files added.
+
+3.4 26 AUG 2008 Performance improvements to Unsquashfs, Mksquashfs
+ and the kernel code. Plus many small bug fixes.
+
+ 1. Kernel code improvements:
+
+ 1.1 Internal Squashfs kernel metadata and fragment cache
+ implementations have been merged and optimised. Spinlocks are
+ now used, locks are held for smaller periods and wakeups have
+ been minimised. Small race condition fixed where if two or
+ more processes tried to read the same cache block
+ simultaneously they would both read and decompress it. 10-20%+
+ speed improvement has been seen on tests.
+ 1.2 NFS export code rewritten following VFS changes in
+ linux-2.6.24.
+ 1.3 New patches for linux-2.6.25, linux-2.6.26, and linux-2.6.27.
+ Fixed patch for linux-2.6.24.
+ 1.4 Fixed small buffer_head leak in squashfs_read_data when
+ handling badly corrupted filesystems.
+ 1.5 Fixed bug in get_dir_index_using_offset.
+
+ 2. Unsquashfs improvements:
+
+ 2.1 Unsquashfs has been parallelised. Filesystem reading, writing
+ and decompression is now multi-threaded. Up to 40% speed
+ improvement seen on tests.
+ 2.2 Unsquashfs now has a progress bar. Use -no-progress to
+ disable it.
+ 2.3 Fixed small bug where unistd.h wasn't being included on
+ some distributions, leading to lseek being used rather than
+ lseek64 - which meant on these distributions Unsquashfs
+ couldn't unsquash filesystems larger than 4GB.
+
+ 3. Mksquashfs improvements:
+
+ 3.1 Removed some small remaining parallelisation bottlenecks.
+ Depending on source filesystem, up to 10%+ speed improvement.
+ 3.2 Progress bar improved, and moved to separate thread.
+ 3.3 Sparse file handling bug in Mksquashfs 3.3 fixed.
+ 3.4 Two rare appending restore bugs fixed (when ^C hit twice).
+
+
+3.3 1 NOV 2007 Increase in block size, sparse file support,
+ Mksquashfs and Unsquashfs extended to use
+ pattern matching in exclude/extract files, plus
+ many more improvements and bug fixes.
+
+ 1. Filesystem improvements:
+
+ 1.1. Maximum block size has been increased to 1Mbyte, and the
+ default block size has been increased to 128 Kbytes.
+ This improves compression.
+
+ 1.2. Sparse files are now supported. Sparse files are files
+ which have large areas of unallocated data commonly called
+ holes. These files are now detected by Squashfs and stored
+ more efficiently. This improves compression and read
+ performance for sparse files.
+
+ 2. Mksquashfs improvements:
+
+ 2.1. Exclude files have been extended to use wildcard pattern
+ matching and regular expressions. Support has also been
+ added for non-anchored excludes, which means it is
+ now possible to specify excludes which match anywhere
+ in the filesystem (i.e. leaf files), rather than always
+ having to specify exclude files starting from the root
+ directory (anchored excludes).
+
+ 2.2. Recovery files are now created when appending to existing
+ Squashfs filesystems. This allows the original filesystem
+ to be recovered if Mksquashfs aborts unexpectedly
+ (i.e. power failure).
+
+ 3. Unsquashfs improvements:
+
+ 3.1. Multiple extract files can now be specified on the
+ command line, and the files/directories to be extracted can
+ now also be given in a file.
+
+ 3.2. Extract files have been extended to use wildcard pattern
+ matching and regular expressions.
+
+ 3.3. Filename printing has been enhanced and Unquashfs can
+ now display filenames with file attributes
+ ('ls -l' style output).
+
+ 3.4. A -stat option has been added which displays the filesystem
+ superblock information.
+
+ 3.5. Unsquashfs now supports 1.x filesystems.
+
+ 4. Miscellaneous improvements/bug fixes:
+
+ 4.1. Squashfs kernel code improved to use SetPageError in
+ squashfs_readpage() if I/O error occurs.
+
+ 4.2. Fixed Squashfs kernel code bug preventing file
+ seeking beyond 2GB.
+
+ 4.3. Mksquashfs now detects file size changes between
+ first phase directory scan and second phase filesystem create.
+ It also deals better with file I/O errors.
+
+
+3.2-r2 15 JAN 2007 Kernel patch update and progress bar bug fix
+
+ 1. Kernel patches 2.6.19/2.6.20 have been updated to use
+ const structures and mutexes rather than older semaphores.
+ 2. Minor SMP bug fixes.
+ 3. Progress bar broken on x86-64. Fixed.
+
+3.2 2 JAN 2007 NFS support, improvements to the Squashfs-tools, major
+ bug fixes, lots of small improvements/bug fixes, and new
+ kernel patches.
+
+ Improvements:
+
+ 1. Squashfs filesystems can now be exported via NFS.
+ 2. Unsquashfs now supports 2.x filesystems.
+ 3. Mksquashfs now displays a progress bar.
+ 4. Squashfs kernel code has been hardened against accidently or
+ maliciously corrupted Squashfs filesystems.
+
+ Bug fixes:
+
+ 5. Race condition occurring on S390 in readpage() fixed.
+ 6. Odd behaviour of MIPS memcpy in read_data() routine worked-around.
+ 7. Missing cache_flush in Squashfs symlink_readpage() added.
+
+
+3.1-r2 30 AUG 2006 Mksquashfs -sort bug fix
+
+ A code optimisation after testing unfortunately
+ broke sorting in Mksquashfs. This has been fixed.
+
+3.1 19 AUG 2006 This release has some major improvements to
+ the squashfs-tools, a couple of major bug
+ fixes, lots of small improvements/bug fixes,
+ and new kernel patches.
+
+
+ 1. Mksquashfs has been rewritten to be multi-threaded. It
+ has the following improvements
+
+ 1.1. Parallel compression. By default as many compression and
+ fragment compression threads are created as there are available
+ processors. This significantly speeds up performance on SMP
+ systems.
+ 1.2. File input and filesystem output is peformed in parallel on
+ separate threads to maximise I/O performance. Even on single
+ processor systems this speeds up performance by at least 10%.
+ 1.3. Appending has been significantly improved, and files within the
+ filesystem being appended to are no longer scanned and
+ checksummed. This significantly improves append time for large
+ filesystems.
+ 1.4. File duplicate checking has been optimised, and split into two
+ separate phases. Only files which are considered possible
+ duplicates after the first phase are checksummed and cached in
+ memory.
+ 1.5 The use of swap memory was found to significantly impact
+ performance. The amount of memory used to cache files is now a
+ command line option, by default this is 512 Mbytes.
+
+ 2. Unsquashfs has the following improvements
+
+ 2.1 Unsquashfs now allows you to specify the filename or the
+ directory within the Squashfs filesystem that is to be
+ extracted, rather than always extracting the entire filesystem.
+ 2.2 A new -force option has been added which forces Unsquashfs to
+ output to the destination directory even if files and directories
+ already exist in the destination directory. This allows you to
+ update an already existing directory tree, or to Unsquashfs to
+ a partially filled directory tree. Without the -force option
+ Unsquashfs will refuse to output.
+
+ 3. The following major bug fixes have been made
+
+ 3.1 A fragment table rounding bug has been fixed in Mksquashfs.
+ Previously if the number of fragments in the filesystem
+ were a multiple of 512, Mksquashfs would generate an
+ incorrect filesystem.
+ 3.2 A rare SMP bug which occurred when simultaneously acccessing
+ multiply mounted Squashfs filesystems has been fixed.
+
+ 4. Miscellaneous improvements/bug fixes
+
+ 4.1 Kernel code stack usage has been reduced. This is to ensure
+ Squashfs works with 4K stacks.
+ 4.2 Readdir (Squashfs kernel code) has been fixed to always
+ return 0, rather than the number of directories read. Squashfs
+ should now interact better with NFS.
+ 4.3 Lseek bug in Mksquashfs when appending to larger than 4GB
+ filesystems fixed.
+ 4.4 Squashfs 2.x initrds can now been mounted.
+ 4.5 Unsquashfs exit status fixed.
+ 4.6 New patches for linux-2.6.18 and linux-2.4.33.
+
+
+3.0 15 MAR 2006 Major filesystem improvements
+
+ 1. Filesystems are no longer limited to 4 GB. In
+ theory 2^64 or 4 exabytes is now supported.
+ 2. Files are no longer limited to 4 GB. In theory the maximum
+ file size is 4 exabytes.
+ 3. Metadata (inode table and directory tables) are no longer
+ restricted to 16 Mbytes.
+ 4. Hardlinks are now suppported.
+ 5. Nlink counts are now supported.
+ 6. Readdir now returns '.' and '..' entries.
+ 7. Special support for files larger than 256 MB has been added to
+ the Squashfs kernel code for faster read access.
+ 8. Inode numbers are now stored within the inode rather than being
+ computed from inode location on disk (this is not so much an
+ improvement, but a change forced by the previously listed
+ improvements).
+
+2.2-r2 8 SEPT 2005 Second release of 2.2, this release fixes a couple
+ of small bugs, a couple of small documentation
+ mistakes, and adds a patch for kernel 2.6.13.
+
+ 1. Mksquashfs now deletes the output filesystem image file if an
+ error occurs whilst generating the filesystem. Previously on
+ error the image file was left empty or partially written.
+ 2. Updated mksquashfs so that it doesn't allow you to generate
+ filesystems with block sizes smaller than 4K. Squashfs hasn't
+ supported block sizes less than 4K since 2.0-alpha.
+ 3. Mksquashfs now ignores missing files/directories in sort files.
+ This was the original behaviour before 2.2.
+ 4. Fixed small mistake in fs/Kconfig where the version was still
+ listed as 2.0.
+ 5. Updated ACKNOWLEDGEMENTS file.
+
+
+2.2 3 JUL 2005 This release has some small improvements, bug fixes
+ and patches for new kernels.
+
+ 1. Sort routine re-worked and debugged from release 2.1. It now allows
+ you to give Mkisofs style sort files and checks for filenames that
+ don't match anything. Sort priority has also been changed to
+ conform to Mkisofs usage, highest priority files are now placed
+ at the start of the filesystem (this means they will be on the
+ inside of a CD or DVD).
+ 2. New Configure options for embedded systems (memory constrained
+ systems). See INSTALL file for further details.
+ 3. Directory index bug fixed where chars were treated as signed on
+ some architectures. A file would not be found in the rare case
+ that the filename started with a chracter greater than 127.
+ 4. Bug introduced into the read_data() routine when sped up to use data
+ block queueing fixed. If the second or later block resulted in an
+ I/O error this was not checked.
+ 5. Append bug introduced in 2.1 fixed. The code to compute the new
+ compressed and uncompressed directory parts after appending was
+ wrong.
+ 6. Metadata block length read routine altered to not perform a
+ misaligned short read. This was to fix reading on an ARM7 running
+ uCLinux without a misaligned read interrupt handler.
+ 7. Checkdata bug introduced in 2.1 fixed.
+
+
+2.1-r2 15 DEC 2004 Code changed so it can be compiled with gcc 2.x
+
+ 1. In some of the code added for release 2.1 I unknowingly used some
+ gcc extensions only supported by 3.x compilers. I have received
+ a couple of reports that the 2.1 release doesn't build on 2.x and so
+ people are clearly still using gcc 2.x. The code has been
+ rewritten to remove these extensions.
+
+2.1 10 DEC 2004 Significantly improved directory handling plus numerous
+ other smaller improvements
+
+ 1. Fast indexed directories implemented. These speed up directory
+ operations (ls, file lookup etc.) significantly for directories
+ larger than 8 KB.
+ 2. All directories are now sorted in alphabetical order. This again
+ speeds up directory operations, and in some cases it also results in
+ a small compression improvement (greater data similarity between
+ files with alphabetically similar names).
+ 3. Maximum directory size increased from 512 KB to 128 MB.
+ 4. Duplicate fragment checking and appending optimised in mksquashfs,
+ depending on filesystem, this is now up to 25% faster.
+ 5. Mksquashfs help information reformatted and reorganised.
+ 6. The Squashfs version and release date is now printed at kernel
+ boot-time or module insertion. This addition will hopefully help
+ to reduce the growing problem where the Squashfs version supported
+ by a kernel is unknown and the kernel source is unavailable.
+ 7. New PERFORMANCE.README file.
+ 8. New -2.0 mksquashfs option.
+ 9. CHANGES file reorganised.
+ 10. README file reorganised, clarified and updated to include the 2.0
+ mksquashfs options.
+ 11. New patch for Linux 2.6.9.
+ 12. New patch for Linux 2.4.28.
+
+2.0r2 29 AUG 2004 Workaround for kernel bug in kernels 2.6.8 and newer
+ added
+
+ 1. New patch for kernel 2.6.8.1. This includes a workaround for a
+ kernel bug introduced in 2.6.7bk14, which is present in all later
+ versions of the kernel.
+
+ If you're using a 2.6.8 kernel or later then you must use this
+ 2.6.8.1 patch. If you've experienced hangs or oopses using Squashfs
+ with a 2.6.8 or later kernel then you've hit this bug, and this
+ patch will fix it.
+
+ It is worth mentioning that this kernel bug potentially affects
+ other filesystems. If you receive odd results with other
+ filesystems you may be experiencing this bug with that filesystem.
+ I submitted a patch but this has not yet gone into the
+ kernel, hopefully the bug will be fixed in later kernels.
+
+2.0 13 JULY 2004 A couple of new options, and some bug fixes
+
+ 1. New mksquashfs -all-root, -root-owned, -force-uid, and -force-gid
+ options. These allow the uids/gids of files in the generated
+ filesystem to be specified, overriding the uids/gids in the
+ source filesystem.
+ 2. Initrds are now supported for kernels 2.6.x.
+ 3. amd64 bug fixes. If you use an amd64, please read the README-AMD64
+ file.
+ 4. Check-data and gid bug fixes. With 2.0-alpha when mounting 1.x
+ filesystems in certain cases file gids were corrupted.
+ 5. New patch for Linux 2.6.7.
+
+2.0-ALPHA 21 MAY 2004 Filesystem changes and compression improvements
+
+ 1. Squashfs 2.0 has added the concept of fragment blocks.
+ Files smaller than the file block size and optionally the
+ remainder of files that do not fit fully into a block (i.e. the
+ last 32K in a 96K file) are packed into shared fragments and
+ compressed together. This achieves on average 5 - 20% better
+ compression than Squashfs 1.x.
+ 2. The maximum block size has been increased to 64K (in the ALPHA
+ version of Squashfs 2.0).
+ 3. The maximum number of UIDs has been increased to 256 (from 48 in
+ 1.x).
+ 4. The maximum number of GIDs has been increased to 256 (from 15 in
+ 1.x).
+ 5. Removal of sleep_on() function call in 2.6.x patch, to allow Squashfs
+ to work on the Fedora rc2 kernel.
+ 6. Numerous small bug fixes have been made.
+
+1.3r3 18 JAN 2004 Third release of 1.3, this adds a new mksquashfs option,
+ some bug fixes, and extra patches for new kernels
+
+ 1. New mksquashfs -ef exclude option. This option reads the exclude
+ dirs/files from an exclude file, one exclude dir/file per line. This
+ avoids the command line size limit when using the -e exclude option,
+ 2. When appending to existing filesystems, if mksquashfs experiences a
+ fatal error (e.g. out of space when adding to the destination), the
+ original filesystem is restored,
+ 3. Mksquashfs now builds standalone, without the kernel needing to be
+ patched.
+ 4. Bug fix in the kernel squashfs filesystem, where the pages being
+ filled were not kmapped. This seems to only have caused problems
+ on an Apple G5,
+ 5. New patch for Linux 2.4.24,
+
+ 6. New patch for Linux 2.6.1, this replaces the patch for 2.6.0-test7.
+
+1.3r2 14 OCT 2003 Second release of 1.3, bug fixes and extra patches for
+ new kernels
+
+ 1. Bug fix in routine that adds files to the filesystem being
+ generated in mksquashfs. This bug was introduced in 1.3
+ (not enough testing...) when I rewrote it to handle files larger
+ than available memory. This bug caused a SEGV, so if you've ever
+ got that, it is now fixed,
+ 2. Long running bug where ls -s and du reported wrong block size
+ fixed. I'm pretty sure this used to work many kernel versions ago
+ (2.4.7) but it broke somewhere along the line since then,
+ 3. New patch for Linux 2.4.22,
+ 4. New patch for 2.6.0-test7, this replaces the patch for 2.6.0-test1.
+
+1.3 29 JUL 2003 FIFO/Socket support added plus optimisations and
+ improvements
+
+ 1. FIFOs and Socket inodes are now supported,
+ 2. Mksquashfs can now compress files larger than available
+ memory,
+ 3. File duplicate check routine optimised,
+ 4. Exit codes fixed in Mksquashfs,
+ 5. Patch for Linux 2.4.21,
+ 6. Patch for Linux 2.6.0-test1. Hopefully, this will work for
+ the next few releases of 2.6.0-testx, otherwise, I'll be
+ releasing a lot of updates to the 2.6.0 patch...
+
+1.2 13 MAR 2003 Append feature and new mksquashfs options added
+
+ Mksquashfs can now add to existing squashfs filesystems. Three extra
+ options "-noappend", "-keep-as-directory", and "root-becomes"
+ have been added.
+
+ The append option with file duplicate detection, means squashfs can be
+ used as a simple versioning archiving filesystem. A squashfs
+ filesystem can be created with for example the linux-2.4.19 source.
+ Appending the linux-2.4.20 source will create a filesystem with the
+ two source trees, but only the changed files will take extra room,
+ the unchanged files will be detected as duplicates.
+
+ See the README file for usage changes.
+
+1.1b 16 JAN 2003 Bug fix release
+
+ Fixed readpage deadlock bug. This was a rare deadlock bug that
+ happened when pushing pages into the page cache when using greater
+ than 4K blocks. I never got this bug when I tested the filesystem,
+ but two people emailed me on the same day about the problem!
+ I fixed it by using a page cache function that wasn't there when
+ I originally did the work, which was nice :-)
+
+1.1 8 JAN 2003 Added features
+
+ 1. Kernel squashfs can now mount different byte order filesystems.
+ 2. Additional features added to mksquashfs. Mksquashfs now supports
+ exclude files and multiple source files/directories can be
+ specified. A nopad option has also been added, which
+ informs mksquashfs not to pad filesystems to a multiple of 4K.
+ See README for mksquashfs usage changes.
+ 3. Greater than 2GB filesystems bug fix. Filesystems greater than 2GB
+ can now be created.
+
+1.0c 14 NOV 2002 Bug fix release
+
+ Fixed bugs with initrds and device nodes
+
+1.0 23 OCT 2002 Initial release
diff --git a/squashfs-tools/COPYING b/squashfs-tools/COPYING
new file mode 100644
index 0000000..d159169
--- /dev/null
+++ b/squashfs-tools/COPYING
@@ -0,0 +1,339 @@
+ GNU GENERAL PUBLIC LICENSE
+ Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users. This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it. (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.) You can apply it to
+your programs, too.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+ To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have. You must make sure that they, too, receive or can get the
+source code. And you must show them these terms so they know their
+rights.
+
+ We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+ Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software. If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+ Finally, any free program is threatened constantly by software
+patents. We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary. To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ GNU GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License. The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language. (Hereinafter, translation is included without limitation in
+the term "modification".) Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+ 1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+ 2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) You must cause the modified files to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ b) You must cause any work that you distribute or publish, that in
+ whole or in part contains or is derived from the Program or any
+ part thereof, to be licensed as a whole at no charge to all third
+ parties under the terms of this License.
+
+ c) If the modified program normally reads commands interactively
+ when run, you must cause it, when started running for such
+ interactive use in the most ordinary way, to print or display an
+ announcement including an appropriate copyright notice and a
+ notice that there is no warranty (or else, saying that you provide
+ a warranty) and that users may redistribute the program under
+ these conditions, and telling the user how to view a copy of this
+ License. (Exception: if the Program itself is interactive but
+ does not normally print such an announcement, your work based on
+ the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+ a) Accompany it with the complete corresponding machine-readable
+ source code, which must be distributed under the terms of Sections
+ 1 and 2 above on a medium customarily used for software interchange; or,
+
+ b) Accompany it with a written offer, valid for at least three
+ years, to give any third party, for a charge no more than your
+ cost of physically performing source distribution, a complete
+ machine-readable copy of the corresponding source code, to be
+ distributed under the terms of Sections 1 and 2 above on a medium
+ customarily used for software interchange; or,
+
+ c) Accompany it with the information you received as to the offer
+ to distribute corresponding source code. (This alternative is
+ allowed only for noncommercial distribution and only if you
+ received the program in object code or executable form with such
+ an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it. For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable. However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License. Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+ 5. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Program or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+ 6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+ 7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all. For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded. In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+ 9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation. If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+ 10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission. For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this. Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+ NO WARRANTY
+
+ 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+ 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the program's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program; if not, write to the Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+ Gnomovision version 69, Copyright (C) year name of author
+ Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+ This is free software, and you are welcome to redistribute it
+ under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+ `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+ <signature of Ty Coon>, 1 April 1989
+ Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs. If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library. If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.
diff --git a/squashfs-tools/INSTALL b/squashfs-tools/INSTALL
new file mode 100644
index 0000000..5212d54
--- /dev/null
+++ b/squashfs-tools/INSTALL
@@ -0,0 +1,30 @@
+ INSTALLING SQUASHFS
+
+The squashfs4.3.tar.gz file contains the squashfs-tools directory containing
+mksquashfs and unsquashfs.
+
+1. Kernel support
+-----------------
+
+This release is for 2.6.29 and newer kernels. Kernel patching is not necessary.
+
+Extended attribute support requires 2.6.35 or newer. File systems with
+extended attributes can be mounted on 2.6.29 and newer kernels (the
+extended attributes will be ignored with a warning).
+
+LZO compression support requires 2.6.36 or newer kernels.
+
+XZ compression support requires 2.6.38 or newer kernels.
+
+LZ4 support is not yet in any mainline kernel.
+
+2. Building squashfs tools
+--------------------------
+
+The squashfs-tools directory contains the mksquashfs and unsquashfs programs.
+These can be made by typing make (or make install to install in /usr/local/bin).
+
+By default the tools are built with GZIP compression and extended attribute
+support. Read the Makefile in squashfs-tools/ for instructions on building
+LZO, LZ4 and XZ compression support, and for instructions on disabling GZIP
+and extended attribute support if desired.
diff --git a/squashfs-tools/MODULE_LICENSE_GPL b/squashfs-tools/MODULE_LICENSE_GPL
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/squashfs-tools/MODULE_LICENSE_GPL
diff --git a/squashfs-tools/NOTICE b/squashfs-tools/NOTICE
new file mode 120000
index 0000000..d24842f
--- /dev/null
+++ b/squashfs-tools/NOTICE
@@ -0,0 +1 @@
+COPYING
\ No newline at end of file
diff --git a/squashfs-tools/README b/squashfs-tools/README
new file mode 100644
index 0000000..3ba308d
--- /dev/null
+++ b/squashfs-tools/README
@@ -0,0 +1,21 @@
+Git status:
+
+This is the squashfs.sourceforge.net CVS repository imported into this
+new git repository. All new development will be under git.
+
+Squashfs-tools: The new Squashfs 4.3 release (2014/05/05).
+
+kernel: obsolete, the kernel code is now in mainline at www.kernel.org.
+
+All Squashfs kernel development trees are stored on kernel.org,
+under git.kernel.org:/linux/kernel/git/pkl/...
+
+kernel-2.4: prehistoric, not updated since the 3.1 release. If you still need
+Squashfs support in the 2.4 kernel then use the squashfs 3.1 release. This
+is the last release that supported 2.4 kernels.
+
+The kernel and kernel-2.4 directories (imported from CVS) are not really
+relevant anymore, but are here temporarily while I decide where to put
+them (I don't want to delete them and have all the pre-mainlining
+kernel commit history disappear from public repositories).
+
diff --git a/squashfs-tools/RELEASE-README b/squashfs-tools/RELEASE-README
new file mode 100644
index 0000000..a033a4b
--- /dev/null
+++ b/squashfs-tools/RELEASE-README
@@ -0,0 +1,1010 @@
+ SQUASHFS 4.3 - A squashed read-only filesystem for Linux
+
+ Copyright 2002-2014 Phillip Lougher <phillip@lougher.demon.co.uk>
+
+ Released under the GPL licence (version 2 or later).
+
+Welcome to Squashfs version 4.3. Please read the README-4.3 and CHANGES files
+for details of changes.
+
+Squashfs is a highly compressed read-only filesystem for Linux.
+It uses either gzip/xz/lzo/lz4 compression to compress both files, inodes
+and directories. Inodes in the system are very small and all blocks are
+packed to minimise data overhead. Block sizes greater than 4K are supported
+up to a maximum of 1Mbytes (default block size 128K).
+
+Squashfs is intended for general read-only filesystem use, for archival
+use (i.e. in cases where a .tar.gz file may be used), and in constrained
+block device/memory systems (e.g. embedded systems) where low overhead is
+needed.
+
+1. SQUASHFS OVERVIEW
+--------------------
+
+1. Data, inodes and directories are compressed.
+
+2. Squashfs stores full uid/gids (32 bits), and file creation time.
+
+3. In theory files up to 2^64 bytes are supported. In theory filesystems can
+ be up to 2^64 bytes.
+
+4. Inode and directory data are highly compacted, and packed on byte
+ boundaries. Each compressed inode is on average 8 bytes in length
+ (the exact length varies on file type, i.e. regular file, directory,
+ symbolic link, and block/char device inodes have different sizes).
+
+5. Squashfs can use block sizes up to 1Mbyte (the default size is 128K).
+ Using 128K blocks achieves greater compression ratios than the normal
+ 4K block size.
+
+6. File duplicates are detected and removed.
+
+7. Filesystems can be compressed with gzip, xz (lzma2), lzo or lz4
+ compression algorithms.
+
+1.1 Extended attributes (xattrs)
+--------------------------------
+
+Squashfs filesystems now have extended attribute support. The
+extended attribute implementation has the following features:
+
+1. Layout can store up to 2^48 bytes of compressed xattr data.
+2. Number of xattrs per inode unlimited.
+3. Total size of xattr data per inode 2^48 bytes of compressed data.
+4. Up to 4 Gbytes of data per xattr value.
+5. Inline and out-of-line xattr values supported for higher performance
+ in xattr scanning (listxattr & getxattr), and to allow xattr value
+ de-duplication.
+6. Both whole inode xattr duplicate detection and individual xattr value
+ duplicate detection supported. These can obviously nest, file C's
+ xattrs can be a complete duplicate of file B, and file B's xattrs
+ can be a partial duplicate of file A.
+7. Xattr name prefix types stored, allowing the redundant "user.", "trusted."
+ etc. characters to be eliminated and more concisely stored.
+8. Support for files, directories, symbolic links, device nodes, fifos
+ and sockets.
+
+Extended attribute support is in 2.6.35 and later kernels. Filesystems
+with extended attributes can be mounted on 2.6.29 and later kernels, the
+extended attributes will be ignored with a warning.
+
+2. USING SQUASHFS
+-----------------
+
+Squashfs filesystems should be mounted with 'mount' with the filesystem type
+'squashfs'. If the filesystem is on a block device, the filesystem can be
+mounted directly, e.g.
+
+%mount -t squashfs /dev/sda1 /mnt
+
+Will mount the squashfs filesystem on "/dev/sda1" under the directory "/mnt".
+
+If the squashfs filesystem has been written to a file, the loopback device
+can be used to mount it (loopback support must be in the kernel), e.g.
+
+%mount -t squashfs image /mnt -o loop
+
+Will mount the squashfs filesystem in the file "image" under
+the directory "/mnt".
+
+3. MKSQUASHFS
+-------------
+
+3.1 Mksquashfs options and overview
+-----------------------------------
+
+As squashfs is a read-only filesystem, the mksquashfs program must be used to
+create populated squashfs filesystems.
+
+SYNTAX:./mksquashfs source1 source2 ... dest [options] [-e list of exclude
+dirs/files]
+
+Filesystem build options:
+-comp <comp> select <comp> compression
+ Compressors available:
+ gzip (default)
+ lzo
+ lz4
+ xz
+-b <block_size> set data block to <block_size>. Default 128 Kbytes
+ Optionally a suffix of K or M can be given to specify
+ Kbytes or Mbytes respectively
+-no-exports don't make the filesystem exportable via NFS
+-no-sparse don't detect sparse files
+-no-xattrs don't store extended attributes
+-xattrs store extended attributes (default)
+-noI do not compress inode table
+-noD do not compress data blocks
+-noF do not compress fragment blocks
+-noX do not compress extended attributes
+-no-fragments do not use fragments
+-always-use-fragments use fragment blocks for files larger than block size
+-no-duplicates do not perform duplicate checking
+-all-root make all files owned by root
+-force-uid uid set all file uids to uid
+-force-gid gid set all file gids to gid
+-nopad do not pad filesystem to a multiple of 4K
+-keep-as-directory if one source directory is specified, create a root
+ directory containing that directory, rather than the
+ contents of the directory
+
+Filesystem filter options:
+-p <pseudo-definition> Add pseudo file definition
+-pf <pseudo-file> Add list of pseudo file definitions
+-sort <sort_file> sort files according to priorities in <sort_file>. One
+ file or dir with priority per line. Priority -32768 to
+ 32767, default priority 0
+-ef <exclude_file> list of exclude dirs/files. One per line
+-wildcards Allow extended shell wildcards (globbing) to be used in
+ exclude dirs/files
+-regex Allow POSIX regular expressions to be used in exclude
+ dirs/files
+
+Filesystem append options:
+-noappend do not append to existing filesystem
+-root-becomes <name> when appending source files/directories, make the
+ original root become a subdirectory in the new root
+ called <name>, rather than adding the new source items
+ to the original root
+
+Mksquashfs runtime options:
+-version print version, licence and copyright message
+-exit-on-error treat normally ignored errors as fatal
+-recover <name> recover filesystem data using recovery file <name>
+-no-recovery don't generate a recovery file
+-info print files written to filesystem
+-no-progress don't display the progress bar
+-progress display progress bar when using the -info option
+-processors <number> Use <number> processors. By default will use number of
+ processors available
+-mem <size> Use <size> physical memory. Currently set to 1922M
+ Optionally a suffix of K, M or G can be given to specify
+ Kbytes, Mbytes or Gbytes respectively
+
+Miscellaneous options:
+-root-owned alternative name for -all-root
+-noInodeCompression alternative name for -noI
+-noDataCompression alternative name for -noD
+-noFragmentCompression alternative name for -noF
+-noXattrCompression alternative name for -noX
+
+-Xhelp print compressor options for selected compressor
+
+Compressors available and compressor specific options:
+ gzip (default)
+ -Xcompression-level <compression-level>
+ <compression-level> should be 1 .. 9 (default 9)
+ -Xwindow-size <window-size>
+ <window-size> should be 8 .. 15 (default 15)
+ -Xstrategy strategy1,strategy2,...,strategyN
+ Compress using strategy1,strategy2,...,strategyN in turn
+ and choose the best compression.
+ Available strategies: default, filtered, huffman_only,
+ run_length_encoded and fixed
+ lzo
+ -Xalgorithm <algorithm>
+ Where <algorithm> is one of:
+ lzo1x_1
+ lzo1x_1_11
+ lzo1x_1_12
+ lzo1x_1_15
+ lzo1x_999 (default)
+ -Xcompression-level <compression-level>
+ <compression-level> should be 1 .. 9 (default 8)
+ Only applies to lzo1x_999 algorithm
+ lz4
+ -Xhc
+ Compress using LZ4 High Compression
+ xz
+ -Xbcj filter1,filter2,...,filterN
+ Compress using filter1,filter2,...,filterN in turn
+ (in addition to no filter), and choose the best compression.
+ Available filters: x86, arm, armthumb, powerpc, sparc, ia64
+ -Xdict-size <dict-size>
+ Use <dict-size> as the XZ dictionary size. The dictionary size
+ can be specified as a percentage of the block size, or as an
+ absolute value. The dictionary size must be less than or equal
+ to the block size and 8192 bytes or larger. It must also be
+ storable in the xz header as either 2^n or as 2^n+2^(n+1).
+ Example dict-sizes are 75%, 50%, 37.5%, 25%, or 32K, 16K, 8K
+ etc.
+
+Source1 source2 ... are the source directories/files containing the
+files/directories that will form the squashfs filesystem. If a single
+directory is specified (i.e. mksquashfs source output_fs) the squashfs
+filesystem will consist of that directory, with the top-level root
+directory corresponding to the source directory.
+
+If multiple source directories or files are specified, mksquashfs will merge
+the specified sources into a single filesystem, with the root directory
+containing each of the source files/directories. The name of each directory
+entry will be the basename of the source path. If more than one source
+entry maps to the same name, the conflicts are named xxx_1, xxx_2, etc. where
+xxx is the original name.
+
+To make this clear, take two example directories. Source directory
+"/home/phillip/test" contains "file1", "file2" and "dir1".
+Source directory "goodies" contains "goodies1", "goodies2" and "goodies3".
+
+usage example 1:
+
+%mksquashfs /home/phillip/test output_fs
+
+This will generate a squashfs filesystem with root entries
+"file1", "file2" and "dir1".
+
+example 2:
+
+%mksquashfs /home/phillip/test goodies output_fs
+
+This will create a squashfs filesystem with the root containing
+entries "test" and "goodies" corresponding to the source
+directories "/home/phillip/test" and "goodies".
+
+example 3:
+
+%mksquashfs /home/phillip/test goodies test output_fs
+
+This is the same as the previous example, except a third
+source directory "test" has been specified. This conflicts
+with the first directory named "test" and will be renamed "test_1".
+
+Multiple sources allow filesystems to be generated without needing to
+copy all source files into a common directory. This simplifies creating
+filesystems.
+
+The -keep-as-directory option can be used when only one source directory
+is specified, and you wish the root to contain that directory, rather than
+the contents of the directory. For example:
+
+example 4:
+
+%mksquashfs /home/phillip/test output_fs -keep-as-directory
+
+This is the same as example 1, except for -keep-as-directory.
+This will generate a root directory containing directory "test",
+rather than the "test" directory contents "file1", "file2" and "dir1".
+
+The Dest argument is the destination where the squashfs filesystem will be
+written. This can either be a conventional file or a block device. If the file
+doesn't exist it will be created, if it does exist and a squashfs
+filesystem exists on it, mksquashfs will append. The -noappend option will
+write a new filesystem irrespective of whether an existing filesystem is
+present.
+
+3.2 Changing compression algorithm and compression specific options
+-------------------------------------------------------------------
+
+By default Mksquashfs will compress using the gzip compression
+algorithm. This algorithm offers a good trade-off between compression
+ratio, and memory and time taken to decompress.
+
+Squashfs also supports LZ4, LZO and XZ (LZMA2) compression. LZO offers worse
+compression ratio than gzip, but is faster to decompress. XZ offers better
+compression ratio than gzip, but at the expense of greater memory and time
+to decompress (and significantly more time to compress). LZ4 is similar
+to LZO, but, support for it is not yet in the mainline kernel, and so
+its usefulness is currently limited to using Squashfs with Mksquashfs/Unsquashfs
+as an archival system like tar.
+
+If you're not building the squashfs-tools and kernel from source, then
+the tools and kernel may or may not have been built with support for LZ4, LZO or
+XZ compression. The compression algorithms supported by the build of
+Mksquashfs can be found by typing mksquashfs without any arguments. The
+compressors available are displayed at the end of the help message, e.g.
+
+Compressors available and compressor specific options:
+ gzip (default)
+ -Xcompression-level <compression-level>
+ <compression-level> should be 1 .. 9 (default 9)
+ -Xwindow-size <window-size>
+ <window-size> should be 8 .. 15 (default 15)
+ -Xstrategy strategy1,strategy2,...,strategyN
+ Compress using strategy1,strategy2,...,strategyN in turn
+ and choose the best compression.
+ Available strategies: default, filtered, huffman_only,
+ run_length_encoded and fixed
+ lzo
+ -Xalgorithm <algorithm>
+ Where <algorithm> is one of:
+ lzo1x_1
+ lzo1x_1_11
+ lzo1x_1_12
+ lzo1x_1_15
+ lzo1x_999 (default)
+ -Xcompression-level <compression-level>
+ <compression-level> should be 1 .. 9 (default 8)
+ Only applies to lzo1x_999 algorithm
+ lz4
+ -Xhc
+ Compress using LZ4 High Compression
+ xz
+ -Xbcj filter1,filter2,...,filterN
+ Compress using filter1,filter2,...,filterN in turn
+ (in addition to no filter), and choose the best compression.
+ Available filters: x86, arm, armthumb, powerpc, sparc, ia64
+ -Xdict-size <dict-size>
+ Use <dict-size> as the XZ dictionary size. The dictionary size
+ can be specified as a percentage of the block size, or as an
+ absolute value. The dictionary size must be less than or equal
+ to the block size and 8192 bytes or larger. It must also be
+ storable in the xz header as either 2^n or as 2^n+2^(n+1).
+ Example dict-sizes are 75%, 50%, 37.5%, 25%, or 32K, 16K, 8K
+ etc.
+
+If the compressor offers compression specific options (all the compressors now
+have compression specific options except the deprecated lzma1 compressor)
+then these options are also displayed (.i.e. in the above XZ is shown with two
+compression specific options). The compression specific options are, obviously,
+specific to the compressor in question, and the compressor documentation and
+web sites should be consulted to understand their behaviour. In general
+the Mksquashfs compression defaults for each compressor are optimised to
+give the best performance for each compressor, where what constitutes
+best depends on the compressor. For gzip/xz best means highest compression,
+for LZO/LZ4 best means a tradeoff between compression and (de)-compression
+overhead (LZO/LZ4 by definition are intended for weaker processors).
+
+3.3 Changing global compression defaults used in mksquashfs
+-----------------------------------------------------------
+
+There are a large number of options that can be used to control the
+compression in mksquashfs. By and large the defaults are the most
+optimum settings and should only be changed in exceptional circumstances!
+Note, this does not apply to the block size, increasing the block size
+from the default of 128Kbytes will increase compression (especially
+for the xz compressor) and should increase I/O performance too. However,
+a block size of greater than 128Kbytes may increase latency in certain
+cases (where the filesystem contains lots of fragments, and no locality
+of reference is observed). For this reason the block size default is
+configured to the less optimal 128Kbytes. Users should experiment
+with 256Kbyte sizes or above.
+
+The -noI, -noD and -noF options (also -noInodeCompression, -noDataCompression
+and -noFragmentCompression) can be used to force mksquashfs to not compress
+inodes/directories, data and fragments respectively. Giving all options
+generates an uncompressed filesystem.
+
+The -no-fragments tells mksquashfs to not generate fragment blocks, and rather
+generate a filesystem similar to a Squashfs 1.x filesystem. It will of course
+still be a Squashfs 4.0 filesystem but without fragments, and so it won't be
+mountable on a Squashfs 1.x system.
+
+The -always-use-fragments option tells mksquashfs to always generate
+fragments for files irrespective of the file length. By default only small
+files less than the block size are packed into fragment blocks. The ends of
+files which do not fit fully into a block, are NOT by default packed into
+fragments. To illustrate this, a 100K file has an initial 64K block and a 36K
+remainder. This 36K remainder is not packed into a fragment by default. This
+is because to do so leads to a 10 - 20% drop in sequential I/O performance, as a
+disk head seek is needed to seek to the initial file data and another disk seek
+is need to seek to the fragment block. Specify this option if you want file
+remainders to be packed into fragment blocks. Doing so may increase the
+compression obtained BUT at the expense of I/O speed.
+
+The -no-duplicates option tells mksquashfs to not check the files being
+added to the filesystem for duplicates. This can result in quicker filesystem
+generation and appending although obviously compression will suffer badly if
+there is a lot of duplicate files.
+
+The -b option allows the block size to be selected, both "K" and "M" postfixes
+are supported, this can be either 4K, 8K, 16K, 32K, 64K, 128K, 256K, 512K or
+1M bytes.
+
+3.4 Specifying the UIDs/GIDs used in the filesystem
+---------------------------------------------------
+
+By default files in the generated filesystem inherit the UID and GID ownership
+of the original file. However, mksquashfs provides a number of options which
+can be used to override the ownership.
+
+The options -all-root and -root-owned (both do exactly the same thing) force all
+file uids/gids in the generated Squashfs filesystem to be root. This allows
+root owned filesystems to be built without root access on the host machine.
+
+The "-force-uid uid" option forces all files in the generated Squashfs
+filesystem to be owned by the specified uid. The uid can be specified either by
+name (i.e. "root") or by number.
+
+The "-force-gid gid" option forces all files in the generated Squashfs
+filesystem to be group owned by the specified gid. The gid can be specified
+either by name (i.e. "root") or by number.
+
+3.5 Excluding files from the filesystem
+---------------------------------------
+
+The -e and -ef options allow files/directories to be specified which are
+excluded from the output filesystem. The -e option takes the exclude
+files/directories from the command line, the -ef option takes the
+exlude files/directories from the specified exclude file, one file/directory
+per line.
+
+Two styles of exclude file matching are supported: basic exclude matching, and
+extended wildcard matching. Basic exclude matching is a legacy feature
+retained for backwards compatibility with earlier versions of Mksquashfs.
+Extended wildcard matching should be used in preference.
+
+3.5.1 Basic exclude matching
+----------------------------
+
+Each exclude file is treated as an exact match of a file/directory in
+the source directories. If an exclude file/directory is absolute (i.e.
+prefixed with /, ../, or ./) the entry is treated as absolute, however, if an
+exclude file/directory is relative, it is treated as being relative to each of
+the sources in turn, i.e.
+
+%mksquashfs /tmp/source1 source2 output_fs -e ex1 /tmp/source1/ex2 out/ex3
+
+Will generate exclude files /tmp/source1/ex2, /tmp/source1/ex1, source2/ex1,
+/tmp/source1/out/ex3 and source2/out/ex3.
+
+3.5.2 Extended exclude file handling
+------------------------------------
+
+Extended exclude file matching treats each exclude file as a wildcard or
+regex expression. To enable wildcard matching specify the -wildcards
+option, and to enable regex matching specify the -regex option. In most
+cases the -wildcards option should be used rather than -regex because wildcard
+matching behaviour is significantly easier to understand!
+
+In addition to wildcards/regex expressions, exclude files can be "anchored" or
+"non-anchored". An anchored exclude is one which matches from the root of the
+directory and nowhere else, a non-anchored exclude matches anywhere. For
+example given the directory hierarchy "a/b/c/a/b", the anchored exclude
+"a/b" will match "a/b" at the root of the directory hierarchy, but
+it will not match the "/a/b" sub-directory within directory "c", whereas a
+non-anchored exclude would.
+
+A couple of examples should make this clearer.
+
+Anchored excludes
+
+ 1. mksquashfs example image.sqsh -wildcards -e 'test/*.gz'
+
+ Exclude all files matching "*.gz" in the top level directory "test".
+
+ 2. mksquashfs example image.sqsh -wildcards -e '*/[Tt]est/example*'
+
+ Exclude all files beginning with "example" inside directories called
+ "Test" or "test", that occur inside any top level directory.
+
+ Using extended wildcards, negative matching is also possible.
+
+ 3. mksquashfs example image.sqsh -wildcards -e 'test/!(*data*).gz'
+
+ Exclude all files matching "*.gz" in top level directory "test",
+ except those with "data" in the name.
+
+Non-anchored excludes
+
+ By default excludes match from the top level directory, but it is
+ often useful to exclude a file matching anywhere in the source directories.
+ For this non-anchored excludes can be used, specified by pre-fixing the
+ exclude with "...".
+
+ Examples:
+
+ 1. mksquashfs example image.sqsh -wildcards -e '... *.gz'
+
+ Exclude files matching "*.gz" anywhere in the source directories.
+ For example this will match "example.gz", "test/example.gz", and
+ "test/test/example.gz".
+
+ 2. mksquashfs example image.sqsh -wildcards -e '... [Tt]est/*.gz'
+
+ Exclude files matching "*.gz" inside directories called "Test" or
+ "test" that occur anywhere in the source directories.
+
+ Again, using extended wildcards, negative matching is also possible.
+
+ 3. mksquashfs example image.sqsh -wildcards -e '... !(*data*).gz'
+
+ Exclude all files matching "*.gz" anywhere in the source directories,
+ except those with "data" in the name.
+
+3.5.3 Exclude files summary
+---------------------------
+
+The -e and -ef exclude options are usefully used in archiving the entire
+filesystem, where it is wished to avoid archiving /proc, and the filesystem
+being generated, i.e.
+
+%mksquashfs / /tmp/root.sqsh -e proc /tmp/root.sqsh
+
+Multiple -ef options can be specified on the command line, and the -ef
+option can be used in conjuction with the -e option.
+
+3.6 Appending to squashfs filesystems
+-------------------------------------
+
+Running squashfs with the destination directory containing an existing
+filesystem will add the source items to the existing filesystem. By default,
+the source items are added to the existing root directory.
+
+To make this clear... An existing filesystem "image" contains root entries
+"old1", and "old2". Source directory "/home/phillip/test" contains "file1",
+"file2" and "dir1".
+
+example 1:
+
+%mksquashfs /home/phillip/test image
+
+Will create a new "image" with root entries "old1", "old2", "file1", "file2" and
+"dir1"
+
+example 2:
+
+%mksquashfs /home/phillip/test image -keep-as-directory
+
+Will create a new "image" with root entries "old1", "old2", and "test".
+As shown in the previous section, for single source directories
+'-keep-as-directory' adds the source directory rather than the
+contents of the directory.
+
+example 3:
+
+%mksquashfs /home/phillip/test image -keep-as-directory -root-becomes
+original-root
+
+Will create a new "image" with root entries "original-root", and "test". The
+'-root-becomes' option specifies that the original root becomes a subdirectory
+in the new root, with the specified name.
+
+The append option with file duplicate detection, means squashfs can be
+used as a simple versioning archiving filesystem. A squashfs filesystem can
+be created with for example the linux-2.4.19 source. Appending the linux-2.4.20
+source will create a filesystem with the two source trees, but only the
+changed files will take extra room, the unchanged files will be detected as
+duplicates.
+
+3.7 Appending recovery file feature
+-----------------------------------
+
+Recovery files are created when appending to existing Squashfs
+filesystems. This allows the original filesystem to be recovered
+if Mksquashfs aborts unexpectedly (i.e. power failure).
+
+The recovery files are called squashfs_recovery_xxx_yyy, where
+"xxx" is the name of the filesystem being appended to, and "yyy" is a
+number to guarantee filename uniqueness (the PID of the parent Mksquashfs
+process).
+
+Normally if Mksquashfs exits correctly the recovery file is deleted to
+avoid cluttering the filesystem. If Mksquashfs aborts, the "-recover"
+option can be used to recover the filesystem, giving the previously
+created recovery file as a parameter, i.e.
+
+mksquashfs dummy image.sqsh -recover squashfs_recovery_image.sqsh_1234
+
+The writing of the recovery file can be disabled by specifying the
+"-no-recovery" option.
+
+3.8 Pseudo file support
+-----------------------
+
+Mksquashfs supports pseudo files, these allow fake files, directories, character
+and block devices to be specified and added to the Squashfs filesystem being
+built, rather than requiring them to be present in the source directories.
+This, for example, allows device nodes to be added to the filesystem without
+requiring root access.
+
+Mksquashfs 4.1 added support for "dynamic pseudo files" and a modify operation.
+Dynamic pseudo files allow files to be dynamically created when Mksquashfs
+is run, their contents being the result of running a command or piece of
+shell script. The modifiy operation allows the mode/uid/gid of an existing
+file in the source filesystem to be modified.
+
+Two Mksquashfs options are supported, -p allows one pseudo file to be specified
+on the command line, and -pf allows a pseudo file to be specified containing a
+list of pseduo definitions, one per line.
+
+3.8.1. Creating a dynamic file
+------------------------------
+
+Pseudo definition
+
+Filename f mode uid gid command
+
+mode is the octal mode specifier, similar to that expected by chmod.
+
+uid and gid can be either specified as a decimal number, or by name.
+
+command can be an executable or a piece of shell script, and it is executed
+by running "/bin/sh -c command". The stdout becomes the contents of
+"Filename".
+
+Examples:
+
+Running a basic command
+-----------------------
+
+/somedir/dmesg f 444 root root dmesg
+
+creates a file "/somedir/dmesg" containing the output from dmesg.
+
+Executing shell script
+----------------------
+
+RELEASE f 444 root root \
+ if [ ! -e /tmp/ver ]; then \
+ echo 0 > /tmp/ver; \
+ fi; \
+ ver=`cat /tmp/ver`; \
+ ver=$((ver +1)); \
+ echo $ver > /tmp/ver; \
+ echo -n `cat /tmp/release`; \
+ echo "-dev #"$ver `date` "Build host" `hostname`
+
+Creates a file RELEASE containing the release name, date, build host, and
+an incrementing version number. The incrementing version is a side-effect
+of executing the shell script, and ensures every time Mksquashfs is run a
+new version number is used without requiring any other shell scripting.
+
+The above example also shows that commands can be split across multiple lines
+using "\". Obviously as the script will be presented to the shell as a single
+line, a semicolon is need to separate individual shell commands within the
+shell script.
+
+Reading from a device (or fifo/named socket)
+--------------------------------------------
+
+input f 444 root root dd if=/dev/sda1 bs=1024 count=10
+
+Copies 10K from the device /dev/sda1 into the file input. Ordinarily Mksquashfs
+given a device, fifo, or named socket will place that special file within the
+Squashfs filesystem, the above allows input from these special files to be
+captured and placed in the Squashfs filesystem.
+
+3.8.2. Creating a block or character device
+-------------------------------------------
+
+Pseudo definition
+
+Filename type mode uid gid major minor
+
+Where type is either
+ b - for block devices, and
+ c - for character devices
+
+mode is the octal mode specifier, similar to that expected by chmod.
+
+uid and gid can be either specified as a decimal number, or by name.
+
+For example:
+
+/dev/chr_dev c 666 root root 100 1
+/dev/blk_dev b 666 0 0 200 200
+
+creates a character device "/dev/chr_dev" with major:minor 100:1 and
+a block device "/dev/blk_dev" with major:minor 200:200, both with root
+uid/gid and a mode of rw-rw-rw.
+
+3.8.3. Creating a directory
+---------------------------
+
+Pseudo definition
+
+Filename d mode uid gid
+
+mode is the octal mode specifier, similar to that expected by chmod.
+
+uid and gid can be either specified as a decimal number, or by name.
+
+For example:
+
+/pseudo_dir d 666 root root
+
+creates a directory "/pseudo_dir" with root uid/gid and mode of rw-rw-rw.
+
+3.8.4. Modifying attributes of an existing file
+-----------------------------------------------
+
+Pseudo definition
+
+Filename m mode uid gid
+
+mode is the octal mode specifier, similar to that expected by chmod.
+
+uid and gid can be either specified as a decimal number, or by name.
+
+For example:
+
+dmesg m 666 root root
+
+Changes the attributes of the file "dmesg" in the filesystem to have
+root uid/gid and a mode of rw-rw-rw, overriding the attributes obtained
+from the source filesystem.
+
+3.9 Miscellaneous options
+-------------------------
+
+The -info option displays the files/directories as they are compressed and
+added to the filesystem. The original uncompressed size of each file
+is printed, along with DUPLICATE if the file is a duplicate of a
+file in the filesystem.
+
+The -nopad option informs mksquashfs to not pad the filesystem to a 4K multiple.
+This is performed by default to enable the output filesystem file to be mounted
+by loopback, which requires files to be a 4K multiple. If the filesystem is
+being written to a block device, or is to be stored in a bootimage, the extra
+pad bytes are not needed.
+
+4. UNSQUASHFS
+-------------
+
+Unsquashfs allows you to decompress and extract a Squashfs filesystem without
+mounting it. It can extract the entire filesystem, or a specific
+file or directory.
+
+The Unsquashfs usage info is:
+
+SYNTAX: ./unsquashfs [options] filesystem [directories or files to extract]
+ -v[ersion] print version, licence and copyright information
+ -d[est] <pathname> unsquash to <pathname>, default "squashfs-root"
+ -n[o-progress] don't display the progress bar
+ -no[-xattrs] don't extract xattrs in file system
+ -x[attrs] extract xattrs in file system (default)
+ -u[ser-xattrs] only extract user xattrs in file system.
+ Enables extracting xattrs
+ -p[rocessors] <number> use <number> processors. By default will use
+ number of processors available
+ -i[nfo] print files as they are unsquashed
+ -li[nfo] print files as they are unsquashed with file
+ attributes (like ls -l output)
+ -l[s] list filesystem, but don't unsquash
+ -ll[s] list filesystem with file attributes (like
+ ls -l output), but don't unsquash
+ -f[orce] if file already exists then overwrite
+ -s[tat] display filesystem superblock information
+ -e[f] <extract file> list of directories or files to extract.
+ One per line
+ -da[ta-queue] <size> Set data queue to <size> Mbytes. Default 256
+ Mbytes
+ -fr[ag-queue] <size> Set fragment queue to <size> Mbytes. Default
+ 256 Mbytes
+ -r[egex] treat extract names as POSIX regular expressions
+ rather than use the default shell wildcard
+ expansion (globbing)
+
+Decompressors available:
+ gzip
+ lzo
+ lz4
+ xz
+
+To extract a subset of the filesystem, the filenames or directory
+trees that are to be extracted can be specified on the command line. The
+files/directories should be specified using the full path to the
+files/directories as they appear within the Squashfs filesystem. The
+files/directories will also be extracted to those positions within the specified
+destination directory.
+
+The extract files can also be given in a file using the "-e[f]" option.
+
+Similarly to Mksquashfs, wildcard matching is performed on the extract
+files. Wildcard matching is enabled by default.
+
+Examples:
+
+ 1. unsquashfs image.sqsh 'test/*.gz'
+
+ Extract all files matching "*.gz" in the top level directory "test".
+
+ 2. unsquashfs image.sqsh '[Tt]est/example*'
+
+ Extract all files beginning with "example" inside top level directories
+ called "Test" or "test".
+
+ Using extended wildcards, negative matching is also possible.
+
+ 3. unsquashfs image.sqsh 'test/!(*data*).gz'
+
+ Extract all files matching "*.gz" in top level directory "test",
+ except those with "data" in the name.
+
+
+4.1 Unsquashfs options
+----------------------
+
+The "-ls" option can be used to list the contents of a filesystem without
+decompressing the filesystem data itself. The "-lls" option is similar
+but it also displays file attributes (ls -l style output).
+
+The "-info" option forces Unsquashfs to print each file as it is decompressed.
+The -"linfo" is similar but it also displays file attributes.
+
+The "-dest" option specifies the directory that is used to decompress
+the filesystem data. If this option is not given then the filesystem is
+decompressed to the directory "squashfs-root" in the current working directory.
+
+The "-force" option forces Unsquashfs to output to the destination
+directory even if files or directories already exist. This allows you
+to update an existing directory tree, or to Unsquashfs to a partially
+filled directory. Without the "-force" option, Unsquashfs will
+refuse to overwrite any existing files, or to create any directories if they
+already exist. This is done to protect data in case of mistakes, and
+so the "-force" option should be used with caution.
+
+The "-stat" option displays filesystem superblock information. This is
+useful to discover the filesystem version, byte ordering, whether it has a NFS
+export table, and what options were used to compress the filesystem, etc.
+
+Unsquashfs can decompress all Squashfs filesystem versions, 1.x, 2.x, 3.x and
+4.0 filesystems.
+
+5. FILESYSTEM LAYOUT
+--------------------
+
+A squashfs filesystem consists of a maximum of nine parts, packed together on a
+byte alignment:
+
+ ---------------
+ | superblock |
+ |---------------|
+ | compression |
+ | options |
+ |---------------|
+ | datablocks |
+ | & fragments |
+ |---------------|
+ | inode table |
+ |---------------|
+ | directory |
+ | table |
+ |---------------|
+ | fragment |
+ | table |
+ |---------------|
+ | export |
+ | table |
+ |---------------|
+ | uid/gid |
+ | lookup table |
+ |---------------|
+ | xattr |
+ | table |
+ ---------------
+
+Compressed data blocks are written to the filesystem as files are read from
+the source directory, and checked for duplicates. Once all file data has been
+written the completed super-block, compression options, inode, directory,
+fragment, export, uid/gid lookup and xattr tables are written.
+
+5.1 Compression options
+-----------------------
+
+Compressors can optionally support compression specific options (e.g.
+dictionary size). If non-default compression options have been used, then
+these are stored here.
+
+5.2 Inodes
+----------
+
+Metadata (inodes and directories) are compressed in 8Kbyte blocks. Each
+compressed block is prefixed by a two byte length, the top bit is set if the
+block is uncompressed. A block will be uncompressed if the -noI option is set,
+or if the compressed block was larger than the uncompressed block.
+
+Inodes are packed into the metadata blocks, and are not aligned to block
+boundaries, therefore inodes overlap compressed blocks. Inodes are identified
+by a 48-bit number which encodes the location of the compressed metadata block
+containing the inode, and the byte offset into that block where the inode is
+placed (<block, offset>).
+
+To maximise compression there are different inodes for each file type
+(regular file, directory, device, etc.), the inode contents and length
+varying with the type.
+
+To further maximise compression, two types of regular file inode and
+directory inode are defined: inodes optimised for frequently occurring
+regular files and directories, and extended types where extra
+information has to be stored.
+
+5.3 Directories
+---------------
+
+Like inodes, directories are packed into compressed metadata blocks, stored
+in a directory table. Directories are accessed using the start address of
+the metablock containing the directory and the offset into the
+decompressed block (<block, offset>).
+
+Directories are organised in a slightly complex way, and are not simply
+a list of file names. The organisation takes advantage of the
+fact that (in most cases) the inodes of the files will be in the same
+compressed metadata block, and therefore, can share the start block.
+Directories are therefore organised in a two level list, a directory
+header containing the shared start block value, and a sequence of directory
+entries, each of which share the shared start block. A new directory header
+is written once/if the inode start block changes. The directory
+header/directory entry list is repeated as many times as necessary.
+
+Directories are sorted, and can contain a directory index to speed up
+file lookup. Directory indexes store one entry per metablock, each entry
+storing the index/filename mapping to the first directory header
+in each metadata block. Directories are sorted in alphabetical order,
+and at lookup the index is scanned linearly looking for the first filename
+alphabetically larger than the filename being looked up. At this point the
+location of the metadata block the filename is in has been found.
+The general idea of the index is ensure only one metadata block needs to be
+decompressed to do a lookup irrespective of the length of the directory.
+This scheme has the advantage that it doesn't require extra memory overhead
+and doesn't require much extra storage on disk.
+
+5.4 File data
+-------------
+
+Regular files consist of a sequence of contiguous compressed blocks, and/or a
+compressed fragment block (tail-end packed block). The compressed size
+of each datablock is stored in a block list contained within the
+file inode.
+
+To speed up access to datablocks when reading 'large' files (256 Mbytes or
+larger), the code implements an index cache that caches the mapping from
+block index to datablock location on disk.
+
+The index cache allows Squashfs to handle large files (up to 1.75 TiB) while
+retaining a simple and space-efficient block list on disk. The cache
+is split into slots, caching up to eight 224 GiB files (128 KiB blocks).
+Larger files use multiple slots, with 1.75 TiB files using all 8 slots.
+The index cache is designed to be memory efficient, and by default uses
+16 KiB.
+
+5.5 Fragment lookup table
+-------------------------
+
+Regular files can contain a fragment index which is mapped to a fragment
+location on disk and compressed size using a fragment lookup table. This
+fragment lookup table is itself stored compressed into metadata blocks.
+A second index table is used to locate these. This second index table for
+speed of access (and because it is small) is read at mount time and cached
+in memory.
+
+5.6 Uid/gid lookup table
+------------------------
+
+For space efficiency regular files store uid and gid indexes, which are
+converted to 32-bit uids/gids using an id look up table. This table is
+stored compressed into metadata blocks. A second index table is used to
+locate these. This second index table for speed of access (and because it
+is small) is read at mount time and cached in memory.
+
+5.7 Export table
+----------------
+
+To enable Squashfs filesystems to be exportable (via NFS etc.) filesystems
+can optionally (disabled with the -no-exports Mksquashfs option) contain
+an inode number to inode disk location lookup table. This is required to
+enable Squashfs to map inode numbers passed in filehandles to the inode
+location on disk, which is necessary when the export code reinstantiates
+expired/flushed inodes.
+
+This table is stored compressed into metadata blocks. A second index table is
+used to locate these. This second index table for speed of access (and because
+it is small) is read at mount time and cached in memory.
+
+5.8 Xattr table
+---------------
+
+The xattr table contains extended attributes for each inode. The xattrs
+for each inode are stored in a list, each list entry containing a type,
+name and value field. The type field encodes the xattr prefix
+("user.", "trusted." etc) and it also encodes how the name/value fields
+should be interpreted. Currently the type indicates whether the value
+is stored inline (in which case the value field contains the xattr value),
+or if it is stored out of line (in which case the value field stores a
+reference to where the actual value is stored). This allows large values
+to be stored out of line improving scanning and lookup performance and it
+also allows values to be de-duplicated, the value being stored once, and
+all other occurences holding an out of line reference to that value.
+
+The xattr lists are packed into compressed 8K metadata blocks.
+To reduce overhead in inodes, rather than storing the on-disk
+location of the xattr list inside each inode, a 32-bit xattr id
+is stored. This xattr id is mapped into the location of the xattr
+list using a second xattr id lookup table.
+
+6. AUTHOR INFO
+--------------
+
+Squashfs was written by Phillip Lougher, email phillip@lougher.demon.co.uk,
+in Chepstow, Wales, UK. If you like the program, or have any problems,
+then please email me, as it's nice to get feedback!
diff --git a/squashfs-tools/RELEASE-READMEs/DONATIONS b/squashfs-tools/RELEASE-READMEs/DONATIONS
new file mode 100644
index 0000000..b4653bb
--- /dev/null
+++ b/squashfs-tools/RELEASE-READMEs/DONATIONS
@@ -0,0 +1,15 @@
+Help sponsor Squashfs development!
+
+Maintaining and improving Squashfs is a lot of work, but Squashfs is one of
+the only widely used Linux file systems that has no company backing. Squashfs
+development is funded soley by the author, partially supported by donations
+from companies and individuals that want to improve Squashfs for themselves
+and others.
+
+There's lots of exciting new improvements to Squashfs in the pipeline, and
+if your company is a serious user of Squashfs, please consider accelerating
+development of Squashfs by donating.
+
+Donatations can be made from the Squashfs sourceforge homepage, or if you
+prefer by contacting the author privately.
+
diff --git a/squashfs-tools/RELEASE-READMEs/PERFORMANCE.README b/squashfs-tools/RELEASE-READMEs/PERFORMANCE.README
new file mode 100644
index 0000000..efb98f2
--- /dev/null
+++ b/squashfs-tools/RELEASE-READMEs/PERFORMANCE.README
@@ -0,0 +1,171 @@
+GENERAL INFORMATION ON PERFORMANCE TESTS
+----------------------------------------
+
+The following performance tests were based on two file sets: the
+liveCD filesystem from the Ubuntu liveCD (Warty release), and the
+liveCD filesystem from the Damn Small Linux liveCD (release 0.8.4).
+The Ubuntu liveCD filesystem was used to test filesystem performance
+from CDROM and hard disk for Zisofs, Cloop, Squashfs 2.0 and Squashfs2.1.
+CRAMFS filesystem performance could not be tested for this filesystem
+bacause it exceeds the maximum supported size of CRAMFS. To test
+CRAMFS performance against Squashfs, the liveCD filesystem from
+Damn Small Linux was used.
+
+NOTE: the usual warnings apply to these results, they are provided for
+illustrative purposes only, and due to different hardware and/or file data, you
+may obtain different results. As such the results are provided "as is" without
+any warranty (either express or implied) and you assume all risks as to their
+quality and accuracy.
+
+1. Ubuntu liveCD performance tests
+
+ ext3 uncompressed size 1.4 GB
+ Zisofs compressed size 589.81 MB
+ Cloop compressed size 471.89 MB
+ Squashfs2.0 compressed size 448.58 MB
+ Squashfs2.1 compressed size 448.58 MB
+
+1.1 Performance tests from CDROM
+
+1.1.1 Directory Lookup performance
+
+ Time taken to perform "ls -lR --color=alawys | cat > /dev/null" on filesystem
+ mounted from CDROM
+
+ Zisofs 49.88 seconds (User 2.60 secs, Sys 11.19 secs)
+ Cloop 20.80 seconds (User 2.71 secs, Sys 13.50 secs)
+ Squashfs2.0 16.56 seconds (User 2.42 secs, Sys 10.37 secs)
+ Squashfs2.1 10.14 seconds (User 2.48 secs, Sys 4.44 secs)
+
+1.1.2 Sequential I/O performance
+
+ Time taken to perform "tar cf - | cat > /dev/null" on filesystem mounted
+ from CDROM
+
+ Zisofs 27 minutes 28.54 seconds (User 3.00 secs, Sys 1 min 4.80 secs)
+ Cloop 5 minutes 55.72 seconds (User 2.90 secs, Sys 3 min 37.90 secs)
+ Squashfs2.0 5 minutes 20.87 seconds (User 2.33 secs, Sys 56.98 secs)
+ Squashfs2.1 5 minutes 15.46 seconds (user 2.28 secs, Sys 51.12 secs)
+
+1.1.3 Random I/O performance
+
+ Random access pattern generated by "find /mnt -type f -printf "%s %p\n" | sort
+ -g | awk '{ printf $2 }' > /tmp/sort
+
+ Time taken to perform "cpio -o --quiet -H newc < /tmp/sort > /dev/null"
+ on filesystem mounted from CDROM
+
+ Zisofs 101 minutes 29.65 seconds (User 5.33 secs, Sys 1 min 17.20 secs)
+ Cloop 35 minutes 27.51 seconds (user 5.93 secs, Sys 4 mins 30.23 secs)
+ Squashfs2.0 21 minutes 53.05 seconds (user 5.71 secs, Sys 2 mins 36.59 secs)
+ Squashfs2.1 21 minutes 46.99 seconds (User 5.80 secs, Sys 2 mins 31.88 secs)
+
+
+1.2 Performance tests from Hard disk
+
+1.2.1 Directory Lookup performance
+
+ Time taken to perform "ls -lR --color=alawys | cat > /dev/null" on filesystem
+ mounted from Hard disk
+
+ Zisofs 17.29 seconds (User 2.62 secs, Sys 11.08 secs)
+ Cloop 16.46 seconds (User 2.63 secs, Sys 13.41 secs)
+ Squashfs2.0 13.75 seconds (User 2.44 secs, Sys 11.00 secs)
+ Squashfs2.1 6.94 seconds (User 2.44 secs, Sys 4.48 secs)
+
+1.2.2 Sequential I/O performance
+
+ Time taken to perform "tar cf - | cat > /dev/null" on filesystem mounted
+ from Hard disk
+
+ Zisofs 1 minute 21.47 seconds (User 2.73 secs, Sys 54.44 secs)
+ Cloop 1 minute 34.06 seconds (user 2.85 secs, Sys 1 min 12.13 secs)
+ Squashfs2.0 1 minute 21.22 seconds (User 2.42 secs, Sys 56.21 secs)
+ Squashfs2.1 1 minute 15.46 seconds (User 2.36 secs, Sys 49.78 secs)
+
+1.2.3 Random I/O performance
+
+ Random access pattern generated by "find /mnt -type f -printf "%s %p\n" | sort
+ -g | awk '{ printf $2 }' > /tmp/sort
+
+ Time taken to perform "cpio -o --quiet -H newc < /tmp/sort > /dev/null"
+ on filesystem mounted from Hard disk
+
+ Zisofs 11 minutes 13.64 seconds (User 5.08 secs, Sys 52.62 secs)
+ Cloop 5 minutes 37.93 seconds (user 6 secs, Sys 2 mins 22.38 secs)
+ Squashfs2.0 5 minutes 7.11 seconds (user 5.63 secs, Sys 2 mins 35.23 secs)
+ Squashfs2.1 5 minutes 1.87 seconds (User 5.71 secs, Sys 2 mins 29.98 secs)
+
+
+2. Damn Small Linux liveCD performance tests
+
+ ext3 uncompressed size 126 MB
+ CRAMFS compressed size 52.19 MB
+ Squashfs2.0 compressed size 46.52 MB
+ Squashfs2.1 compressed size 46.52 MB
+
+2.1 Performance tests from CDROM
+
+2.1.1 Directory Lookup performance
+
+ Time taken to perform "ls -lR --color=alawys | cat > /dev/null" on filesystem
+ mounted from CDROM
+
+ CRAMFS 10.85 seconds (User 0.39 secs, Sys 0.98 secs)
+ Squashfs2.0 2.97 seconds (User 0.36 secs, Sys 2.15 secs)
+ Squashfs2.1 2.43 seconds (User 0.40 secs, Sys 1.42 secs)
+
+2.1.2 Sequential I/O performance
+
+ Time taken to perform "tar cf - | cat > /dev/null" on filesystem mounted
+ from CDROM
+
+ CRAMFS 55.38 seconds (User 0.34 secs, Sys 6.98 secs)
+ Squashfs2.0 35.99 seconds (User 0.30 secs, Sys 6.35 secs)
+ Squashfs2.1 33.83 seconds (User 0.26 secs, Sys 5.56 secs)
+
+2.1.3 Random I/O performance
+
+ Random access pattern generated by "find /mnt -type f -printf "%s %p\n" | sort
+ -g | awk '{ printf $2 }' > /tmp/sort
+
+ Time taken to perform "cpio -o --quiet -H newc < /tmp/sort > /dev/null"
+ on filesystem mounted from CDROM
+
+
+ CRAMFS 3 minutes 1.68 seconds (User 0.54 secs, Sys 9.51 secs)
+ Squashfs2.0 1 minute 39.45 seconds (User 0.57 secs, Sys 13.14 secs)
+ Squashfs2.1 1 minute 38.41 seconds (User 0.58 secs, Sys 13.08 secs)
+
+2.2 Performance tests from Hard disk
+
+2.2.1 Directory Lookup performance
+
+ Time taken to perform "ls -lR --color=alawys | cat > /dev/null" on filesystem
+ mounted from Hard disk
+
+ CRAMFS 1.77 seconds (User 0.53 secs, Sys 1.21 secs)
+ Squashfs2.0 2.67 seconds (User 0.41 secs, Sys 2.25 secs)
+ Squashfs2.1 1.87 seconds (User 0.41 secs, Sys 1.46 secs)
+
+2.2.2 Sequential I/O performance
+
+ Time taken to perform "tar cf - | cat > /dev/null" on filesystem mounted
+ from Hard disk
+
+ CRAMFS 6.80 seconds (User 0.36 secs, Sys 6.02 secs)
+ Squashfs2.0 7.23 seconds (User 0.29 secs, Sys 6.62 secs)
+ Squashfs2.1 6.53 seconds (User 0.31 secs, Sys 5.82 secs)
+
+2.2.3 Random I/O performance
+
+ Random access pattern generated by "find /mnt -type f -printf "%s %p\n" | sort
+ -g | awk '{ printf $2 }' > /tmp/sort
+
+ Time taken to perform "cpio -o --quiet -H newc < /tmp/sort > /dev/null"
+ on filesystem mounted from Hard disk
+
+
+ CRAMFS 28.55 seconds (User 0.49 secs, Sys 6.49 secs)
+ Squashfs2.0 25.44 seconds (User 0.58 secs, Sys 13.17 secs)
+ Squashfs2.1 24.72 seconds (User 0.56 secs, Sys 13.15 secs)
diff --git a/squashfs-tools/RELEASE-READMEs/README-2.0 b/squashfs-tools/RELEASE-READMEs/README-2.0
new file mode 100644
index 0000000..41931d8
--- /dev/null
+++ b/squashfs-tools/RELEASE-READMEs/README-2.0
@@ -0,0 +1,161 @@
+NOTE: This the original README for version 2.0. It is retained as it
+contains information about the fragment design. A description of the new 2.0
+mksquashfs options has been added to the main README file, and that
+file should now be consulted for these.
+
+ SQUASHFS 2.0 - A squashed read-only filesystem for Linux
+
+ Copyright 2004 Phillip Lougher (plougher@users.sourceforge.net)
+
+ Released under the GPL licence (version 2 or later).
+
+Welcome to the final release of Squashfs version 2.0! A lot of changes to the
+filesystem have been made under the bonnet (hood). Squashfs 2.0 uses fragment
+blocks and larger blocks (64K) to improve compression ratio by about 5 - 20%
+over Squashfs 1.0 depending on the files being compressed. Using fragment
+blocks allows Squashfs 2.0 to achieve better compression than cloop and similar
+compression to tgz files while retaining the I/O efficiency of a compressed
+filesystem.
+
+Detailed changes:
+
+1. Squashfs 2.0 has added the concept of fragment blocks (see later discussion).
+ Files smaller than the file block size (64K in Squashfs 2.0) and optionally
+ the remainder of files that do not fit fully into a block (i.e. the last 32K
+ in a 96K file) are packed into shared fragments and compressed together.
+ This achieves on average 5 - 20% better compression than Squashfs 1.x.
+
+2. The maximum block size has been increased to 64K.
+
+3. The maximum number of UIDs has been increased to 256 (from 48 in 1.x).
+
+4. The maximum number of GIDs has been increased to 256 (from 15 in 1.x).
+
+5. New mksquashfs -all-root, -root-owned, -force-uid, and -force-gid
+ options. These allow the uids/gids of files in the generated
+ filesystem to be specified, overriding the uids/gids in the
+ source filesystem.
+
+6. Initrds are now supported for kernels 2.6.x.
+
+7. Removal of sleep_on() function call in 2.6.x patch, to allow Squashfs
+ to work on the Fedora rc2 kernel.
+
+8. AMD64, check-data and gid bug fixes.
+
+9. Numerous small bug fixes have been made.
+
+10. New patch for Linux 2.6.7.
+
+
+New Squashfs 2.0 options
+------------------------
+
+-noF or -noFragmentCompression
+
+ Do not compress the fragments. Added for compatibility with noI and
+ noD, probably not that useful.
+
+-no-fragments
+
+ Do not use fragment blocks, and rather generate a filesystem
+ similar to a Squashfs 1.x filesystem. It will of course still
+ be a Squashfs 2.0 filesystem but without fragments, and so
+ it won't be mountable on a Squashfs 1.x system.
+
+-always-use-fragments
+
+ By default only small files less than the block size are packed into
+ fragment blocks. The ends of files which do not fit fully into a block,
+ are NOT by default packed into fragments. To illustrate this, a
+ 100K file has an initial 64K block and a 36K remainder. This
+ 36K remainder is not packed into a fragment by default. This is
+ because to do so leads to a 10 - 20% drop in sequential I/O
+ performance, as a disk head seek is needed to seek to the initial
+ file data and another disk seek is need to seek to the fragment
+ block.
+
+ Specify this option if you want file remainders to be packed into
+ fragment blocks. Doing so may increase the compression obtained
+ BUT at the expense of I/O speed.
+
+-no-duplicates
+
+ Do not detect duplicate files.
+
+-all-root
+-root-owned
+
+ These options (both do exactly the same thing), force all file
+ uids/gids in the generated Squashfs filesystem to be root.
+ This allows root owned filesystems to be built without root access
+ on the host machine.
+
+-force-uid uid
+
+ This option forces all files in the generated Squashfs filesystem to
+ be owned by the specified uid. The uid can be specified either by
+ name (i.e. "root") or by number.
+
+-force-gid gid
+
+ This option forces all files in the generated Squashfs filesystem to
+ be group owned by the specified gid. The gid can be specified either by
+ name (i.e. "root") or by number.
+
+
+Compression improvements example
+--------------------------------
+
+The following is the compression results obtained compressing the 2.6.6
+linux kernel source using CRAMFS, Cloop (with iso filesystem), Squashfs 1.3 and
+Squashfs 2.0 (results generated using big-endian filesystems).
+
+In decreasing order of size:
+
+ CRAMFS 62791680 bytes (59.9M)
+ Squashfs 1.x 51351552 bytes (48.9M)
+ Cloop 46118681 bytes (44.0M)
+ Squashfs 2.0 45604854 bytes (43.5M)
+
+
+The Squashfs 1.x filesystem is 12.6% larger than the new 2.0 filesystem.
+The cloop filesystem is 1.1% larger than the Squashfs 2.0 filesystem.
+
+
+Fragment blocks in Squashfs 2.0
+-------------------------------
+
+Squashfs like all other compressed filesystems compresses files individually
+on a block by block basis. This is performed to allow mounting and
+de-compression of files on a block by block basis without requiring the entire
+filesystem to be decompressed. This is in contrast to data-based compression
+schemes which compress without understanding the underlying filesystem (i.e.
+cloop and tgz files) and which, therefore, do not compress files individually.
+Each approach has advantages and disadvantages, data-based systems have better
+compression because compression is always performed at the maximum block size
+(64K in cloop) irrespective of the size of each file (which could be less than
+the block size). Compressed filesystems tend to be faster at I/O because
+they understand the filesystem and therefore employ better caching stategies
+and read less un-needed data from the filesystem.
+
+Fragment blocks in Squashfs 2.0 solves this problem by packing files (and
+optionally the ends of files) which are smaller than the block size into
+shared blocks, which are compressed together. For example five files each of
+10K will be packed into one shared fragment of 50K and compressed together,
+rather than being compressed in five 10K blocks.
+
+This scheme produces a hybrid filesystem, retaining the I/O efficiency
+of a compressed filesystem, while obtaining the compression efficiency
+of data-based schemes by compressing small files together.
+
+
+Squashfs 1.x and Squashfs 2.0 compatibility
+-------------------------------------------
+
+Appending to Squashfs 1.x filesystems is not supported. If you wish to append
+to 1.x filesystems, then either use the original mksquashfs, or convert them
+to Squashfs 2.0 by mounting the filesystem and running the 2.0 mksquashfs
+on the mounted filesystem.
+
+Mounting Squashfs 1.x filesystems IS supported by the 2.0 kernel patch.
diff --git a/squashfs-tools/RELEASE-READMEs/README-2.0-AMD64 b/squashfs-tools/RELEASE-READMEs/README-2.0-AMD64
new file mode 100644
index 0000000..5569617
--- /dev/null
+++ b/squashfs-tools/RELEASE-READMEs/README-2.0-AMD64
@@ -0,0 +1,18 @@
+Information for amd64 users
+---------------------------
+
+All previous releases of Squashfs (2.0-alpha and older) generate incorrect
+filesystems on amd64 machines. These filesystems work correctly on amd64
+machines, but cannot be mounted on non-amd64 machines. Likewise, filesystems
+generated on non amd64 machines could not be mounted on amd64 machines.
+This bug was caused by the different size of the "time_t" definition used in
+SquashFS filesystem structures.
+
+This bug is now fixed in this release. However, all amd64 filesystems
+generated by previous releases will not be mountable on amd64 machines
+with this release. If you have pre-existing amd64 generated filesystems,
+it is important that you recreate the filesystem. This can be performed
+by mounting the filesystem using a kernel with the original patch
+(i.e. a 2.0-alpha or older patch) and running the SquashFS 2.0
+(i.e. this release) mksquashfs tool to create a new SquashFS filesystem.
+
diff --git a/squashfs-tools/RELEASE-READMEs/README-2.1 b/squashfs-tools/RELEASE-READMEs/README-2.1
new file mode 100644
index 0000000..e70167e
--- /dev/null
+++ b/squashfs-tools/RELEASE-READMEs/README-2.1
@@ -0,0 +1,87 @@
+ SQUASHFS 2.1 - A squashed read-only filesystem for Linux
+
+ Copyright 2004 Phillip Lougher (plougher@users.sourceforge.net)
+
+ Released under the GPL licence (version 2 or later).
+
+Welcome to Squashfs version 2.1-r2. Squashfs 2.1 introduces indexed
+directories which considerably speed up directory lookup (ls, find etc.) for
+directories which are greater than 8K in size. All directories are now also
+sorted alphabetically which further speeds up directory lookup. Many smaller
+improvements have also been made to this release, please see the CHANGES file
+entry for detailed changes.
+
+1. DIRECTORY SPEED IMPROVEMENT EXAMPLES
+---------------------------------------
+
+To give an indication of the directory speed improvements a number of test
+results are shown here. There is in addition a new PERFORMANCE.README file
+which gives details of I/O and lookup performance for Squashfs 2.1 against
+the Zisofs, Cloop and CRAMFS filesystems.
+
+example 1:
+
+Filesystems generated from a single directory of 72,784 files (2.6 MB
+directory size). Each file is 10 bytes in size (the test is directory
+lookup and so the file size isn't an issue). The ext3 uncompressed
+directory size is 288 MB (presumably because of one file per block).
+
+Zisofs compressed size 153.50 MB
+Cloop (isofs) compressed size 1.74 MB
+Squashfs2.1 compressed size 612 KB (0.60 MB)
+
+Time taken to perform "ls -lR --color=always | cat > /dev/null" on
+filesystems mounted on hard disk.
+
+Zisofs 35 minutes 7.895 seconds (User 7.868 secs, Sys 34 mins 5.621 secs)
+Cloop 35 minutes 12.765 seconds (User 7.771 secs, Sys 34 mins 3.869 secs)
+Squashfs2.1 19 seconds (User 5.119 secs, Sys 14.547 secs)
+
+example 2:
+
+Filesystems were generated from the Ubuntu Warty livecd (original uncompressed
+size on ext3 is 1.4 GB).
+
+Zisofs compressed size 589.81 MB
+Cloop (isofs) compressed size 471.19 MB
+Squashfs2.0 compressed size 448.58 MB
+Squashfs2.1 compressed size 448.58 MB
+
+Time taken to perform "ls -lR --color=always | cat > /dev/null" on
+filesystems mounted on hard disk.
+
+Zisofs 49.875 seconds (User time 2.589 secs, Sys 11.194 secs)
+Cloop 20.797 seconds (User time 2.706 secs, Sys 13.496 secs)
+Squashfs2.0 16.556 seconds (User time 2.424 secs, Sys 10.371 secs)
+Squashfs2.1 10.143 seconds (User time 2.475 secs, Sys 4.440 secs)
+
+
+NOTE: the usual warnings apply to these results, they are provided for
+illustrative purposes only, and due to different hardware and/or file data, you
+may obtain different results. As such the results are provided "as is" without
+any warranty (either express or implied) and you assume all risks as to their
+quality and accuracy.
+
+2. NEW MKSQUASHFS OPTIONS
+-------------------------
+
+There is only one extra option "-2.0". This tells mksquashfs to generate
+a filesystem which is mountable with Squashfs version 2.0.
+
+3. APPENDING AND MOUNTING SQUASHFS 2.0 FILESYSTEMS
+--------------------------------------------------
+
+Mounting 2.0 filesystems is supported by Squashfs 2.1. In addition
+mksquashfs v2.1 can append to 2.0 filesystems, although the generated
+filesystem will still be a 2.0 filesystem.
+
+4. DONATIONS
+------------
+
+If you find Squashfs useful then please consider making a donation,
+particularly if you use Squashfs in a commercial product. Please consider
+giving something back especially if you're making money from it.
+
+Off the Squashfs subject somewhat I'm currently looking for another
+job doing Linux kernel or filesystems work. If you know of any such
+work that can be performed from the UK then please get in touch. Thanks.
diff --git a/squashfs-tools/RELEASE-READMEs/README-3.0 b/squashfs-tools/RELEASE-READMEs/README-3.0
new file mode 100644
index 0000000..fd16dd3
--- /dev/null
+++ b/squashfs-tools/RELEASE-READMEs/README-3.0
@@ -0,0 +1,60 @@
+ SQUASHFS 3.0 - A squashed read-only filesystem for Linux
+
+ Copyright 2002-2006 Phillip Lougher <phillip@lougher.org.uk>
+
+ Released under the GPL licence (version 2 or later).
+
+Welcome to the first release of Squashfs version 3.0. Squashfs 3.0 has the
+the following improvements to 2.x.
+
+ 1. Filesystems are no longer limited to 4 GB. In
+ theory 2^64 or 4 exabytes is now supported.
+
+ 2. Files are no longer limited to 4 GB. In theory the maximum
+ file size is 4 exabytes.
+
+ 3. Metadata (inode table and directory tables) are no longer
+ restricted to 16 Mbytes.
+
+ 4. Hardlinks are now suppported.
+
+ 5. Nlink counts are now supported.
+
+ 6. Readdir now returns '.' and '..' entries.
+
+ 7. Special support for files larger than 256 MB has been added to
+ the Squashfs kernel code for faster read access.
+
+ 8. Inode numbers are now stored within the inode rather than being
+ computed from inode location on disk (this is not so much an
+ improvement, but a change forced by the previously listed
+ improvements).
+
+There is a new Unsquashfs utility (in squashfs-tools) than can be used to
+decompress a filesystem without mounting it.
+
+Squashfs 3.0 supports 2.x filesystems. Support for 1.x filesystems
+will be added in the future.
+
+1. UNSQUASHFS
+-------------
+
+Unsquashfs has the following options:
+
+SYNTAX: unsquashfs [-ls | -dest] filesystem
+ -version print version, licence and copyright information
+ -info print files as they are unsquashed
+ -ls list filesystem only
+ -dest <pathname> unsquash to <pathname>, default "squashfs-root"
+
+The "-ls" option can be used to list the contents of a filesystem without
+decompressing the filesystem data itself.
+
+The "-info" option forces Unsquashfs to print each file as it is decompressed.
+
+The "-dest" option specifies the directory that is used to decompress
+the filesystem data. If this option is not given then the filesystem is
+decompressed to the directory "squashfs-root" in the current working directory.
+
+Unsquashfs can decompress 3.0 filesystems. Support for 2.x and 1.x
+filesystems will be added in the future.
diff --git a/squashfs-tools/RELEASE-READMEs/README-3.1 b/squashfs-tools/RELEASE-READMEs/README-3.1
new file mode 100755
index 0000000..0e1ee79
--- /dev/null
+++ b/squashfs-tools/RELEASE-READMEs/README-3.1
@@ -0,0 +1,158 @@
+ SQUASHFS 3.1 - A squashed read-only filesystem for Linux
+
+ Copyright 2002-2006 Phillip Lougher <phillip@lougher.org.uk>
+
+ Released under the GPL licence (version 2 or later).
+
+Welcome to Squashfs version 3.1-r2. Squashfs 3.1 has major improvements to
+the Squashfs tools (Mksquashfs and Unsquashfs), some major bug fixes, new
+kernel patches, and various other smaller improvements and bug fixes.
+Please see the CHANGES file for a detailed list.
+
+1. MKSQUASHFS
+-------------
+
+Mksquashfs has been rewritten and it is now multi-threaded. It offers
+the following improvements:
+
+1. Parallel compression. By default as many compression and fragment
+compression threads are created as there are available processors.
+This significantly speeds up performance on SMP systems.
+
+2. File input and filesystem output is peformed in parallel on separate
+threads to maximise I/O performance. Even on single processor systems
+this speeds up performance by at least 10%.
+
+3. Appending has been significantly improved, and files within the
+filesystem being appended to are no longer scanned and checksummed. This
+significantly improves append time for large filesystems.
+
+4. File duplicate checking has been optimised, and split into two separate
+phases. Only files which are considered possible duplicates after the
+first phase are checksummed and cached in memory.
+
+5. The use of swap memory was found to significantly impact performance. The
+amount of memory used to cache the file is now a command line option, by default
+this is 512 Mbytes.
+
+1.1 NEW COMMAND LINE OPTIONS
+----------------------------
+
+The new Mksquashfs program has a couple of extra command line options
+which can be used to control the new features:
+
+-processors <processors>
+
+This specifies the number of processors used by Mksquashfs.
+By default this is the number of available processors.
+
+-read_queue <size in Mbytes>
+
+This specifies the size of the file input queue used by the reader thread.
+This defaults to 64 Mbytes.
+
+-write_queue <size in Mbytes>
+
+This specifies the size of the filesystem output queue used by the
+writer thread. It also specifies the maximum cache used in file
+duplicate detection (the output queue is shared between these tasks).
+This defaults to 512 Mbytes.
+
+1.2 PERFORMANCE RESULTS
+-----------------------
+
+The following results give an indication of the speed improvements. Two
+example filesystems were tested, a liveCD filesystem (about 1.8 Gbytes
+uncompressed), and my home directory consisting largely of text files
+(about 1.3 Gbytes uncompressed). Tests were run on a single core
+and a dual core system.
+
+Dual Core (AMDx2 3800+) system:
+Source directories on ext3.
+
+LiveCD, old mksquashfs:
+
+real 11m48.401s
+user 9m27.056s
+sys 0m15.281s
+
+LiveCD, new par_mksquashfs:
+
+real 4m8.736s
+user 7m11.771s
+sys 0m27.749s
+
+"Home", old mksquashfs:
+
+real 4m34.360s
+user 3m54.007s
+sys 0m32.155s
+
+"Home", new par_mksquashfs:
+
+real 1m27.381s
+user 2m7.304s
+sys 0m17.234s
+
+Single Core PowerBook (PowerPC G4 1.5 GHz Ubuntu Linux)
+Source directories on ext3.
+
+LiveCD, old mksquashs:
+
+real 11m38.472s
+user 9m6.137s
+sys 0m23.799s
+
+LiveCD, par_mksquashfs:
+
+real 10m5.572s
+user 8m59.921s
+sys 0m16.145s
+
+"Home", old mksquashfs:
+
+real 3m42.298s
+user 2m49.478s
+sys 0m13.675s
+
+"Home", new par_mksquashfs:
+
+real 3m9.178s
+user 2m50.699s
+sys 0m9.069s
+
+I'll be interested in any performance results obtained, especially from SMP
+machines larger than my dual-core AMD box, as this will give an indication of
+the scalability of the code. Obviously, I'm also interested in any problems,
+deadlocks, low performance etc.
+
+2. UNSQUASHFS
+-------------
+
+Unsquashfs now allows you to specify the filename or directory that is to be
+extracted from the Squashfs filesystem, rather than always extracting the
+entire filesystem. It also has a new "-force" option, and all options can be
+specified in a short form (-i rather than -info).
+
+The Unsquashfs usage info is now:
+
+SYNTAX: ./unsquashfs [options] filesystem [directory or file to extract]
+ -v[ersion] print version, licence and copyright information
+ -i[nfo] print files as they are unsquashed
+ -l[s] list filesystem only
+ -d[est] <pathname> unsquash to <pathname>, default "squashfs-root"
+ -f[orce] if file already exists then overwrite
+
+To extract a subset of the filesystem, the filename or directory
+tree that is to be extracted can now be specified on the command line. The
+file/directory should be specified using the full path to the file/directory
+as it appears within the Squashfs filesystem. The file/directory will also be
+extracted to that position within the specified destination directory.
+
+The new "-force" option forces Unsquashfs to output to the destination
+directory even if files or directories already exist. This allows you
+to update an existing directory tree, or to Unsquashfs to a partially
+filled directory. Without the "-force" option, Unsquashfs will
+refuse to overwrite any existing files, or to create any directories if they
+already exist. This is done to protect data in case of mistakes, and
+so the "-force" option should be used with caution.
diff --git a/squashfs-tools/RELEASE-READMEs/README-3.2 b/squashfs-tools/RELEASE-READMEs/README-3.2
new file mode 100755
index 0000000..e38286f
--- /dev/null
+++ b/squashfs-tools/RELEASE-READMEs/README-3.2
@@ -0,0 +1,33 @@
+ SQUASHFS 3.2 - A squashed read-only filesystem for Linux
+
+ Copyright 2002-2007 Phillip Lougher <phillip@lougher.org.uk>
+
+ Released under the GPL licence (version 2 or later).
+
+Welcome to Squashfs version 3.2. Squashfs 3.2 has support for NFS exporting,
+some improvements to the Squashfs tools (Mksquashfs and Unsquashfs), some
+major bug fixes, new kernel patches, and various other smaller improvements
+and bug fixes. Please see the CHANGES file for a detailed list.
+
+1. MKSQUASHFS
+-------------
+
+New command line options:
+
+-no-exports
+
+ Squashfs now supports NFS exports. By default the additional
+ information necessary is added to the filesystem by Mksquashfs. If you
+ do not wish this extra information, then this option can be specified.
+ This will save a couple of bytes per file, and the filesystem
+ will be identical to Squashfs 3.1.
+
+-no-progress
+
+ Mksquashfs by default now displays a progress bar. This option disables
+ it.
+
+2. UNSQUASHFS
+-------------
+
+ Unsquashfs now supports Squashfs 2.x filesystems.
diff --git a/squashfs-tools/RELEASE-READMEs/README-3.3 b/squashfs-tools/RELEASE-READMEs/README-3.3
new file mode 100644
index 0000000..a38a39e
--- /dev/null
+++ b/squashfs-tools/RELEASE-READMEs/README-3.3
@@ -0,0 +1,169 @@
+ SQUASHFS 3.3 - A squashed read-only filesystem for Linux
+
+ Copyright 2002-2007 Phillip Lougher <phillip@lougher.demon.co.uk>
+
+ Released under the GPL licence (version 2 or later).
+
+Welcome to another release of Squashfs. This is the 22nd release in just
+over five years of work. Squashfs 3.3 has lots of nice improvements,
+both to the filesystem itself (bigger blocks, and sparse files), but
+also to the Squashfs-tools Mksquashfs and Unsquashfs. As usual the
+CHANGES file has a detailed list of all the improvements.
+
+Following is a description of the changes to the Squashfs tools, usage
+guides to the new options, and a summary of the new options.
+
+1. MKSQUASHFS - EXTENDED EXCLUDE FILE HANDLING
+----------------------------------------------
+
+1. Extended wildcard pattern matching now supported in exclude files
+
+ Enabled by specifying -wildcards option
+
+ Supports both anchored and non-anchored exclude files.
+
+1.1 Anchored excludes
+
+ Similar to existing exclude files except with wildcards. Exclude
+ file matches from root of source directories.
+
+ Examples:
+
+ 1. mksquashfs example image.sqsh -wildcards -e 'test/*.gz'
+
+ Exclude all files matching "*.gz" in the top level directory "test".
+
+ 2. mksquashfs example image.sqsh -wildcards -e '*/[Tt]est/example*'
+
+ Exclude all files beginning with "example" inside directories called
+ "Test" or "test", that occur inside any top level directory.
+
+ Using extended wildcards, negative matching is also possible.
+
+ 3. mksquashfs example image.sqsh -wildcards -e 'test/!(*data*).gz'
+
+ Exclude all files matching "*.gz" in top level directory "test",
+ except those with "data" in the name.
+
+1.2 Non-anchored excludes
+
+ By default excludes match from the top level directory, but it is
+ often useful to exclude a file matching anywhere in the source directories.
+ For this non-anchored excludes can be used, specified by pre-fixing the
+ exclude with "...".
+
+ Examples:
+
+ 1. mksquashfs example image.sqsh -wildcards -e '... *.gz'
+
+ Exclude files matching "*.gz" anywhere in the source directories.
+ For example this will match "example.gz", "test/example.gz", and
+ "test/test/example.gz".
+
+ 2. mksquashfs example image.sqsh -wildcards -e '... [Tt]est/*.gz'
+
+ Exclude files matching "*.gz" inside directories called "Test" or
+ "test" that occur anywhere in the source directories.
+
+ Again, using extended wildcards, negative matching is also possible.
+
+ 3. mksquashfs example image.sqsh -wildcards -e '... !(*data*).gz'
+
+ Exclude all files matching "*.gz" anywhere in the source directories,
+ except those with "data" in the name.
+
+2. Regular expression pattern matching now supported in exclude files
+
+ Enabled by specifying -regex option. Identical behaviour to wild
+card pattern matching, except patterns are considered to be regular
+expressions.
+
+ Supports both anchored and non-anchored exclude files.
+
+
+2. MKSQUASHFS - NEW RECOVERY FILE FEATURE
+-----------------------------------------
+
+Recovery files are now created when appending to existing Squashfs
+filesystems. This allows the original filesystem to be recovered
+if Mksquashfs aborts unexpectedly (i.e. power failure).
+
+The recovery files are called squashfs_recovery_xxx_yyy, where
+"xxx" is the name of the filesystem being appended to, and "yyy" is a
+number to guarantee filename uniqueness (the PID of the parent Mksquashfs
+process).
+
+Normally if Mksquashfs exits correctly the recovery file is deleted to
+avoid cluttering the filesystem. If Mksquashfs aborts, the "-recover"
+option can be used to recover the filesystem, giving the previously
+created recovery file as a parameter, i.e.
+
+mksquashfs dummy image.sqsh -recover squashfs_recovery_image.sqsh_1234
+
+The writing of the recovery file can be disabled by specifying the
+"-no-recovery" option.
+
+
+3. UNSQUASHFS - EXTENDED EXTRACT FILE HANDLING
+----------------------------------------------
+
+1. Multiple extract files can now be specified on the command line, and the
+files/directories to be extracted can now also be given in a file.
+
+To specify a file containing the extract files use the "-e[f]" option.
+
+2. Extended wildcard pattern matching now supported in extract files
+
+ Enabled by default. Similar to existing extract files except with
+wildcards.
+
+ Examples:
+
+ 1. unsquashfs image.sqsh 'test/*.gz'
+
+ Extract all files matching "*.gz" in the top level directory "test".
+
+ 2. unsquashfs image.sqsh '[Tt]est/example*'
+
+ Extract all files beginning with "example" inside top level directories
+ called "Test" or "test".
+
+ Using extended wildcards, negative matching is also possible.
+
+ 3. unsquashfs image.sqsh 'test/!(*data*).gz'
+
+ Extract all files matching "*.gz" in top level directory "test",
+ except those with "data" in the name.
+
+3. Regular expression pattern matching now supported in extract files
+
+ Enabled by specifying -r[egex] option. Identical behaviour to wild
+card pattern matching, except patterns are considered to be regular
+expressions.
+
+4. UNSQUASHFS - EXTENDED FILENAME PRINTING
+------------------------------------------
+
+Filename printing has been enhanced and Unquashfs can now display filenames
+with file attributes ('ls -l' style output).
+
+New options:
+
+ -ll[s]
+
+ list filesystem with file attributes, but don't unsquash
+
+ -li[nfo]
+
+ print files as they are unsquashed with file attributes
+
+
+5. UNSQUASHFS - MISCELLANEOUS OPTIONS
+-------------------------------------
+
+ -s[tat]
+
+ Display the filesystem superblock information. This is useful to
+ discover the filesystem version, byte ordering, whether it has an
+ NFS export table, and what options were used to compress
+ the filesystem.
diff --git a/squashfs-tools/RELEASE-READMEs/README-4.0 b/squashfs-tools/RELEASE-READMEs/README-4.0
new file mode 100644
index 0000000..8cc9514
--- /dev/null
+++ b/squashfs-tools/RELEASE-READMEs/README-4.0
@@ -0,0 +1,48 @@
+ SQUASHFS 4.0 - A squashed read-only filesystem for Linux
+
+ Copyright 2002-2009 Phillip Lougher <phillip@lougher.demon.co.uk>
+
+ Released under the GPL licence (version 2 or later).
+
+Welcome to Squashfs 4.0. This is an initial tools only release to
+support users of the 2.6.29 kernel, following the mainlining of Squashfs
+earlier this year.
+
+Later releases will probably contain kernel patches supporting 4.0
+layouts for earlier kernels.
+
+New Mksquashfs options
+----------------------
+
+Mksquashfs now supports pseudo files, these allow fake directories, character
+and block devices to be specified and added to the Squashfs filesystem being
+built, rather than requiring them to be present in the source directories.
+This, for example, allows device nodes to be added to the filesystem without
+requiring root access.
+
+Two options are supported, -p allows one pseudo file to be specified on the
+command line, and -pf allows a pseudo file to be specified containing a
+list of pseduo definitions, one per line.
+
+Pseudo device nodes are specified using 7 arguments
+
+Filename type mode uid gid major minor
+
+Where type is either
+ b - for block devices, and
+ c - for character devices
+
+mode is the octal mode specifier, similar to that expected by chmod.
+
+Uid and gid can be either specified as a decimal number, or by name.
+
+For example:
+
+/dev/chr_dev c 666 root root 100 1
+/dev/blk_dev b 444 0 0 200 200
+
+Directories are specified using 5 arguments
+
+Filename type mode uid gid
+
+Where type is d.
diff --git a/squashfs-tools/RELEASE-READMEs/README-4.1 b/squashfs-tools/RELEASE-READMEs/README-4.1
new file mode 100644
index 0000000..d2712f9
--- /dev/null
+++ b/squashfs-tools/RELEASE-READMEs/README-4.1
@@ -0,0 +1,265 @@
+ SQUASHFS 4.1 - A squashed read-only filesystem for Linux
+
+ Copyright 2002-2010 Phillip Lougher <phillip@lougher.demon.co.uk>
+
+ Released under the GPL licence (version 2 or later).
+
+Welcome to Squashfs 4.1. This is a tools only release, support for Squashfs
+file systems is in mainline (2.6.29 and later).
+
+New features in Squashfs-tools 4.1
+----------------------------------
+
+ 1. Support for extended attributes
+ 2. Support for LZMA and LZO compression
+ 3. New pseudo file features
+
+Compatiblity
+------------
+
+Mksquashfs 4.1 generates 4.0 filesystems. These filesystems are fully
+compatible/interchangable with filesystems generated by Mksquashfs 4.0 and are
+mountable on 2.6.29 and later kernels.
+
+Extended attributes (xattrs)
+----------------------------
+
+Squashfs file systems now have extended attribute support. The
+extended attribute implementation has the following features:
+
+1. Layout can store up to 2^48 bytes of compressed xattr data.
+2. Number of xattrs per inode unlimited.
+3. Total size of xattr data per inode 2^48 bytes of compressed data.
+4. Up to 4 Gbytes of data per xattr value.
+5. Inline and out-of-line xattr values supported for higher performance
+ in xattr scanning (listxattr & getxattr), and to allow xattr value
+ de-duplication.
+6. Both whole inode xattr duplicate detection and individual xattr value
+ duplicate detection supported. These can obviously nest, file C's
+ xattrs can be a complete duplicate of file B, and file B's xattrs
+ can be a partial duplicate of file A.
+7. Xattr name prefix types stored, allowing the redundant "user.", "trusted."
+ etc. characters to be eliminated and more concisely stored.
+8. Support for files, directories, symbolic links, device nodes, fifos
+ and sockets.
+
+Extended attribute support is in 2.6.35 and later kernels. File systems
+with extended attributes can be mounted on 2.6.29 and later kernels, the
+extended attributes will be ignored with a warning.
+
+LZMA and LZO compression
+------------------------
+
+Squashfs now supports LZMA and LZO compression.
+
+LZO support is in 2.6.36 and newer kernels. LZMA is not yet in mainline.
+
+New Mksquashfs options
+----------------------
+
+-comp <comp>
+
+ Select <comp> compression.
+
+ The compression algorithms supported by the build of Mksquashfs can be
+ found by typing mksquashfs without any arguments. The compressors available
+ are displayed at the end of the help message, e.g.
+
+ Compressors available:
+ gzip (default)
+ lzma
+ lzo
+
+ The default compression used when -comp isn't specified on the command line
+ is indicated by "(default)".
+
+-no-xattrs
+ Don't store extended attributes
+
+-xattrs
+ Store extended attributes
+
+ The default behaviour of Mksquashfs with respect to extended attribute
+ storage is build time selectable. The Mksquashfs help message indicates
+ whether extended attributes are stored or not, e.g.
+
+ -no-xattrs don't store extended attributes
+ -xattrs store extended attributes (default)
+
+ shows that extended attributes are stored by default, and can be disabled
+ by the -no-xattrs option.
+
+ -no-xattrs don't store extended attributes (default)
+ -xattrs store extended attributes
+
+ shows that extended attributes are not stored by default, storage can be
+ enabled by the -xattrs option.
+
+
+-noX
+-noXattrCompression
+ Don't compress extended attributes
+
+
+New Unsquashfs options
+----------------------
+
+-n[o-xattrs]
+ Don't extract xattrs in filesystem
+
+-x[attrs]
+ Extract xattrs in filesystem
+
+ The default behaviour of Unsquashfs with respect to extended attributes
+ is build time selectable. The Unsquashfs help message indicates whether
+ extended attributes are stored or not, e.g.
+
+ -no[-xattrs] don't extract xattrs in file system
+ -x[attrs] extract xattrs in file system (default)
+
+ shows that xattrs are extracted by default.
+
+ -no[-xattrs] don't extract xattrs in file system (default)
+ -x[attrs] extract xattrs in file system
+
+ shows that xattrs are not extracted by default.
+
+
+New pseudo file support
+-----------------------
+
+Mksquashfs supports pseudo files, these allow fake files, directories, character
+and block devices to be specified and added to the Squashfs filesystem being
+built, rather than requiring them to be present in the source directories.
+This, for example, allows device nodes to be added to the filesystem without
+requiring root access.
+
+Mksquashfs 4.1 adds support for "dynamic pseudo files" and a modify operation.
+Dynamic pseudo files allow files to be dynamically created when Mksquashfs
+is run, their contents being the result of running a command or piece of
+shell script. The modifiy operation allows the mode/uid/gid of an existing
+file in the source filesystem to be modified.
+
+Two Mksquashfs options are supported, -p allows one pseudo file to be specified
+on the command line, and -pf allows a pseudo file to be specified containing a
+list of pseduo definitions, one per line.
+
+Pseudo operations
+-----------------
+
+1. Creating a dynamic file
+--------------------------
+
+Pseudo definition
+
+Filename f mode uid gid command
+
+mode is the octal mode specifier, similar to that expected by chmod.
+
+uid and gid can be either specified as a decimal number, or by name.
+
+command can be an executable or a piece of shell script, and it is executed
+by running "/bin/sh -c command". The stdout becomes the contents of
+"Filename".
+
+Examples:
+
+Running a basic command
+-----------------------
+
+/somedir/dmesg f 444 root root dmesg
+
+creates a file "/somedir/dmesg" containing the output from dmesg.
+
+Executing shell script
+----------------------
+
+RELEASE f 444 root root \
+ if [ ! -e /tmp/ver ]; then \
+ echo 0 > /tmp/ver; \
+ fi; \
+ ver=`cat /tmp/ver`; \
+ ver=$((ver +1)); \
+ echo $ver > /tmp/ver; \
+ echo -n `cat /tmp/release`; \
+ echo "-dev #"$ver `date` "Build host" `hostname`
+
+Creates a file RELEASE containing the release name, date, build host, and
+an incrementing version number. The incrementing version is a side-effect
+of executing the shell script, and ensures every time Mksquashfs is run a
+new version number is used without requiring any other shell scripting.
+
+The above example also shows that commands can be split across multiple lines
+using "\". Obviously as the script will be presented to the shell as a single
+line, a semicolon is need to separate individual shell commands within the
+shell script.
+
+Reading from a device (or fifo/named socket)
+--------------------------------------------
+
+input f 444 root root dd if=/dev/sda1 bs=1024 count=10
+
+Copies 10K from the device /dev/sda1 into the file input. Ordinarily Mksquashfs
+given a device, fifo, or named socket will place that special file within the
+Squashfs filesystem, the above allows input from these special files to be
+captured and placed in the Squashfs filesystem.
+
+2. Creating a block or character device
+---------------------------------------
+
+Pseudo definition
+
+Filename type mode uid gid major minor
+
+Where type is either
+ b - for block devices, and
+ c - for character devices
+
+mode is the octal mode specifier, similar to that expected by chmod.
+
+uid and gid can be either specified as a decimal number, or by name.
+
+For example:
+
+/dev/chr_dev c 666 root root 100 1
+/dev/blk_dev b 666 0 0 200 200
+
+creates a character device "/dev/chr_dev" with major:minor 100:1 and
+a block device "/dev/blk_dev" with major:minor 200:200, both with root
+uid/gid and a mode of rw-rw-rw.
+
+3. Creating a directory
+-----------------------
+
+Pseudo definition
+
+Filename d mode uid gid
+
+mode is the octal mode specifier, similar to that expected by chmod.
+
+uid and gid can be either specified as a decimal number, or by name.
+
+For example:
+
+/pseudo_dir d 666 root root
+
+creates a directory "/pseudo_dir" with root uid/gid and mode of rw-rw-rw.
+
+4. Modifying attributes of an existing file
+-------------------------------------------
+
+Pseudo definition
+
+Filename m mode uid gid
+
+mode is the octal mode specifier, similar to that expected by chmod.
+
+uid and gid can be either specified as a decimal number, or by name.
+
+For example:
+
+dmesg m 666 root root
+
+Changes the attributes of the file "dmesg" in the filesystem to have
+root uid/gid and a mode of rw-rw-rw, overriding the attributes obtained
+from the source filesystem.
diff --git a/squashfs-tools/RELEASE-READMEs/README-4.2 b/squashfs-tools/RELEASE-READMEs/README-4.2
new file mode 100644
index 0000000..db28f53
--- /dev/null
+++ b/squashfs-tools/RELEASE-READMEs/README-4.2
@@ -0,0 +1,57 @@
+ SQUASHFS 4.2 - A squashed read-only filesystem for Linux
+
+ Copyright 2002-2011 Phillip Lougher <phillip@lougher.demon.co.uk>
+
+ Released under the GPL licence (version 2 or later).
+
+Welcome to Squashfs 4.2. This is a tools only release, support for Squashfs
+filesystems is in mainline (2.6.29 and later).
+
+New features in Squashfs-tools 4.2
+----------------------------------
+
+ 1. Support for XZ compression
+ 2. Support for compressor specific options
+
+Compatiblity
+------------
+
+Mksquashfs 4.2 generates 4.0 filesystems. These filesystems are fully
+compatible/interchangable with filesystems generated by Mksquashfs 4.0 and are
+mountable on 2.6.29 and later kernels.
+
+XZ compression
+--------------
+
+Squashfs now supports XZ compression.
+
+XZ support is in 2.6.38 and newer kernels.
+
+New Mksquashfs options
+----------------------
+
+-X<compressor-option>
+
+ Compression algorithms can now support compression specific options. These
+options are prefixed by -X, and are passed to the compressor for handling.
+
+ The compression specific options supported by each compressor can be
+found by typing mksquashfs without any arguments. They are displayed at the
+end of the help message, e.g.
+
+Compressors available and compressor specific options:
+ gzip (no options) (default)
+ lzo (no options)
+ xz
+ -Xbcj filter1,filter2,...,filterN
+ Compress using filter1,filter2,...,filterN in turn
+ (in addition to no filter), and choose the best compression.
+ Available filters: x86, arm, armthumb, powerpc, sparc, ia64
+ -Xdict-size <dict-size>
+ Use <dict-size> as the XZ dictionary size. The dictionary size
+ can be specified as a percentage of the block size, or as an
+ absolute value. The dictionary size must be less than or equal
+ to the block size and 8192 bytes or larger. It must also be
+ storable in the xz header as either 2^n or as 2^n+2^(n+1).
+ Example dict-sizes are 75%, 50%, 37.5%, 25%, or 32K, 16K, 8K
+ etc.
diff --git a/squashfs-tools/RELEASE-READMEs/README-4.3 b/squashfs-tools/RELEASE-READMEs/README-4.3
new file mode 100644
index 0000000..d2370a0
--- /dev/null
+++ b/squashfs-tools/RELEASE-READMEs/README-4.3
@@ -0,0 +1,182 @@
+ SQUASHFS 4.3 - A squashed read-only filesystem for Linux
+
+ Copyright 2002-2014 Phillip Lougher <phillip@lougher.demon.co.uk>
+
+ Released under the GPL licence (version 2 or later).
+
+Welcome to Squashfs 4.3. This is the first release in over 3 years, and
+there are substantial improvements to stability, new compression options
+and compressors, speed optimisations, and new options for Mksquashfs/Unsquashfs.
+
+This is a tools only release, support for Squashfs filesystems is
+in mainline (2.6.29 and later).
+
+Changes in Squashfs-tools 4.3
+-----------------------------
+
+1. Stability improvements. Better checking of user input for out of
+ range/invalid values. Better handling of corrupted Squashfs filesystems
+ (Mksquashfs append mode, and Unsquashfs). Better handling of buffer
+ overflow/underflow.
+
+2. GZIP compressor now supports compression options, allowing different
+ compression levels to be used.
+
+3. Rewritten LZO compressor with compression options, allowing different
+ LZO algorithms and different compression levels to be used.
+
+4. New LZ4 compressor (note not yet in mainline kernel)
+
+5. Better default memory usage for Mksquashfs. Mksquashfs by default now
+ uses 25% of physical memory.
+
+6. Duplicate checking in Mksquashfs further optimised. With certain
+ "problem filesystems" greater than 2x performance improvement.
+ Filesystems with a lot of duplicates should see at least 10-20% speed
+ improvement.
+
+7. The -stat option in Unsquashfs now displays the compression options
+ used to generate the original filesystem. Previously -stat only displayed
+ the compression algorithm used.
+
+8. The file being compressed/uncompressed in Mksquashfs/Unsquashfs is now
+ displayed if CTRL-\ (SIGQUIT from keyboard) typed.
+
+9. The status of the internal queues/caches in Mksquashfs/Unsquashfs is
+ now displayed if CTRL-\ (SIGQUIT from keyboard) is typed twice within
+ one second. Normally only useful for "power users", but it can be
+ used to discover if there's any bottlenecks affecting performance
+ (the bottleneck will normally be the compressors/fragment compressors).
+
+10. Miscellaneous new options for Mksquashfs/Unsquashfs to fine tune behaviour.
+
+11. Fixes for CVE-2012-4024 and CVE-2012-4025.
+
+Compatiblity
+------------
+
+Mksquashfs 4.3 generates 4.0 filesystems. These filesystems are fully
+compatible/interchangable with filesystems generated by Mksquashfs 4.0 and are
+mountable on 2.6.29 and later kernels.
+
+Compressors
+-----------
+
+New compression options and compressors are now supported.
+
+The new options and compressors are:
+
+1. gzip
+ -Xcompression-level <compression-level>
+ <compression-level> should be 1 .. 9 (default 9)
+ -Xwindow-size <window-size>
+ <window-size> should be 8 .. 15 (default 15)
+ -Xstrategy strategy1,strategy2,...,strategyN
+ Compress using strategy1,strategy2,...,strategyN in turn
+ and choose the best compression.
+ Available strategies: default, filtered, huffman_only,
+ run_length_encoded and fixed
+
+2. lzo
+ -Xalgorithm <algorithm>
+ Where <algorithm> is one of:
+ lzo1x_1
+ lzo1x_1_11
+ lzo1x_1_12
+ lzo1x_1_15
+ lzo1x_999 (default)
+ -Xcompression-level <compression-level>
+ <compression-level> should be 1 .. 9 (default 8)
+ Only applies to lzo1x_999 algorithm
+
+3. lz4
+ -Xhc
+ Compress using LZ4 High Compression
+
+The compression specific options are, obviously, specific to the compressor
+in question, and you should read the compressor documentation and check
+their web sites to understand their behaviour.
+
+In general the defaults used by Mksquashfs for each compressor are optimised
+to give the best performance for each compressor, where what constitutes
+best depends on the compressor. For gzip/xz best means highest compression
+(trying multiple filters/strategies can improve compression, but this is
+extremely expensive computationally, and hence, not suitable for the defaults),
+for LZO/LZ4 best means a tradeoff between compression and (de)-compression
+overhead (LZO/LZ4 by definition are intended for weaker processors).
+
+New Mksquashfs options
+----------------------
+
+1. -mem <size>
+
+ Set the amount of memory used by Mksquashfs to <size> bytes. G/M and K
+ post-fixes are supported.
+
+ By default Mksquashfs uses 25% of the physical memory. Increasing
+ this with the -mem option can increase performance (note it does not have
+ any effect on compression). Reducing it can prevent thrashing if the
+ system is busy and there is not 25% of physical memory free (again, note
+ it does not have any effect on compression).
+
+2. -exit-on-error
+
+ By default Mksquashfs treats certain errors as benign, if these
+ errors occur Mksquashfs prints the error on the console but continues.
+ These errors are typically failure to read a file from the source filesystem.
+ This is deliberate, in many cases users prefer Mksquashfs to flag
+ the error but continue rather than abort what may be hours of compression.
+
+ But there are times where failure to read any file is considered critical,
+ and users (especially in the case of automated scripts where the
+ errors output to the console may be missed) prefer Mksquashfs to exit.
+
+ The new -exit-on-error option can be used in this scenario. This option
+ makes Mksquashfs treat all benign errors as fatal.
+
+3. -progress
+
+ By default if -info is specified, the progress bar is disabled as it gets
+ in the way. Occasionally you might want the progress bar enabled whilst
+ -info is enabled. This option forces Mksquashfs to output the progress
+ bar when -info is specified.
+
+4. -Xhelp
+
+ Display the usage text for the currently selected compressor.
+
+New Unsquashfs options
+----------------------
+
+1. -u[ser-xattrs]
+
+ Only write user xattrs. This forces Unsquashfs to ignore system xattrs.
+ This is useful when Unsquashing a filesystem as a non-root user, and the
+ filesystem contains system xattrs which are only writable by root.
+
+Major bugs fixed
+----------------
+
+1. If Mksquashfs ran out of space in the destination filesystem, this
+ would not cause Mksquashfs to immediately abort, and Mksquashfs would
+ continue to process the source filesystem. Mksquashfs now immediately
+ aborts on out of space in the destination filesystem.
+
+2. Unsquashfs ignored the maximum number of open files limit, and if that
+ was lower than the default limit for Linux, it would run out of file
+ descriptors. Unsquashfs now limits the number of open files to the
+ limit currently in force (e.g. specified by setrlimit).
+
+3. If huge numbers of dynamic pseudo files were specified, Mksquashfs
+ could exceed the maximum number of open files limit. This was because
+ Mksquashfs created all the dynamic file processes up front before
+ commencing source filesystem reading and compression. Mksquashfs
+ now creates the dynamic file processes on demand whilst reading
+ and compressing the source filesystem, thus limiting the number of
+ dynamic pseudo file processes in existence at any one time.
+
+4. When outputting Unsquashfs used to set the permissions of directories
+ as it recursively descended. This in hindsight had an obvious oversight,
+ if a directory had only read permission (or was otherwise restricted), then
+ Unsquashfs would fail to write its contents when descending into it. Fixed
+ by setting directory permissions as Unsquashfs recursively unwinds.
diff --git a/squashfs-tools/RELEASE-READMEs/pseudo-file.example b/squashfs-tools/RELEASE-READMEs/pseudo-file.example
new file mode 100644
index 0000000..f866d90
--- /dev/null
+++ b/squashfs-tools/RELEASE-READMEs/pseudo-file.example
@@ -0,0 +1,74 @@
+# Pseudo file example
+
+# Mksquashfs supports pseudo files, these allow fake files, directories,
+# character and block devices to be specified and added to the Squashfs
+# filesystem being built, rather than requiring them to be present in the
+# source directories.
+#
+# This, for example, allows device nodes to be added to the filesystem without
+# requiring root access.
+
+# Mksquashfs 4.1 adds support for "dynamic pseudo files" and a modify operation.
+# Dynamic pseudo files allow files to be dynamically created when Mksquashfs
+# is run, their contents being the result of running a command or piece of
+# shell script. The modifiy operation allows the mode/uid/gid of an existing
+# file in the source filesystem to be modified.
+
+# Two Mksquashfs options are supported, -p allows one pseudo file to be
+# specified #on the command line, and -pf allows a pseudo file to be specified
+# containing a list of pseduo definitions, one per line.
+
+# Pseudo file examples
+# Run mkquashfs . /tmp/img -pf pseudo-file.examples
+# to see their effect
+
+# Creating dynamic file examples
+
+# Create a file "dmesg" containing the output from dmesg.
+dmesg f 444 root root dmesg
+
+
+# Create a file RELEASE containing the release name, date, build host, and
+# an incrementing version number. The incrementing version is a side-effect
+# of executing the shell script, and ensures every time Mksquashfs is run a
+# new version number is used without requiring any other shell scripting.
+RELEASE f 444 root root \
+ if [ ! -e /tmp/ver ]; then \
+ echo 0 > /tmp/ver; \
+ fi; \
+ ver=`cat /tmp/ver`; \
+ ver=$((ver +1)); \
+ echo $ver > /tmp/ver; \
+ echo -n "release x.x"; \
+ echo "-dev #"$ver `date` "Build host" `hostname`
+
+
+# Copy 10K from the device /dev/sda1 into the file input. Ordinarily
+# Mksquashfs given a device, fifo, or named socket will place that special file
+# within the Squashfs filesystem, this allows input from these special
+# files to be captured and placed in the Squashfs filesystem.
+input f 444 root root dd if=/dev/sda1 bs=1024 count=10
+
+
+# Creating a block or character device examples
+
+# Create a character device "chr_dev" with major:minor 100:1 and
+# a block device "blk_dev" with major:minor 200:200, both with root
+# uid/gid and a mode of rw-rw-rw.
+chr_dev c 666 root root 100 1
+blk_dev b 666 0 0 200 200
+
+
+# Creating a directory example
+
+# create a directory "pseudo_dir" with root uid/gid and mode of r--r--r--.
+pseudo_dir d 444 root root
+
+
+# Modifying attributes of an existing file exmaple
+
+# Change the attributes of the file "INSTALL" in the filesystem to have
+# root uid/gid and a mode of rw-rw-rw, overriding the attributes obtained
+# from the source filesystem.
+INSTALL m 666 root root
+
diff --git a/squashfs-tools/kernel-2.4/fs/squashfs/Makefile b/squashfs-tools/kernel-2.4/fs/squashfs/Makefile
new file mode 100644
index 0000000..0965287
--- /dev/null
+++ b/squashfs-tools/kernel-2.4/fs/squashfs/Makefile
@@ -0,0 +1,11 @@
+#
+# Makefile for the linux squashfs routines.
+#
+
+O_TARGET := squashfs.o
+
+obj-y := inode.o squashfs2_0.o
+
+obj-m := $(O_TARGET)
+
+include $(TOPDIR)/Rules.make
diff --git a/squashfs-tools/kernel-2.4/fs/squashfs/inode.c b/squashfs-tools/kernel-2.4/fs/squashfs/inode.c
new file mode 100755
index 0000000..54061f6
--- /dev/null
+++ b/squashfs-tools/kernel-2.4/fs/squashfs/inode.c
@@ -0,0 +1,2029 @@
+/*
+ * Squashfs - a compressed read only filesystem for Linux
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006
+ * Phillip Lougher <phillip@lougher.demon.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * inode.c
+ */
+
+#include <linux/types.h>
+#include <linux/squashfs_fs.h>
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/slab.h>
+#include <linux/zlib.h>
+#include <linux/fs.h>
+#include <linux/smp_lock.h>
+#include <linux/locks.h>
+#include <linux/init.h>
+#include <linux/dcache.h>
+#include <linux/wait.h>
+#include <linux/blkdev.h>
+#include <linux/vmalloc.h>
+#include <asm/uaccess.h>
+#include <asm/semaphore.h>
+
+#include "squashfs.h"
+
+static struct super_block *squashfs_read_super(struct super_block *, void *, int);
+static void squashfs_put_super(struct super_block *);
+static int squashfs_statfs(struct super_block *, struct statfs *);
+static int squashfs_symlink_readpage(struct file *file, struct page *page);
+static int squashfs_readpage(struct file *file, struct page *page);
+static int squashfs_readpage4K(struct file *file, struct page *page);
+static int squashfs_readdir(struct file *, void *, filldir_t);
+static struct dentry *squashfs_lookup(struct inode *, struct dentry *);
+static struct inode *squashfs_iget(struct super_block *s, squashfs_inode_t inode);
+static long long read_blocklist(struct inode *inode, int index,
+ int readahead_blks, char *block_list,
+ unsigned short **block_p, unsigned int *bsize);
+
+static DECLARE_FSTYPE_DEV(squashfs_fs_type, "squashfs", squashfs_read_super);
+
+static unsigned char squashfs_filetype_table[] = {
+ DT_UNKNOWN, DT_DIR, DT_REG, DT_LNK, DT_BLK, DT_CHR, DT_FIFO, DT_SOCK
+};
+
+static struct super_operations squashfs_ops = {
+ .statfs = squashfs_statfs,
+ .put_super = squashfs_put_super,
+};
+
+SQSH_EXTERN struct address_space_operations squashfs_symlink_aops = {
+ .readpage = squashfs_symlink_readpage
+};
+
+SQSH_EXTERN struct address_space_operations squashfs_aops = {
+ .readpage = squashfs_readpage
+};
+
+SQSH_EXTERN struct address_space_operations squashfs_aops_4K = {
+ .readpage = squashfs_readpage4K
+};
+
+static struct file_operations squashfs_dir_ops = {
+ .read = generic_read_dir,
+ .readdir = squashfs_readdir
+};
+
+static struct inode_operations squashfs_dir_inode_ops = {
+ .lookup = squashfs_lookup
+};
+
+static struct buffer_head *get_block_length(struct super_block *s,
+ int *cur_index, int *offset, int *c_byte)
+{
+ struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
+ unsigned short temp;
+ struct buffer_head *bh;
+
+ if (!(bh = sb_bread(s, *cur_index)))
+ goto out;
+
+ if (msblk->devblksize - *offset == 1) {
+ if (msblk->swap)
+ ((unsigned char *) &temp)[1] = *((unsigned char *)
+ (bh->b_data + *offset));
+ else
+ ((unsigned char *) &temp)[0] = *((unsigned char *)
+ (bh->b_data + *offset));
+ brelse(bh);
+ if (!(bh = sb_bread(s, ++(*cur_index))))
+ goto out;
+ if (msblk->swap)
+ ((unsigned char *) &temp)[0] = *((unsigned char *)
+ bh->b_data);
+ else
+ ((unsigned char *) &temp)[1] = *((unsigned char *)
+ bh->b_data);
+ *c_byte = temp;
+ *offset = 1;
+ } else {
+ if (msblk->swap) {
+ ((unsigned char *) &temp)[1] = *((unsigned char *)
+ (bh->b_data + *offset));
+ ((unsigned char *) &temp)[0] = *((unsigned char *)
+ (bh->b_data + *offset + 1));
+ } else {
+ ((unsigned char *) &temp)[0] = *((unsigned char *)
+ (bh->b_data + *offset));
+ ((unsigned char *) &temp)[1] = *((unsigned char *)
+ (bh->b_data + *offset + 1));
+ }
+ *c_byte = temp;
+ *offset += 2;
+ }
+
+ if (SQUASHFS_CHECK_DATA(msblk->sblk.flags)) {
+ if (*offset == msblk->devblksize) {
+ brelse(bh);
+ if (!(bh = sb_bread(s, ++(*cur_index))))
+ goto out;
+ *offset = 0;
+ }
+ if (*((unsigned char *) (bh->b_data + *offset)) !=
+ SQUASHFS_MARKER_BYTE) {
+ ERROR("Metadata block marker corrupt @ %x\n",
+ *cur_index);
+ brelse(bh);
+ goto out;
+ }
+ (*offset)++;
+ }
+ return bh;
+
+out:
+ return NULL;
+}
+
+
+SQSH_EXTERN unsigned int squashfs_read_data(struct super_block *s, char *buffer,
+ long long index, unsigned int length,
+ long long *next_index)
+{
+ struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
+ struct buffer_head *bh[((SQUASHFS_FILE_MAX_SIZE - 1) >>
+ msblk->devblksize_log2) + 2];
+ unsigned int offset = index & ((1 << msblk->devblksize_log2) - 1);
+ unsigned int cur_index = index >> msblk->devblksize_log2;
+ int bytes, avail_bytes, b = 0, k;
+ char *c_buffer;
+ unsigned int compressed;
+ unsigned int c_byte = length;
+
+ if (c_byte) {
+ bytes = msblk->devblksize - offset;
+ compressed = SQUASHFS_COMPRESSED_BLOCK(c_byte);
+ c_buffer = compressed ? msblk->read_data : buffer;
+ c_byte = SQUASHFS_COMPRESSED_SIZE_BLOCK(c_byte);
+
+ TRACE("Block @ 0x%llx, %scompressed size %d\n", index, compressed
+ ? "" : "un", (unsigned int) c_byte);
+
+ if (!(bh[0] = sb_getblk(s, cur_index)))
+ goto block_release;
+
+ for (b = 1; bytes < c_byte; b++) {
+ if (!(bh[b] = sb_getblk(s, ++cur_index)))
+ goto block_release;
+ bytes += msblk->devblksize;
+ }
+ ll_rw_block(READ, b, bh);
+ } else {
+ if (!(bh[0] = get_block_length(s, &cur_index, &offset,
+ &c_byte)))
+ goto read_failure;
+
+ bytes = msblk->devblksize - offset;
+ compressed = SQUASHFS_COMPRESSED(c_byte);
+ c_buffer = compressed ? msblk->read_data : buffer;
+ c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte);
+
+ TRACE("Block @ 0x%llx, %scompressed size %d\n", index, compressed
+ ? "" : "un", (unsigned int) c_byte);
+
+ for (b = 1; bytes < c_byte; b++) {
+ if (!(bh[b] = sb_getblk(s, ++cur_index)))
+ goto block_release;
+ bytes += msblk->devblksize;
+ }
+ ll_rw_block(READ, b - 1, bh + 1);
+ }
+
+ if (compressed)
+ down(&msblk->read_data_mutex);
+
+ for (bytes = 0, k = 0; k < b; k++) {
+ avail_bytes = (c_byte - bytes) > (msblk->devblksize - offset) ?
+ msblk->devblksize - offset :
+ c_byte - bytes;
+ wait_on_buffer(bh[k]);
+ if (!buffer_uptodate(bh[k]))
+ goto block_release;
+ memcpy(c_buffer + bytes, bh[k]->b_data + offset, avail_bytes);
+ bytes += avail_bytes;
+ offset = 0;
+ brelse(bh[k]);
+ }
+
+ /*
+ * uncompress block
+ */
+ if (compressed) {
+ int zlib_err;
+
+ msblk->stream.next_in = c_buffer;
+ msblk->stream.avail_in = c_byte;
+ msblk->stream.next_out = buffer;
+ msblk->stream.avail_out = msblk->read_size;
+
+ if (((zlib_err = zlib_inflateInit(&msblk->stream)) != Z_OK) ||
+ ((zlib_err = zlib_inflate(&msblk->stream, Z_FINISH))
+ != Z_STREAM_END) || ((zlib_err =
+ zlib_inflateEnd(&msblk->stream)) != Z_OK)) {
+ ERROR("zlib_fs returned unexpected result 0x%x\n",
+ zlib_err);
+ bytes = 0;
+ } else
+ bytes = msblk->stream.total_out;
+
+ up(&msblk->read_data_mutex);
+ }
+
+ if (next_index)
+ *next_index = index + c_byte + (length ? 0 :
+ (SQUASHFS_CHECK_DATA(msblk->sblk.flags)
+ ? 3 : 2));
+ return bytes;
+
+block_release:
+ while (--b >= 0)
+ brelse(bh[b]);
+
+read_failure:
+ ERROR("sb_bread failed reading block 0x%x\n", cur_index);
+ return 0;
+}
+
+
+SQSH_EXTERN int squashfs_get_cached_block(struct super_block *s, char *buffer,
+ long long block, unsigned int offset,
+ int length, long long *next_block,
+ unsigned int *next_offset)
+{
+ struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
+ int n, i, bytes, return_length = length;
+ long long next_index;
+
+ TRACE("Entered squashfs_get_cached_block [%llx:%x]\n", block, offset);
+
+ while ( 1 ) {
+ for (i = 0; i < SQUASHFS_CACHED_BLKS; i++)
+ if (msblk->block_cache[i].block == block)
+ break;
+
+ down(&msblk->block_cache_mutex);
+
+ if (i == SQUASHFS_CACHED_BLKS) {
+ /* read inode header block */
+ for (i = msblk->next_cache, n = SQUASHFS_CACHED_BLKS;
+ n ; n --, i = (i + 1) %
+ SQUASHFS_CACHED_BLKS)
+ if (msblk->block_cache[i].block !=
+ SQUASHFS_USED_BLK)
+ break;
+
+ if (n == 0) {
+ wait_queue_t wait;
+
+ init_waitqueue_entry(&wait, current);
+ add_wait_queue(&msblk->waitq, &wait);
+ set_current_state(TASK_UNINTERRUPTIBLE);
+ up(&msblk->block_cache_mutex);
+ schedule();
+ set_current_state(TASK_RUNNING);
+ remove_wait_queue(&msblk->waitq, &wait);
+ continue;
+ }
+ msblk->next_cache = (i + 1) % SQUASHFS_CACHED_BLKS;
+
+ if (msblk->block_cache[i].block ==
+ SQUASHFS_INVALID_BLK) {
+ if (!(msblk->block_cache[i].data =
+ kmalloc(SQUASHFS_METADATA_SIZE,
+ GFP_KERNEL))) {
+ ERROR("Failed to allocate cache"
+ "block\n");
+ up(&msblk->block_cache_mutex);
+ goto out;
+ }
+ }
+
+ msblk->block_cache[i].block = SQUASHFS_USED_BLK;
+ up(&msblk->block_cache_mutex);
+
+ if (!(msblk->block_cache[i].length =
+ squashfs_read_data(s,
+ msblk->block_cache[i].data,
+ block, 0, &next_index))) {
+ ERROR("Unable to read cache block [%llx:%x]\n",
+ block, offset);
+ goto out;
+ }
+
+ down(&msblk->block_cache_mutex);
+ wake_up(&msblk->waitq);
+ msblk->block_cache[i].block = block;
+ msblk->block_cache[i].next_index = next_index;
+ TRACE("Read cache block [%llx:%x]\n", block, offset);
+ }
+
+ if (msblk->block_cache[i].block != block) {
+ up(&msblk->block_cache_mutex);
+ continue;
+ }
+
+ if ((bytes = msblk->block_cache[i].length - offset) >= length) {
+ if (buffer)
+ memcpy(buffer, msblk->block_cache[i].data +
+ offset, length);
+ if (msblk->block_cache[i].length - offset == length) {
+ *next_block = msblk->block_cache[i].next_index;
+ *next_offset = 0;
+ } else {
+ *next_block = block;
+ *next_offset = offset + length;
+ }
+ up(&msblk->block_cache_mutex);
+ goto finish;
+ } else {
+ if (buffer) {
+ memcpy(buffer, msblk->block_cache[i].data +
+ offset, bytes);
+ buffer += bytes;
+ }
+ block = msblk->block_cache[i].next_index;
+ up(&msblk->block_cache_mutex);
+ length -= bytes;
+ offset = 0;
+ }
+ }
+
+finish:
+ return return_length;
+out:
+ return 0;
+}
+
+
+static int get_fragment_location(struct super_block *s, unsigned int fragment,
+ long long *fragment_start_block,
+ unsigned int *fragment_size)
+{
+ struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
+ long long start_block =
+ msblk->fragment_index[SQUASHFS_FRAGMENT_INDEX(fragment)];
+ int offset = SQUASHFS_FRAGMENT_INDEX_OFFSET(fragment);
+ struct squashfs_fragment_entry fragment_entry;
+
+ if (msblk->swap) {
+ struct squashfs_fragment_entry sfragment_entry;
+
+ if (!squashfs_get_cached_block(s, (char *) &sfragment_entry,
+ start_block, offset,
+ sizeof(sfragment_entry), &start_block,
+ &offset))
+ goto out;
+ SQUASHFS_SWAP_FRAGMENT_ENTRY(&fragment_entry, &sfragment_entry);
+ } else
+ if (!squashfs_get_cached_block(s, (char *) &fragment_entry,
+ start_block, offset,
+ sizeof(fragment_entry), &start_block,
+ &offset))
+ goto out;
+
+ *fragment_start_block = fragment_entry.start_block;
+ *fragment_size = fragment_entry.size;
+
+ return 1;
+
+out:
+ return 0;
+}
+
+
+SQSH_EXTERN void release_cached_fragment(struct squashfs_sb_info *msblk, struct
+ squashfs_fragment_cache *fragment)
+{
+ down(&msblk->fragment_mutex);
+ fragment->locked --;
+ wake_up(&msblk->fragment_wait_queue);
+ up(&msblk->fragment_mutex);
+}
+
+
+SQSH_EXTERN struct squashfs_fragment_cache *get_cached_fragment(struct super_block
+ *s, long long start_block,
+ int length)
+{
+ int i, n;
+ struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
+
+ while ( 1 ) {
+ down(&msblk->fragment_mutex);
+
+ for (i = 0; i < SQUASHFS_CACHED_FRAGMENTS &&
+ msblk->fragment[i].block != start_block; i++);
+
+ if (i == SQUASHFS_CACHED_FRAGMENTS) {
+ for (i = msblk->next_fragment, n =
+ SQUASHFS_CACHED_FRAGMENTS; n &&
+ msblk->fragment[i].locked; n--, i = (i + 1) %
+ SQUASHFS_CACHED_FRAGMENTS);
+
+ if (n == 0) {
+ wait_queue_t wait;
+
+ init_waitqueue_entry(&wait, current);
+ add_wait_queue(&msblk->fragment_wait_queue,
+ &wait);
+ set_current_state(TASK_UNINTERRUPTIBLE);
+ up(&msblk->fragment_mutex);
+ schedule();
+ set_current_state(TASK_RUNNING);
+ remove_wait_queue(&msblk->fragment_wait_queue,
+ &wait);
+ continue;
+ }
+ msblk->next_fragment = (msblk->next_fragment + 1) %
+ SQUASHFS_CACHED_FRAGMENTS;
+
+ if (msblk->fragment[i].data == NULL)
+ if (!(msblk->fragment[i].data = SQUASHFS_ALLOC
+ (SQUASHFS_FILE_MAX_SIZE))) {
+ ERROR("Failed to allocate fragment "
+ "cache block\n");
+ up(&msblk->fragment_mutex);
+ goto out;
+ }
+
+ msblk->fragment[i].block = SQUASHFS_INVALID_BLK;
+ msblk->fragment[i].locked = 1;
+ up(&msblk->fragment_mutex);
+
+ if (!(msblk->fragment[i].length = squashfs_read_data(s,
+ msblk->fragment[i].data,
+ start_block, length, NULL))) {
+ ERROR("Unable to read fragment cache block "
+ "[%llx]\n", start_block);
+ msblk->fragment[i].locked = 0;
+ goto out;
+ }
+
+ msblk->fragment[i].block = start_block;
+ TRACE("New fragment %d, start block %lld, locked %d\n",
+ i, msblk->fragment[i].block,
+ msblk->fragment[i].locked);
+ break;
+ }
+
+ msblk->fragment[i].locked++;
+ up(&msblk->fragment_mutex);
+ TRACE("Got fragment %d, start block %lld, locked %d\n", i,
+ msblk->fragment[i].block,
+ msblk->fragment[i].locked);
+ break;
+ }
+
+ return &msblk->fragment[i];
+
+out:
+ return NULL;
+}
+
+
+static struct inode *squashfs_new_inode(struct super_block *s,
+ struct squashfs_base_inode_header *inodeb)
+{
+ struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
+ struct inode *i = new_inode(s);
+
+ if (i) {
+ i->i_ino = inodeb->inode_number;
+ i->i_mtime = inodeb->mtime;
+ i->i_atime = inodeb->mtime;
+ i->i_ctime = inodeb->mtime;
+ i->i_uid = msblk->uid[inodeb->uid];
+ i->i_mode = inodeb->mode;
+ i->i_size = 0;
+ if (inodeb->guid == SQUASHFS_GUIDS)
+ i->i_gid = i->i_uid;
+ else
+ i->i_gid = msblk->guid[inodeb->guid];
+ }
+
+ return i;
+}
+
+
+static struct inode *squashfs_iget(struct super_block *s, squashfs_inode_t inode)
+{
+ struct inode *i;
+ struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
+ struct squashfs_super_block *sblk = &msblk->sblk;
+ long long block = SQUASHFS_INODE_BLK(inode) +
+ sblk->inode_table_start;
+ unsigned int offset = SQUASHFS_INODE_OFFSET(inode);
+ long long next_block;
+ unsigned int next_offset;
+ union squashfs_inode_header id, sid;
+ struct squashfs_base_inode_header *inodeb = &id.base,
+ *sinodeb = &sid.base;
+
+ TRACE("Entered squashfs_iget\n");
+
+ if (msblk->swap) {
+ if (!squashfs_get_cached_block(s, (char *) sinodeb, block,
+ offset, sizeof(*sinodeb), &next_block,
+ &next_offset))
+ goto failed_read;
+ SQUASHFS_SWAP_BASE_INODE_HEADER(inodeb, sinodeb,
+ sizeof(*sinodeb));
+ } else
+ if (!squashfs_get_cached_block(s, (char *) inodeb, block,
+ offset, sizeof(*inodeb), &next_block,
+ &next_offset))
+ goto failed_read;
+
+ switch(inodeb->inode_type) {
+ case SQUASHFS_FILE_TYPE: {
+ unsigned int frag_size;
+ long long frag_blk;
+ struct squashfs_reg_inode_header *inodep = &id.reg;
+ struct squashfs_reg_inode_header *sinodep = &sid.reg;
+
+ if (msblk->swap) {
+ if (!squashfs_get_cached_block(s, (char *)
+ sinodep, block, offset,
+ sizeof(*sinodep), &next_block,
+ &next_offset))
+ goto failed_read;
+ SQUASHFS_SWAP_REG_INODE_HEADER(inodep, sinodep);
+ } else
+ if (!squashfs_get_cached_block(s, (char *)
+ inodep, block, offset,
+ sizeof(*inodep), &next_block,
+ &next_offset))
+ goto failed_read;
+
+ frag_blk = SQUASHFS_INVALID_BLK;
+ if (inodep->fragment != SQUASHFS_INVALID_FRAG &&
+ !get_fragment_location(s,
+ inodep->fragment, &frag_blk, &frag_size))
+ goto failed_read;
+
+ if((i = squashfs_new_inode(s, inodeb)) == NULL)
+ goto failed_read1;
+
+ i->i_nlink = 1;
+ i->i_size = inodep->file_size;
+ i->i_fop = &generic_ro_fops;
+ i->i_mode |= S_IFREG;
+ i->i_blocks = ((i->i_size - 1) >> 9) + 1;
+ i->i_blksize = PAGE_CACHE_SIZE;
+ SQUASHFS_I(i)->u.s1.fragment_start_block = frag_blk;
+ SQUASHFS_I(i)->u.s1.fragment_size = frag_size;
+ SQUASHFS_I(i)->u.s1.fragment_offset = inodep->offset;
+ SQUASHFS_I(i)->start_block = inodep->start_block;
+ SQUASHFS_I(i)->u.s1.block_list_start = next_block;
+ SQUASHFS_I(i)->offset = next_offset;
+ if (sblk->block_size > 4096)
+ i->i_data.a_ops = &squashfs_aops;
+ else
+ i->i_data.a_ops = &squashfs_aops_4K;
+
+ TRACE("File inode %x:%x, start_block %llx, "
+ "block_list_start %llx, offset %x\n",
+ SQUASHFS_INODE_BLK(inode), offset,
+ inodep->start_block, next_block,
+ next_offset);
+ break;
+ }
+ case SQUASHFS_LREG_TYPE: {
+ unsigned int frag_size;
+ long long frag_blk;
+ struct squashfs_lreg_inode_header *inodep = &id.lreg;
+ struct squashfs_lreg_inode_header *sinodep = &sid.lreg;
+
+ if (msblk->swap) {
+ if (!squashfs_get_cached_block(s, (char *)
+ sinodep, block, offset,
+ sizeof(*sinodep), &next_block,
+ &next_offset))
+ goto failed_read;
+ SQUASHFS_SWAP_LREG_INODE_HEADER(inodep, sinodep);
+ } else
+ if (!squashfs_get_cached_block(s, (char *)
+ inodep, block, offset,
+ sizeof(*inodep), &next_block,
+ &next_offset))
+ goto failed_read;
+
+ frag_blk = SQUASHFS_INVALID_BLK;
+ if (inodep->fragment != SQUASHFS_INVALID_FRAG &&
+ !get_fragment_location(s,
+ inodep->fragment, &frag_blk, &frag_size))
+ goto failed_read;
+
+ if((i = squashfs_new_inode(s, inodeb)) == NULL)
+ goto failed_read1;
+
+ i->i_nlink = inodep->nlink;
+ i->i_size = inodep->file_size;
+ i->i_fop = &generic_ro_fops;
+ i->i_mode |= S_IFREG;
+ i->i_blocks = ((i->i_size - 1) >> 9) + 1;
+ i->i_blksize = PAGE_CACHE_SIZE;
+ SQUASHFS_I(i)->u.s1.fragment_start_block = frag_blk;
+ SQUASHFS_I(i)->u.s1.fragment_size = frag_size;
+ SQUASHFS_I(i)->u.s1.fragment_offset = inodep->offset;
+ SQUASHFS_I(i)->start_block = inodep->start_block;
+ SQUASHFS_I(i)->u.s1.block_list_start = next_block;
+ SQUASHFS_I(i)->offset = next_offset;
+ if (sblk->block_size > 4096)
+ i->i_data.a_ops = &squashfs_aops;
+ else
+ i->i_data.a_ops = &squashfs_aops_4K;
+
+ TRACE("File inode %x:%x, start_block %llx, "
+ "block_list_start %llx, offset %x\n",
+ SQUASHFS_INODE_BLK(inode), offset,
+ inodep->start_block, next_block,
+ next_offset);
+ break;
+ }
+ case SQUASHFS_DIR_TYPE: {
+ struct squashfs_dir_inode_header *inodep = &id.dir;
+ struct squashfs_dir_inode_header *sinodep = &sid.dir;
+
+ if (msblk->swap) {
+ if (!squashfs_get_cached_block(s, (char *)
+ sinodep, block, offset,
+ sizeof(*sinodep), &next_block,
+ &next_offset))
+ goto failed_read;
+ SQUASHFS_SWAP_DIR_INODE_HEADER(inodep, sinodep);
+ } else
+ if (!squashfs_get_cached_block(s, (char *)
+ inodep, block, offset,
+ sizeof(*inodep), &next_block,
+ &next_offset))
+ goto failed_read;
+
+ if((i = squashfs_new_inode(s, inodeb)) == NULL)
+ goto failed_read1;
+
+ i->i_nlink = inodep->nlink;
+ i->i_size = inodep->file_size;
+ i->i_op = &squashfs_dir_inode_ops;
+ i->i_fop = &squashfs_dir_ops;
+ i->i_mode |= S_IFDIR;
+ SQUASHFS_I(i)->start_block = inodep->start_block;
+ SQUASHFS_I(i)->offset = inodep->offset;
+ SQUASHFS_I(i)->u.s2.directory_index_count = 0;
+ SQUASHFS_I(i)->u.s2.parent_inode = inodep->parent_inode;
+
+ TRACE("Directory inode %x:%x, start_block %x, offset "
+ "%x\n", SQUASHFS_INODE_BLK(inode),
+ offset, inodep->start_block,
+ inodep->offset);
+ break;
+ }
+ case SQUASHFS_LDIR_TYPE: {
+ struct squashfs_ldir_inode_header *inodep = &id.ldir;
+ struct squashfs_ldir_inode_header *sinodep = &sid.ldir;
+
+ if (msblk->swap) {
+ if (!squashfs_get_cached_block(s, (char *)
+ sinodep, block, offset,
+ sizeof(*sinodep), &next_block,
+ &next_offset))
+ goto failed_read;
+ SQUASHFS_SWAP_LDIR_INODE_HEADER(inodep,
+ sinodep);
+ } else
+ if (!squashfs_get_cached_block(s, (char *)
+ inodep, block, offset,
+ sizeof(*inodep), &next_block,
+ &next_offset))
+ goto failed_read;
+
+ if((i = squashfs_new_inode(s, inodeb)) == NULL)
+ goto failed_read1;
+
+ i->i_nlink = inodep->nlink;
+ i->i_size = inodep->file_size;
+ i->i_op = &squashfs_dir_inode_ops;
+ i->i_fop = &squashfs_dir_ops;
+ i->i_mode |= S_IFDIR;
+ SQUASHFS_I(i)->start_block = inodep->start_block;
+ SQUASHFS_I(i)->offset = inodep->offset;
+ SQUASHFS_I(i)->u.s2.directory_index_start = next_block;
+ SQUASHFS_I(i)->u.s2.directory_index_offset =
+ next_offset;
+ SQUASHFS_I(i)->u.s2.directory_index_count =
+ inodep->i_count;
+ SQUASHFS_I(i)->u.s2.parent_inode = inodep->parent_inode;
+
+ TRACE("Long directory inode %x:%x, start_block %x, "
+ "offset %x\n",
+ SQUASHFS_INODE_BLK(inode), offset,
+ inodep->start_block, inodep->offset);
+ break;
+ }
+ case SQUASHFS_SYMLINK_TYPE: {
+ struct squashfs_symlink_inode_header *inodep =
+ &id.symlink;
+ struct squashfs_symlink_inode_header *sinodep =
+ &sid.symlink;
+
+ if (msblk->swap) {
+ if (!squashfs_get_cached_block(s, (char *)
+ sinodep, block, offset,
+ sizeof(*sinodep), &next_block,
+ &next_offset))
+ goto failed_read;
+ SQUASHFS_SWAP_SYMLINK_INODE_HEADER(inodep,
+ sinodep);
+ } else
+ if (!squashfs_get_cached_block(s, (char *)
+ inodep, block, offset,
+ sizeof(*inodep), &next_block,
+ &next_offset))
+ goto failed_read;
+
+ if((i = squashfs_new_inode(s, inodeb)) == NULL)
+ goto failed_read1;
+
+ i->i_nlink = inodep->nlink;
+ i->i_size = inodep->symlink_size;
+ i->i_op = &page_symlink_inode_operations;
+ i->i_data.a_ops = &squashfs_symlink_aops;
+ i->i_mode |= S_IFLNK;
+ SQUASHFS_I(i)->start_block = next_block;
+ SQUASHFS_I(i)->offset = next_offset;
+
+ TRACE("Symbolic link inode %x:%x, start_block %llx, "
+ "offset %x\n",
+ SQUASHFS_INODE_BLK(inode), offset,
+ next_block, next_offset);
+ break;
+ }
+ case SQUASHFS_BLKDEV_TYPE:
+ case SQUASHFS_CHRDEV_TYPE: {
+ struct squashfs_dev_inode_header *inodep = &id.dev;
+ struct squashfs_dev_inode_header *sinodep = &sid.dev;
+
+ if (msblk->swap) {
+ if (!squashfs_get_cached_block(s, (char *)
+ sinodep, block, offset,
+ sizeof(*sinodep), &next_block,
+ &next_offset))
+ goto failed_read;
+ SQUASHFS_SWAP_DEV_INODE_HEADER(inodep, sinodep);
+ } else
+ if (!squashfs_get_cached_block(s, (char *)
+ inodep, block, offset,
+ sizeof(*inodep), &next_block,
+ &next_offset))
+ goto failed_read;
+
+ if ((i = squashfs_new_inode(s, inodeb)) == NULL)
+ goto failed_read1;
+
+ i->i_nlink = inodep->nlink;
+ i->i_mode |= (inodeb->inode_type ==
+ SQUASHFS_CHRDEV_TYPE) ? S_IFCHR :
+ S_IFBLK;
+ init_special_inode(i, i->i_mode, inodep->rdev);
+
+ TRACE("Device inode %x:%x, rdev %x\n",
+ SQUASHFS_INODE_BLK(inode), offset,
+ inodep->rdev);
+ break;
+ }
+ case SQUASHFS_FIFO_TYPE:
+ case SQUASHFS_SOCKET_TYPE: {
+ struct squashfs_ipc_inode_header *inodep = &id.ipc;
+ struct squashfs_ipc_inode_header *sinodep = &sid.ipc;
+
+ if (msblk->swap) {
+ if (!squashfs_get_cached_block(s, (char *)
+ sinodep, block, offset,
+ sizeof(*sinodep), &next_block,
+ &next_offset))
+ goto failed_read;
+ SQUASHFS_SWAP_IPC_INODE_HEADER(inodep, sinodep);
+ } else
+ if (!squashfs_get_cached_block(s, (char *)
+ inodep, block, offset,
+ sizeof(*inodep), &next_block,
+ &next_offset))
+ goto failed_read;
+
+ if ((i = squashfs_new_inode(s, inodeb)) == NULL)
+ goto failed_read1;
+
+ i->i_nlink = inodep->nlink;
+ i->i_mode |= (inodeb->inode_type == SQUASHFS_FIFO_TYPE)
+ ? S_IFIFO : S_IFSOCK;
+ init_special_inode(i, i->i_mode, 0);
+ break;
+ }
+ default:
+ ERROR("Unknown inode type %d in squashfs_iget!\n",
+ inodeb->inode_type);
+ goto failed_read1;
+ }
+
+ insert_inode_hash(i);
+ return i;
+
+failed_read:
+ ERROR("Unable to read inode [%llx:%x]\n", block, offset);
+
+failed_read1:
+ return NULL;
+}
+
+
+int read_fragment_index_table(struct super_block *s)
+{
+ struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
+ struct squashfs_super_block *sblk = &msblk->sblk;
+
+ if (!(msblk->fragment_index = kmalloc(SQUASHFS_FRAGMENT_INDEX_BYTES
+ (sblk->fragments), GFP_KERNEL))) {
+ ERROR("Failed to allocate uid/gid table\n");
+ return 0;
+ }
+
+ if (SQUASHFS_FRAGMENT_INDEX_BYTES(sblk->fragments) &&
+ !squashfs_read_data(s, (char *)
+ msblk->fragment_index,
+ sblk->fragment_table_start,
+ SQUASHFS_FRAGMENT_INDEX_BYTES
+ (sblk->fragments) |
+ SQUASHFS_COMPRESSED_BIT_BLOCK, NULL)) {
+ ERROR("unable to read fragment index table\n");
+ return 0;
+ }
+
+ if (msblk->swap) {
+ int i;
+ long long fragment;
+
+ for (i = 0; i < SQUASHFS_FRAGMENT_INDEXES(sblk->fragments);
+ i++) {
+ SQUASHFS_SWAP_FRAGMENT_INDEXES((&fragment),
+ &msblk->fragment_index[i], 1);
+ msblk->fragment_index[i] = fragment;
+ }
+ }
+
+ return 1;
+}
+
+
+static int supported_squashfs_filesystem(struct squashfs_sb_info *msblk, int silent)
+{
+ struct squashfs_super_block *sblk = &msblk->sblk;
+
+ msblk->iget = squashfs_iget;
+ msblk->read_blocklist = read_blocklist;
+ msblk->read_fragment_index_table = read_fragment_index_table;
+
+ if (sblk->s_major == 1) {
+ if (!squashfs_1_0_supported(msblk)) {
+ SERROR("Major/Minor mismatch, Squashfs 1.0 filesystems "
+ "are unsupported\n");
+ SERROR("Please recompile with "
+ "Squashfs 1.0 support enabled\n");
+ return 0;
+ }
+ } else if (sblk->s_major == 2) {
+ if (!squashfs_2_0_supported(msblk)) {
+ SERROR("Major/Minor mismatch, Squashfs 2.0 filesystems "
+ "are unsupported\n");
+ SERROR("Please recompile with "
+ "Squashfs 2.0 support enabled\n");
+ return 0;
+ }
+ } else if(sblk->s_major != SQUASHFS_MAJOR || sblk->s_minor >
+ SQUASHFS_MINOR) {
+ SERROR("Major/Minor mismatch, trying to mount newer %d.%d "
+ "filesystem\n", sblk->s_major, sblk->s_minor);
+ SERROR("Please update your kernel\n");
+ return 0;
+ }
+
+ return 1;
+}
+
+
+static struct super_block *squashfs_read_super(struct super_block *s,
+ void *data, int silent)
+{
+ kdev_t dev = s->s_dev;
+ struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
+ struct squashfs_super_block *sblk = &msblk->sblk;
+ int i;
+ struct inode *root;
+
+ if (!(msblk->stream.workspace = vmalloc(zlib_inflate_workspacesize()))) {
+ ERROR("Failed to allocate zlib workspace\n");
+ goto failed_mount;
+ }
+
+ msblk->devblksize = get_hardsect_size(dev);
+ if(msblk->devblksize < BLOCK_SIZE)
+ msblk->devblksize = BLOCK_SIZE;
+ msblk->devblksize_log2 = ffz(~msblk->devblksize);
+ set_blocksize(dev, msblk->devblksize);
+ s->s_blocksize = msblk->devblksize;
+ s->s_blocksize_bits = msblk->devblksize_log2;
+
+ init_MUTEX(&msblk->read_data_mutex);
+ init_MUTEX(&msblk->read_page_mutex);
+ init_MUTEX(&msblk->block_cache_mutex);
+ init_MUTEX(&msblk->fragment_mutex);
+
+ init_waitqueue_head(&msblk->waitq);
+ init_waitqueue_head(&msblk->fragment_wait_queue);
+
+ if (!squashfs_read_data(s, (char *) sblk, SQUASHFS_START,
+ sizeof(struct squashfs_super_block) |
+ SQUASHFS_COMPRESSED_BIT_BLOCK, NULL)) {
+ SERROR("unable to read superblock\n");
+ goto failed_mount;
+ }
+
+ /* Check it is a SQUASHFS superblock */
+ msblk->swap = 0;
+ if ((s->s_magic = sblk->s_magic) != SQUASHFS_MAGIC) {
+ if (sblk->s_magic == SQUASHFS_MAGIC_SWAP) {
+ struct squashfs_super_block ssblk;
+
+ WARNING("Mounting a different endian SQUASHFS "
+ "filesystem on %s\n", bdevname(dev));
+
+ SQUASHFS_SWAP_SUPER_BLOCK(&ssblk, sblk);
+ memcpy(sblk, &ssblk, sizeof(struct squashfs_super_block));
+ msblk->swap = 1;
+ } else {
+ SERROR("Can't find a SQUASHFS superblock on %s\n",
+ bdevname(dev));
+ goto failed_mount;
+ }
+ }
+
+ /* Check the MAJOR & MINOR versions */
+ if(!supported_squashfs_filesystem(msblk, silent))
+ goto failed_mount;
+
+ TRACE("Found valid superblock on %s\n", bdevname(dev));
+ TRACE("Inodes are %scompressed\n",
+ SQUASHFS_UNCOMPRESSED_INODES
+ (sblk->flags) ? "un" : "");
+ TRACE("Data is %scompressed\n",
+ SQUASHFS_UNCOMPRESSED_DATA(sblk->flags)
+ ? "un" : "");
+ TRACE("Check data is %s present in the filesystem\n",
+ SQUASHFS_CHECK_DATA(sblk->flags) ?
+ "" : "not");
+ TRACE("Filesystem size %lld bytes\n", sblk->bytes_used);
+ TRACE("Block size %d\n", sblk->block_size);
+ TRACE("Number of inodes %d\n", sblk->inodes);
+ if (sblk->s_major > 1)
+ TRACE("Number of fragments %d\n", sblk->fragments);
+ TRACE("Number of uids %d\n", sblk->no_uids);
+ TRACE("Number of gids %d\n", sblk->no_guids);
+ TRACE("sblk->inode_table_start %llx\n", sblk->inode_table_start);
+ TRACE("sblk->directory_table_start %llx\n", sblk->directory_table_start);
+ if (sblk->s_major > 1)
+ TRACE("sblk->fragment_table_start %llx\n",
+ sblk->fragment_table_start);
+ TRACE("sblk->uid_start %llx\n", sblk->uid_start);
+
+ s->s_flags |= MS_RDONLY;
+ s->s_op = &squashfs_ops;
+
+ /* Init inode_table block pointer array */
+ if (!(msblk->block_cache = kmalloc(sizeof(struct squashfs_cache) *
+ SQUASHFS_CACHED_BLKS, GFP_KERNEL))) {
+ ERROR("Failed to allocate block cache\n");
+ goto failed_mount;
+ }
+
+ for (i = 0; i < SQUASHFS_CACHED_BLKS; i++)
+ msblk->block_cache[i].block = SQUASHFS_INVALID_BLK;
+
+ msblk->next_cache = 0;
+
+ /* Allocate read_data block */
+ msblk->read_size = (sblk->block_size < SQUASHFS_METADATA_SIZE) ?
+ SQUASHFS_METADATA_SIZE :
+ sblk->block_size;
+
+ if (!(msblk->read_data = kmalloc(msblk->read_size, GFP_KERNEL))) {
+ ERROR("Failed to allocate read_data block\n");
+ goto failed_mount;
+ }
+
+ /* Allocate read_page block */
+ if (!(msblk->read_page = kmalloc(sblk->block_size, GFP_KERNEL))) {
+ ERROR("Failed to allocate read_page block\n");
+ goto failed_mount;
+ }
+
+ /* Allocate uid and gid tables */
+ if (!(msblk->uid = kmalloc((sblk->no_uids + sblk->no_guids) *
+ sizeof(unsigned int), GFP_KERNEL))) {
+ ERROR("Failed to allocate uid/gid table\n");
+ goto failed_mount;
+ }
+ msblk->guid = msblk->uid + sblk->no_uids;
+
+ if (msblk->swap) {
+ unsigned int suid[sblk->no_uids + sblk->no_guids];
+
+ if (!squashfs_read_data(s, (char *) &suid, sblk->uid_start,
+ ((sblk->no_uids + sblk->no_guids) *
+ sizeof(unsigned int)) |
+ SQUASHFS_COMPRESSED_BIT_BLOCK, NULL)) {
+ ERROR("unable to read uid/gid table\n");
+ goto failed_mount;
+ }
+
+ SQUASHFS_SWAP_DATA(msblk->uid, suid, (sblk->no_uids +
+ sblk->no_guids), (sizeof(unsigned int) * 8));
+ } else
+ if (!squashfs_read_data(s, (char *) msblk->uid, sblk->uid_start,
+ ((sblk->no_uids + sblk->no_guids) *
+ sizeof(unsigned int)) |
+ SQUASHFS_COMPRESSED_BIT_BLOCK, NULL)) {
+ ERROR("unable to read uid/gid table\n");
+ goto failed_mount;
+ }
+
+
+ if (sblk->s_major == 1 && squashfs_1_0_supported(msblk))
+ goto allocate_root;
+
+ if (!(msblk->fragment = kmalloc(sizeof(struct squashfs_fragment_cache) *
+ SQUASHFS_CACHED_FRAGMENTS, GFP_KERNEL))) {
+ ERROR("Failed to allocate fragment block cache\n");
+ goto failed_mount;
+ }
+
+ for (i = 0; i < SQUASHFS_CACHED_FRAGMENTS; i++) {
+ msblk->fragment[i].locked = 0;
+ msblk->fragment[i].block = SQUASHFS_INVALID_BLK;
+ msblk->fragment[i].data = NULL;
+ }
+
+ msblk->next_fragment = 0;
+
+ /* Allocate fragment index table */
+ if(msblk->read_fragment_index_table(s) == 0)
+ goto failed_mount;
+
+allocate_root:
+ if ((root = (msblk->iget)(s, sblk->root_inode)) == NULL)
+ goto failed_mount;
+
+ if ((s->s_root = d_alloc_root(root)) == NULL) {
+ ERROR("Root inode create failed\n");
+ iput(root);
+ goto failed_mount;
+ }
+
+ TRACE("Leaving squashfs_read_super\n");
+ return s;
+
+failed_mount:
+ kfree(msblk->fragment_index);
+ kfree(msblk->fragment);
+ kfree(msblk->uid);
+ kfree(msblk->read_page);
+ kfree(msblk->read_data);
+ kfree(msblk->block_cache);
+ kfree(msblk->fragment_index_2);
+ vfree(msblk->stream.workspace);
+ return NULL;
+}
+
+
+static int squashfs_statfs(struct super_block *s, struct statfs *buf)
+{
+ struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
+ struct squashfs_super_block *sblk = &msblk->sblk;
+
+ TRACE("Entered squashfs_statfs\n");
+
+ buf->f_type = SQUASHFS_MAGIC;
+ buf->f_bsize = sblk->block_size;
+ buf->f_blocks = ((sblk->bytes_used - 1) >> sblk->block_log) + 1;
+ buf->f_bfree = buf->f_bavail = 0;
+ buf->f_files = sblk->inodes;
+ buf->f_ffree = 0;
+ buf->f_namelen = SQUASHFS_NAME_LEN;
+
+ return 0;
+}
+
+
+static int squashfs_symlink_readpage(struct file *file, struct page *page)
+{
+ struct inode *inode = page->mapping->host;
+ int index = page->index << PAGE_CACHE_SHIFT, length, bytes;
+ long long block = SQUASHFS_I(inode)->start_block;
+ int offset = SQUASHFS_I(inode)->offset;
+ void *pageaddr = kmap(page);
+
+ TRACE("Entered squashfs_symlink_readpage, page index %ld, start block "
+ "%llx, offset %x\n", page->index,
+ SQUASHFS_I(inode)->start_block,
+ SQUASHFS_I(inode)->offset);
+
+ for (length = 0; length < index; length += bytes) {
+ if (!(bytes = squashfs_get_cached_block(inode->i_sb, NULL,
+ block, offset, PAGE_CACHE_SIZE, &block,
+ &offset))) {
+ ERROR("Unable to read symbolic link [%llx:%x]\n", block,
+ offset);
+ goto skip_read;
+ }
+ }
+
+ if (length != index) {
+ ERROR("(squashfs_symlink_readpage) length != index\n");
+ bytes = 0;
+ goto skip_read;
+ }
+
+ bytes = (i_size_read(inode) - length) > PAGE_CACHE_SIZE ? PAGE_CACHE_SIZE :
+ i_size_read(inode) - length;
+
+ if (!(bytes = squashfs_get_cached_block(inode->i_sb, pageaddr, block,
+ offset, bytes, &block, &offset)))
+ ERROR("Unable to read symbolic link [%llx:%x]\n", block, offset);
+
+skip_read:
+ memset(pageaddr + bytes, 0, PAGE_CACHE_SIZE - bytes);
+ kunmap(page);
+ SetPageUptodate(page);
+ UnlockPage(page);
+
+ return 0;
+}
+
+
+struct meta_index *locate_meta_index(struct inode *inode, int index, int offset)
+{
+ struct meta_index *meta = NULL;
+ struct squashfs_sb_info *msblk = &inode->i_sb->u.squashfs_sb;
+ int i;
+
+ down(&msblk->meta_index_mutex);
+
+ TRACE("locate_meta_index: index %d, offset %d\n", index, offset);
+
+ if(msblk->meta_index == NULL)
+ goto not_allocated;
+
+ for (i = 0; i < SQUASHFS_META_NUMBER; i ++)
+ if (msblk->meta_index[i].inode_number == inode->i_ino &&
+ msblk->meta_index[i].offset >= offset &&
+ msblk->meta_index[i].offset <= index &&
+ msblk->meta_index[i].locked == 0) {
+ TRACE("locate_meta_index: entry %d, offset %d\n", i,
+ msblk->meta_index[i].offset);
+ meta = &msblk->meta_index[i];
+ offset = meta->offset;
+ }
+
+ if (meta)
+ meta->locked = 1;
+
+not_allocated:
+ up(&msblk->meta_index_mutex);
+
+ return meta;
+}
+
+
+struct meta_index *empty_meta_index(struct inode *inode, int offset, int skip)
+{
+ struct squashfs_sb_info *msblk = &inode->i_sb->u.squashfs_sb;
+ struct meta_index *meta = NULL;
+ int i;
+
+ down(&msblk->meta_index_mutex);
+
+ TRACE("empty_meta_index: offset %d, skip %d\n", offset, skip);
+
+ if(msblk->meta_index == NULL) {
+ if (!(msblk->meta_index = kmalloc(sizeof(struct meta_index) *
+ SQUASHFS_META_NUMBER, GFP_KERNEL))) {
+ ERROR("Failed to allocate meta_index\n");
+ goto failed;
+ }
+ for(i = 0; i < SQUASHFS_META_NUMBER; i++) {
+ msblk->meta_index[i].inode_number = 0;
+ msblk->meta_index[i].locked = 0;
+ }
+ msblk->next_meta_index = 0;
+ }
+
+ for(i = SQUASHFS_META_NUMBER; i &&
+ msblk->meta_index[msblk->next_meta_index].locked; i --)
+ msblk->next_meta_index = (msblk->next_meta_index + 1) %
+ SQUASHFS_META_NUMBER;
+
+ if(i == 0) {
+ TRACE("empty_meta_index: failed!\n");
+ goto failed;
+ }
+
+ TRACE("empty_meta_index: returned meta entry %d, %p\n",
+ msblk->next_meta_index,
+ &msblk->meta_index[msblk->next_meta_index]);
+
+ meta = &msblk->meta_index[msblk->next_meta_index];
+ msblk->next_meta_index = (msblk->next_meta_index + 1) %
+ SQUASHFS_META_NUMBER;
+
+ meta->inode_number = inode->i_ino;
+ meta->offset = offset;
+ meta->skip = skip;
+ meta->entries = 0;
+ meta->locked = 1;
+
+failed:
+ up(&msblk->meta_index_mutex);
+ return meta;
+}
+
+
+void release_meta_index(struct inode *inode, struct meta_index *meta)
+{
+ meta->locked = 0;
+}
+
+
+static int read_block_index(struct super_block *s, int blocks, char *block_list,
+ long long *start_block, int *offset)
+{
+ struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
+ unsigned int *block_listp;
+ int block = 0;
+
+ if (msblk->swap) {
+ char sblock_list[blocks << 2];
+
+ if (!squashfs_get_cached_block(s, sblock_list, *start_block,
+ *offset, blocks << 2, start_block, offset)) {
+ ERROR("Unable to read block list [%llx:%x]\n",
+ *start_block, *offset);
+ goto failure;
+ }
+ SQUASHFS_SWAP_INTS(((unsigned int *)block_list),
+ ((unsigned int *)sblock_list), blocks);
+ } else
+ if (!squashfs_get_cached_block(s, block_list, *start_block,
+ *offset, blocks << 2, start_block, offset)) {
+ ERROR("Unable to read block list [%llx:%x]\n",
+ *start_block, *offset);
+ goto failure;
+ }
+
+ for (block_listp = (unsigned int *) block_list; blocks;
+ block_listp++, blocks --)
+ block += SQUASHFS_COMPRESSED_SIZE_BLOCK(*block_listp);
+
+ return block;
+
+failure:
+ return -1;
+}
+
+
+#define SIZE 256
+
+static inline int calculate_skip(int blocks) {
+ int skip = (blocks - 1) / ((SQUASHFS_SLOTS * SQUASHFS_META_ENTRIES + 1) * SQUASHFS_META_INDEXES);
+ return skip >= 7 ? 7 : skip + 1;
+}
+
+
+static int get_meta_index(struct inode *inode, int index,
+ long long *index_block, int *index_offset,
+ long long *data_block, char *block_list)
+{
+ struct squashfs_sb_info *msblk = &inode->i_sb->u.squashfs_sb;
+ struct squashfs_super_block *sblk = &msblk->sblk;
+ int skip = calculate_skip(i_size_read(inode) >> sblk->block_log);
+ int offset = 0;
+ struct meta_index *meta;
+ struct meta_entry *meta_entry;
+ long long cur_index_block = SQUASHFS_I(inode)->u.s1.block_list_start;
+ int cur_offset = SQUASHFS_I(inode)->offset;
+ long long cur_data_block = SQUASHFS_I(inode)->start_block;
+ int i;
+
+ index /= SQUASHFS_META_INDEXES * skip;
+
+ while ( offset < index ) {
+ meta = locate_meta_index(inode, index, offset + 1);
+
+ if (meta == NULL) {
+ if ((meta = empty_meta_index(inode, offset + 1,
+ skip)) == NULL)
+ goto all_done;
+ } else {
+ offset = index < meta->offset + meta->entries ? index :
+ meta->offset + meta->entries - 1;
+ meta_entry = &meta->meta_entry[offset - meta->offset];
+ cur_index_block = meta_entry->index_block + sblk->inode_table_start;
+ cur_offset = meta_entry->offset;
+ cur_data_block = meta_entry->data_block;
+ TRACE("get_meta_index: offset %d, meta->offset %d, "
+ "meta->entries %d\n", offset, meta->offset,
+ meta->entries);
+ TRACE("get_meta_index: index_block 0x%llx, offset 0x%x"
+ " data_block 0x%llx\n", cur_index_block,
+ cur_offset, cur_data_block);
+ }
+
+ for (i = meta->offset + meta->entries; i <= index &&
+ i < meta->offset + SQUASHFS_META_ENTRIES; i++) {
+ int blocks = skip * SQUASHFS_META_INDEXES;
+
+ while (blocks) {
+ int block = blocks > (SIZE >> 2) ? (SIZE >> 2) :
+ blocks;
+ int res = read_block_index(inode->i_sb, block,
+ block_list, &cur_index_block,
+ &cur_offset);
+
+ if (res == -1)
+ goto failed;
+
+ cur_data_block += res;
+ blocks -= block;
+ }
+
+ meta_entry = &meta->meta_entry[i - meta->offset];
+ meta_entry->index_block = cur_index_block - sblk->inode_table_start;
+ meta_entry->offset = cur_offset;
+ meta_entry->data_block = cur_data_block;
+ meta->entries ++;
+ offset ++;
+ }
+
+ TRACE("get_meta_index: meta->offset %d, meta->entries %d\n",
+ meta->offset, meta->entries);
+
+ release_meta_index(inode, meta);
+ }
+
+all_done:
+ *index_block = cur_index_block;
+ *index_offset = cur_offset;
+ *data_block = cur_data_block;
+
+ return offset * SQUASHFS_META_INDEXES * skip;
+
+failed:
+ release_meta_index(inode, meta);
+ return -1;
+}
+
+
+static long long read_blocklist(struct inode *inode, int index,
+ int readahead_blks, char *block_list,
+ unsigned short **block_p, unsigned int *bsize)
+{
+ long long block_ptr;
+ int offset;
+ long long block;
+ int res = get_meta_index(inode, index, &block_ptr, &offset, &block,
+ block_list);
+
+ TRACE("read_blocklist: res %d, index %d, block_ptr 0x%llx, offset"
+ " 0x%x, block 0x%llx\n", res, index, block_ptr, offset,
+ block);
+
+ if(res == -1)
+ goto failure;
+
+ index -= res;
+
+ while ( index ) {
+ int blocks = index > (SIZE >> 2) ? (SIZE >> 2) : index;
+ int res = read_block_index(inode->i_sb, blocks, block_list,
+ &block_ptr, &offset);
+ if (res == -1)
+ goto failure;
+ block += res;
+ index -= blocks;
+ }
+
+ if (read_block_index(inode->i_sb, 1, block_list,
+ &block_ptr, &offset) == -1)
+ goto failure;
+ *bsize = *((unsigned int *) block_list);
+
+ return block;
+
+failure:
+ return 0;
+}
+
+
+static int squashfs_readpage(struct file *file, struct page *page)
+{
+ struct inode *inode = page->mapping->host;
+ struct squashfs_sb_info *msblk = &inode->i_sb->u.squashfs_sb;
+ struct squashfs_super_block *sblk = &msblk->sblk;
+ unsigned char block_list[SIZE];
+ long long block;
+ unsigned int bsize, i = 0, bytes = 0, byte_offset = 0;
+ int index = page->index >> (sblk->block_log - PAGE_CACHE_SHIFT);
+ void *pageaddr;
+ struct squashfs_fragment_cache *fragment = NULL;
+ char *data_ptr = msblk->read_page;
+
+ int mask = (1 << (sblk->block_log - PAGE_CACHE_SHIFT)) - 1;
+ int start_index = page->index & ~mask;
+ int end_index = start_index | mask;
+
+ TRACE("Entered squashfs_readpage, page index %lx, start block %llx\n",
+ page->index,
+ SQUASHFS_I(inode)->start_block);
+
+ if (page->index >= ((i_size_read(inode) + PAGE_CACHE_SIZE - 1) >>
+ PAGE_CACHE_SHIFT))
+ goto skip_read;
+
+ if (SQUASHFS_I(inode)->u.s1.fragment_start_block == SQUASHFS_INVALID_BLK
+ || index < (i_size_read(inode) >>
+ sblk->block_log)) {
+ if ((block = (msblk->read_blocklist)(inode, index, 1,
+ block_list, NULL, &bsize)) == 0)
+ goto skip_read;
+
+ down(&msblk->read_page_mutex);
+
+ if (!(bytes = squashfs_read_data(inode->i_sb, msblk->read_page,
+ block, bsize, NULL))) {
+ ERROR("Unable to read page, block %llx, size %x\n", block,
+ bsize);
+ up(&msblk->read_page_mutex);
+ goto skip_read;
+ }
+ } else {
+ if ((fragment = get_cached_fragment(inode->i_sb,
+ SQUASHFS_I(inode)->
+ u.s1.fragment_start_block,
+ SQUASHFS_I(inode)->u.s1.fragment_size))
+ == NULL) {
+ ERROR("Unable to read page, block %llx, size %x\n",
+ SQUASHFS_I(inode)->
+ u.s1.fragment_start_block,
+ (int) SQUASHFS_I(inode)->
+ u.s1.fragment_size);
+ goto skip_read;
+ }
+ bytes = SQUASHFS_I(inode)->u.s1.fragment_offset +
+ (i_size_read(inode) & (sblk->block_size
+ - 1));
+ byte_offset = SQUASHFS_I(inode)->u.s1.fragment_offset;
+ data_ptr = fragment->data;
+ }
+
+ for (i = start_index; i <= end_index && byte_offset < bytes;
+ i++, byte_offset += PAGE_CACHE_SIZE) {
+ struct page *push_page;
+ int available_bytes = (bytes - byte_offset) > PAGE_CACHE_SIZE ?
+ PAGE_CACHE_SIZE : bytes - byte_offset;
+
+ TRACE("bytes %d, i %d, byte_offset %d, available_bytes %d\n",
+ bytes, i, byte_offset, available_bytes);
+
+ if (i == page->index) {
+ pageaddr = kmap_atomic(page, KM_USER0);
+ memcpy(pageaddr, data_ptr + byte_offset,
+ available_bytes);
+ memset(pageaddr + available_bytes, 0,
+ PAGE_CACHE_SIZE - available_bytes);
+ kunmap_atomic(pageaddr, KM_USER0);
+ flush_dcache_page(page);
+ SetPageUptodate(page);
+ UnlockPage(page);
+ } else if ((push_page =
+ grab_cache_page_nowait(page->mapping, i))) {
+ pageaddr = kmap_atomic(push_page, KM_USER0);
+
+ memcpy(pageaddr, data_ptr + byte_offset,
+ available_bytes);
+ memset(pageaddr + available_bytes, 0,
+ PAGE_CACHE_SIZE - available_bytes);
+ kunmap_atomic(pageaddr, KM_USER0);
+ flush_dcache_page(push_page);
+ SetPageUptodate(push_page);
+ UnlockPage(push_page);
+ page_cache_release(push_page);
+ }
+ }
+
+ if (SQUASHFS_I(inode)->u.s1.fragment_start_block == SQUASHFS_INVALID_BLK
+ || index < (i_size_read(inode) >>
+ sblk->block_log))
+ up(&msblk->read_page_mutex);
+ else
+ release_cached_fragment(msblk, fragment);
+
+ return 0;
+
+skip_read:
+ pageaddr = kmap_atomic(page, KM_USER0);
+ memset(pageaddr + bytes, 0, PAGE_CACHE_SIZE - bytes);
+ kunmap_atomic(pageaddr, KM_USER0);
+ flush_dcache_page(page);
+ SetPageUptodate(page);
+ UnlockPage(page);
+
+ return 0;
+}
+
+
+static int squashfs_readpage4K(struct file *file, struct page *page)
+{
+ struct inode *inode = page->mapping->host;
+ struct squashfs_sb_info *msblk = &inode->i_sb->u.squashfs_sb;
+ struct squashfs_super_block *sblk = &msblk->sblk;
+ unsigned char block_list[SIZE];
+ long long block;
+ unsigned int bsize, bytes = 0;
+ void *pageaddr;
+
+ TRACE("Entered squashfs_readpage4K, page index %lx, start block %llx\n",
+ page->index,
+ SQUASHFS_I(inode)->start_block);
+
+ if (page->index >= ((i_size_read(inode) + PAGE_CACHE_SIZE - 1) >>
+ PAGE_CACHE_SHIFT)) {
+ pageaddr = kmap_atomic(page, KM_USER0);
+ goto skip_read;
+ }
+
+ if (SQUASHFS_I(inode)->u.s1.fragment_start_block == SQUASHFS_INVALID_BLK
+ || page->index < (i_size_read(inode) >>
+ sblk->block_log)) {
+ block = (msblk->read_blocklist)(inode, page->index, 1,
+ block_list, NULL, &bsize);
+
+ down(&msblk->read_page_mutex);
+ bytes = squashfs_read_data(inode->i_sb, msblk->read_page, block,
+ bsize, NULL);
+ pageaddr = kmap_atomic(page, KM_USER0);
+ if (bytes)
+ memcpy(pageaddr, msblk->read_page, bytes);
+ else
+ ERROR("Unable to read page, block %llx, size %x\n",
+ block, bsize);
+ up(&msblk->read_page_mutex);
+ } else {
+ struct squashfs_fragment_cache *fragment =
+ get_cached_fragment(inode->i_sb,
+ SQUASHFS_I(inode)->
+ u.s1.fragment_start_block,
+ SQUASHFS_I(inode)-> u.s1.fragment_size);
+ pageaddr = kmap_atomic(page, KM_USER0);
+ if (fragment) {
+ bytes = i_size_read(inode) & (sblk->block_size - 1);
+ memcpy(pageaddr, fragment->data + SQUASHFS_I(inode)->
+ u.s1.fragment_offset, bytes);
+ release_cached_fragment(msblk, fragment);
+ } else
+ ERROR("Unable to read page, block %llx, size %x\n",
+ SQUASHFS_I(inode)->
+ u.s1.fragment_start_block, (int)
+ SQUASHFS_I(inode)-> u.s1.fragment_size);
+ }
+
+skip_read:
+ memset(pageaddr + bytes, 0, PAGE_CACHE_SIZE - bytes);
+ kunmap_atomic(pageaddr, KM_USER0);
+ flush_dcache_page(page);
+ SetPageUptodate(page);
+ UnlockPage(page);
+
+ return 0;
+}
+
+
+static int get_dir_index_using_offset(struct super_block *s, long long
+ *next_block, unsigned int *next_offset,
+ long long index_start,
+ unsigned int index_offset, int i_count,
+ long long f_pos)
+{
+ struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
+ struct squashfs_super_block *sblk = &msblk->sblk;
+ int i, length = 0;
+ struct squashfs_dir_index index;
+
+ TRACE("Entered get_dir_index_using_offset, i_count %d, f_pos %d\n",
+ i_count, (unsigned int) f_pos);
+
+ f_pos -= 3;
+ if (f_pos == 0)
+ goto finish;
+
+ for (i = 0; i < i_count; i++) {
+ if (msblk->swap) {
+ struct squashfs_dir_index sindex;
+ squashfs_get_cached_block(s, (char *) &sindex,
+ index_start, index_offset,
+ sizeof(sindex), &index_start,
+ &index_offset);
+ SQUASHFS_SWAP_DIR_INDEX(&index, &sindex);
+ } else
+ squashfs_get_cached_block(s, (char *) &index,
+ index_start, index_offset,
+ sizeof(index), &index_start,
+ &index_offset);
+
+ if (index.index > f_pos)
+ break;
+
+ squashfs_get_cached_block(s, NULL, index_start, index_offset,
+ index.size + 1, &index_start,
+ &index_offset);
+
+ length = index.index;
+ *next_block = index.start_block + sblk->directory_table_start;
+ }
+
+ *next_offset = (length + *next_offset) % SQUASHFS_METADATA_SIZE;
+
+finish:
+ return length + 3;
+}
+
+
+static int get_dir_index_using_name(struct super_block *s, long long
+ *next_block, unsigned int *next_offset,
+ long long index_start,
+ unsigned int index_offset, int i_count,
+ const char *name, int size)
+{
+ struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
+ struct squashfs_super_block *sblk = &msblk->sblk;
+ int i, length = 0;
+ char buffer[sizeof(struct squashfs_dir_index) + SQUASHFS_NAME_LEN + 1];
+ struct squashfs_dir_index *index = (struct squashfs_dir_index *) buffer;
+ char str[SQUASHFS_NAME_LEN + 1];
+
+ TRACE("Entered get_dir_index_using_name, i_count %d\n", i_count);
+
+ strncpy(str, name, size);
+ str[size] = '\0';
+
+ for (i = 0; i < i_count; i++) {
+ if (msblk->swap) {
+ struct squashfs_dir_index sindex;
+ squashfs_get_cached_block(s, (char *) &sindex,
+ index_start, index_offset,
+ sizeof(sindex), &index_start,
+ &index_offset);
+ SQUASHFS_SWAP_DIR_INDEX(index, &sindex);
+ } else
+ squashfs_get_cached_block(s, (char *) index,
+ index_start, index_offset,
+ sizeof(struct squashfs_dir_index),
+ &index_start, &index_offset);
+
+ squashfs_get_cached_block(s, index->name, index_start,
+ index_offset, index->size + 1,
+ &index_start, &index_offset);
+
+ index->name[index->size + 1] = '\0';
+
+ if (strcmp(index->name, str) > 0)
+ break;
+
+ length = index->index;
+ *next_block = index->start_block + sblk->directory_table_start;
+ }
+
+ *next_offset = (length + *next_offset) % SQUASHFS_METADATA_SIZE;
+ return length + 3;
+}
+
+
+static int squashfs_readdir(struct file *file, void *dirent, filldir_t filldir)
+{
+ struct inode *i = file->f_dentry->d_inode;
+ struct squashfs_sb_info *msblk = &i->i_sb->u.squashfs_sb;
+ struct squashfs_super_block *sblk = &msblk->sblk;
+ long long next_block = SQUASHFS_I(i)->start_block +
+ sblk->directory_table_start;
+ int next_offset = SQUASHFS_I(i)->offset, length = 0,
+ dir_count;
+ struct squashfs_dir_header dirh;
+ char buffer[sizeof(struct squashfs_dir_entry) + SQUASHFS_NAME_LEN + 1];
+ struct squashfs_dir_entry *dire = (struct squashfs_dir_entry *) buffer;
+
+ TRACE("Entered squashfs_readdir [%llx:%x]\n", next_block, next_offset);
+
+ while(file->f_pos < 3) {
+ char *name;
+ int size, i_ino;
+
+ if(file->f_pos == 0) {
+ name = ".";
+ size = 1;
+ i_ino = i->i_ino;
+ } else {
+ name = "..";
+ size = 2;
+ i_ino = SQUASHFS_I(i)->u.s2.parent_inode;
+ }
+ TRACE("Calling filldir(%x, %s, %d, %d, %d, %d)\n",
+ (unsigned int) dirent, name, size, (int)
+ file->f_pos, i_ino,
+ squashfs_filetype_table[1]);
+
+ if (filldir(dirent, name, size,
+ file->f_pos, i_ino,
+ squashfs_filetype_table[1]) < 0) {
+ TRACE("Filldir returned less than 0\n");
+ goto finish;
+ }
+ file->f_pos += size;
+ }
+
+ length = get_dir_index_using_offset(i->i_sb, &next_block, &next_offset,
+ SQUASHFS_I(i)->u.s2.directory_index_start,
+ SQUASHFS_I(i)->u.s2.directory_index_offset,
+ SQUASHFS_I(i)->u.s2.directory_index_count,
+ file->f_pos);
+
+ while (length < i_size_read(i)) {
+ /* read directory header */
+ if (msblk->swap) {
+ struct squashfs_dir_header sdirh;
+
+ if (!squashfs_get_cached_block(i->i_sb, (char *) &sdirh,
+ next_block, next_offset, sizeof(sdirh),
+ &next_block, &next_offset))
+ goto failed_read;
+
+ length += sizeof(sdirh);
+ SQUASHFS_SWAP_DIR_HEADER(&dirh, &sdirh);
+ } else {
+ if (!squashfs_get_cached_block(i->i_sb, (char *) &dirh,
+ next_block, next_offset, sizeof(dirh),
+ &next_block, &next_offset))
+ goto failed_read;
+
+ length += sizeof(dirh);
+ }
+
+ dir_count = dirh.count + 1;
+ while (dir_count--) {
+ if (msblk->swap) {
+ struct squashfs_dir_entry sdire;
+ if (!squashfs_get_cached_block(i->i_sb, (char *)
+ &sdire, next_block, next_offset,
+ sizeof(sdire), &next_block,
+ &next_offset))
+ goto failed_read;
+
+ length += sizeof(sdire);
+ SQUASHFS_SWAP_DIR_ENTRY(dire, &sdire);
+ } else {
+ if (!squashfs_get_cached_block(i->i_sb, (char *)
+ dire, next_block, next_offset,
+ sizeof(*dire), &next_block,
+ &next_offset))
+ goto failed_read;
+
+ length += sizeof(*dire);
+ }
+
+ if (!squashfs_get_cached_block(i->i_sb, dire->name,
+ next_block, next_offset,
+ dire->size + 1, &next_block,
+ &next_offset))
+ goto failed_read;
+
+ length += dire->size + 1;
+
+ if (file->f_pos >= length)
+ continue;
+
+ dire->name[dire->size + 1] = '\0';
+
+ TRACE("Calling filldir(%x, %s, %d, %d, %x:%x, %d, %d)\n",
+ (unsigned int) dirent, dire->name,
+ dire->size + 1, (int) file->f_pos,
+ dirh.start_block, dire->offset,
+ dirh.inode_number + dire->inode_number,
+ squashfs_filetype_table[dire->type]);
+
+ if (filldir(dirent, dire->name, dire->size + 1,
+ file->f_pos,
+ dirh.inode_number + dire->inode_number,
+ squashfs_filetype_table[dire->type])
+ < 0) {
+ TRACE("Filldir returned less than 0\n");
+ goto finish;
+ }
+ file->f_pos = length;
+ }
+ }
+
+finish:
+ return 0;
+
+failed_read:
+ ERROR("Unable to read directory block [%llx:%x]\n", next_block,
+ next_offset);
+ return 0;
+}
+
+
+static struct dentry *squashfs_lookup(struct inode *i, struct dentry *dentry)
+{
+ const unsigned char *name = dentry->d_name.name;
+ int len = dentry->d_name.len;
+ struct inode *inode = NULL;
+ struct squashfs_sb_info *msblk = &i->i_sb->u.squashfs_sb;
+ struct squashfs_super_block *sblk = &msblk->sblk;
+ long long next_block = SQUASHFS_I(i)->start_block +
+ sblk->directory_table_start;
+ int next_offset = SQUASHFS_I(i)->offset, length = 0,
+ dir_count;
+ struct squashfs_dir_header dirh;
+ char buffer[sizeof(struct squashfs_dir_entry) + SQUASHFS_NAME_LEN];
+ struct squashfs_dir_entry *dire = (struct squashfs_dir_entry *) buffer;
+
+ TRACE("Entered squashfs_lookup [%llx:%x]\n", next_block, next_offset);
+
+ if (len > SQUASHFS_NAME_LEN)
+ goto exit_loop;
+
+ length = get_dir_index_using_name(i->i_sb, &next_block, &next_offset,
+ SQUASHFS_I(i)->u.s2.directory_index_start,
+ SQUASHFS_I(i)->u.s2.directory_index_offset,
+ SQUASHFS_I(i)->u.s2.directory_index_count, name,
+ len);
+
+ while (length < i_size_read(i)) {
+ /* read directory header */
+ if (msblk->swap) {
+ struct squashfs_dir_header sdirh;
+ if (!squashfs_get_cached_block(i->i_sb, (char *) &sdirh,
+ next_block, next_offset, sizeof(sdirh),
+ &next_block, &next_offset))
+ goto failed_read;
+
+ length += sizeof(sdirh);
+ SQUASHFS_SWAP_DIR_HEADER(&dirh, &sdirh);
+ } else {
+ if (!squashfs_get_cached_block(i->i_sb, (char *) &dirh,
+ next_block, next_offset, sizeof(dirh),
+ &next_block, &next_offset))
+ goto failed_read;
+
+ length += sizeof(dirh);
+ }
+
+ dir_count = dirh.count + 1;
+ while (dir_count--) {
+ if (msblk->swap) {
+ struct squashfs_dir_entry sdire;
+ if (!squashfs_get_cached_block(i->i_sb, (char *)
+ &sdire, next_block,next_offset,
+ sizeof(sdire), &next_block,
+ &next_offset))
+ goto failed_read;
+
+ length += sizeof(sdire);
+ SQUASHFS_SWAP_DIR_ENTRY(dire, &sdire);
+ } else {
+ if (!squashfs_get_cached_block(i->i_sb, (char *)
+ dire, next_block,next_offset,
+ sizeof(*dire), &next_block,
+ &next_offset))
+ goto failed_read;
+
+ length += sizeof(*dire);
+ }
+
+ if (!squashfs_get_cached_block(i->i_sb, dire->name,
+ next_block, next_offset, dire->size + 1,
+ &next_block, &next_offset))
+ goto failed_read;
+
+ length += dire->size + 1;
+
+ if (name[0] < dire->name[0])
+ goto exit_loop;
+
+ if ((len == dire->size + 1) && !strncmp(name,
+ dire->name, len)) {
+ squashfs_inode_t ino =
+ SQUASHFS_MKINODE(dirh.start_block,
+ dire->offset);
+
+ TRACE("calling squashfs_iget for directory "
+ "entry %s, inode %x:%x, %d\n", name,
+ dirh.start_block, dire->offset,
+ dirh.inode_number + dire->inode_number);
+
+ inode = (msblk->iget)(i->i_sb, ino);
+
+ goto exit_loop;
+ }
+ }
+ }
+
+exit_loop:
+ d_add(dentry, inode);
+ return ERR_PTR(0);
+
+failed_read:
+ ERROR("Unable to read directory block [%llx:%x]\n", next_block,
+ next_offset);
+ goto exit_loop;
+}
+
+
+static void squashfs_put_super(struct super_block *s)
+{
+ int i;
+
+ struct squashfs_sb_info *sbi = &s->u.squashfs_sb;
+ if (sbi->block_cache)
+ for (i = 0; i < SQUASHFS_CACHED_BLKS; i++)
+ if (sbi->block_cache[i].block !=
+ SQUASHFS_INVALID_BLK)
+ kfree(sbi->block_cache[i].data);
+ if (sbi->fragment)
+ for (i = 0; i < SQUASHFS_CACHED_FRAGMENTS; i++)
+ SQUASHFS_FREE(sbi->fragment[i].data);
+ kfree(sbi->fragment);
+ kfree(sbi->block_cache);
+ kfree(sbi->read_data);
+ kfree(sbi->read_page);
+ kfree(sbi->uid);
+ kfree(sbi->fragment_index);
+ kfree(sbi->fragment_index_2);
+ kfree(sbi->meta_index);
+ vfree(sbi->stream.workspace);
+ sbi->block_cache = NULL;
+ sbi->uid = NULL;
+ sbi->read_data = NULL;
+ sbi->read_page = NULL;
+ sbi->fragment = NULL;
+ sbi->fragment_index = NULL;
+ sbi->fragment_index_2 = NULL;
+ sbi->meta_index = NULL;
+ sbi->stream.workspace = NULL;
+}
+
+
+static int __init init_squashfs_fs(void)
+{
+
+ printk(KERN_INFO "squashfs: version 3.1 (2006/08/15) "
+ "Phillip Lougher\n");
+
+ return register_filesystem(&squashfs_fs_type);
+}
+
+
+static void __exit exit_squashfs_fs(void)
+{
+ unregister_filesystem(&squashfs_fs_type);
+}
+
+
+EXPORT_NO_SYMBOLS;
+
+module_init(init_squashfs_fs);
+module_exit(exit_squashfs_fs);
+MODULE_DESCRIPTION("squashfs 3.1, a compressed read-only filesystem");
+MODULE_AUTHOR("Phillip Lougher <phillip@lougher.demon.co.uk>");
+MODULE_LICENSE("GPL");
diff --git a/squashfs-tools/kernel-2.4/fs/squashfs/squashfs.h b/squashfs-tools/kernel-2.4/fs/squashfs/squashfs.h
new file mode 100755
index 0000000..b5f93fb
--- /dev/null
+++ b/squashfs-tools/kernel-2.4/fs/squashfs/squashfs.h
@@ -0,0 +1,85 @@
+/*
+ * Squashfs - a compressed read only filesystem for Linux
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006
+ * Phillip Lougher <phillip@lougher.demon.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * squashfs.h
+ */
+
+#ifdef CONFIG_SQUASHFS_1_0_COMPATIBILITY
+#undef CONFIG_SQUASHFS_1_0_COMPATIBILITY
+#endif
+#ifdef SQUASHFS_TRACE
+#define TRACE(s, args...) printk(KERN_NOTICE "SQUASHFS: "s, ## args)
+#else
+#define TRACE(s, args...) {}
+#endif
+
+#define ERROR(s, args...) printk(KERN_ERR "SQUASHFS error: "s, ## args)
+
+#define SERROR(s, args...) do { \
+ if (!silent) \
+ printk(KERN_ERR "SQUASHFS error: "s, ## args);\
+ } while(0)
+
+#define WARNING(s, args...) printk(KERN_WARNING "SQUASHFS: "s, ## args)
+
+#define SQUASHFS_I(INO) (&INO->u.squashfs_i)
+
+#define i_size_read(INO) (INO->i_size)
+
+#if defined(CONFIG_SQUASHFS_1_0_COMPATIBILITY ) || defined(CONFIG_SQUASHFS_2_0_COMPATIBILITY)
+#define SQSH_EXTERN
+extern unsigned int squashfs_read_data(struct super_block *s, char *buffer,
+ long long index, unsigned int length,
+ long long *next_index);
+extern int squashfs_get_cached_block(struct super_block *s, char *buffer,
+ long long block, unsigned int offset,
+ int length, long long *next_block,
+ unsigned int *next_offset);
+extern void release_cached_fragment(struct squashfs_sb_info *msblk, struct
+ squashfs_fragment_cache *fragment);
+extern struct squashfs_fragment_cache *get_cached_fragment(struct super_block
+ *s, long long start_block,
+ int length);
+extern struct address_space_operations squashfs_symlink_aops;
+extern struct address_space_operations squashfs_aops;
+extern struct address_space_operations squashfs_aops_4K;
+extern struct file_operations squashfs_dir_ops;
+extern struct inode_operations squashfs_dir_inode_ops;
+#else
+#define SQSH_EXTERN static
+#endif
+
+#ifdef CONFIG_SQUASHFS_1_0_COMPATIBILITY
+extern int squashfs_1_0_supported(struct squashfs_sb_info *msblk);
+#else
+static inline int squashfs_1_0_supported(struct squashfs_sb_info *msblk)
+{
+ return 0;
+}
+#endif
+
+#ifdef CONFIG_SQUASHFS_2_0_COMPATIBILITY
+extern int squashfs_2_0_supported(struct squashfs_sb_info *msblk);
+#else
+static inline int squashfs_2_0_supported(struct squashfs_sb_info *msblk)
+{
+ return 0;
+}
+#endif
diff --git a/squashfs-tools/kernel-2.4/fs/squashfs/squashfs2_0.c b/squashfs-tools/kernel-2.4/fs/squashfs/squashfs2_0.c
new file mode 100755
index 0000000..6411a04
--- /dev/null
+++ b/squashfs-tools/kernel-2.4/fs/squashfs/squashfs2_0.c
@@ -0,0 +1,751 @@
+/*
+ * Squashfs - a compressed read only filesystem for Linux
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006
+ * Phillip Lougher <phillip@lougher.demon.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * squashfs2_0.c
+ */
+
+#include <linux/types.h>
+#include <linux/squashfs_fs.h>
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/slab.h>
+#include <linux/zlib.h>
+#include <linux/fs.h>
+#include <linux/smp_lock.h>
+#include <linux/locks.h>
+#include <linux/init.h>
+#include <linux/dcache.h>
+#include <linux/wait.h>
+#include <linux/zlib.h>
+#include <linux/blkdev.h>
+#include <linux/vmalloc.h>
+#include <asm/uaccess.h>
+#include <asm/semaphore.h>
+#include "squashfs.h"
+
+static int squashfs_readdir_2(struct file *file, void *dirent, filldir_t filldir);
+static struct dentry *squashfs_lookup_2(struct inode *i, struct dentry *dentry);
+
+static struct file_operations squashfs_dir_ops_2 = {
+ .read = generic_read_dir,
+ .readdir = squashfs_readdir_2
+};
+
+static struct inode_operations squashfs_dir_inode_ops_2 = {
+ .lookup = squashfs_lookup_2
+};
+
+static unsigned char squashfs_filetype_table[] = {
+ DT_UNKNOWN, DT_DIR, DT_REG, DT_LNK, DT_BLK, DT_CHR, DT_FIFO, DT_SOCK
+};
+
+static int read_fragment_index_table_2(struct super_block *s)
+{
+ struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
+ struct squashfs_super_block *sblk = &msblk->sblk;
+
+ if (!(msblk->fragment_index_2 = kmalloc(SQUASHFS_FRAGMENT_INDEX_BYTES_2
+ (sblk->fragments), GFP_KERNEL))) {
+ ERROR("Failed to allocate uid/gid table\n");
+ return 0;
+ }
+
+ if (SQUASHFS_FRAGMENT_INDEX_BYTES_2(sblk->fragments) &&
+ !squashfs_read_data(s, (char *)
+ msblk->fragment_index_2,
+ sblk->fragment_table_start,
+ SQUASHFS_FRAGMENT_INDEX_BYTES_2
+ (sblk->fragments) |
+ SQUASHFS_COMPRESSED_BIT_BLOCK, NULL)) {
+ ERROR("unable to read fragment index table\n");
+ return 0;
+ }
+
+ if (msblk->swap) {
+ int i;
+ unsigned int fragment;
+
+ for (i = 0; i < SQUASHFS_FRAGMENT_INDEXES_2(sblk->fragments);
+ i++) {
+ SQUASHFS_SWAP_FRAGMENT_INDEXES_2((&fragment),
+ &msblk->fragment_index_2[i], 1);
+ msblk->fragment_index_2[i] = fragment;
+ }
+ }
+
+ return 1;
+}
+
+
+static int get_fragment_location_2(struct super_block *s, unsigned int fragment,
+ long long *fragment_start_block,
+ unsigned int *fragment_size)
+{
+ struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
+ long long start_block =
+ msblk->fragment_index_2[SQUASHFS_FRAGMENT_INDEX_2(fragment)];
+ int offset = SQUASHFS_FRAGMENT_INDEX_OFFSET_2(fragment);
+ struct squashfs_fragment_entry_2 fragment_entry;
+
+ if (msblk->swap) {
+ struct squashfs_fragment_entry_2 sfragment_entry;
+
+ if (!squashfs_get_cached_block(s, (char *) &sfragment_entry,
+ start_block, offset,
+ sizeof(sfragment_entry), &start_block,
+ &offset))
+ goto out;
+ SQUASHFS_SWAP_FRAGMENT_ENTRY_2(&fragment_entry, &sfragment_entry);
+ } else
+ if (!squashfs_get_cached_block(s, (char *) &fragment_entry,
+ start_block, offset,
+ sizeof(fragment_entry), &start_block,
+ &offset))
+ goto out;
+
+ *fragment_start_block = fragment_entry.start_block;
+ *fragment_size = fragment_entry.size;
+
+ return 1;
+
+out:
+ return 0;
+}
+
+
+static struct inode *squashfs_new_inode(struct super_block *s,
+ struct squashfs_base_inode_header_2 *inodeb, unsigned int ino)
+{
+ struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
+ struct squashfs_super_block *sblk = &msblk->sblk;
+ struct inode *i = new_inode(s);
+
+ if (i) {
+ i->i_ino = ino;
+ i->i_mtime = sblk->mkfs_time;
+ i->i_atime = sblk->mkfs_time;
+ i->i_ctime = sblk->mkfs_time;
+ i->i_uid = msblk->uid[inodeb->uid];
+ i->i_mode = inodeb->mode;
+ i->i_nlink = 1;
+ i->i_size = 0;
+ if (inodeb->guid == SQUASHFS_GUIDS)
+ i->i_gid = i->i_uid;
+ else
+ i->i_gid = msblk->guid[inodeb->guid];
+ }
+
+ return i;
+}
+
+
+static struct inode *squashfs_iget_2(struct super_block *s, squashfs_inode_t inode)
+{
+ struct inode *i;
+ struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
+ struct squashfs_super_block *sblk = &msblk->sblk;
+ unsigned int block = SQUASHFS_INODE_BLK(inode) +
+ sblk->inode_table_start;
+ unsigned int offset = SQUASHFS_INODE_OFFSET(inode);
+ unsigned int ino = SQUASHFS_MK_VFS_INODE(block
+ - sblk->inode_table_start, offset);
+ long long next_block;
+ unsigned int next_offset;
+ union squashfs_inode_header_2 id, sid;
+ struct squashfs_base_inode_header_2 *inodeb = &id.base,
+ *sinodeb = &sid.base;
+
+ TRACE("Entered squashfs_iget\n");
+
+ if (msblk->swap) {
+ if (!squashfs_get_cached_block(s, (char *) sinodeb, block,
+ offset, sizeof(*sinodeb), &next_block,
+ &next_offset))
+ goto failed_read;
+ SQUASHFS_SWAP_BASE_INODE_HEADER_2(inodeb, sinodeb,
+ sizeof(*sinodeb));
+ } else
+ if (!squashfs_get_cached_block(s, (char *) inodeb, block,
+ offset, sizeof(*inodeb), &next_block,
+ &next_offset))
+ goto failed_read;
+
+ switch(inodeb->inode_type) {
+ case SQUASHFS_FILE_TYPE: {
+ struct squashfs_reg_inode_header_2 *inodep = &id.reg;
+ struct squashfs_reg_inode_header_2 *sinodep = &sid.reg;
+ long long frag_blk;
+ unsigned int frag_size;
+
+ if (msblk->swap) {
+ if (!squashfs_get_cached_block(s, (char *)
+ sinodep, block, offset,
+ sizeof(*sinodep), &next_block,
+ &next_offset))
+ goto failed_read;
+ SQUASHFS_SWAP_REG_INODE_HEADER_2(inodep, sinodep);
+ } else
+ if (!squashfs_get_cached_block(s, (char *)
+ inodep, block, offset,
+ sizeof(*inodep), &next_block,
+ &next_offset))
+ goto failed_read;
+
+ frag_blk = SQUASHFS_INVALID_BLK;
+ if (inodep->fragment != SQUASHFS_INVALID_FRAG &&
+ !get_fragment_location_2(s,
+ inodep->fragment, &frag_blk, &frag_size))
+ goto failed_read;
+
+ if((i = squashfs_new_inode(s, inodeb, ino)) == NULL)
+ goto failed_read1;
+
+ i->i_size = inodep->file_size;
+ i->i_fop = &generic_ro_fops;
+ i->i_mode |= S_IFREG;
+ i->i_mtime = inodep->mtime;
+ i->i_atime = inodep->mtime;
+ i->i_ctime = inodep->mtime;
+ i->i_blocks = ((i->i_size - 1) >> 9) + 1;
+ i->i_blksize = PAGE_CACHE_SIZE;
+ SQUASHFS_I(i)->u.s1.fragment_start_block = frag_blk;
+ SQUASHFS_I(i)->u.s1.fragment_size = frag_size;
+ SQUASHFS_I(i)->u.s1.fragment_offset = inodep->offset;
+ SQUASHFS_I(i)->start_block = inodep->start_block;
+ SQUASHFS_I(i)->u.s1.block_list_start = next_block;
+ SQUASHFS_I(i)->offset = next_offset;
+ if (sblk->block_size > 4096)
+ i->i_data.a_ops = &squashfs_aops;
+ else
+ i->i_data.a_ops = &squashfs_aops_4K;
+
+ TRACE("File inode %x:%x, start_block %x, "
+ "block_list_start %llx, offset %x\n",
+ SQUASHFS_INODE_BLK(inode), offset,
+ inodep->start_block, next_block,
+ next_offset);
+ break;
+ }
+ case SQUASHFS_DIR_TYPE: {
+ struct squashfs_dir_inode_header_2 *inodep = &id.dir;
+ struct squashfs_dir_inode_header_2 *sinodep = &sid.dir;
+
+ if (msblk->swap) {
+ if (!squashfs_get_cached_block(s, (char *)
+ sinodep, block, offset,
+ sizeof(*sinodep), &next_block,
+ &next_offset))
+ goto failed_read;
+ SQUASHFS_SWAP_DIR_INODE_HEADER_2(inodep, sinodep);
+ } else
+ if (!squashfs_get_cached_block(s, (char *)
+ inodep, block, offset,
+ sizeof(*inodep), &next_block,
+ &next_offset))
+ goto failed_read;
+
+ if((i = squashfs_new_inode(s, inodeb, ino)) == NULL)
+ goto failed_read1;
+
+ i->i_size = inodep->file_size;
+ i->i_op = &squashfs_dir_inode_ops_2;
+ i->i_fop = &squashfs_dir_ops_2;
+ i->i_mode |= S_IFDIR;
+ i->i_mtime = inodep->mtime;
+ i->i_atime = inodep->mtime;
+ i->i_ctime = inodep->mtime;
+ SQUASHFS_I(i)->start_block = inodep->start_block;
+ SQUASHFS_I(i)->offset = inodep->offset;
+ SQUASHFS_I(i)->u.s2.directory_index_count = 0;
+ SQUASHFS_I(i)->u.s2.parent_inode = 0;
+
+ TRACE("Directory inode %x:%x, start_block %x, offset "
+ "%x\n", SQUASHFS_INODE_BLK(inode),
+ offset, inodep->start_block,
+ inodep->offset);
+ break;
+ }
+ case SQUASHFS_LDIR_TYPE: {
+ struct squashfs_ldir_inode_header_2 *inodep = &id.ldir;
+ struct squashfs_ldir_inode_header_2 *sinodep = &sid.ldir;
+
+ if (msblk->swap) {
+ if (!squashfs_get_cached_block(s, (char *)
+ sinodep, block, offset,
+ sizeof(*sinodep), &next_block,
+ &next_offset))
+ goto failed_read;
+ SQUASHFS_SWAP_LDIR_INODE_HEADER_2(inodep,
+ sinodep);
+ } else
+ if (!squashfs_get_cached_block(s, (char *)
+ inodep, block, offset,
+ sizeof(*inodep), &next_block,
+ &next_offset))
+ goto failed_read;
+
+ if((i = squashfs_new_inode(s, inodeb, ino)) == NULL)
+ goto failed_read1;
+
+ i->i_size = inodep->file_size;
+ i->i_op = &squashfs_dir_inode_ops_2;
+ i->i_fop = &squashfs_dir_ops_2;
+ i->i_mode |= S_IFDIR;
+ i->i_mtime = inodep->mtime;
+ i->i_atime = inodep->mtime;
+ i->i_ctime = inodep->mtime;
+ SQUASHFS_I(i)->start_block = inodep->start_block;
+ SQUASHFS_I(i)->offset = inodep->offset;
+ SQUASHFS_I(i)->u.s2.directory_index_start = next_block;
+ SQUASHFS_I(i)->u.s2.directory_index_offset =
+ next_offset;
+ SQUASHFS_I(i)->u.s2.directory_index_count =
+ inodep->i_count;
+ SQUASHFS_I(i)->u.s2.parent_inode = 0;
+
+ TRACE("Long directory inode %x:%x, start_block %x, "
+ "offset %x\n",
+ SQUASHFS_INODE_BLK(inode), offset,
+ inodep->start_block, inodep->offset);
+ break;
+ }
+ case SQUASHFS_SYMLINK_TYPE: {
+ struct squashfs_symlink_inode_header_2 *inodep =
+ &id.symlink;
+ struct squashfs_symlink_inode_header_2 *sinodep =
+ &sid.symlink;
+
+ if (msblk->swap) {
+ if (!squashfs_get_cached_block(s, (char *)
+ sinodep, block, offset,
+ sizeof(*sinodep), &next_block,
+ &next_offset))
+ goto failed_read;
+ SQUASHFS_SWAP_SYMLINK_INODE_HEADER_2(inodep,
+ sinodep);
+ } else
+ if (!squashfs_get_cached_block(s, (char *)
+ inodep, block, offset,
+ sizeof(*inodep), &next_block,
+ &next_offset))
+ goto failed_read;
+
+ if((i = squashfs_new_inode(s, inodeb, ino)) == NULL)
+ goto failed_read1;
+
+ i->i_size = inodep->symlink_size;
+ i->i_op = &page_symlink_inode_operations;
+ i->i_data.a_ops = &squashfs_symlink_aops;
+ i->i_mode |= S_IFLNK;
+ SQUASHFS_I(i)->start_block = next_block;
+ SQUASHFS_I(i)->offset = next_offset;
+
+ TRACE("Symbolic link inode %x:%x, start_block %llx, "
+ "offset %x\n",
+ SQUASHFS_INODE_BLK(inode), offset,
+ next_block, next_offset);
+ break;
+ }
+ case SQUASHFS_BLKDEV_TYPE:
+ case SQUASHFS_CHRDEV_TYPE: {
+ struct squashfs_dev_inode_header_2 *inodep = &id.dev;
+ struct squashfs_dev_inode_header_2 *sinodep = &sid.dev;
+
+ if (msblk->swap) {
+ if (!squashfs_get_cached_block(s, (char *)
+ sinodep, block, offset,
+ sizeof(*sinodep), &next_block,
+ &next_offset))
+ goto failed_read;
+ SQUASHFS_SWAP_DEV_INODE_HEADER_2(inodep, sinodep);
+ } else
+ if (!squashfs_get_cached_block(s, (char *)
+ inodep, block, offset,
+ sizeof(*inodep), &next_block,
+ &next_offset))
+ goto failed_read;
+
+ if ((i = squashfs_new_inode(s, inodeb, ino)) == NULL)
+ goto failed_read1;
+
+ i->i_mode |= (inodeb->inode_type ==
+ SQUASHFS_CHRDEV_TYPE) ? S_IFCHR :
+ S_IFBLK;
+ init_special_inode(i, i->i_mode, inodep->rdev);
+
+ TRACE("Device inode %x:%x, rdev %x\n",
+ SQUASHFS_INODE_BLK(inode), offset,
+ inodep->rdev);
+ break;
+ }
+ case SQUASHFS_FIFO_TYPE:
+ case SQUASHFS_SOCKET_TYPE: {
+ if ((i = squashfs_new_inode(s, inodeb, ino)) == NULL)
+ goto failed_read1;
+
+ i->i_mode |= (inodeb->inode_type == SQUASHFS_FIFO_TYPE)
+ ? S_IFIFO : S_IFSOCK;
+ init_special_inode(i, i->i_mode, 0);
+ break;
+ }
+ default:
+ ERROR("Unknown inode type %d in squashfs_iget!\n",
+ inodeb->inode_type);
+ goto failed_read1;
+ }
+
+ insert_inode_hash(i);
+ return i;
+
+failed_read:
+ ERROR("Unable to read inode [%x:%x]\n", block, offset);
+
+failed_read1:
+ return NULL;
+}
+
+
+static int get_dir_index_using_offset(struct super_block *s, long long
+ *next_block, unsigned int *next_offset,
+ long long index_start,
+ unsigned int index_offset, int i_count,
+ long long f_pos)
+{
+ struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
+ struct squashfs_super_block *sblk = &msblk->sblk;
+ int i, length = 0;
+ struct squashfs_dir_index_2 index;
+
+ TRACE("Entered get_dir_index_using_offset, i_count %d, f_pos %d\n",
+ i_count, (unsigned int) f_pos);
+
+ if (f_pos == 0)
+ goto finish;
+
+ for (i = 0; i < i_count; i++) {
+ if (msblk->swap) {
+ struct squashfs_dir_index_2 sindex;
+ squashfs_get_cached_block(s, (char *) &sindex,
+ index_start, index_offset,
+ sizeof(sindex), &index_start,
+ &index_offset);
+ SQUASHFS_SWAP_DIR_INDEX_2(&index, &sindex);
+ } else
+ squashfs_get_cached_block(s, (char *) &index,
+ index_start, index_offset,
+ sizeof(index), &index_start,
+ &index_offset);
+
+ if (index.index > f_pos)
+ break;
+
+ squashfs_get_cached_block(s, NULL, index_start, index_offset,
+ index.size + 1, &index_start,
+ &index_offset);
+
+ length = index.index;
+ *next_block = index.start_block + sblk->directory_table_start;
+ }
+
+ *next_offset = (length + *next_offset) % SQUASHFS_METADATA_SIZE;
+
+finish:
+ return length;
+}
+
+
+static int get_dir_index_using_name(struct super_block *s, long long
+ *next_block, unsigned int *next_offset,
+ long long index_start,
+ unsigned int index_offset, int i_count,
+ const char *name, int size)
+{
+ struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
+ struct squashfs_super_block *sblk = &msblk->sblk;
+ int i, length = 0;
+ char buffer[sizeof(struct squashfs_dir_index_2) + SQUASHFS_NAME_LEN + 1];
+ struct squashfs_dir_index_2 *index = (struct squashfs_dir_index_2 *) buffer;
+ char str[SQUASHFS_NAME_LEN + 1];
+
+ TRACE("Entered get_dir_index_using_name, i_count %d\n", i_count);
+
+ strncpy(str, name, size);
+ str[size] = '\0';
+
+ for (i = 0; i < i_count; i++) {
+ if (msblk->swap) {
+ struct squashfs_dir_index_2 sindex;
+ squashfs_get_cached_block(s, (char *) &sindex,
+ index_start, index_offset,
+ sizeof(sindex), &index_start,
+ &index_offset);
+ SQUASHFS_SWAP_DIR_INDEX_2(index, &sindex);
+ } else
+ squashfs_get_cached_block(s, (char *) index,
+ index_start, index_offset,
+ sizeof(struct squashfs_dir_index_2),
+ &index_start, &index_offset);
+
+ squashfs_get_cached_block(s, index->name, index_start,
+ index_offset, index->size + 1,
+ &index_start, &index_offset);
+
+ index->name[index->size + 1] = '\0';
+
+ if (strcmp(index->name, str) > 0)
+ break;
+
+ length = index->index;
+ *next_block = index->start_block + sblk->directory_table_start;
+ }
+
+ *next_offset = (length + *next_offset) % SQUASHFS_METADATA_SIZE;
+ return length;
+}
+
+
+static int squashfs_readdir_2(struct file *file, void *dirent, filldir_t filldir)
+{
+ struct inode *i = file->f_dentry->d_inode;
+ struct squashfs_sb_info *msblk = &i->i_sb->u.squashfs_sb;
+ struct squashfs_super_block *sblk = &msblk->sblk;
+ long long next_block = SQUASHFS_I(i)->start_block +
+ sblk->directory_table_start;
+ int next_offset = SQUASHFS_I(i)->offset, length = 0,
+ dir_count;
+ struct squashfs_dir_header_2 dirh;
+ char buffer[sizeof(struct squashfs_dir_entry_2) + SQUASHFS_NAME_LEN + 1];
+ struct squashfs_dir_entry_2 *dire = (struct squashfs_dir_entry_2 *) buffer;
+
+ TRACE("Entered squashfs_readdir_2 [%llx:%x]\n", next_block, next_offset);
+
+ length = get_dir_index_using_offset(i->i_sb, &next_block, &next_offset,
+ SQUASHFS_I(i)->u.s2.directory_index_start,
+ SQUASHFS_I(i)->u.s2.directory_index_offset,
+ SQUASHFS_I(i)->u.s2.directory_index_count,
+ file->f_pos);
+
+ while (length < i_size_read(i)) {
+ /* read directory header */
+ if (msblk->swap) {
+ struct squashfs_dir_header_2 sdirh;
+
+ if (!squashfs_get_cached_block(i->i_sb, (char *) &sdirh,
+ next_block, next_offset, sizeof(sdirh),
+ &next_block, &next_offset))
+ goto failed_read;
+
+ length += sizeof(sdirh);
+ SQUASHFS_SWAP_DIR_HEADER_2(&dirh, &sdirh);
+ } else {
+ if (!squashfs_get_cached_block(i->i_sb, (char *) &dirh,
+ next_block, next_offset, sizeof(dirh),
+ &next_block, &next_offset))
+ goto failed_read;
+
+ length += sizeof(dirh);
+ }
+
+ dir_count = dirh.count + 1;
+ while (dir_count--) {
+ if (msblk->swap) {
+ struct squashfs_dir_entry_2 sdire;
+ if (!squashfs_get_cached_block(i->i_sb, (char *)
+ &sdire, next_block, next_offset,
+ sizeof(sdire), &next_block,
+ &next_offset))
+ goto failed_read;
+
+ length += sizeof(sdire);
+ SQUASHFS_SWAP_DIR_ENTRY_2(dire, &sdire);
+ } else {
+ if (!squashfs_get_cached_block(i->i_sb, (char *)
+ dire, next_block, next_offset,
+ sizeof(*dire), &next_block,
+ &next_offset))
+ goto failed_read;
+
+ length += sizeof(*dire);
+ }
+
+ if (!squashfs_get_cached_block(i->i_sb, dire->name,
+ next_block, next_offset,
+ dire->size + 1, &next_block,
+ &next_offset))
+ goto failed_read;
+
+ length += dire->size + 1;
+
+ if (file->f_pos >= length)
+ continue;
+
+ dire->name[dire->size + 1] = '\0';
+
+ TRACE("Calling filldir(%x, %s, %d, %d, %x:%x, %d)\n",
+ (unsigned int) dirent, dire->name,
+ dire->size + 1, (int) file->f_pos,
+ dirh.start_block, dire->offset,
+ squashfs_filetype_table[dire->type]);
+
+ if (filldir(dirent, dire->name, dire->size + 1,
+ file->f_pos, SQUASHFS_MK_VFS_INODE(
+ dirh.start_block, dire->offset),
+ squashfs_filetype_table[dire->type])
+ < 0) {
+ TRACE("Filldir returned less than 0\n");
+ goto finish;
+ }
+ file->f_pos = length;
+ }
+ }
+
+finish:
+ return 0;
+
+failed_read:
+ ERROR("Unable to read directory block [%llx:%x]\n", next_block,
+ next_offset);
+ return 0;
+}
+
+
+static struct dentry *squashfs_lookup_2(struct inode *i, struct dentry *dentry)
+{
+ const unsigned char *name = dentry->d_name.name;
+ int len = dentry->d_name.len;
+ struct inode *inode = NULL;
+ struct squashfs_sb_info *msblk = &i->i_sb->u.squashfs_sb;
+ struct squashfs_super_block *sblk = &msblk->sblk;
+ long long next_block = SQUASHFS_I(i)->start_block +
+ sblk->directory_table_start;
+ int next_offset = SQUASHFS_I(i)->offset, length = 0,
+ dir_count;
+ struct squashfs_dir_header_2 dirh;
+ char buffer[sizeof(struct squashfs_dir_entry_2) + SQUASHFS_NAME_LEN];
+ struct squashfs_dir_entry_2 *dire = (struct squashfs_dir_entry_2 *) buffer;
+ int sorted = sblk->s_major == 2 && sblk->s_minor >= 1;
+
+ TRACE("Entered squashfs_lookup [%llx:%x]\n", next_block, next_offset);
+
+ if (len > SQUASHFS_NAME_LEN)
+ goto exit_loop;
+
+ length = get_dir_index_using_name(i->i_sb, &next_block, &next_offset,
+ SQUASHFS_I(i)->u.s2.directory_index_start,
+ SQUASHFS_I(i)->u.s2.directory_index_offset,
+ SQUASHFS_I(i)->u.s2.directory_index_count, name,
+ len);
+
+ while (length < i_size_read(i)) {
+ /* read directory header */
+ if (msblk->swap) {
+ struct squashfs_dir_header_2 sdirh;
+ if (!squashfs_get_cached_block(i->i_sb, (char *) &sdirh,
+ next_block, next_offset, sizeof(sdirh),
+ &next_block, &next_offset))
+ goto failed_read;
+
+ length += sizeof(sdirh);
+ SQUASHFS_SWAP_DIR_HEADER_2(&dirh, &sdirh);
+ } else {
+ if (!squashfs_get_cached_block(i->i_sb, (char *) &dirh,
+ next_block, next_offset, sizeof(dirh),
+ &next_block, &next_offset))
+ goto failed_read;
+
+ length += sizeof(dirh);
+ }
+
+ dir_count = dirh.count + 1;
+ while (dir_count--) {
+ if (msblk->swap) {
+ struct squashfs_dir_entry_2 sdire;
+ if (!squashfs_get_cached_block(i->i_sb, (char *)
+ &sdire, next_block,next_offset,
+ sizeof(sdire), &next_block,
+ &next_offset))
+ goto failed_read;
+
+ length += sizeof(sdire);
+ SQUASHFS_SWAP_DIR_ENTRY_2(dire, &sdire);
+ } else {
+ if (!squashfs_get_cached_block(i->i_sb, (char *)
+ dire, next_block,next_offset,
+ sizeof(*dire), &next_block,
+ &next_offset))
+ goto failed_read;
+
+ length += sizeof(*dire);
+ }
+
+ if (!squashfs_get_cached_block(i->i_sb, dire->name,
+ next_block, next_offset, dire->size + 1,
+ &next_block, &next_offset))
+ goto failed_read;
+
+ length += dire->size + 1;
+
+ if (sorted && name[0] < dire->name[0])
+ goto exit_loop;
+
+ if ((len == dire->size + 1) && !strncmp(name,
+ dire->name, len)) {
+ squashfs_inode_t ino =
+ SQUASHFS_MKINODE(dirh.start_block,
+ dire->offset);
+
+ TRACE("calling squashfs_iget for directory "
+ "entry %s, inode %x:%x, %d\n", name,
+ dirh.start_block, dire->offset, ino);
+
+ inode = (msblk->iget)(i->i_sb, ino);
+
+ goto exit_loop;
+ }
+ }
+ }
+
+exit_loop:
+ d_add(dentry, inode);
+ return ERR_PTR(0);
+
+failed_read:
+ ERROR("Unable to read directory block [%llx:%x]\n", next_block,
+ next_offset);
+ goto exit_loop;
+}
+
+
+int squashfs_2_0_supported(struct squashfs_sb_info *msblk)
+{
+ struct squashfs_super_block *sblk = &msblk->sblk;
+
+ msblk->iget = squashfs_iget_2;
+ msblk->read_fragment_index_table = read_fragment_index_table_2;
+
+ sblk->bytes_used = sblk->bytes_used_2;
+ sblk->uid_start = sblk->uid_start_2;
+ sblk->guid_start = sblk->guid_start_2;
+ sblk->inode_table_start = sblk->inode_table_start_2;
+ sblk->directory_table_start = sblk->directory_table_start_2;
+ sblk->fragment_table_start = sblk->fragment_table_start_2;
+
+ return 1;
+}
diff --git a/squashfs-tools/kernel-2.4/include/linux/squashfs_fs.h b/squashfs-tools/kernel-2.4/include/linux/squashfs_fs.h
new file mode 100755
index 0000000..eed48c3
--- /dev/null
+++ b/squashfs-tools/kernel-2.4/include/linux/squashfs_fs.h
@@ -0,0 +1,915 @@
+#ifndef SQUASHFS_FS
+#define SQUASHFS_FS
+
+/*
+ * Squashfs
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006
+ * Phillip Lougher <phillip@lougher.demon.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * squashfs_fs.h
+ */
+
+#ifndef CONFIG_SQUASHFS_2_0_COMPATIBILITY
+#define CONFIG_SQUASHFS_2_0_COMPATIBILITY
+#endif
+
+#ifdef CONFIG_SQUASHFS_VMALLOC
+#define SQUASHFS_ALLOC(a) vmalloc(a)
+#define SQUASHFS_FREE(a) vfree(a)
+#else
+#define SQUASHFS_ALLOC(a) kmalloc(a, GFP_KERNEL)
+#define SQUASHFS_FREE(a) kfree(a)
+#endif
+#ifdef CONFIG_SQUASHFS_FRAGMENT_CACHE_SIZE
+#define SQUASHFS_CACHED_FRAGMENTS CONFIG_SQUASHFS_FRAGMENT_CACHE_SIZE
+#else
+#define SQUASHFS_CACHED_FRAGMENTS 3
+#endif
+#define SQUASHFS_MAJOR 3
+#define SQUASHFS_MINOR 0
+#define SQUASHFS_MAGIC 0x73717368
+#define SQUASHFS_MAGIC_SWAP 0x68737173
+#define SQUASHFS_START 0
+
+/* size of metadata (inode and directory) blocks */
+#define SQUASHFS_METADATA_SIZE 8192
+#define SQUASHFS_METADATA_LOG 13
+
+/* default size of data blocks */
+#define SQUASHFS_FILE_SIZE 65536
+#define SQUASHFS_FILE_LOG 16
+
+#define SQUASHFS_FILE_MAX_SIZE 65536
+
+/* Max number of uids and gids */
+#define SQUASHFS_UIDS 256
+#define SQUASHFS_GUIDS 255
+
+/* Max length of filename (not 255) */
+#define SQUASHFS_NAME_LEN 256
+
+#define SQUASHFS_INVALID ((long long) 0xffffffffffff)
+#define SQUASHFS_INVALID_FRAG ((unsigned int) 0xffffffff)
+#define SQUASHFS_INVALID_BLK ((long long) -1)
+#define SQUASHFS_USED_BLK ((long long) -2)
+
+/* Filesystem flags */
+#define SQUASHFS_NOI 0
+#define SQUASHFS_NOD 1
+#define SQUASHFS_CHECK 2
+#define SQUASHFS_NOF 3
+#define SQUASHFS_NO_FRAG 4
+#define SQUASHFS_ALWAYS_FRAG 5
+#define SQUASHFS_DUPLICATE 6
+
+#define SQUASHFS_BIT(flag, bit) ((flag >> bit) & 1)
+
+#define SQUASHFS_UNCOMPRESSED_INODES(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_NOI)
+
+#define SQUASHFS_UNCOMPRESSED_DATA(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_NOD)
+
+#define SQUASHFS_UNCOMPRESSED_FRAGMENTS(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_NOF)
+
+#define SQUASHFS_NO_FRAGMENTS(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_NO_FRAG)
+
+#define SQUASHFS_ALWAYS_FRAGMENTS(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_ALWAYS_FRAG)
+
+#define SQUASHFS_DUPLICATES(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_DUPLICATE)
+
+#define SQUASHFS_CHECK_DATA(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_CHECK)
+
+#define SQUASHFS_MKFLAGS(noi, nod, check_data, nof, no_frag, always_frag, \
+ duplicate_checking) (noi | (nod << 1) | (check_data << 2) \
+ | (nof << 3) | (no_frag << 4) | (always_frag << 5) | \
+ (duplicate_checking << 6))
+
+/* Max number of types and file types */
+#define SQUASHFS_DIR_TYPE 1
+#define SQUASHFS_FILE_TYPE 2
+#define SQUASHFS_SYMLINK_TYPE 3
+#define SQUASHFS_BLKDEV_TYPE 4
+#define SQUASHFS_CHRDEV_TYPE 5
+#define SQUASHFS_FIFO_TYPE 6
+#define SQUASHFS_SOCKET_TYPE 7
+#define SQUASHFS_LDIR_TYPE 8
+#define SQUASHFS_LREG_TYPE 9
+
+/* 1.0 filesystem type definitions */
+#define SQUASHFS_TYPES 5
+#define SQUASHFS_IPC_TYPE 0
+
+/* Flag whether block is compressed or uncompressed, bit is set if block is
+ * uncompressed */
+#define SQUASHFS_COMPRESSED_BIT (1 << 15)
+
+#define SQUASHFS_COMPRESSED_SIZE(B) (((B) & ~SQUASHFS_COMPRESSED_BIT) ? \
+ (B) & ~SQUASHFS_COMPRESSED_BIT : SQUASHFS_COMPRESSED_BIT)
+
+#define SQUASHFS_COMPRESSED(B) (!((B) & SQUASHFS_COMPRESSED_BIT))
+
+#define SQUASHFS_COMPRESSED_BIT_BLOCK (1 << 24)
+
+#define SQUASHFS_COMPRESSED_SIZE_BLOCK(B) (((B) & \
+ ~SQUASHFS_COMPRESSED_BIT_BLOCK) ? (B) & \
+ ~SQUASHFS_COMPRESSED_BIT_BLOCK : SQUASHFS_COMPRESSED_BIT_BLOCK)
+
+#define SQUASHFS_COMPRESSED_BLOCK(B) (!((B) & SQUASHFS_COMPRESSED_BIT_BLOCK))
+
+/*
+ * Inode number ops. Inodes consist of a compressed block number, and an
+ * uncompressed offset within that block
+ */
+#define SQUASHFS_INODE_BLK(a) ((unsigned int) ((a) >> 16))
+
+#define SQUASHFS_INODE_OFFSET(a) ((unsigned int) ((a) & 0xffff))
+
+#define SQUASHFS_MKINODE(A, B) ((squashfs_inode_t)(((squashfs_inode_t) (A)\
+ << 16) + (B)))
+
+/* Compute 32 bit VFS inode number from squashfs inode number */
+#define SQUASHFS_MK_VFS_INODE(a, b) ((unsigned int) (((a) << 8) + \
+ ((b) >> 2) + 1))
+/* XXX */
+
+/* Translate between VFS mode and squashfs mode */
+#define SQUASHFS_MODE(a) ((a) & 0xfff)
+
+/* fragment and fragment table defines */
+#define SQUASHFS_FRAGMENT_BYTES(A) (A * sizeof(struct squashfs_fragment_entry))
+
+#define SQUASHFS_FRAGMENT_INDEX(A) (SQUASHFS_FRAGMENT_BYTES(A) / \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_FRAGMENT_INDEX_OFFSET(A) (SQUASHFS_FRAGMENT_BYTES(A) % \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_FRAGMENT_INDEXES(A) ((SQUASHFS_FRAGMENT_BYTES(A) + \
+ SQUASHFS_METADATA_SIZE - 1) / \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_FRAGMENT_INDEX_BYTES(A) (SQUASHFS_FRAGMENT_INDEXES(A) *\
+ sizeof(long long))
+
+/* cached data constants for filesystem */
+#define SQUASHFS_CACHED_BLKS 8
+
+#define SQUASHFS_MAX_FILE_SIZE_LOG 64
+
+#define SQUASHFS_MAX_FILE_SIZE ((long long) 1 << \
+ (SQUASHFS_MAX_FILE_SIZE_LOG - 2))
+
+#define SQUASHFS_MARKER_BYTE 0xff
+
+/* meta index cache */
+#define SQUASHFS_META_INDEXES (SQUASHFS_METADATA_SIZE / sizeof(unsigned int))
+#define SQUASHFS_META_ENTRIES 31
+#define SQUASHFS_META_NUMBER 8
+#define SQUASHFS_SLOTS 4
+
+struct meta_entry {
+ long long data_block;
+ unsigned int index_block;
+ unsigned short offset;
+ unsigned short pad;
+};
+
+struct meta_index {
+ unsigned int inode_number;
+ unsigned int offset;
+ unsigned short entries;
+ unsigned short skip;
+ unsigned short locked;
+ unsigned short pad;
+ struct meta_entry meta_entry[SQUASHFS_META_ENTRIES];
+};
+
+
+/*
+ * definitions for structures on disk
+ */
+
+typedef long long squashfs_block_t;
+typedef long long squashfs_inode_t;
+
+struct squashfs_super_block {
+ unsigned int s_magic;
+ unsigned int inodes;
+ unsigned int bytes_used_2;
+ unsigned int uid_start_2;
+ unsigned int guid_start_2;
+ unsigned int inode_table_start_2;
+ unsigned int directory_table_start_2;
+ unsigned int s_major:16;
+ unsigned int s_minor:16;
+ unsigned int block_size_1:16;
+ unsigned int block_log:16;
+ unsigned int flags:8;
+ unsigned int no_uids:8;
+ unsigned int no_guids:8;
+ unsigned int mkfs_time /* time of filesystem creation */;
+ squashfs_inode_t root_inode;
+ unsigned int block_size;
+ unsigned int fragments;
+ unsigned int fragment_table_start_2;
+ long long bytes_used;
+ long long uid_start;
+ long long guid_start;
+ long long inode_table_start;
+ long long directory_table_start;
+ long long fragment_table_start;
+ long long unused;
+} __attribute__ ((packed));
+
+struct squashfs_dir_index {
+ unsigned int index;
+ unsigned int start_block;
+ unsigned char size;
+ unsigned char name[0];
+} __attribute__ ((packed));
+
+#define SQUASHFS_BASE_INODE_HEADER \
+ unsigned int inode_type:4; \
+ unsigned int mode:12; \
+ unsigned int uid:8; \
+ unsigned int guid:8; \
+ unsigned int mtime; \
+ unsigned int inode_number;
+
+struct squashfs_base_inode_header {
+ SQUASHFS_BASE_INODE_HEADER;
+} __attribute__ ((packed));
+
+struct squashfs_ipc_inode_header {
+ SQUASHFS_BASE_INODE_HEADER;
+ unsigned int nlink;
+} __attribute__ ((packed));
+
+struct squashfs_dev_inode_header {
+ SQUASHFS_BASE_INODE_HEADER;
+ unsigned int nlink;
+ unsigned short rdev;
+} __attribute__ ((packed));
+
+struct squashfs_symlink_inode_header {
+ SQUASHFS_BASE_INODE_HEADER;
+ unsigned int nlink;
+ unsigned short symlink_size;
+ char symlink[0];
+} __attribute__ ((packed));
+
+struct squashfs_reg_inode_header {
+ SQUASHFS_BASE_INODE_HEADER;
+ squashfs_block_t start_block;
+ unsigned int fragment;
+ unsigned int offset;
+ unsigned int file_size;
+ unsigned short block_list[0];
+} __attribute__ ((packed));
+
+struct squashfs_lreg_inode_header {
+ SQUASHFS_BASE_INODE_HEADER;
+ unsigned int nlink;
+ squashfs_block_t start_block;
+ unsigned int fragment;
+ unsigned int offset;
+ long long file_size;
+ unsigned short block_list[0];
+} __attribute__ ((packed));
+
+struct squashfs_dir_inode_header {
+ SQUASHFS_BASE_INODE_HEADER;
+ unsigned int nlink;
+ unsigned int file_size:19;
+ unsigned int offset:13;
+ unsigned int start_block;
+ unsigned int parent_inode;
+} __attribute__ ((packed));
+
+struct squashfs_ldir_inode_header {
+ SQUASHFS_BASE_INODE_HEADER;
+ unsigned int nlink;
+ unsigned int file_size:27;
+ unsigned int offset:13;
+ unsigned int start_block;
+ unsigned int i_count:16;
+ unsigned int parent_inode;
+ struct squashfs_dir_index index[0];
+} __attribute__ ((packed));
+
+union squashfs_inode_header {
+ struct squashfs_base_inode_header base;
+ struct squashfs_dev_inode_header dev;
+ struct squashfs_symlink_inode_header symlink;
+ struct squashfs_reg_inode_header reg;
+ struct squashfs_lreg_inode_header lreg;
+ struct squashfs_dir_inode_header dir;
+ struct squashfs_ldir_inode_header ldir;
+ struct squashfs_ipc_inode_header ipc;
+};
+
+struct squashfs_dir_entry {
+ unsigned int offset:13;
+ unsigned int type:3;
+ unsigned int size:8;
+ int inode_number:16;
+ char name[0];
+} __attribute__ ((packed));
+
+struct squashfs_dir_header {
+ unsigned int count:8;
+ unsigned int start_block;
+ unsigned int inode_number;
+} __attribute__ ((packed));
+
+struct squashfs_fragment_entry {
+ long long start_block;
+ unsigned int size;
+ unsigned int unused;
+} __attribute__ ((packed));
+
+extern int squashfs_uncompress_block(void *d, int dstlen, void *s, int srclen);
+extern int squashfs_uncompress_init(void);
+extern int squashfs_uncompress_exit(void);
+
+/*
+ * macros to convert each packed bitfield structure from little endian to big
+ * endian and vice versa. These are needed when creating or using a filesystem
+ * on a machine with different byte ordering to the target architecture.
+ *
+ */
+
+#define SQUASHFS_SWAP_START \
+ int bits;\
+ int b_pos;\
+ unsigned long long val;\
+ unsigned char *s;\
+ unsigned char *d;
+
+#define SQUASHFS_SWAP_SUPER_BLOCK(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_super_block));\
+ SQUASHFS_SWAP((s)->s_magic, d, 0, 32);\
+ SQUASHFS_SWAP((s)->inodes, d, 32, 32);\
+ SQUASHFS_SWAP((s)->bytes_used_2, d, 64, 32);\
+ SQUASHFS_SWAP((s)->uid_start_2, d, 96, 32);\
+ SQUASHFS_SWAP((s)->guid_start_2, d, 128, 32);\
+ SQUASHFS_SWAP((s)->inode_table_start_2, d, 160, 32);\
+ SQUASHFS_SWAP((s)->directory_table_start_2, d, 192, 32);\
+ SQUASHFS_SWAP((s)->s_major, d, 224, 16);\
+ SQUASHFS_SWAP((s)->s_minor, d, 240, 16);\
+ SQUASHFS_SWAP((s)->block_size_1, d, 256, 16);\
+ SQUASHFS_SWAP((s)->block_log, d, 272, 16);\
+ SQUASHFS_SWAP((s)->flags, d, 288, 8);\
+ SQUASHFS_SWAP((s)->no_uids, d, 296, 8);\
+ SQUASHFS_SWAP((s)->no_guids, d, 304, 8);\
+ SQUASHFS_SWAP((s)->mkfs_time, d, 312, 32);\
+ SQUASHFS_SWAP((s)->root_inode, d, 344, 64);\
+ SQUASHFS_SWAP((s)->block_size, d, 408, 32);\
+ SQUASHFS_SWAP((s)->fragments, d, 440, 32);\
+ SQUASHFS_SWAP((s)->fragment_table_start_2, d, 472, 32);\
+ SQUASHFS_SWAP((s)->bytes_used, d, 504, 64);\
+ SQUASHFS_SWAP((s)->uid_start, d, 568, 64);\
+ SQUASHFS_SWAP((s)->guid_start, d, 632, 64);\
+ SQUASHFS_SWAP((s)->inode_table_start, d, 696, 64);\
+ SQUASHFS_SWAP((s)->directory_table_start, d, 760, 64);\
+ SQUASHFS_SWAP((s)->fragment_table_start, d, 824, 64);\
+ SQUASHFS_SWAP((s)->unused, d, 888, 64);\
+}
+
+#define SQUASHFS_SWAP_BASE_INODE_CORE(s, d, n)\
+ SQUASHFS_MEMSET(s, d, n);\
+ SQUASHFS_SWAP((s)->inode_type, d, 0, 4);\
+ SQUASHFS_SWAP((s)->mode, d, 4, 12);\
+ SQUASHFS_SWAP((s)->uid, d, 16, 8);\
+ SQUASHFS_SWAP((s)->guid, d, 24, 8);\
+ SQUASHFS_SWAP((s)->mtime, d, 32, 32);\
+ SQUASHFS_SWAP((s)->inode_number, d, 64, 32);
+
+#define SQUASHFS_SWAP_BASE_INODE_HEADER(s, d, n) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE(s, d, n)\
+}
+
+#define SQUASHFS_SWAP_IPC_INODE_HEADER(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE(s, d, \
+ sizeof(struct squashfs_ipc_inode_header))\
+ SQUASHFS_SWAP((s)->nlink, d, 96, 32);\
+}
+
+#define SQUASHFS_SWAP_DEV_INODE_HEADER(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE(s, d, \
+ sizeof(struct squashfs_dev_inode_header)); \
+ SQUASHFS_SWAP((s)->nlink, d, 96, 32);\
+ SQUASHFS_SWAP((s)->rdev, d, 128, 16);\
+}
+
+#define SQUASHFS_SWAP_SYMLINK_INODE_HEADER(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE(s, d, \
+ sizeof(struct squashfs_symlink_inode_header));\
+ SQUASHFS_SWAP((s)->nlink, d, 96, 32);\
+ SQUASHFS_SWAP((s)->symlink_size, d, 128, 16);\
+}
+
+#define SQUASHFS_SWAP_REG_INODE_HEADER(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE(s, d, \
+ sizeof(struct squashfs_reg_inode_header));\
+ SQUASHFS_SWAP((s)->start_block, d, 96, 64);\
+ SQUASHFS_SWAP((s)->fragment, d, 160, 32);\
+ SQUASHFS_SWAP((s)->offset, d, 192, 32);\
+ SQUASHFS_SWAP((s)->file_size, d, 224, 32);\
+}
+
+#define SQUASHFS_SWAP_LREG_INODE_HEADER(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE(s, d, \
+ sizeof(struct squashfs_lreg_inode_header));\
+ SQUASHFS_SWAP((s)->nlink, d, 96, 32);\
+ SQUASHFS_SWAP((s)->start_block, d, 128, 64);\
+ SQUASHFS_SWAP((s)->fragment, d, 192, 32);\
+ SQUASHFS_SWAP((s)->offset, d, 224, 32);\
+ SQUASHFS_SWAP((s)->file_size, d, 256, 64);\
+}
+
+#define SQUASHFS_SWAP_DIR_INODE_HEADER(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE(s, d, \
+ sizeof(struct squashfs_dir_inode_header));\
+ SQUASHFS_SWAP((s)->nlink, d, 96, 32);\
+ SQUASHFS_SWAP((s)->file_size, d, 128, 19);\
+ SQUASHFS_SWAP((s)->offset, d, 147, 13);\
+ SQUASHFS_SWAP((s)->start_block, d, 160, 32);\
+ SQUASHFS_SWAP((s)->parent_inode, d, 192, 32);\
+}
+
+#define SQUASHFS_SWAP_LDIR_INODE_HEADER(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE(s, d, \
+ sizeof(struct squashfs_ldir_inode_header));\
+ SQUASHFS_SWAP((s)->nlink, d, 96, 32);\
+ SQUASHFS_SWAP((s)->file_size, d, 128, 27);\
+ SQUASHFS_SWAP((s)->offset, d, 155, 13);\
+ SQUASHFS_SWAP((s)->start_block, d, 168, 32);\
+ SQUASHFS_SWAP((s)->i_count, d, 200, 16);\
+ SQUASHFS_SWAP((s)->parent_inode, d, 216, 32);\
+}
+
+#define SQUASHFS_SWAP_DIR_INDEX(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_index));\
+ SQUASHFS_SWAP((s)->index, d, 0, 32);\
+ SQUASHFS_SWAP((s)->start_block, d, 32, 32);\
+ SQUASHFS_SWAP((s)->size, d, 64, 8);\
+}
+
+#define SQUASHFS_SWAP_DIR_HEADER(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_header));\
+ SQUASHFS_SWAP((s)->count, d, 0, 8);\
+ SQUASHFS_SWAP((s)->start_block, d, 8, 32);\
+ SQUASHFS_SWAP((s)->inode_number, d, 40, 32);\
+}
+
+#define SQUASHFS_SWAP_DIR_ENTRY(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_entry));\
+ SQUASHFS_SWAP((s)->offset, d, 0, 13);\
+ SQUASHFS_SWAP((s)->type, d, 13, 3);\
+ SQUASHFS_SWAP((s)->size, d, 16, 8);\
+ SQUASHFS_SWAP((s)->inode_number, d, 24, 16);\
+}
+
+#define SQUASHFS_SWAP_FRAGMENT_ENTRY(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_fragment_entry));\
+ SQUASHFS_SWAP((s)->start_block, d, 0, 64);\
+ SQUASHFS_SWAP((s)->size, d, 64, 32);\
+}
+
+#define SQUASHFS_SWAP_SHORTS(s, d, n) {\
+ int entry;\
+ int bit_position;\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_MEMSET(s, d, n * 2);\
+ for(entry = 0, bit_position = 0; entry < n; entry++, bit_position += \
+ 16)\
+ SQUASHFS_SWAP(s[entry], d, bit_position, 16);\
+}
+
+#define SQUASHFS_SWAP_INTS(s, d, n) {\
+ int entry;\
+ int bit_position;\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_MEMSET(s, d, n * 4);\
+ for(entry = 0, bit_position = 0; entry < n; entry++, bit_position += \
+ 32)\
+ SQUASHFS_SWAP(s[entry], d, bit_position, 32);\
+}
+
+#define SQUASHFS_SWAP_LONG_LONGS(s, d, n) {\
+ int entry;\
+ int bit_position;\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_MEMSET(s, d, n * 8);\
+ for(entry = 0, bit_position = 0; entry < n; entry++, bit_position += \
+ 64)\
+ SQUASHFS_SWAP(s[entry], d, bit_position, 64);\
+}
+
+#define SQUASHFS_SWAP_DATA(s, d, n, bits) {\
+ int entry;\
+ int bit_position;\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_MEMSET(s, d, n * bits / 8);\
+ for(entry = 0, bit_position = 0; entry < n; entry++, bit_position += \
+ bits)\
+ SQUASHFS_SWAP(s[entry], d, bit_position, bits);\
+}
+
+#define SQUASHFS_SWAP_FRAGMENT_INDEXES(s, d, n) SQUASHFS_SWAP_LONG_LONGS(s, d, n)
+
+#ifdef CONFIG_SQUASHFS_1_0_COMPATIBILITY
+
+struct squashfs_base_inode_header_1 {
+ unsigned int inode_type:4;
+ unsigned int mode:12; /* protection */
+ unsigned int uid:4; /* index into uid table */
+ unsigned int guid:4; /* index into guid table */
+} __attribute__ ((packed));
+
+struct squashfs_ipc_inode_header_1 {
+ unsigned int inode_type:4;
+ unsigned int mode:12; /* protection */
+ unsigned int uid:4; /* index into uid table */
+ unsigned int guid:4; /* index into guid table */
+ unsigned int type:4;
+ unsigned int offset:4;
+} __attribute__ ((packed));
+
+struct squashfs_dev_inode_header_1 {
+ unsigned int inode_type:4;
+ unsigned int mode:12; /* protection */
+ unsigned int uid:4; /* index into uid table */
+ unsigned int guid:4; /* index into guid table */
+ unsigned short rdev;
+} __attribute__ ((packed));
+
+struct squashfs_symlink_inode_header_1 {
+ unsigned int inode_type:4;
+ unsigned int mode:12; /* protection */
+ unsigned int uid:4; /* index into uid table */
+ unsigned int guid:4; /* index into guid table */
+ unsigned short symlink_size;
+ char symlink[0];
+} __attribute__ ((packed));
+
+struct squashfs_reg_inode_header_1 {
+ unsigned int inode_type:4;
+ unsigned int mode:12; /* protection */
+ unsigned int uid:4; /* index into uid table */
+ unsigned int guid:4; /* index into guid table */
+ unsigned int mtime;
+ unsigned int start_block;
+ unsigned int file_size:32;
+ unsigned short block_list[0];
+} __attribute__ ((packed));
+
+struct squashfs_dir_inode_header_1 {
+ unsigned int inode_type:4;
+ unsigned int mode:12; /* protection */
+ unsigned int uid:4; /* index into uid table */
+ unsigned int guid:4; /* index into guid table */
+ unsigned int file_size:19;
+ unsigned int offset:13;
+ unsigned int mtime;
+ unsigned int start_block:24;
+} __attribute__ ((packed));
+
+#define SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, n) \
+ SQUASHFS_MEMSET(s, d, n);\
+ SQUASHFS_SWAP((s)->inode_type, d, 0, 4);\
+ SQUASHFS_SWAP((s)->mode, d, 4, 12);\
+ SQUASHFS_SWAP((s)->uid, d, 16, 4);\
+ SQUASHFS_SWAP((s)->guid, d, 20, 4);
+
+#define SQUASHFS_SWAP_BASE_INODE_HEADER_1(s, d, n) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, n)\
+}
+
+#define SQUASHFS_SWAP_IPC_INODE_HEADER_1(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \
+ sizeof(struct squashfs_ipc_inode_header_1));\
+ SQUASHFS_SWAP((s)->type, d, 24, 4);\
+ SQUASHFS_SWAP((s)->offset, d, 28, 4);\
+}
+
+#define SQUASHFS_SWAP_DEV_INODE_HEADER_1(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \
+ sizeof(struct squashfs_dev_inode_header_1));\
+ SQUASHFS_SWAP((s)->rdev, d, 24, 16);\
+}
+
+#define SQUASHFS_SWAP_SYMLINK_INODE_HEADER_1(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \
+ sizeof(struct squashfs_symlink_inode_header_1));\
+ SQUASHFS_SWAP((s)->symlink_size, d, 24, 16);\
+}
+
+#define SQUASHFS_SWAP_REG_INODE_HEADER_1(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \
+ sizeof(struct squashfs_reg_inode_header_1));\
+ SQUASHFS_SWAP((s)->mtime, d, 24, 32);\
+ SQUASHFS_SWAP((s)->start_block, d, 56, 32);\
+ SQUASHFS_SWAP((s)->file_size, d, 88, 32);\
+}
+
+#define SQUASHFS_SWAP_DIR_INODE_HEADER_1(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \
+ sizeof(struct squashfs_dir_inode_header_1));\
+ SQUASHFS_SWAP((s)->file_size, d, 24, 19);\
+ SQUASHFS_SWAP((s)->offset, d, 43, 13);\
+ SQUASHFS_SWAP((s)->mtime, d, 56, 32);\
+ SQUASHFS_SWAP((s)->start_block, d, 88, 24);\
+}
+
+#endif
+
+#ifdef CONFIG_SQUASHFS_2_0_COMPATIBILITY
+
+struct squashfs_dir_index_2 {
+ unsigned int index:27;
+ unsigned int start_block:29;
+ unsigned char size;
+ unsigned char name[0];
+} __attribute__ ((packed));
+
+struct squashfs_base_inode_header_2 {
+ unsigned int inode_type:4;
+ unsigned int mode:12; /* protection */
+ unsigned int uid:8; /* index into uid table */
+ unsigned int guid:8; /* index into guid table */
+} __attribute__ ((packed));
+
+struct squashfs_ipc_inode_header_2 {
+ unsigned int inode_type:4;
+ unsigned int mode:12; /* protection */
+ unsigned int uid:8; /* index into uid table */
+ unsigned int guid:8; /* index into guid table */
+} __attribute__ ((packed));
+
+struct squashfs_dev_inode_header_2 {
+ unsigned int inode_type:4;
+ unsigned int mode:12; /* protection */
+ unsigned int uid:8; /* index into uid table */
+ unsigned int guid:8; /* index into guid table */
+ unsigned short rdev;
+} __attribute__ ((packed));
+
+struct squashfs_symlink_inode_header_2 {
+ unsigned int inode_type:4;
+ unsigned int mode:12; /* protection */
+ unsigned int uid:8; /* index into uid table */
+ unsigned int guid:8; /* index into guid table */
+ unsigned short symlink_size;
+ char symlink[0];
+} __attribute__ ((packed));
+
+struct squashfs_reg_inode_header_2 {
+ unsigned int inode_type:4;
+ unsigned int mode:12; /* protection */
+ unsigned int uid:8; /* index into uid table */
+ unsigned int guid:8; /* index into guid table */
+ unsigned int mtime;
+ unsigned int start_block;
+ unsigned int fragment;
+ unsigned int offset;
+ unsigned int file_size:32;
+ unsigned short block_list[0];
+} __attribute__ ((packed));
+
+struct squashfs_dir_inode_header_2 {
+ unsigned int inode_type:4;
+ unsigned int mode:12; /* protection */
+ unsigned int uid:8; /* index into uid table */
+ unsigned int guid:8; /* index into guid table */
+ unsigned int file_size:19;
+ unsigned int offset:13;
+ unsigned int mtime;
+ unsigned int start_block:24;
+} __attribute__ ((packed));
+
+struct squashfs_ldir_inode_header_2 {
+ unsigned int inode_type:4;
+ unsigned int mode:12; /* protection */
+ unsigned int uid:8; /* index into uid table */
+ unsigned int guid:8; /* index into guid table */
+ unsigned int file_size:27;
+ unsigned int offset:13;
+ unsigned int mtime;
+ unsigned int start_block:24;
+ unsigned int i_count:16;
+ struct squashfs_dir_index_2 index[0];
+} __attribute__ ((packed));
+
+union squashfs_inode_header_2 {
+ struct squashfs_base_inode_header_2 base;
+ struct squashfs_dev_inode_header_2 dev;
+ struct squashfs_symlink_inode_header_2 symlink;
+ struct squashfs_reg_inode_header_2 reg;
+ struct squashfs_dir_inode_header_2 dir;
+ struct squashfs_ldir_inode_header_2 ldir;
+ struct squashfs_ipc_inode_header_2 ipc;
+};
+
+struct squashfs_dir_header_2 {
+ unsigned int count:8;
+ unsigned int start_block:24;
+} __attribute__ ((packed));
+
+struct squashfs_dir_entry_2 {
+ unsigned int offset:13;
+ unsigned int type:3;
+ unsigned int size:8;
+ char name[0];
+} __attribute__ ((packed));
+
+struct squashfs_fragment_entry_2 {
+ unsigned int start_block;
+ unsigned int size;
+} __attribute__ ((packed));
+
+#define SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, n)\
+ SQUASHFS_MEMSET(s, d, n);\
+ SQUASHFS_SWAP((s)->inode_type, d, 0, 4);\
+ SQUASHFS_SWAP((s)->mode, d, 4, 12);\
+ SQUASHFS_SWAP((s)->uid, d, 16, 8);\
+ SQUASHFS_SWAP((s)->guid, d, 24, 8);\
+
+#define SQUASHFS_SWAP_BASE_INODE_HEADER_2(s, d, n) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, n)\
+}
+
+#define SQUASHFS_SWAP_IPC_INODE_HEADER_2(s, d) \
+ SQUASHFS_SWAP_BASE_INODE_HEADER_2(s, d, sizeof(struct squashfs_ipc_inode_header_2))
+
+#define SQUASHFS_SWAP_DEV_INODE_HEADER_2(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \
+ sizeof(struct squashfs_dev_inode_header_2)); \
+ SQUASHFS_SWAP((s)->rdev, d, 32, 16);\
+}
+
+#define SQUASHFS_SWAP_SYMLINK_INODE_HEADER_2(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \
+ sizeof(struct squashfs_symlink_inode_header_2));\
+ SQUASHFS_SWAP((s)->symlink_size, d, 32, 16);\
+}
+
+#define SQUASHFS_SWAP_REG_INODE_HEADER_2(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \
+ sizeof(struct squashfs_reg_inode_header_2));\
+ SQUASHFS_SWAP((s)->mtime, d, 32, 32);\
+ SQUASHFS_SWAP((s)->start_block, d, 64, 32);\
+ SQUASHFS_SWAP((s)->fragment, d, 96, 32);\
+ SQUASHFS_SWAP((s)->offset, d, 128, 32);\
+ SQUASHFS_SWAP((s)->file_size, d, 160, 32);\
+}
+
+#define SQUASHFS_SWAP_DIR_INODE_HEADER_2(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \
+ sizeof(struct squashfs_dir_inode_header_2));\
+ SQUASHFS_SWAP((s)->file_size, d, 32, 19);\
+ SQUASHFS_SWAP((s)->offset, d, 51, 13);\
+ SQUASHFS_SWAP((s)->mtime, d, 64, 32);\
+ SQUASHFS_SWAP((s)->start_block, d, 96, 24);\
+}
+
+#define SQUASHFS_SWAP_LDIR_INODE_HEADER_2(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \
+ sizeof(struct squashfs_ldir_inode_header_2));\
+ SQUASHFS_SWAP((s)->file_size, d, 32, 27);\
+ SQUASHFS_SWAP((s)->offset, d, 59, 13);\
+ SQUASHFS_SWAP((s)->mtime, d, 72, 32);\
+ SQUASHFS_SWAP((s)->start_block, d, 104, 24);\
+ SQUASHFS_SWAP((s)->i_count, d, 128, 16);\
+}
+
+#define SQUASHFS_SWAP_DIR_INDEX_2(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_index_2));\
+ SQUASHFS_SWAP((s)->index, d, 0, 27);\
+ SQUASHFS_SWAP((s)->start_block, d, 27, 29);\
+ SQUASHFS_SWAP((s)->size, d, 56, 8);\
+}
+#define SQUASHFS_SWAP_DIR_HEADER_2(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_header_2));\
+ SQUASHFS_SWAP((s)->count, d, 0, 8);\
+ SQUASHFS_SWAP((s)->start_block, d, 8, 24);\
+}
+
+#define SQUASHFS_SWAP_DIR_ENTRY_2(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_entry_2));\
+ SQUASHFS_SWAP((s)->offset, d, 0, 13);\
+ SQUASHFS_SWAP((s)->type, d, 13, 3);\
+ SQUASHFS_SWAP((s)->size, d, 16, 8);\
+}
+
+#define SQUASHFS_SWAP_FRAGMENT_ENTRY_2(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_fragment_entry_2));\
+ SQUASHFS_SWAP((s)->start_block, d, 0, 32);\
+ SQUASHFS_SWAP((s)->size, d, 32, 32);\
+}
+
+#define SQUASHFS_SWAP_FRAGMENT_INDEXES_2(s, d, n) SQUASHFS_SWAP_INTS(s, d, n)
+
+/* fragment and fragment table defines */
+#define SQUASHFS_FRAGMENT_BYTES_2(A) (A * sizeof(struct squashfs_fragment_entry_2))
+
+#define SQUASHFS_FRAGMENT_INDEX_2(A) (SQUASHFS_FRAGMENT_BYTES_2(A) / \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_FRAGMENT_INDEX_OFFSET_2(A) (SQUASHFS_FRAGMENT_BYTES_2(A) % \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_FRAGMENT_INDEXES_2(A) ((SQUASHFS_FRAGMENT_BYTES_2(A) + \
+ SQUASHFS_METADATA_SIZE - 1) / \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_FRAGMENT_INDEX_BYTES_2(A) (SQUASHFS_FRAGMENT_INDEXES_2(A) *\
+ sizeof(int))
+
+#endif
+
+#ifdef __KERNEL__
+
+/*
+ * macros used to swap each structure entry, taking into account
+ * bitfields and different bitfield placing conventions on differing
+ * architectures
+ */
+
+#include <asm/byteorder.h>
+
+#ifdef __BIG_ENDIAN
+ /* convert from little endian to big endian */
+#define SQUASHFS_SWAP(value, p, pos, tbits) _SQUASHFS_SWAP(value, p, pos, \
+ tbits, b_pos)
+#else
+ /* convert from big endian to little endian */
+#define SQUASHFS_SWAP(value, p, pos, tbits) _SQUASHFS_SWAP(value, p, pos, \
+ tbits, 64 - tbits - b_pos)
+#endif
+
+#define _SQUASHFS_SWAP(value, p, pos, tbits, SHIFT) {\
+ b_pos = pos % 8;\
+ val = 0;\
+ s = (unsigned char *)p + (pos / 8);\
+ d = ((unsigned char *) &val) + 7;\
+ for(bits = 0; bits < (tbits + b_pos); bits += 8) \
+ *d-- = *s++;\
+ value = (val >> (SHIFT))/* & ((1 << tbits) - 1)*/;\
+}
+
+#define SQUASHFS_MEMSET(s, d, n) memset(s, 0, n);
+
+#endif
+#endif
diff --git a/squashfs-tools/kernel-2.4/include/linux/squashfs_fs_i.h b/squashfs-tools/kernel-2.4/include/linux/squashfs_fs_i.h
new file mode 100755
index 0000000..1d7720c
--- /dev/null
+++ b/squashfs-tools/kernel-2.4/include/linux/squashfs_fs_i.h
@@ -0,0 +1,44 @@
+#ifndef SQUASHFS_FS_I
+#define SQUASHFS_FS_I
+/*
+ * Squashfs
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006
+ * Phillip Lougher <phillip@lougher.demon.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * squashfs_fs_i.h
+ */
+
+struct squashfs_inode_info {
+ long long start_block;
+ unsigned int offset;
+ union {
+ struct {
+ long long fragment_start_block;
+ unsigned int fragment_size;
+ unsigned int fragment_offset;
+ long long block_list_start;
+ } s1;
+ struct {
+ long long directory_index_start;
+ unsigned int directory_index_offset;
+ unsigned int directory_index_count;
+ unsigned int parent_inode;
+ } s2;
+ } u;
+};
+#endif
diff --git a/squashfs-tools/kernel-2.4/include/linux/squashfs_fs_sb.h b/squashfs-tools/kernel-2.4/include/linux/squashfs_fs_sb.h
new file mode 100755
index 0000000..ba08d7f
--- /dev/null
+++ b/squashfs-tools/kernel-2.4/include/linux/squashfs_fs_sb.h
@@ -0,0 +1,76 @@
+#ifndef SQUASHFS_FS_SB
+#define SQUASHFS_FS_SB
+/*
+ * Squashfs
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006
+ * Phillip Lougher <phillip@lougher.demon.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * squashfs_fs_sb.h
+ */
+
+#include <linux/squashfs_fs.h>
+#include <linux/zlib.h>
+
+struct squashfs_cache {
+ long long block;
+ int length;
+ long long next_index;
+ char *data;
+};
+
+struct squashfs_fragment_cache {
+ long long block;
+ int length;
+ unsigned int locked;
+ char *data;
+};
+
+struct squashfs_sb_info {
+ struct squashfs_super_block sblk;
+ int devblksize;
+ int devblksize_log2;
+ int swap;
+ struct squashfs_cache *block_cache;
+ struct squashfs_fragment_cache *fragment;
+ int next_cache;
+ int next_fragment;
+ int next_meta_index;
+ unsigned int *uid;
+ unsigned int *guid;
+ long long *fragment_index;
+ unsigned int *fragment_index_2;
+ unsigned int read_size;
+ char *read_data;
+ char *read_page;
+ struct semaphore read_data_mutex;
+ struct semaphore read_page_mutex;
+ struct semaphore block_cache_mutex;
+ struct semaphore fragment_mutex;
+ struct semaphore meta_index_mutex;
+ wait_queue_head_t waitq;
+ wait_queue_head_t fragment_wait_queue;
+ struct meta_index *meta_index;
+ z_stream stream;
+ struct inode *(*iget)(struct super_block *s, squashfs_inode_t
+ inode);
+ long long (*read_blocklist)(struct inode *inode, int
+ index, int readahead_blks, char *block_list,
+ unsigned short **block_p, unsigned int *bsize);
+ int (*read_fragment_index_table)(struct super_block *s);
+};
+#endif
diff --git a/squashfs-tools/kernel/Documentation/filesystems/squashfs.txt b/squashfs-tools/kernel/Documentation/filesystems/squashfs.txt
new file mode 100644
index 0000000..3e79e4a
--- /dev/null
+++ b/squashfs-tools/kernel/Documentation/filesystems/squashfs.txt
@@ -0,0 +1,225 @@
+SQUASHFS 4.0 FILESYSTEM
+=======================
+
+Squashfs is a compressed read-only filesystem for Linux.
+It uses zlib compression to compress files, inodes and directories.
+Inodes in the system are very small and all blocks are packed to minimise
+data overhead. Block sizes greater than 4K are supported up to a maximum
+of 1Mbytes (default block size 128K).
+
+Squashfs is intended for general read-only filesystem use, for archival
+use (i.e. in cases where a .tar.gz file may be used), and in constrained
+block device/memory systems (e.g. embedded systems) where low overhead is
+needed.
+
+Mailing list: squashfs-devel@lists.sourceforge.net
+Web site: www.squashfs.org
+
+1. FILESYSTEM FEATURES
+----------------------
+
+Squashfs filesystem features versus Cramfs:
+
+ Squashfs Cramfs
+
+Max filesystem size: 2^64 16 MiB
+Max file size: ~ 2 TiB 16 MiB
+Max files: unlimited unlimited
+Max directories: unlimited unlimited
+Max entries per directory: unlimited unlimited
+Max block size: 1 MiB 4 KiB
+Metadata compression: yes no
+Directory indexes: yes no
+Sparse file support: yes no
+Tail-end packing (fragments): yes no
+Exportable (NFS etc.): yes no
+Hard link support: yes no
+"." and ".." in readdir: yes no
+Real inode numbers: yes no
+32-bit uids/gids: yes no
+File creation time: yes no
+Xattr and ACL support: no no
+
+Squashfs compresses data, inodes and directories. In addition, inode and
+directory data are highly compacted, and packed on byte boundaries. Each
+compressed inode is on average 8 bytes in length (the exact length varies on
+file type, i.e. regular file, directory, symbolic link, and block/char device
+inodes have different sizes).
+
+2. USING SQUASHFS
+-----------------
+
+As squashfs is a read-only filesystem, the mksquashfs program must be used to
+create populated squashfs filesystems. This and other squashfs utilities
+can be obtained from http://www.squashfs.org. Usage instructions can be
+obtained from this site also.
+
+
+3. SQUASHFS FILESYSTEM DESIGN
+-----------------------------
+
+A squashfs filesystem consists of seven parts, packed together on a byte
+alignment:
+
+ ---------------
+ | superblock |
+ |---------------|
+ | datablocks |
+ | & fragments |
+ |---------------|
+ | inode table |
+ |---------------|
+ | directory |
+ | table |
+ |---------------|
+ | fragment |
+ | table |
+ |---------------|
+ | export |
+ | table |
+ |---------------|
+ | uid/gid |
+ | lookup table |
+ ---------------
+
+Compressed data blocks are written to the filesystem as files are read from
+the source directory, and checked for duplicates. Once all file data has been
+written the completed inode, directory, fragment, export and uid/gid lookup
+tables are written.
+
+3.1 Inodes
+----------
+
+Metadata (inodes and directories) are compressed in 8Kbyte blocks. Each
+compressed block is prefixed by a two byte length, the top bit is set if the
+block is uncompressed. A block will be uncompressed if the -noI option is set,
+or if the compressed block was larger than the uncompressed block.
+
+Inodes are packed into the metadata blocks, and are not aligned to block
+boundaries, therefore inodes overlap compressed blocks. Inodes are identified
+by a 48-bit number which encodes the location of the compressed metadata block
+containing the inode, and the byte offset into that block where the inode is
+placed (<block, offset>).
+
+To maximise compression there are different inodes for each file type
+(regular file, directory, device, etc.), the inode contents and length
+varying with the type.
+
+To further maximise compression, two types of regular file inode and
+directory inode are defined: inodes optimised for frequently occurring
+regular files and directories, and extended types where extra
+information has to be stored.
+
+3.2 Directories
+---------------
+
+Like inodes, directories are packed into compressed metadata blocks, stored
+in a directory table. Directories are accessed using the start address of
+the metablock containing the directory and the offset into the
+decompressed block (<block, offset>).
+
+Directories are organised in a slightly complex way, and are not simply
+a list of file names. The organisation takes advantage of the
+fact that (in most cases) the inodes of the files will be in the same
+compressed metadata block, and therefore, can share the start block.
+Directories are therefore organised in a two level list, a directory
+header containing the shared start block value, and a sequence of directory
+entries, each of which share the shared start block. A new directory header
+is written once/if the inode start block changes. The directory
+header/directory entry list is repeated as many times as necessary.
+
+Directories are sorted, and can contain a directory index to speed up
+file lookup. Directory indexes store one entry per metablock, each entry
+storing the index/filename mapping to the first directory header
+in each metadata block. Directories are sorted in alphabetical order,
+and at lookup the index is scanned linearly looking for the first filename
+alphabetically larger than the filename being looked up. At this point the
+location of the metadata block the filename is in has been found.
+The general idea of the index is ensure only one metadata block needs to be
+decompressed to do a lookup irrespective of the length of the directory.
+This scheme has the advantage that it doesn't require extra memory overhead
+and doesn't require much extra storage on disk.
+
+3.3 File data
+-------------
+
+Regular files consist of a sequence of contiguous compressed blocks, and/or a
+compressed fragment block (tail-end packed block). The compressed size
+of each datablock is stored in a block list contained within the
+file inode.
+
+To speed up access to datablocks when reading 'large' files (256 Mbytes or
+larger), the code implements an index cache that caches the mapping from
+block index to datablock location on disk.
+
+The index cache allows Squashfs to handle large files (up to 1.75 TiB) while
+retaining a simple and space-efficient block list on disk. The cache
+is split into slots, caching up to eight 224 GiB files (128 KiB blocks).
+Larger files use multiple slots, with 1.75 TiB files using all 8 slots.
+The index cache is designed to be memory efficient, and by default uses
+16 KiB.
+
+3.4 Fragment lookup table
+-------------------------
+
+Regular files can contain a fragment index which is mapped to a fragment
+location on disk and compressed size using a fragment lookup table. This
+fragment lookup table is itself stored compressed into metadata blocks.
+A second index table is used to locate these. This second index table for
+speed of access (and because it is small) is read at mount time and cached
+in memory.
+
+3.5 Uid/gid lookup table
+------------------------
+
+For space efficiency regular files store uid and gid indexes, which are
+converted to 32-bit uids/gids using an id look up table. This table is
+stored compressed into metadata blocks. A second index table is used to
+locate these. This second index table for speed of access (and because it
+is small) is read at mount time and cached in memory.
+
+3.6 Export table
+----------------
+
+To enable Squashfs filesystems to be exportable (via NFS etc.) filesystems
+can optionally (disabled with the -no-exports Mksquashfs option) contain
+an inode number to inode disk location lookup table. This is required to
+enable Squashfs to map inode numbers passed in filehandles to the inode
+location on disk, which is necessary when the export code reinstantiates
+expired/flushed inodes.
+
+This table is stored compressed into metadata blocks. A second index table is
+used to locate these. This second index table for speed of access (and because
+it is small) is read at mount time and cached in memory.
+
+
+4. TODOS AND OUTSTANDING ISSUES
+-------------------------------
+
+4.1 Todo list
+-------------
+
+Implement Xattr and ACL support. The Squashfs 4.0 filesystem layout has hooks
+for these but the code has not been written. Once the code has been written
+the existing layout should not require modification.
+
+4.2 Squashfs internal cache
+---------------------------
+
+Blocks in Squashfs are compressed. To avoid repeatedly decompressing
+recently accessed data Squashfs uses two small metadata and fragment caches.
+
+The cache is not used for file datablocks, these are decompressed and cached in
+the page-cache in the normal way. The cache is used to temporarily cache
+fragment and metadata blocks which have been read as a result of a metadata
+(i.e. inode or directory) or fragment access. Because metadata and fragments
+are packed together into blocks (to gain greater compression) the read of a
+particular piece of metadata or fragment will retrieve other metadata/fragments
+which have been packed with it, these because of locality-of-reference may be
+read in the near future. Temporarily caching them ensures they are available
+for near future access without requiring an additional read and decompress.
+
+In the future this internal cache may be replaced with an implementation which
+uses the kernel page cache. Because the page cache operates on page sized
+units this may introduce additional complexity in terms of locking and
+associated race conditions.
diff --git a/squashfs-tools/kernel/README b/squashfs-tools/kernel/README
new file mode 100644
index 0000000..54ab958
--- /dev/null
+++ b/squashfs-tools/kernel/README
@@ -0,0 +1,3 @@
+Squashfs is now in mainline at www.kernel.org.
+
+These files are obsolete and not updated.
diff --git a/squashfs-tools/kernel/fs/squashfs/Makefile b/squashfs-tools/kernel/fs/squashfs/Makefile
new file mode 100644
index 0000000..8258cf9
--- /dev/null
+++ b/squashfs-tools/kernel/fs/squashfs/Makefile
@@ -0,0 +1,8 @@
+#
+# Makefile for the linux squashfs routines.
+#
+
+obj-$(CONFIG_SQUASHFS) += squashfs.o
+squashfs-y += block.o cache.o dir.o export.o file.o fragment.o id.o inode.o
+squashfs-y += namei.o super.o symlink.o
+#squashfs-y += squashfs2_0.o
diff --git a/squashfs-tools/kernel/fs/squashfs/block.c b/squashfs-tools/kernel/fs/squashfs/block.c
new file mode 100644
index 0000000..c837dfc
--- /dev/null
+++ b/squashfs-tools/kernel/fs/squashfs/block.c
@@ -0,0 +1,274 @@
+/*
+ * Squashfs - a compressed read only filesystem for Linux
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ * Phillip Lougher <phillip@lougher.demon.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * block.c
+ */
+
+/*
+ * This file implements the low-level routines to read and decompress
+ * datablocks and metadata blocks.
+ */
+
+#include <linux/fs.h>
+#include <linux/vfs.h>
+#include <linux/slab.h>
+#include <linux/mutex.h>
+#include <linux/string.h>
+#include <linux/buffer_head.h>
+#include <linux/zlib.h>
+
+#include "squashfs_fs.h"
+#include "squashfs_fs_sb.h"
+#include "squashfs_fs_i.h"
+#include "squashfs.h"
+
+/*
+ * Read the metadata block length, this is stored in the first two
+ * bytes of the metadata block.
+ */
+static struct buffer_head *get_block_length(struct super_block *sb,
+ u64 *cur_index, int *offset, int *length)
+{
+ struct squashfs_sb_info *msblk = sb->s_fs_info;
+ struct buffer_head *bh;
+
+ bh = sb_bread(sb, *cur_index);
+ if (bh == NULL)
+ return NULL;
+
+ if (msblk->devblksize - *offset == 1) {
+ *length = (unsigned char) bh->b_data[*offset];
+ put_bh(bh);
+ bh = sb_bread(sb, ++(*cur_index));
+ if (bh == NULL)
+ return NULL;
+ *length |= (unsigned char) bh->b_data[0] << 8;
+ *offset = 1;
+ } else {
+ *length = (unsigned char) bh->b_data[*offset] |
+ (unsigned char) bh->b_data[*offset + 1] << 8;
+ *offset += 2;
+ }
+
+ return bh;
+}
+
+
+/*
+ * Read and decompress a metadata block or datablock. Length is non-zero
+ * if a datablock is being read (the size is stored elsewhere in the
+ * filesystem), otherwise the length is obtained from the first two bytes of
+ * the metadata block. A bit in the length field indicates if the block
+ * is stored uncompressed in the filesystem (usually because compression
+ * generated a larger block - this does occasionally happen with zlib).
+ */
+int squashfs_read_data(struct super_block *sb, void **buffer, u64 index,
+ int length, u64 *next_index, int srclength)
+{
+ struct squashfs_sb_info *msblk = sb->s_fs_info;
+ struct buffer_head **bh;
+ int offset = index & ((1 << msblk->devblksize_log2) - 1);
+ u64 cur_index = index >> msblk->devblksize_log2;
+ int bytes, compressed, b = 0, k = 0, page = 0, avail;
+
+
+ bh = kcalloc((msblk->block_size >> msblk->devblksize_log2) + 1,
+ sizeof(*bh), GFP_KERNEL);
+ if (bh == NULL)
+ return -ENOMEM;
+
+ if (length) {
+ /*
+ * Datablock.
+ */
+ bytes = -offset;
+ compressed = SQUASHFS_COMPRESSED_BLOCK(length);
+ length = SQUASHFS_COMPRESSED_SIZE_BLOCK(length);
+ if (next_index)
+ *next_index = index + length;
+
+ TRACE("Block @ 0x%llx, %scompressed size %d, src size %d\n",
+ index, compressed ? "" : "un", length, srclength);
+
+ if (length < 0 || length > srclength ||
+ (index + length) > msblk->bytes_used)
+ goto read_failure;
+
+ for (b = 0; bytes < length; b++, cur_index++) {
+ bh[b] = sb_getblk(sb, cur_index);
+ if (bh[b] == NULL)
+ goto block_release;
+ bytes += msblk->devblksize;
+ }
+ ll_rw_block(READ, b, bh);
+ } else {
+ /*
+ * Metadata block.
+ */
+ if ((index + 2) > msblk->bytes_used)
+ goto read_failure;
+
+ bh[0] = get_block_length(sb, &cur_index, &offset, &length);
+ if (bh[0] == NULL)
+ goto read_failure;
+ b = 1;
+
+ bytes = msblk->devblksize - offset;
+ compressed = SQUASHFS_COMPRESSED(length);
+ length = SQUASHFS_COMPRESSED_SIZE(length);
+ if (next_index)
+ *next_index = index + length + 2;
+
+ TRACE("Block @ 0x%llx, %scompressed size %d\n", index,
+ compressed ? "" : "un", length);
+
+ if (length < 0 || length > srclength ||
+ (index + length) > msblk->bytes_used)
+ goto block_release;
+
+ for (; bytes < length; b++) {
+ bh[b] = sb_getblk(sb, ++cur_index);
+ if (bh[b] == NULL)
+ goto block_release;
+ bytes += msblk->devblksize;
+ }
+ ll_rw_block(READ, b - 1, bh + 1);
+ }
+
+ if (compressed) {
+ int zlib_err = 0, zlib_init = 0;
+
+ /*
+ * Uncompress block.
+ */
+
+ mutex_lock(&msblk->read_data_mutex);
+
+ msblk->stream.avail_out = 0;
+ msblk->stream.avail_in = 0;
+
+ bytes = length;
+ do {
+ if (msblk->stream.avail_in == 0 && k < b) {
+ avail = min(bytes, msblk->devblksize - offset);
+ bytes -= avail;
+ wait_on_buffer(bh[k]);
+ if (!buffer_uptodate(bh[k]))
+ goto release_mutex;
+
+ if (avail == 0) {
+ offset = 0;
+ put_bh(bh[k++]);
+ continue;
+ }
+
+ msblk->stream.next_in = bh[k]->b_data + offset;
+ msblk->stream.avail_in = avail;
+ offset = 0;
+ }
+
+ if (msblk->stream.avail_out == 0) {
+ msblk->stream.next_out = buffer[page++];
+ msblk->stream.avail_out = PAGE_CACHE_SIZE;
+ }
+
+ if (!zlib_init) {
+ zlib_err = zlib_inflateInit(&msblk->stream);
+ if (zlib_err != Z_OK) {
+ ERROR("zlib_inflateInit returned"
+ " unexpected result 0x%x,"
+ " srclength %d\n", zlib_err,
+ srclength);
+ goto release_mutex;
+ }
+ zlib_init = 1;
+ }
+
+ zlib_err = zlib_inflate(&msblk->stream, Z_NO_FLUSH);
+
+ if (msblk->stream.avail_in == 0 && k < b)
+ put_bh(bh[k++]);
+ } while (zlib_err == Z_OK);
+
+ if (zlib_err != Z_STREAM_END) {
+ ERROR("zlib_inflate returned unexpected result"
+ " 0x%x, srclength %d, avail_in %d,"
+ " avail_out %d\n", zlib_err, srclength,
+ msblk->stream.avail_in,
+ msblk->stream.avail_out);
+ goto release_mutex;
+ }
+
+ zlib_err = zlib_inflateEnd(&msblk->stream);
+ if (zlib_err != Z_OK) {
+ ERROR("zlib_inflateEnd returned unexpected result 0x%x,"
+ " srclength %d\n", zlib_err, srclength);
+ goto release_mutex;
+ }
+ length = msblk->stream.total_out;
+ mutex_unlock(&msblk->read_data_mutex);
+ } else {
+ /*
+ * Block is uncompressed.
+ */
+ int i, in, pg_offset = 0;
+
+ for (i = 0; i < b; i++) {
+ wait_on_buffer(bh[i]);
+ if (!buffer_uptodate(bh[i]))
+ goto block_release;
+ }
+
+ for (bytes = length; k < b; k++) {
+ in = min(bytes, msblk->devblksize - offset);
+ bytes -= in;
+ while (in) {
+ if (pg_offset == PAGE_CACHE_SIZE) {
+ page++;
+ pg_offset = 0;
+ }
+ avail = min_t(int, in, PAGE_CACHE_SIZE -
+ pg_offset);
+ memcpy(buffer[page] + pg_offset,
+ bh[k]->b_data + offset, avail);
+ in -= avail;
+ pg_offset += avail;
+ offset += avail;
+ }
+ offset = 0;
+ put_bh(bh[k]);
+ }
+ }
+
+ kfree(bh);
+ return length;
+
+release_mutex:
+ mutex_unlock(&msblk->read_data_mutex);
+
+block_release:
+ for (; k < b; k++)
+ put_bh(bh[k]);
+
+read_failure:
+ ERROR("sb_bread failed reading block 0x%llx\n", cur_index);
+ kfree(bh);
+ return -EIO;
+}
diff --git a/squashfs-tools/kernel/fs/squashfs/cache.c b/squashfs-tools/kernel/fs/squashfs/cache.c
new file mode 100644
index 0000000..f29eda1
--- /dev/null
+++ b/squashfs-tools/kernel/fs/squashfs/cache.c
@@ -0,0 +1,412 @@
+/*
+ * Squashfs - a compressed read only filesystem for Linux
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ * Phillip Lougher <phillip@lougher.demon.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * cache.c
+ */
+
+/*
+ * Blocks in Squashfs are compressed. To avoid repeatedly decompressing
+ * recently accessed data Squashfs uses two small metadata and fragment caches.
+ *
+ * This file implements a generic cache implementation used for both caches,
+ * plus functions layered ontop of the generic cache implementation to
+ * access the metadata and fragment caches.
+ *
+ * To avoid out of memory and fragmentation isssues with vmalloc the cache
+ * uses sequences of kmalloced PAGE_CACHE_SIZE buffers.
+ *
+ * It should be noted that the cache is not used for file datablocks, these
+ * are decompressed and cached in the page-cache in the normal way. The
+ * cache is only used to temporarily cache fragment and metadata blocks
+ * which have been read as as a result of a metadata (i.e. inode or
+ * directory) or fragment access. Because metadata and fragments are packed
+ * together into blocks (to gain greater compression) the read of a particular
+ * piece of metadata or fragment will retrieve other metadata/fragments which
+ * have been packed with it, these because of locality-of-reference may be read
+ * in the near future. Temporarily caching them ensures they are available for
+ * near future access without requiring an additional read and decompress.
+ */
+
+#include <linux/fs.h>
+#include <linux/vfs.h>
+#include <linux/slab.h>
+#include <linux/vmalloc.h>
+#include <linux/sched.h>
+#include <linux/spinlock.h>
+#include <linux/wait.h>
+#include <linux/zlib.h>
+#include <linux/pagemap.h>
+
+#include "squashfs_fs.h"
+#include "squashfs_fs_sb.h"
+#include "squashfs_fs_i.h"
+#include "squashfs.h"
+
+/*
+ * Look-up block in cache, and increment usage count. If not in cache, read
+ * and decompress it from disk.
+ */
+struct squashfs_cache_entry *squashfs_cache_get(struct super_block *sb,
+ struct squashfs_cache *cache, u64 block, int length)
+{
+ int i, n;
+ struct squashfs_cache_entry *entry;
+
+ spin_lock(&cache->lock);
+
+ while (1) {
+ for (i = 0; i < cache->entries; i++)
+ if (cache->entry[i].block == block)
+ break;
+
+ if (i == cache->entries) {
+ /*
+ * Block not in cache, if all cache entries are used
+ * go to sleep waiting for one to become available.
+ */
+ if (cache->unused == 0) {
+ cache->num_waiters++;
+ spin_unlock(&cache->lock);
+ wait_event(cache->wait_queue, cache->unused);
+ spin_lock(&cache->lock);
+ cache->num_waiters--;
+ continue;
+ }
+
+ /*
+ * At least one unused cache entry. A simple
+ * round-robin strategy is used to choose the entry to
+ * be evicted from the cache.
+ */
+ i = cache->next_blk;
+ for (n = 0; n < cache->entries; n++) {
+ if (cache->entry[i].refcount == 0)
+ break;
+ i = (i + 1) % cache->entries;
+ }
+
+ cache->next_blk = (i + 1) % cache->entries;
+ entry = &cache->entry[i];
+
+ /*
+ * Initialise choosen cache entry, and fill it in from
+ * disk.
+ */
+ cache->unused--;
+ entry->block = block;
+ entry->refcount = 1;
+ entry->pending = 1;
+ entry->num_waiters = 0;
+ entry->error = 0;
+ spin_unlock(&cache->lock);
+
+ entry->length = squashfs_read_data(sb, entry->data,
+ block, length, &entry->next_index,
+ cache->block_size);
+
+ spin_lock(&cache->lock);
+
+ if (entry->length < 0)
+ entry->error = entry->length;
+
+ entry->pending = 0;
+
+ /*
+ * While filling this entry one or more other processes
+ * have looked it up in the cache, and have slept
+ * waiting for it to become available.
+ */
+ if (entry->num_waiters) {
+ spin_unlock(&cache->lock);
+ wake_up_all(&entry->wait_queue);
+ } else
+ spin_unlock(&cache->lock);
+
+ goto out;
+ }
+
+ /*
+ * Block already in cache. Increment refcount so it doesn't
+ * get reused until we're finished with it, if it was
+ * previously unused there's one less cache entry available
+ * for reuse.
+ */
+ entry = &cache->entry[i];
+ if (entry->refcount == 0)
+ cache->unused--;
+ entry->refcount++;
+
+ /*
+ * If the entry is currently being filled in by another process
+ * go to sleep waiting for it to become available.
+ */
+ if (entry->pending) {
+ entry->num_waiters++;
+ spin_unlock(&cache->lock);
+ wait_event(entry->wait_queue, !entry->pending);
+ } else
+ spin_unlock(&cache->lock);
+
+ goto out;
+ }
+
+out:
+ TRACE("Got %s %d, start block %lld, refcount %d, error %d\n",
+ cache->name, i, entry->block, entry->refcount, entry->error);
+
+ if (entry->error)
+ ERROR("Unable to read %s cache entry [%llx]\n", cache->name,
+ block);
+ return entry;
+}
+
+
+/*
+ * Release cache entry, once usage count is zero it can be reused.
+ */
+void squashfs_cache_put(struct squashfs_cache_entry *entry)
+{
+ struct squashfs_cache *cache = entry->cache;
+
+ spin_lock(&cache->lock);
+ entry->refcount--;
+ if (entry->refcount == 0) {
+ cache->unused++;
+ /*
+ * If there's any processes waiting for a block to become
+ * available, wake one up.
+ */
+ if (cache->num_waiters) {
+ spin_unlock(&cache->lock);
+ wake_up(&cache->wait_queue);
+ return;
+ }
+ }
+ spin_unlock(&cache->lock);
+}
+
+/*
+ * Delete cache reclaiming all kmalloced buffers.
+ */
+void squashfs_cache_delete(struct squashfs_cache *cache)
+{
+ int i, j;
+
+ if (cache == NULL)
+ return;
+
+ for (i = 0; i < cache->entries; i++) {
+ if (cache->entry[i].data) {
+ for (j = 0; j < cache->pages; j++)
+ kfree(cache->entry[i].data[j]);
+ kfree(cache->entry[i].data);
+ }
+ }
+
+ kfree(cache->entry);
+ kfree(cache);
+}
+
+
+/*
+ * Initialise cache allocating the specified number of entries, each of
+ * size block_size. To avoid vmalloc fragmentation issues each entry
+ * is allocated as a sequence of kmalloced PAGE_CACHE_SIZE buffers.
+ */
+struct squashfs_cache *squashfs_cache_init(char *name, int entries,
+ int block_size)
+{
+ int i, j;
+ struct squashfs_cache *cache = kzalloc(sizeof(*cache), GFP_KERNEL);
+
+ if (cache == NULL) {
+ ERROR("Failed to allocate %s cache\n", name);
+ return NULL;
+ }
+
+ cache->entry = kcalloc(entries, sizeof(*(cache->entry)), GFP_KERNEL);
+ if (cache->entry == NULL) {
+ ERROR("Failed to allocate %s cache\n", name);
+ goto cleanup;
+ }
+
+ cache->next_blk = 0;
+ cache->unused = entries;
+ cache->entries = entries;
+ cache->block_size = block_size;
+ cache->pages = block_size >> PAGE_CACHE_SHIFT;
+ cache->name = name;
+ cache->num_waiters = 0;
+ spin_lock_init(&cache->lock);
+ init_waitqueue_head(&cache->wait_queue);
+
+ for (i = 0; i < entries; i++) {
+ struct squashfs_cache_entry *entry = &cache->entry[i];
+
+ init_waitqueue_head(&cache->entry[i].wait_queue);
+ entry->cache = cache;
+ entry->block = SQUASHFS_INVALID_BLK;
+ entry->data = kcalloc(cache->pages, sizeof(void *), GFP_KERNEL);
+ if (entry->data == NULL) {
+ ERROR("Failed to allocate %s cache entry\n", name);
+ goto cleanup;
+ }
+
+ for (j = 0; j < cache->pages; j++) {
+ entry->data[j] = kmalloc(PAGE_CACHE_SIZE, GFP_KERNEL);
+ if (entry->data[j] == NULL) {
+ ERROR("Failed to allocate %s buffer\n", name);
+ goto cleanup;
+ }
+ }
+ }
+
+ return cache;
+
+cleanup:
+ squashfs_cache_delete(cache);
+ return NULL;
+}
+
+
+/*
+ * Copy upto length bytes from cache entry to buffer starting at offset bytes
+ * into the cache entry. If there's not length bytes then copy the number of
+ * bytes available. In all cases return the number of bytes copied.
+ */
+int squashfs_copy_data(void *buffer, struct squashfs_cache_entry *entry,
+ int offset, int length)
+{
+ int remaining = length;
+
+ if (length == 0)
+ return 0;
+ else if (buffer == NULL)
+ return min(length, entry->length - offset);
+
+ while (offset < entry->length) {
+ void *buff = entry->data[offset / PAGE_CACHE_SIZE]
+ + (offset % PAGE_CACHE_SIZE);
+ int bytes = min_t(int, entry->length - offset,
+ PAGE_CACHE_SIZE - (offset % PAGE_CACHE_SIZE));
+
+ if (bytes >= remaining) {
+ memcpy(buffer, buff, remaining);
+ remaining = 0;
+ break;
+ }
+
+ memcpy(buffer, buff, bytes);
+ buffer += bytes;
+ remaining -= bytes;
+ offset += bytes;
+ }
+
+ return length - remaining;
+}
+
+
+/*
+ * Read length bytes from metadata position <block, offset> (block is the
+ * start of the compressed block on disk, and offset is the offset into
+ * the block once decompressed). Data is packed into consecutive blocks,
+ * and length bytes may require reading more than one block.
+ */
+int squashfs_read_metadata(struct super_block *sb, void *buffer,
+ u64 *block, int *offset, int length)
+{
+ struct squashfs_sb_info *msblk = sb->s_fs_info;
+ int bytes, copied = length;
+ struct squashfs_cache_entry *entry;
+
+ TRACE("Entered squashfs_read_metadata [%llx:%x]\n", *block, *offset);
+
+ while (length) {
+ entry = squashfs_cache_get(sb, msblk->block_cache, *block, 0);
+ if (entry->error)
+ return entry->error;
+ else if (*offset >= entry->length)
+ return -EIO;
+
+ bytes = squashfs_copy_data(buffer, entry, *offset, length);
+ if (buffer)
+ buffer += bytes;
+ length -= bytes;
+ *offset += bytes;
+
+ if (*offset == entry->length) {
+ *block = entry->next_index;
+ *offset = 0;
+ }
+
+ squashfs_cache_put(entry);
+ }
+
+ return copied;
+}
+
+
+/*
+ * Look-up in the fragmment cache the fragment located at <start_block> in the
+ * filesystem. If necessary read and decompress it from disk.
+ */
+struct squashfs_cache_entry *squashfs_get_fragment(struct super_block *sb,
+ u64 start_block, int length)
+{
+ struct squashfs_sb_info *msblk = sb->s_fs_info;
+
+ return squashfs_cache_get(sb, msblk->fragment_cache, start_block,
+ length);
+}
+
+
+/*
+ * Read and decompress the datablock located at <start_block> in the
+ * filesystem. The cache is used here to avoid duplicating locking and
+ * read/decompress code.
+ */
+struct squashfs_cache_entry *squashfs_get_datablock(struct super_block *sb,
+ u64 start_block, int length)
+{
+ struct squashfs_sb_info *msblk = sb->s_fs_info;
+
+ return squashfs_cache_get(sb, msblk->read_page, start_block, length);
+}
+
+
+/*
+ * Read a filesystem table (uncompressed sequence of bytes) from disk
+ */
+int squashfs_read_table(struct super_block *sb, void *buffer, u64 block,
+ int length)
+{
+ int pages = (length + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
+ int i, res;
+ void **data = kcalloc(pages, sizeof(void *), GFP_KERNEL);
+ if (data == NULL)
+ return -ENOMEM;
+
+ for (i = 0; i < pages; i++, buffer += PAGE_CACHE_SIZE)
+ data[i] = buffer;
+ res = squashfs_read_data(sb, data, block, length |
+ SQUASHFS_COMPRESSED_BIT_BLOCK, NULL, length);
+ kfree(data);
+ return res;
+}
diff --git a/squashfs-tools/kernel/fs/squashfs/dir.c b/squashfs-tools/kernel/fs/squashfs/dir.c
new file mode 100644
index 0000000..566b0ea
--- /dev/null
+++ b/squashfs-tools/kernel/fs/squashfs/dir.c
@@ -0,0 +1,235 @@
+/*
+ * Squashfs - a compressed read only filesystem for Linux
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ * Phillip Lougher <phillip@lougher.demon.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * dir.c
+ */
+
+/*
+ * This file implements code to read directories from disk.
+ *
+ * See namei.c for a description of directory organisation on disk.
+ */
+
+#include <linux/fs.h>
+#include <linux/vfs.h>
+#include <linux/slab.h>
+#include <linux/zlib.h>
+
+#include "squashfs_fs.h"
+#include "squashfs_fs_sb.h"
+#include "squashfs_fs_i.h"
+#include "squashfs.h"
+
+static const unsigned char squashfs_filetype_table[] = {
+ DT_UNKNOWN, DT_DIR, DT_REG, DT_LNK, DT_BLK, DT_CHR, DT_FIFO, DT_SOCK
+};
+
+/*
+ * Lookup offset (f_pos) in the directory index, returning the
+ * metadata block containing it.
+ *
+ * If we get an error reading the index then return the part of the index
+ * (if any) we have managed to read - the index isn't essential, just
+ * quicker.
+ */
+static int get_dir_index_using_offset(struct super_block *sb,
+ u64 *next_block, int *next_offset, u64 index_start, int index_offset,
+ int i_count, u64 f_pos)
+{
+ struct squashfs_sb_info *msblk = sb->s_fs_info;
+ int err, i, index, length = 0;
+ struct squashfs_dir_index dir_index;
+
+ TRACE("Entered get_dir_index_using_offset, i_count %d, f_pos %lld\n",
+ i_count, f_pos);
+
+ /*
+ * Translate from external f_pos to the internal f_pos. This
+ * is offset by 3 because we invent "." and ".." entries which are
+ * not actually stored in the directory.
+ */
+ if (f_pos < 3)
+ return f_pos;
+ f_pos -= 3;
+
+ for (i = 0; i < i_count; i++) {
+ err = squashfs_read_metadata(sb, &dir_index, &index_start,
+ &index_offset, sizeof(dir_index));
+ if (err < 0)
+ break;
+
+ index = le32_to_cpu(dir_index.index);
+ if (index > f_pos)
+ /*
+ * Found the index we're looking for.
+ */
+ break;
+
+ err = squashfs_read_metadata(sb, NULL, &index_start,
+ &index_offset, le32_to_cpu(dir_index.size) + 1);
+ if (err < 0)
+ break;
+
+ length = index;
+ *next_block = le32_to_cpu(dir_index.start_block) +
+ msblk->directory_table;
+ }
+
+ *next_offset = (length + *next_offset) % SQUASHFS_METADATA_SIZE;
+
+ /*
+ * Translate back from internal f_pos to external f_pos.
+ */
+ return length + 3;
+}
+
+
+static int squashfs_readdir(struct file *file, void *dirent, filldir_t filldir)
+{
+ struct inode *inode = file->f_dentry->d_inode;
+ struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
+ u64 block = squashfs_i(inode)->start + msblk->directory_table;
+ int offset = squashfs_i(inode)->offset, length = 0, dir_count, size,
+ type, err;
+ unsigned int inode_number;
+ struct squashfs_dir_header dirh;
+ struct squashfs_dir_entry *dire;
+
+ TRACE("Entered squashfs_readdir [%llx:%x]\n", block, offset);
+
+ dire = kmalloc(sizeof(*dire) + SQUASHFS_NAME_LEN + 1, GFP_KERNEL);
+ if (dire == NULL) {
+ ERROR("Failed to allocate squashfs_dir_entry\n");
+ goto finish;
+ }
+
+ /*
+ * Return "." and ".." entries as the first two filenames in the
+ * directory. To maximise compression these two entries are not
+ * stored in the directory, and so we invent them here.
+ *
+ * It also means that the external f_pos is offset by 3 from the
+ * on-disk directory f_pos.
+ */
+ while (file->f_pos < 3) {
+ char *name;
+ int i_ino;
+
+ if (file->f_pos == 0) {
+ name = ".";
+ size = 1;
+ i_ino = inode->i_ino;
+ } else {
+ name = "..";
+ size = 2;
+ i_ino = squashfs_i(inode)->parent;
+ }
+
+ TRACE("Calling filldir(%p, %s, %d, %lld, %d, %d)\n",
+ dirent, name, size, file->f_pos, i_ino,
+ squashfs_filetype_table[1]);
+
+ if (filldir(dirent, name, size, file->f_pos, i_ino,
+ squashfs_filetype_table[1]) < 0) {
+ TRACE("Filldir returned less than 0\n");
+ goto finish;
+ }
+
+ file->f_pos += size;
+ }
+
+ length = get_dir_index_using_offset(inode->i_sb, &block, &offset,
+ squashfs_i(inode)->dir_idx_start,
+ squashfs_i(inode)->dir_idx_offset,
+ squashfs_i(inode)->dir_idx_cnt,
+ file->f_pos);
+
+ while (length < i_size_read(inode)) {
+ /*
+ * Read directory header
+ */
+ err = squashfs_read_metadata(inode->i_sb, &dirh, &block,
+ &offset, sizeof(dirh));
+ if (err < 0)
+ goto failed_read;
+
+ length += sizeof(dirh);
+
+ dir_count = le32_to_cpu(dirh.count) + 1;
+ while (dir_count--) {
+ /*
+ * Read directory entry.
+ */
+ err = squashfs_read_metadata(inode->i_sb, dire, &block,
+ &offset, sizeof(*dire));
+ if (err < 0)
+ goto failed_read;
+
+ size = le16_to_cpu(dire->size) + 1;
+
+ err = squashfs_read_metadata(inode->i_sb, dire->name,
+ &block, &offset, size);
+ if (err < 0)
+ goto failed_read;
+
+ length += sizeof(*dire) + size;
+
+ if (file->f_pos >= length)
+ continue;
+
+ dire->name[size] = '\0';
+ inode_number = le32_to_cpu(dirh.inode_number) +
+ ((short) le16_to_cpu(dire->inode_number));
+ type = le16_to_cpu(dire->type);
+
+ TRACE("Calling filldir(%p, %s, %d, %lld, %x:%x, %d, %d)"
+ "\n", dirent, dire->name, size,
+ file->f_pos,
+ le32_to_cpu(dirh.start_block),
+ le16_to_cpu(dire->offset),
+ inode_number,
+ squashfs_filetype_table[type]);
+
+ if (filldir(dirent, dire->name, size, file->f_pos,
+ inode_number,
+ squashfs_filetype_table[type]) < 0) {
+ TRACE("Filldir returned less than 0\n");
+ goto finish;
+ }
+
+ file->f_pos = length;
+ }
+ }
+
+finish:
+ kfree(dire);
+ return 0;
+
+failed_read:
+ ERROR("Unable to read directory block [%llx:%x]\n", block, offset);
+ kfree(dire);
+ return 0;
+}
+
+
+const struct file_operations squashfs_dir_ops = {
+ .read = generic_read_dir,
+ .readdir = squashfs_readdir
+};
diff --git a/squashfs-tools/kernel/fs/squashfs/export.c b/squashfs-tools/kernel/fs/squashfs/export.c
new file mode 100644
index 0000000..69e971d
--- /dev/null
+++ b/squashfs-tools/kernel/fs/squashfs/export.c
@@ -0,0 +1,155 @@
+/*
+ * Squashfs - a compressed read only filesystem for Linux
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ * Phillip Lougher <phillip@lougher.demon.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * export.c
+ */
+
+/*
+ * This file implements code to make Squashfs filesystems exportable (NFS etc.)
+ *
+ * The export code uses an inode lookup table to map inode numbers passed in
+ * filehandles to an inode location on disk. This table is stored compressed
+ * into metadata blocks. A second index table is used to locate these. This
+ * second index table for speed of access (and because it is small) is read at
+ * mount time and cached in memory.
+ *
+ * The inode lookup table is used only by the export code, inode disk
+ * locations are directly encoded in directories, enabling direct access
+ * without an intermediate lookup for all operations except the export ops.
+ */
+
+#include <linux/fs.h>
+#include <linux/vfs.h>
+#include <linux/dcache.h>
+#include <linux/exportfs.h>
+#include <linux/zlib.h>
+
+#include "squashfs_fs.h"
+#include "squashfs_fs_sb.h"
+#include "squashfs_fs_i.h"
+#include "squashfs.h"
+
+/*
+ * Look-up inode number (ino) in table, returning the inode location.
+ */
+static long long squashfs_inode_lookup(struct super_block *sb, int ino_num)
+{
+ struct squashfs_sb_info *msblk = sb->s_fs_info;
+ int blk = SQUASHFS_LOOKUP_BLOCK(ino_num - 1);
+ int offset = SQUASHFS_LOOKUP_BLOCK_OFFSET(ino_num - 1);
+ u64 start = le64_to_cpu(msblk->inode_lookup_table[blk]);
+ __le64 ino;
+ int err;
+
+ TRACE("Entered squashfs_inode_lookup, inode_number = %d\n", ino_num);
+
+ err = squashfs_read_metadata(sb, &ino, &start, &offset, sizeof(ino));
+ if (err < 0)
+ return err;
+
+ TRACE("squashfs_inode_lookup, inode = 0x%llx\n",
+ (u64) le64_to_cpu(ino));
+
+ return le64_to_cpu(ino);
+}
+
+
+static struct dentry *squashfs_export_iget(struct super_block *sb,
+ unsigned int ino_num)
+{
+ long long ino;
+ struct dentry *dentry = ERR_PTR(-ENOENT);
+
+ TRACE("Entered squashfs_export_iget\n");
+
+ ino = squashfs_inode_lookup(sb, ino_num);
+ if (ino >= 0)
+ dentry = d_obtain_alias(squashfs_iget(sb, ino, ino_num));
+
+ return dentry;
+}
+
+
+static struct dentry *squashfs_fh_to_dentry(struct super_block *sb,
+ struct fid *fid, int fh_len, int fh_type)
+{
+ if ((fh_type != FILEID_INO32_GEN && fh_type != FILEID_INO32_GEN_PARENT)
+ || fh_len < 2)
+ return NULL;
+
+ return squashfs_export_iget(sb, fid->i32.ino);
+}
+
+
+static struct dentry *squashfs_fh_to_parent(struct super_block *sb,
+ struct fid *fid, int fh_len, int fh_type)
+{
+ if (fh_type != FILEID_INO32_GEN_PARENT || fh_len < 4)
+ return NULL;
+
+ return squashfs_export_iget(sb, fid->i32.parent_ino);
+}
+
+
+static struct dentry *squashfs_get_parent(struct dentry *child)
+{
+ struct inode *inode = child->d_inode;
+ unsigned int parent_ino = squashfs_i(inode)->parent;
+
+ return squashfs_export_iget(inode->i_sb, parent_ino);
+}
+
+
+/*
+ * Read uncompressed inode lookup table indexes off disk into memory
+ */
+__le64 *squashfs_read_inode_lookup_table(struct super_block *sb,
+ u64 lookup_table_start, unsigned int inodes)
+{
+ unsigned int length = SQUASHFS_LOOKUP_BLOCK_BYTES(inodes);
+ __le64 *inode_lookup_table;
+ int err;
+
+ TRACE("In read_inode_lookup_table, length %d\n", length);
+
+ /* Allocate inode lookup table indexes */
+ inode_lookup_table = kmalloc(length, GFP_KERNEL);
+ if (inode_lookup_table == NULL) {
+ ERROR("Failed to allocate inode lookup table\n");
+ return ERR_PTR(-ENOMEM);
+ }
+
+ err = squashfs_read_table(sb, inode_lookup_table, lookup_table_start,
+ length);
+ if (err < 0) {
+ ERROR("unable to read inode lookup table\n");
+ kfree(inode_lookup_table);
+ return ERR_PTR(err);
+ }
+
+ return inode_lookup_table;
+}
+
+
+const struct export_operations squashfs_export_ops = {
+ .fh_to_dentry = squashfs_fh_to_dentry,
+ .fh_to_parent = squashfs_fh_to_parent,
+ .get_parent = squashfs_get_parent
+};
diff --git a/squashfs-tools/kernel/fs/squashfs/file.c b/squashfs-tools/kernel/fs/squashfs/file.c
new file mode 100644
index 0000000..717767d
--- /dev/null
+++ b/squashfs-tools/kernel/fs/squashfs/file.c
@@ -0,0 +1,502 @@
+/*
+ * Squashfs - a compressed read only filesystem for Linux
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ * Phillip Lougher <phillip@lougher.demon.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * file.c
+ */
+
+/*
+ * This file contains code for handling regular files. A regular file
+ * consists of a sequence of contiguous compressed blocks, and/or a
+ * compressed fragment block (tail-end packed block). The compressed size
+ * of each datablock is stored in a block list contained within the
+ * file inode (itself stored in one or more compressed metadata blocks).
+ *
+ * To speed up access to datablocks when reading 'large' files (256 Mbytes or
+ * larger), the code implements an index cache that caches the mapping from
+ * block index to datablock location on disk.
+ *
+ * The index cache allows Squashfs to handle large files (up to 1.75 TiB) while
+ * retaining a simple and space-efficient block list on disk. The cache
+ * is split into slots, caching up to eight 224 GiB files (128 KiB blocks).
+ * Larger files use multiple slots, with 1.75 TiB files using all 8 slots.
+ * The index cache is designed to be memory efficient, and by default uses
+ * 16 KiB.
+ */
+
+#include <linux/fs.h>
+#include <linux/vfs.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <linux/pagemap.h>
+#include <linux/mutex.h>
+#include <linux/zlib.h>
+
+#include "squashfs_fs.h"
+#include "squashfs_fs_sb.h"
+#include "squashfs_fs_i.h"
+#include "squashfs.h"
+
+/*
+ * Locate cache slot in range [offset, index] for specified inode. If
+ * there's more than one return the slot closest to index.
+ */
+static struct meta_index *locate_meta_index(struct inode *inode, int offset,
+ int index)
+{
+ struct meta_index *meta = NULL;
+ struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
+ int i;
+
+ mutex_lock(&msblk->meta_index_mutex);
+
+ TRACE("locate_meta_index: index %d, offset %d\n", index, offset);
+
+ if (msblk->meta_index == NULL)
+ goto not_allocated;
+
+ for (i = 0; i < SQUASHFS_META_SLOTS; i++) {
+ if (msblk->meta_index[i].inode_number == inode->i_ino &&
+ msblk->meta_index[i].offset >= offset &&
+ msblk->meta_index[i].offset <= index &&
+ msblk->meta_index[i].locked == 0) {
+ TRACE("locate_meta_index: entry %d, offset %d\n", i,
+ msblk->meta_index[i].offset);
+ meta = &msblk->meta_index[i];
+ offset = meta->offset;
+ }
+ }
+
+ if (meta)
+ meta->locked = 1;
+
+not_allocated:
+ mutex_unlock(&msblk->meta_index_mutex);
+
+ return meta;
+}
+
+
+/*
+ * Find and initialise an empty cache slot for index offset.
+ */
+static struct meta_index *empty_meta_index(struct inode *inode, int offset,
+ int skip)
+{
+ struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
+ struct meta_index *meta = NULL;
+ int i;
+
+ mutex_lock(&msblk->meta_index_mutex);
+
+ TRACE("empty_meta_index: offset %d, skip %d\n", offset, skip);
+
+ if (msblk->meta_index == NULL) {
+ /*
+ * First time cache index has been used, allocate and
+ * initialise. The cache index could be allocated at
+ * mount time but doing it here means it is allocated only
+ * if a 'large' file is read.
+ */
+ msblk->meta_index = kcalloc(SQUASHFS_META_SLOTS,
+ sizeof(*(msblk->meta_index)), GFP_KERNEL);
+ if (msblk->meta_index == NULL) {
+ ERROR("Failed to allocate meta_index\n");
+ goto failed;
+ }
+ for (i = 0; i < SQUASHFS_META_SLOTS; i++) {
+ msblk->meta_index[i].inode_number = 0;
+ msblk->meta_index[i].locked = 0;
+ }
+ msblk->next_meta_index = 0;
+ }
+
+ for (i = SQUASHFS_META_SLOTS; i &&
+ msblk->meta_index[msblk->next_meta_index].locked; i--)
+ msblk->next_meta_index = (msblk->next_meta_index + 1) %
+ SQUASHFS_META_SLOTS;
+
+ if (i == 0) {
+ TRACE("empty_meta_index: failed!\n");
+ goto failed;
+ }
+
+ TRACE("empty_meta_index: returned meta entry %d, %p\n",
+ msblk->next_meta_index,
+ &msblk->meta_index[msblk->next_meta_index]);
+
+ meta = &msblk->meta_index[msblk->next_meta_index];
+ msblk->next_meta_index = (msblk->next_meta_index + 1) %
+ SQUASHFS_META_SLOTS;
+
+ meta->inode_number = inode->i_ino;
+ meta->offset = offset;
+ meta->skip = skip;
+ meta->entries = 0;
+ meta->locked = 1;
+
+failed:
+ mutex_unlock(&msblk->meta_index_mutex);
+ return meta;
+}
+
+
+static void release_meta_index(struct inode *inode, struct meta_index *meta)
+{
+ struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
+ mutex_lock(&msblk->meta_index_mutex);
+ meta->locked = 0;
+ mutex_unlock(&msblk->meta_index_mutex);
+}
+
+
+/*
+ * Read the next n blocks from the block list, starting from
+ * metadata block <start_block, offset>.
+ */
+static long long read_indexes(struct super_block *sb, int n,
+ u64 *start_block, int *offset)
+{
+ int err, i;
+ long long block = 0;
+ __le32 *blist = kmalloc(PAGE_CACHE_SIZE, GFP_KERNEL);
+
+ if (blist == NULL) {
+ ERROR("read_indexes: Failed to allocate block_list\n");
+ return -ENOMEM;
+ }
+
+ while (n) {
+ int blocks = min_t(int, n, PAGE_CACHE_SIZE >> 2);
+
+ err = squashfs_read_metadata(sb, blist, start_block,
+ offset, blocks << 2);
+ if (err < 0) {
+ ERROR("read_indexes: reading block [%llx:%x]\n",
+ *start_block, *offset);
+ goto failure;
+ }
+
+ for (i = 0; i < blocks; i++) {
+ int size = le32_to_cpu(blist[i]);
+ block += SQUASHFS_COMPRESSED_SIZE_BLOCK(size);
+ }
+ n -= blocks;
+ }
+
+ kfree(blist);
+ return block;
+
+failure:
+ kfree(blist);
+ return err;
+}
+
+
+/*
+ * Each cache index slot has SQUASHFS_META_ENTRIES, each of which
+ * can cache one index -> datablock/blocklist-block mapping. We wish
+ * to distribute these over the length of the file, entry[0] maps index x,
+ * entry[1] maps index x + skip, entry[2] maps index x + 2 * skip, and so on.
+ * The larger the file, the greater the skip factor. The skip factor is
+ * limited to the size of the metadata cache (SQUASHFS_CACHED_BLKS) to ensure
+ * the number of metadata blocks that need to be read fits into the cache.
+ * If the skip factor is limited in this way then the file will use multiple
+ * slots.
+ */
+static inline int calculate_skip(int blocks)
+{
+ int skip = blocks / ((SQUASHFS_META_ENTRIES + 1)
+ * SQUASHFS_META_INDEXES);
+ return min(SQUASHFS_CACHED_BLKS - 1, skip + 1);
+}
+
+
+/*
+ * Search and grow the index cache for the specified inode, returning the
+ * on-disk locations of the datablock and block list metadata block
+ * <index_block, index_offset> for index (scaled to nearest cache index).
+ */
+static int fill_meta_index(struct inode *inode, int index,
+ u64 *index_block, int *index_offset, u64 *data_block)
+{
+ struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
+ int skip = calculate_skip(i_size_read(inode) >> msblk->block_log);
+ int offset = 0;
+ struct meta_index *meta;
+ struct meta_entry *meta_entry;
+ u64 cur_index_block = squashfs_i(inode)->block_list_start;
+ int cur_offset = squashfs_i(inode)->offset;
+ u64 cur_data_block = squashfs_i(inode)->start;
+ int err, i;
+
+ /*
+ * Scale index to cache index (cache slot entry)
+ */
+ index /= SQUASHFS_META_INDEXES * skip;
+
+ while (offset < index) {
+ meta = locate_meta_index(inode, offset + 1, index);
+
+ if (meta == NULL) {
+ meta = empty_meta_index(inode, offset + 1, skip);
+ if (meta == NULL)
+ goto all_done;
+ } else {
+ offset = index < meta->offset + meta->entries ? index :
+ meta->offset + meta->entries - 1;
+ meta_entry = &meta->meta_entry[offset - meta->offset];
+ cur_index_block = meta_entry->index_block +
+ msblk->inode_table;
+ cur_offset = meta_entry->offset;
+ cur_data_block = meta_entry->data_block;
+ TRACE("get_meta_index: offset %d, meta->offset %d, "
+ "meta->entries %d\n", offset, meta->offset,
+ meta->entries);
+ TRACE("get_meta_index: index_block 0x%llx, offset 0x%x"
+ " data_block 0x%llx\n", cur_index_block,
+ cur_offset, cur_data_block);
+ }
+
+ /*
+ * If necessary grow cache slot by reading block list. Cache
+ * slot is extended up to index or to the end of the slot, in
+ * which case further slots will be used.
+ */
+ for (i = meta->offset + meta->entries; i <= index &&
+ i < meta->offset + SQUASHFS_META_ENTRIES; i++) {
+ int blocks = skip * SQUASHFS_META_INDEXES;
+ long long res = read_indexes(inode->i_sb, blocks,
+ &cur_index_block, &cur_offset);
+
+ if (res < 0) {
+ if (meta->entries == 0)
+ /*
+ * Don't leave an empty slot on read
+ * error allocated to this inode...
+ */
+ meta->inode_number = 0;
+ err = res;
+ goto failed;
+ }
+
+ cur_data_block += res;
+ meta_entry = &meta->meta_entry[i - meta->offset];
+ meta_entry->index_block = cur_index_block -
+ msblk->inode_table;
+ meta_entry->offset = cur_offset;
+ meta_entry->data_block = cur_data_block;
+ meta->entries++;
+ offset++;
+ }
+
+ TRACE("get_meta_index: meta->offset %d, meta->entries %d\n",
+ meta->offset, meta->entries);
+
+ release_meta_index(inode, meta);
+ }
+
+all_done:
+ *index_block = cur_index_block;
+ *index_offset = cur_offset;
+ *data_block = cur_data_block;
+
+ /*
+ * Scale cache index (cache slot entry) to index
+ */
+ return offset * SQUASHFS_META_INDEXES * skip;
+
+failed:
+ release_meta_index(inode, meta);
+ return err;
+}
+
+
+/*
+ * Get the on-disk location and compressed size of the datablock
+ * specified by index. Fill_meta_index() does most of the work.
+ */
+static int read_blocklist(struct inode *inode, int index, u64 *block)
+{
+ u64 start;
+ long long blks;
+ int offset;
+ __le32 size;
+ int res = fill_meta_index(inode, index, &start, &offset, block);
+
+ TRACE("read_blocklist: res %d, index %d, start 0x%llx, offset"
+ " 0x%x, block 0x%llx\n", res, index, start, offset,
+ *block);
+
+ if (res < 0)
+ return res;
+
+ /*
+ * res contains the index of the mapping returned by fill_meta_index(),
+ * this will likely be less than the desired index (because the
+ * meta_index cache works at a higher granularity). Read any
+ * extra block indexes needed.
+ */
+ if (res < index) {
+ blks = read_indexes(inode->i_sb, index - res, &start, &offset);
+ if (blks < 0)
+ return (int) blks;
+ *block += blks;
+ }
+
+ /*
+ * Read length of block specified by index.
+ */
+ res = squashfs_read_metadata(inode->i_sb, &size, &start, &offset,
+ sizeof(size));
+ if (res < 0)
+ return res;
+ return le32_to_cpu(size);
+}
+
+
+static int squashfs_readpage(struct file *file, struct page *page)
+{
+ struct inode *inode = page->mapping->host;
+ struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
+ int bytes, i, offset = 0, sparse = 0;
+ struct squashfs_cache_entry *buffer = NULL;
+ void *pageaddr;
+
+ int mask = (1 << (msblk->block_log - PAGE_CACHE_SHIFT)) - 1;
+ int index = page->index >> (msblk->block_log - PAGE_CACHE_SHIFT);
+ int start_index = page->index & ~mask;
+ int end_index = start_index | mask;
+ int file_end = i_size_read(inode) >> msblk->block_log;
+
+ TRACE("Entered squashfs_readpage, page index %lx, start block %llx\n",
+ page->index, squashfs_i(inode)->start);
+
+ if (page->index >= ((i_size_read(inode) + PAGE_CACHE_SIZE - 1) >>
+ PAGE_CACHE_SHIFT))
+ goto out;
+
+ if (index < file_end || squashfs_i(inode)->fragment_block ==
+ SQUASHFS_INVALID_BLK) {
+ /*
+ * Reading a datablock from disk. Need to read block list
+ * to get location and block size.
+ */
+ u64 block = 0;
+ int bsize = read_blocklist(inode, index, &block);
+ if (bsize < 0)
+ goto error_out;
+
+ if (bsize == 0) { /* hole */
+ bytes = index == file_end ?
+ (i_size_read(inode) & (msblk->block_size - 1)) :
+ msblk->block_size;
+ sparse = 1;
+ } else {
+ /*
+ * Read and decompress datablock.
+ */
+ buffer = squashfs_get_datablock(inode->i_sb,
+ block, bsize);
+ if (buffer->error) {
+ ERROR("Unable to read page, block %llx, size %x"
+ "\n", block, bsize);
+ squashfs_cache_put(buffer);
+ goto error_out;
+ }
+ bytes = buffer->length;
+ }
+ } else {
+ /*
+ * Datablock is stored inside a fragment (tail-end packed
+ * block).
+ */
+ buffer = squashfs_get_fragment(inode->i_sb,
+ squashfs_i(inode)->fragment_block,
+ squashfs_i(inode)->fragment_size);
+
+ if (buffer->error) {
+ ERROR("Unable to read page, block %llx, size %x\n",
+ squashfs_i(inode)->fragment_block,
+ squashfs_i(inode)->fragment_size);
+ squashfs_cache_put(buffer);
+ goto error_out;
+ }
+ bytes = i_size_read(inode) & (msblk->block_size - 1);
+ offset = squashfs_i(inode)->fragment_offset;
+ }
+
+ /*
+ * Loop copying datablock into pages. As the datablock likely covers
+ * many PAGE_CACHE_SIZE pages (default block size is 128 KiB) explicitly
+ * grab the pages from the page cache, except for the page that we've
+ * been called to fill.
+ */
+ for (i = start_index; i <= end_index && bytes > 0; i++,
+ bytes -= PAGE_CACHE_SIZE, offset += PAGE_CACHE_SIZE) {
+ struct page *push_page;
+ int avail = sparse ? 0 : min_t(int, bytes, PAGE_CACHE_SIZE);
+
+ TRACE("bytes %d, i %d, available_bytes %d\n", bytes, i, avail);
+
+ push_page = (i == page->index) ? page :
+ grab_cache_page_nowait(page->mapping, i);
+
+ if (!push_page)
+ continue;
+
+ if (PageUptodate(push_page))
+ goto skip_page;
+
+ pageaddr = kmap_atomic(push_page, KM_USER0);
+ squashfs_copy_data(pageaddr, buffer, offset, avail);
+ memset(pageaddr + avail, 0, PAGE_CACHE_SIZE - avail);
+ kunmap_atomic(pageaddr, KM_USER0);
+ flush_dcache_page(push_page);
+ SetPageUptodate(push_page);
+skip_page:
+ unlock_page(push_page);
+ if (i != page->index)
+ page_cache_release(push_page);
+ }
+
+ if (!sparse)
+ squashfs_cache_put(buffer);
+
+ return 0;
+
+error_out:
+ SetPageError(page);
+out:
+ pageaddr = kmap_atomic(page, KM_USER0);
+ memset(pageaddr, 0, PAGE_CACHE_SIZE);
+ kunmap_atomic(pageaddr, KM_USER0);
+ flush_dcache_page(page);
+ if (!PageError(page))
+ SetPageUptodate(page);
+ unlock_page(page);
+
+ return 0;
+}
+
+
+const struct address_space_operations squashfs_aops = {
+ .readpage = squashfs_readpage
+};
diff --git a/squashfs-tools/kernel/fs/squashfs/fragment.c b/squashfs-tools/kernel/fs/squashfs/fragment.c
new file mode 100644
index 0000000..b5a2c15
--- /dev/null
+++ b/squashfs-tools/kernel/fs/squashfs/fragment.c
@@ -0,0 +1,98 @@
+/*
+ * Squashfs - a compressed read only filesystem for Linux
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ * Phillip Lougher <phillip@lougher.demon.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * fragment.c
+ */
+
+/*
+ * This file implements code to handle compressed fragments (tail-end packed
+ * datablocks).
+ *
+ * Regular files contain a fragment index which is mapped to a fragment
+ * location on disk and compressed size using a fragment lookup table.
+ * Like everything in Squashfs this fragment lookup table is itself stored
+ * compressed into metadata blocks. A second index table is used to locate
+ * these. This second index table for speed of access (and because it
+ * is small) is read at mount time and cached in memory.
+ */
+
+#include <linux/fs.h>
+#include <linux/vfs.h>
+#include <linux/slab.h>
+#include <linux/zlib.h>
+
+#include "squashfs_fs.h"
+#include "squashfs_fs_sb.h"
+#include "squashfs_fs_i.h"
+#include "squashfs.h"
+
+/*
+ * Look-up fragment using the fragment index table. Return the on disk
+ * location of the fragment and its compressed size
+ */
+int squashfs_frag_lookup(struct super_block *sb, unsigned int fragment,
+ u64 *fragment_block)
+{
+ struct squashfs_sb_info *msblk = sb->s_fs_info;
+ int block = SQUASHFS_FRAGMENT_INDEX(fragment);
+ int offset = SQUASHFS_FRAGMENT_INDEX_OFFSET(fragment);
+ u64 start_block = le64_to_cpu(msblk->fragment_index[block]);
+ struct squashfs_fragment_entry fragment_entry;
+ int size;
+
+ size = squashfs_read_metadata(sb, &fragment_entry, &start_block,
+ &offset, sizeof(fragment_entry));
+ if (size < 0)
+ return size;
+
+ *fragment_block = le64_to_cpu(fragment_entry.start_block);
+ size = le32_to_cpu(fragment_entry.size);
+
+ return size;
+}
+
+
+/*
+ * Read the uncompressed fragment lookup table indexes off disk into memory
+ */
+__le64 *squashfs_read_fragment_index_table(struct super_block *sb,
+ u64 fragment_table_start, unsigned int fragments)
+{
+ unsigned int length = SQUASHFS_FRAGMENT_INDEX_BYTES(fragments);
+ __le64 *fragment_index;
+ int err;
+
+ /* Allocate fragment lookup table indexes */
+ fragment_index = kmalloc(length, GFP_KERNEL);
+ if (fragment_index == NULL) {
+ ERROR("Failed to allocate fragment index table\n");
+ return ERR_PTR(-ENOMEM);
+ }
+
+ err = squashfs_read_table(sb, fragment_index, fragment_table_start,
+ length);
+ if (err < 0) {
+ ERROR("unable to read fragment index table\n");
+ kfree(fragment_index);
+ return ERR_PTR(err);
+ }
+
+ return fragment_index;
+}
diff --git a/squashfs-tools/kernel/fs/squashfs/id.c b/squashfs-tools/kernel/fs/squashfs/id.c
new file mode 100644
index 0000000..3795b83
--- /dev/null
+++ b/squashfs-tools/kernel/fs/squashfs/id.c
@@ -0,0 +1,94 @@
+/*
+ * Squashfs - a compressed read only filesystem for Linux
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ * Phillip Lougher <phillip@lougher.demon.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * id.c
+ */
+
+/*
+ * This file implements code to handle uids and gids.
+ *
+ * For space efficiency regular files store uid and gid indexes, which are
+ * converted to 32-bit uids/gids using an id look up table. This table is
+ * stored compressed into metadata blocks. A second index table is used to
+ * locate these. This second index table for speed of access (and because it
+ * is small) is read at mount time and cached in memory.
+ */
+
+#include <linux/fs.h>
+#include <linux/vfs.h>
+#include <linux/slab.h>
+#include <linux/zlib.h>
+
+#include "squashfs_fs.h"
+#include "squashfs_fs_sb.h"
+#include "squashfs_fs_i.h"
+#include "squashfs.h"
+
+/*
+ * Map uid/gid index into real 32-bit uid/gid using the id look up table
+ */
+int squashfs_get_id(struct super_block *sb, unsigned int index,
+ unsigned int *id)
+{
+ struct squashfs_sb_info *msblk = sb->s_fs_info;
+ int block = SQUASHFS_ID_BLOCK(index);
+ int offset = SQUASHFS_ID_BLOCK_OFFSET(index);
+ u64 start_block = le64_to_cpu(msblk->id_table[block]);
+ __le32 disk_id;
+ int err;
+
+ err = squashfs_read_metadata(sb, &disk_id, &start_block, &offset,
+ sizeof(disk_id));
+ if (err < 0)
+ return err;
+
+ *id = le32_to_cpu(disk_id);
+ return 0;
+}
+
+
+/*
+ * Read uncompressed id lookup table indexes from disk into memory
+ */
+__le64 *squashfs_read_id_index_table(struct super_block *sb,
+ u64 id_table_start, unsigned short no_ids)
+{
+ unsigned int length = SQUASHFS_ID_BLOCK_BYTES(no_ids);
+ __le64 *id_table;
+ int err;
+
+ TRACE("In read_id_index_table, length %d\n", length);
+
+ /* Allocate id lookup table indexes */
+ id_table = kmalloc(length, GFP_KERNEL);
+ if (id_table == NULL) {
+ ERROR("Failed to allocate id index table\n");
+ return ERR_PTR(-ENOMEM);
+ }
+
+ err = squashfs_read_table(sb, id_table, id_table_start, length);
+ if (err < 0) {
+ ERROR("unable to read id index table\n");
+ kfree(id_table);
+ return ERR_PTR(err);
+ }
+
+ return id_table;
+}
diff --git a/squashfs-tools/kernel/fs/squashfs/inode.c b/squashfs-tools/kernel/fs/squashfs/inode.c
new file mode 100644
index 0000000..7a63398
--- /dev/null
+++ b/squashfs-tools/kernel/fs/squashfs/inode.c
@@ -0,0 +1,346 @@
+/*
+ * Squashfs - a compressed read only filesystem for Linux
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ * Phillip Lougher <phillip@lougher.demon.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * inode.c
+ */
+
+/*
+ * This file implements code to create and read inodes from disk.
+ *
+ * Inodes in Squashfs are identified by a 48-bit inode which encodes the
+ * location of the compressed metadata block containing the inode, and the byte
+ * offset into that block where the inode is placed (<block, offset>).
+ *
+ * To maximise compression there are different inodes for each file type
+ * (regular file, directory, device, etc.), the inode contents and length
+ * varying with the type.
+ *
+ * To further maximise compression, two types of regular file inode and
+ * directory inode are defined: inodes optimised for frequently occurring
+ * regular files and directories, and extended types where extra
+ * information has to be stored.
+ */
+
+#include <linux/fs.h>
+#include <linux/vfs.h>
+#include <linux/zlib.h>
+
+#include "squashfs_fs.h"
+#include "squashfs_fs_sb.h"
+#include "squashfs_fs_i.h"
+#include "squashfs.h"
+
+/*
+ * Initialise VFS inode with the base inode information common to all
+ * Squashfs inode types. Sqsh_ino contains the unswapped base inode
+ * off disk.
+ */
+static int squashfs_new_inode(struct super_block *sb, struct inode *inode,
+ struct squashfs_base_inode *sqsh_ino)
+{
+ int err;
+
+ err = squashfs_get_id(sb, le16_to_cpu(sqsh_ino->uid), &inode->i_uid);
+ if (err)
+ return err;
+
+ err = squashfs_get_id(sb, le16_to_cpu(sqsh_ino->guid), &inode->i_gid);
+ if (err)
+ return err;
+
+ inode->i_ino = le32_to_cpu(sqsh_ino->inode_number);
+ inode->i_mtime.tv_sec = le32_to_cpu(sqsh_ino->mtime);
+ inode->i_atime.tv_sec = inode->i_mtime.tv_sec;
+ inode->i_ctime.tv_sec = inode->i_mtime.tv_sec;
+ inode->i_mode = le16_to_cpu(sqsh_ino->mode);
+ inode->i_size = 0;
+
+ return err;
+}
+
+
+struct inode *squashfs_iget(struct super_block *sb, long long ino,
+ unsigned int ino_number)
+{
+ struct inode *inode = iget_locked(sb, ino_number);
+ int err;
+
+ TRACE("Entered squashfs_iget\n");
+
+ if (!inode)
+ return ERR_PTR(-ENOMEM);
+ if (!(inode->i_state & I_NEW))
+ return inode;
+
+ err = squashfs_read_inode(inode, ino);
+ if (err) {
+ iget_failed(inode);
+ return ERR_PTR(err);
+ }
+
+ unlock_new_inode(inode);
+ return inode;
+}
+
+
+/*
+ * Initialise VFS inode by reading inode from inode table (compressed
+ * metadata). The format and amount of data read depends on type.
+ */
+int squashfs_read_inode(struct inode *inode, long long ino)
+{
+ struct super_block *sb = inode->i_sb;
+ struct squashfs_sb_info *msblk = sb->s_fs_info;
+ u64 block = SQUASHFS_INODE_BLK(ino) + msblk->inode_table;
+ int err, type, offset = SQUASHFS_INODE_OFFSET(ino);
+ union squashfs_inode squashfs_ino;
+ struct squashfs_base_inode *sqshb_ino = &squashfs_ino.base;
+
+ TRACE("Entered squashfs_read_inode\n");
+
+ /*
+ * Read inode base common to all inode types.
+ */
+ err = squashfs_read_metadata(sb, sqshb_ino, &block,
+ &offset, sizeof(*sqshb_ino));
+ if (err < 0)
+ goto failed_read;
+
+ err = squashfs_new_inode(sb, inode, sqshb_ino);
+ if (err)
+ goto failed_read;
+
+ block = SQUASHFS_INODE_BLK(ino) + msblk->inode_table;
+ offset = SQUASHFS_INODE_OFFSET(ino);
+
+ type = le16_to_cpu(sqshb_ino->inode_type);
+ switch (type) {
+ case SQUASHFS_REG_TYPE: {
+ unsigned int frag_offset, frag_size, frag;
+ u64 frag_blk;
+ struct squashfs_reg_inode *sqsh_ino = &squashfs_ino.reg;
+
+ err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset,
+ sizeof(*sqsh_ino));
+ if (err < 0)
+ goto failed_read;
+
+ frag = le32_to_cpu(sqsh_ino->fragment);
+ if (frag != SQUASHFS_INVALID_FRAG) {
+ frag_offset = le32_to_cpu(sqsh_ino->offset);
+ frag_size = squashfs_frag_lookup(sb, frag, &frag_blk);
+ if (frag_size < 0) {
+ err = frag_size;
+ goto failed_read;
+ }
+ } else {
+ frag_blk = SQUASHFS_INVALID_BLK;
+ frag_size = 0;
+ frag_offset = 0;
+ }
+
+ inode->i_nlink = 1;
+ inode->i_size = le32_to_cpu(sqsh_ino->file_size);
+ inode->i_fop = &generic_ro_fops;
+ inode->i_mode |= S_IFREG;
+ inode->i_blocks = ((inode->i_size - 1) >> 9) + 1;
+ squashfs_i(inode)->fragment_block = frag_blk;
+ squashfs_i(inode)->fragment_size = frag_size;
+ squashfs_i(inode)->fragment_offset = frag_offset;
+ squashfs_i(inode)->start = le32_to_cpu(sqsh_ino->start_block);
+ squashfs_i(inode)->block_list_start = block;
+ squashfs_i(inode)->offset = offset;
+ inode->i_data.a_ops = &squashfs_aops;
+
+ TRACE("File inode %x:%x, start_block %llx, block_list_start "
+ "%llx, offset %x\n", SQUASHFS_INODE_BLK(ino),
+ offset, squashfs_i(inode)->start, block, offset);
+ break;
+ }
+ case SQUASHFS_LREG_TYPE: {
+ unsigned int frag_offset, frag_size, frag;
+ u64 frag_blk;
+ struct squashfs_lreg_inode *sqsh_ino = &squashfs_ino.lreg;
+
+ err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset,
+ sizeof(*sqsh_ino));
+ if (err < 0)
+ goto failed_read;
+
+ frag = le32_to_cpu(sqsh_ino->fragment);
+ if (frag != SQUASHFS_INVALID_FRAG) {
+ frag_offset = le32_to_cpu(sqsh_ino->offset);
+ frag_size = squashfs_frag_lookup(sb, frag, &frag_blk);
+ if (frag_size < 0) {
+ err = frag_size;
+ goto failed_read;
+ }
+ } else {
+ frag_blk = SQUASHFS_INVALID_BLK;
+ frag_size = 0;
+ frag_offset = 0;
+ }
+
+ inode->i_nlink = le32_to_cpu(sqsh_ino->nlink);
+ inode->i_size = le64_to_cpu(sqsh_ino->file_size);
+ inode->i_fop = &generic_ro_fops;
+ inode->i_mode |= S_IFREG;
+ inode->i_blocks = ((inode->i_size -
+ le64_to_cpu(sqsh_ino->sparse) - 1) >> 9) + 1;
+
+ squashfs_i(inode)->fragment_block = frag_blk;
+ squashfs_i(inode)->fragment_size = frag_size;
+ squashfs_i(inode)->fragment_offset = frag_offset;
+ squashfs_i(inode)->start = le64_to_cpu(sqsh_ino->start_block);
+ squashfs_i(inode)->block_list_start = block;
+ squashfs_i(inode)->offset = offset;
+ inode->i_data.a_ops = &squashfs_aops;
+
+ TRACE("File inode %x:%x, start_block %llx, block_list_start "
+ "%llx, offset %x\n", SQUASHFS_INODE_BLK(ino),
+ offset, squashfs_i(inode)->start, block, offset);
+ break;
+ }
+ case SQUASHFS_DIR_TYPE: {
+ struct squashfs_dir_inode *sqsh_ino = &squashfs_ino.dir;
+
+ err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset,
+ sizeof(*sqsh_ino));
+ if (err < 0)
+ goto failed_read;
+
+ inode->i_nlink = le32_to_cpu(sqsh_ino->nlink);
+ inode->i_size = le16_to_cpu(sqsh_ino->file_size);
+ inode->i_op = &squashfs_dir_inode_ops;
+ inode->i_fop = &squashfs_dir_ops;
+ inode->i_mode |= S_IFDIR;
+ squashfs_i(inode)->start = le32_to_cpu(sqsh_ino->start_block);
+ squashfs_i(inode)->offset = le16_to_cpu(sqsh_ino->offset);
+ squashfs_i(inode)->dir_idx_cnt = 0;
+ squashfs_i(inode)->parent = le32_to_cpu(sqsh_ino->parent_inode);
+
+ TRACE("Directory inode %x:%x, start_block %llx, offset %x\n",
+ SQUASHFS_INODE_BLK(ino), offset,
+ squashfs_i(inode)->start,
+ le16_to_cpu(sqsh_ino->offset));
+ break;
+ }
+ case SQUASHFS_LDIR_TYPE: {
+ struct squashfs_ldir_inode *sqsh_ino = &squashfs_ino.ldir;
+
+ err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset,
+ sizeof(*sqsh_ino));
+ if (err < 0)
+ goto failed_read;
+
+ inode->i_nlink = le32_to_cpu(sqsh_ino->nlink);
+ inode->i_size = le32_to_cpu(sqsh_ino->file_size);
+ inode->i_op = &squashfs_dir_inode_ops;
+ inode->i_fop = &squashfs_dir_ops;
+ inode->i_mode |= S_IFDIR;
+ squashfs_i(inode)->start = le32_to_cpu(sqsh_ino->start_block);
+ squashfs_i(inode)->offset = le16_to_cpu(sqsh_ino->offset);
+ squashfs_i(inode)->dir_idx_start = block;
+ squashfs_i(inode)->dir_idx_offset = offset;
+ squashfs_i(inode)->dir_idx_cnt = le16_to_cpu(sqsh_ino->i_count);
+ squashfs_i(inode)->parent = le32_to_cpu(sqsh_ino->parent_inode);
+
+ TRACE("Long directory inode %x:%x, start_block %llx, offset "
+ "%x\n", SQUASHFS_INODE_BLK(ino), offset,
+ squashfs_i(inode)->start,
+ le16_to_cpu(sqsh_ino->offset));
+ break;
+ }
+ case SQUASHFS_SYMLINK_TYPE:
+ case SQUASHFS_LSYMLINK_TYPE: {
+ struct squashfs_symlink_inode *sqsh_ino = &squashfs_ino.symlink;
+
+ err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset,
+ sizeof(*sqsh_ino));
+ if (err < 0)
+ goto failed_read;
+
+ inode->i_nlink = le32_to_cpu(sqsh_ino->nlink);
+ inode->i_size = le32_to_cpu(sqsh_ino->symlink_size);
+ inode->i_op = &page_symlink_inode_operations;
+ inode->i_data.a_ops = &squashfs_symlink_aops;
+ inode->i_mode |= S_IFLNK;
+ squashfs_i(inode)->start = block;
+ squashfs_i(inode)->offset = offset;
+
+ TRACE("Symbolic link inode %x:%x, start_block %llx, offset "
+ "%x\n", SQUASHFS_INODE_BLK(ino), offset,
+ block, offset);
+ break;
+ }
+ case SQUASHFS_BLKDEV_TYPE:
+ case SQUASHFS_CHRDEV_TYPE:
+ case SQUASHFS_LBLKDEV_TYPE:
+ case SQUASHFS_LCHRDEV_TYPE: {
+ struct squashfs_dev_inode *sqsh_ino = &squashfs_ino.dev;
+ unsigned int rdev;
+
+ err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset,
+ sizeof(*sqsh_ino));
+ if (err < 0)
+ goto failed_read;
+
+ if (type == SQUASHFS_CHRDEV_TYPE)
+ inode->i_mode |= S_IFCHR;
+ else
+ inode->i_mode |= S_IFBLK;
+ inode->i_nlink = le32_to_cpu(sqsh_ino->nlink);
+ rdev = le32_to_cpu(sqsh_ino->rdev);
+ init_special_inode(inode, inode->i_mode, new_decode_dev(rdev));
+
+ TRACE("Device inode %x:%x, rdev %x\n",
+ SQUASHFS_INODE_BLK(ino), offset, rdev);
+ break;
+ }
+ case SQUASHFS_FIFO_TYPE:
+ case SQUASHFS_SOCKET_TYPE:
+ case SQUASHFS_LFIFO_TYPE:
+ case SQUASHFS_LSOCKET_TYPE: {
+ struct squashfs_ipc_inode *sqsh_ino = &squashfs_ino.ipc;
+
+ err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset,
+ sizeof(*sqsh_ino));
+ if (err < 0)
+ goto failed_read;
+
+ if (type == SQUASHFS_FIFO_TYPE)
+ inode->i_mode |= S_IFIFO;
+ else
+ inode->i_mode |= S_IFSOCK;
+ inode->i_nlink = le32_to_cpu(sqsh_ino->nlink);
+ init_special_inode(inode, inode->i_mode, 0);
+ break;
+ }
+ default:
+ ERROR("Unknown inode type %d in squashfs_iget!\n", type);
+ return -EINVAL;
+ }
+
+ return 0;
+
+failed_read:
+ ERROR("Unable to read inode 0x%llx\n", ino);
+ return err;
+}
diff --git a/squashfs-tools/kernel/fs/squashfs/namei.c b/squashfs-tools/kernel/fs/squashfs/namei.c
new file mode 100644
index 0000000..9e39865
--- /dev/null
+++ b/squashfs-tools/kernel/fs/squashfs/namei.c
@@ -0,0 +1,242 @@
+/*
+ * Squashfs - a compressed read only filesystem for Linux
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ * Phillip Lougher <phillip@lougher.demon.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * namei.c
+ */
+
+/*
+ * This file implements code to do filename lookup in directories.
+ *
+ * Like inodes, directories are packed into compressed metadata blocks, stored
+ * in a directory table. Directories are accessed using the start address of
+ * the metablock containing the directory and the offset into the
+ * decompressed block (<block, offset>).
+ *
+ * Directories are organised in a slightly complex way, and are not simply
+ * a list of file names. The organisation takes advantage of the
+ * fact that (in most cases) the inodes of the files will be in the same
+ * compressed metadata block, and therefore, can share the start block.
+ * Directories are therefore organised in a two level list, a directory
+ * header containing the shared start block value, and a sequence of directory
+ * entries, each of which share the shared start block. A new directory header
+ * is written once/if the inode start block changes. The directory
+ * header/directory entry list is repeated as many times as necessary.
+ *
+ * Directories are sorted, and can contain a directory index to speed up
+ * file lookup. Directory indexes store one entry per metablock, each entry
+ * storing the index/filename mapping to the first directory header
+ * in each metadata block. Directories are sorted in alphabetical order,
+ * and at lookup the index is scanned linearly looking for the first filename
+ * alphabetically larger than the filename being looked up. At this point the
+ * location of the metadata block the filename is in has been found.
+ * The general idea of the index is ensure only one metadata block needs to be
+ * decompressed to do a lookup irrespective of the length of the directory.
+ * This scheme has the advantage that it doesn't require extra memory overhead
+ * and doesn't require much extra storage on disk.
+ */
+
+#include <linux/fs.h>
+#include <linux/vfs.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <linux/dcache.h>
+#include <linux/zlib.h>
+
+#include "squashfs_fs.h"
+#include "squashfs_fs_sb.h"
+#include "squashfs_fs_i.h"
+#include "squashfs.h"
+
+/*
+ * Lookup name in the directory index, returning the location of the metadata
+ * block containing it, and the directory index this represents.
+ *
+ * If we get an error reading the index then return the part of the index
+ * (if any) we have managed to read - the index isn't essential, just
+ * quicker.
+ */
+static int get_dir_index_using_name(struct super_block *sb,
+ u64 *next_block, int *next_offset, u64 index_start,
+ int index_offset, int i_count, const char *name,
+ int len)
+{
+ struct squashfs_sb_info *msblk = sb->s_fs_info;
+ int i, size, length = 0, err;
+ struct squashfs_dir_index *index;
+ char *str;
+
+ TRACE("Entered get_dir_index_using_name, i_count %d\n", i_count);
+
+ index = kmalloc(sizeof(*index) + SQUASHFS_NAME_LEN * 2 + 2, GFP_KERNEL);
+ if (index == NULL) {
+ ERROR("Failed to allocate squashfs_dir_index\n");
+ goto out;
+ }
+
+ str = &index->name[SQUASHFS_NAME_LEN + 1];
+ strncpy(str, name, len);
+ str[len] = '\0';
+
+ for (i = 0; i < i_count; i++) {
+ err = squashfs_read_metadata(sb, index, &index_start,
+ &index_offset, sizeof(*index));
+ if (err < 0)
+ break;
+
+
+ size = le32_to_cpu(index->size) + 1;
+
+ err = squashfs_read_metadata(sb, index->name, &index_start,
+ &index_offset, size);
+ if (err < 0)
+ break;
+
+ index->name[size] = '\0';
+
+ if (strcmp(index->name, str) > 0)
+ break;
+
+ length = le32_to_cpu(index->index);
+ *next_block = le32_to_cpu(index->start_block) +
+ msblk->directory_table;
+ }
+
+ *next_offset = (length + *next_offset) % SQUASHFS_METADATA_SIZE;
+ kfree(index);
+
+out:
+ /*
+ * Return index (f_pos) of the looked up metadata block. Translate
+ * from internal f_pos to external f_pos which is offset by 3 because
+ * we invent "." and ".." entries which are not actually stored in the
+ * directory.
+ */
+ return length + 3;
+}
+
+
+static struct dentry *squashfs_lookup(struct inode *dir, struct dentry *dentry,
+ struct nameidata *nd)
+{
+ const unsigned char *name = dentry->d_name.name;
+ int len = dentry->d_name.len;
+ struct inode *inode = NULL;
+ struct squashfs_sb_info *msblk = dir->i_sb->s_fs_info;
+ struct squashfs_dir_header dirh;
+ struct squashfs_dir_entry *dire;
+ u64 block = squashfs_i(dir)->start + msblk->directory_table;
+ int offset = squashfs_i(dir)->offset;
+ int err, length = 0, dir_count, size;
+
+ TRACE("Entered squashfs_lookup [%llx:%x]\n", block, offset);
+
+ dire = kmalloc(sizeof(*dire) + SQUASHFS_NAME_LEN + 1, GFP_KERNEL);
+ if (dire == NULL) {
+ ERROR("Failed to allocate squashfs_dir_entry\n");
+ return ERR_PTR(-ENOMEM);
+ }
+
+ if (len > SQUASHFS_NAME_LEN) {
+ err = -ENAMETOOLONG;
+ goto failed;
+ }
+
+ length = get_dir_index_using_name(dir->i_sb, &block, &offset,
+ squashfs_i(dir)->dir_idx_start,
+ squashfs_i(dir)->dir_idx_offset,
+ squashfs_i(dir)->dir_idx_cnt, name, len);
+
+ while (length < i_size_read(dir)) {
+ /*
+ * Read directory header.
+ */
+ err = squashfs_read_metadata(dir->i_sb, &dirh, &block,
+ &offset, sizeof(dirh));
+ if (err < 0)
+ goto read_failure;
+
+ length += sizeof(dirh);
+
+ dir_count = le32_to_cpu(dirh.count) + 1;
+ while (dir_count--) {
+ /*
+ * Read directory entry.
+ */
+ err = squashfs_read_metadata(dir->i_sb, dire, &block,
+ &offset, sizeof(*dire));
+ if (err < 0)
+ goto read_failure;
+
+ size = le16_to_cpu(dire->size) + 1;
+
+ err = squashfs_read_metadata(dir->i_sb, dire->name,
+ &block, &offset, size);
+ if (err < 0)
+ goto read_failure;
+
+ length += sizeof(*dire) + size;
+
+ if (name[0] < dire->name[0])
+ goto exit_lookup;
+
+ if (len == size && !strncmp(name, dire->name, len)) {
+ unsigned int blk, off, ino_num;
+ long long ino;
+ blk = le32_to_cpu(dirh.start_block);
+ off = le16_to_cpu(dire->offset);
+ ino_num = le32_to_cpu(dirh.inode_number) +
+ (short) le16_to_cpu(dire->inode_number);
+ ino = SQUASHFS_MKINODE(blk, off);
+
+ TRACE("calling squashfs_iget for directory "
+ "entry %s, inode %x:%x, %d\n", name,
+ blk, off, ino_num);
+
+ inode = squashfs_iget(dir->i_sb, ino, ino_num);
+ if (IS_ERR(inode)) {
+ err = PTR_ERR(inode);
+ goto failed;
+ }
+
+ goto exit_lookup;
+ }
+ }
+ }
+
+exit_lookup:
+ kfree(dire);
+ if (inode)
+ return d_splice_alias(inode, dentry);
+ d_add(dentry, inode);
+ return ERR_PTR(0);
+
+read_failure:
+ ERROR("Unable to read directory block [%llx:%x]\n",
+ squashfs_i(dir)->start + msblk->directory_table,
+ squashfs_i(dir)->offset);
+failed:
+ kfree(dire);
+ return ERR_PTR(err);
+}
+
+
+const struct inode_operations squashfs_dir_inode_ops = {
+ .lookup = squashfs_lookup
+};
diff --git a/squashfs-tools/kernel/fs/squashfs/squashfs.h b/squashfs-tools/kernel/fs/squashfs/squashfs.h
new file mode 100644
index 0000000..6b2515d
--- /dev/null
+++ b/squashfs-tools/kernel/fs/squashfs/squashfs.h
@@ -0,0 +1,90 @@
+/*
+ * Squashfs - a compressed read only filesystem for Linux
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ * Phillip Lougher <phillip@lougher.demon.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * squashfs.h
+ */
+
+#define TRACE(s, args...) pr_debug("SQUASHFS: "s, ## args)
+
+#define ERROR(s, args...) pr_err("SQUASHFS error: "s, ## args)
+
+#define WARNING(s, args...) pr_warning("SQUASHFS: "s, ## args)
+
+static inline struct squashfs_inode_info *squashfs_i(struct inode *inode)
+{
+ return list_entry(inode, struct squashfs_inode_info, vfs_inode);
+}
+
+/* block.c */
+extern int squashfs_read_data(struct super_block *, void **, u64, int, u64 *,
+ int);
+
+/* cache.c */
+extern struct squashfs_cache *squashfs_cache_init(char *, int, int);
+extern void squashfs_cache_delete(struct squashfs_cache *);
+extern struct squashfs_cache_entry *squashfs_cache_get(struct super_block *,
+ struct squashfs_cache *, u64, int);
+extern void squashfs_cache_put(struct squashfs_cache_entry *);
+extern int squashfs_copy_data(void *, struct squashfs_cache_entry *, int, int);
+extern int squashfs_read_metadata(struct super_block *, void *, u64 *,
+ int *, int);
+extern struct squashfs_cache_entry *squashfs_get_fragment(struct super_block *,
+ u64, int);
+extern struct squashfs_cache_entry *squashfs_get_datablock(struct super_block *,
+ u64, int);
+extern int squashfs_read_table(struct super_block *, void *, u64, int);
+
+/* export.c */
+extern __le64 *squashfs_read_inode_lookup_table(struct super_block *, u64,
+ unsigned int);
+
+/* fragment.c */
+extern int squashfs_frag_lookup(struct super_block *, unsigned int, u64 *);
+extern __le64 *squashfs_read_fragment_index_table(struct super_block *,
+ u64, unsigned int);
+
+/* id.c */
+extern int squashfs_get_id(struct super_block *, unsigned int, unsigned int *);
+extern __le64 *squashfs_read_id_index_table(struct super_block *, u64,
+ unsigned short);
+
+/* inode.c */
+extern struct inode *squashfs_iget(struct super_block *, long long,
+ unsigned int);
+extern int squashfs_read_inode(struct inode *, long long);
+
+/*
+ * Inodes and files operations
+ */
+
+/* dir.c */
+extern const struct file_operations squashfs_dir_ops;
+
+/* export.c */
+extern const struct export_operations squashfs_export_ops;
+
+/* file.c */
+extern const struct address_space_operations squashfs_aops;
+
+/* namei.c */
+extern const struct inode_operations squashfs_dir_inode_ops;
+
+/* symlink.c */
+extern const struct address_space_operations squashfs_symlink_aops;
diff --git a/squashfs-tools/kernel/fs/squashfs/squashfs_fs.h b/squashfs-tools/kernel/fs/squashfs/squashfs_fs.h
new file mode 100644
index 0000000..6840da1
--- /dev/null
+++ b/squashfs-tools/kernel/fs/squashfs/squashfs_fs.h
@@ -0,0 +1,381 @@
+#ifndef SQUASHFS_FS
+#define SQUASHFS_FS
+/*
+ * Squashfs
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ * Phillip Lougher <phillip@lougher.demon.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * squashfs_fs.h
+ */
+
+#define SQUASHFS_CACHED_FRAGMENTS CONFIG_SQUASHFS_FRAGMENT_CACHE_SIZE
+#define SQUASHFS_MAJOR 4
+#define SQUASHFS_MINOR 0
+#define SQUASHFS_MAGIC 0x73717368
+#define SQUASHFS_START 0
+
+/* size of metadata (inode and directory) blocks */
+#define SQUASHFS_METADATA_SIZE 8192
+#define SQUASHFS_METADATA_LOG 13
+
+/* default size of data blocks */
+#define SQUASHFS_FILE_SIZE 131072
+#define SQUASHFS_FILE_LOG 17
+
+#define SQUASHFS_FILE_MAX_SIZE 1048576
+#define SQUASHFS_FILE_MAX_LOG 20
+
+/* Max number of uids and gids */
+#define SQUASHFS_IDS 65536
+
+/* Max length of filename (not 255) */
+#define SQUASHFS_NAME_LEN 256
+
+#define SQUASHFS_INVALID_FRAG (0xffffffffU)
+#define SQUASHFS_INVALID_BLK (-1LL)
+
+/* Filesystem flags */
+#define SQUASHFS_NOI 0
+#define SQUASHFS_NOD 1
+#define SQUASHFS_NOF 3
+#define SQUASHFS_NO_FRAG 4
+#define SQUASHFS_ALWAYS_FRAG 5
+#define SQUASHFS_DUPLICATE 6
+#define SQUASHFS_EXPORT 7
+
+#define SQUASHFS_BIT(flag, bit) ((flag >> bit) & 1)
+
+#define SQUASHFS_UNCOMPRESSED_INODES(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_NOI)
+
+#define SQUASHFS_UNCOMPRESSED_DATA(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_NOD)
+
+#define SQUASHFS_UNCOMPRESSED_FRAGMENTS(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_NOF)
+
+#define SQUASHFS_NO_FRAGMENTS(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_NO_FRAG)
+
+#define SQUASHFS_ALWAYS_FRAGMENTS(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_ALWAYS_FRAG)
+
+#define SQUASHFS_DUPLICATES(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_DUPLICATE)
+
+#define SQUASHFS_EXPORTABLE(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_EXPORT)
+
+/* Max number of types and file types */
+#define SQUASHFS_DIR_TYPE 1
+#define SQUASHFS_REG_TYPE 2
+#define SQUASHFS_SYMLINK_TYPE 3
+#define SQUASHFS_BLKDEV_TYPE 4
+#define SQUASHFS_CHRDEV_TYPE 5
+#define SQUASHFS_FIFO_TYPE 6
+#define SQUASHFS_SOCKET_TYPE 7
+#define SQUASHFS_LDIR_TYPE 8
+#define SQUASHFS_LREG_TYPE 9
+#define SQUASHFS_LSYMLINK_TYPE 10
+#define SQUASHFS_LBLKDEV_TYPE 11
+#define SQUASHFS_LCHRDEV_TYPE 12
+#define SQUASHFS_LFIFO_TYPE 13
+#define SQUASHFS_LSOCKET_TYPE 14
+
+/* Flag whether block is compressed or uncompressed, bit is set if block is
+ * uncompressed */
+#define SQUASHFS_COMPRESSED_BIT (1 << 15)
+
+#define SQUASHFS_COMPRESSED_SIZE(B) (((B) & ~SQUASHFS_COMPRESSED_BIT) ? \
+ (B) & ~SQUASHFS_COMPRESSED_BIT : SQUASHFS_COMPRESSED_BIT)
+
+#define SQUASHFS_COMPRESSED(B) (!((B) & SQUASHFS_COMPRESSED_BIT))
+
+#define SQUASHFS_COMPRESSED_BIT_BLOCK (1 << 24)
+
+#define SQUASHFS_COMPRESSED_SIZE_BLOCK(B) ((B) & \
+ ~SQUASHFS_COMPRESSED_BIT_BLOCK)
+
+#define SQUASHFS_COMPRESSED_BLOCK(B) (!((B) & SQUASHFS_COMPRESSED_BIT_BLOCK))
+
+/*
+ * Inode number ops. Inodes consist of a compressed block number, and an
+ * uncompressed offset within that block
+ */
+#define SQUASHFS_INODE_BLK(A) ((unsigned int) ((A) >> 16))
+
+#define SQUASHFS_INODE_OFFSET(A) ((unsigned int) ((A) & 0xffff))
+
+#define SQUASHFS_MKINODE(A, B) ((long long)(((long long) (A)\
+ << 16) + (B)))
+
+/* Translate between VFS mode and squashfs mode */
+#define SQUASHFS_MODE(A) ((A) & 0xfff)
+
+/* fragment and fragment table defines */
+#define SQUASHFS_FRAGMENT_BYTES(A) \
+ ((A) * sizeof(struct squashfs_fragment_entry))
+
+#define SQUASHFS_FRAGMENT_INDEX(A) (SQUASHFS_FRAGMENT_BYTES(A) / \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_FRAGMENT_INDEX_OFFSET(A) (SQUASHFS_FRAGMENT_BYTES(A) % \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_FRAGMENT_INDEXES(A) ((SQUASHFS_FRAGMENT_BYTES(A) + \
+ SQUASHFS_METADATA_SIZE - 1) / \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_FRAGMENT_INDEX_BYTES(A) (SQUASHFS_FRAGMENT_INDEXES(A) *\
+ sizeof(u64))
+
+/* inode lookup table defines */
+#define SQUASHFS_LOOKUP_BYTES(A) ((A) * sizeof(u64))
+
+#define SQUASHFS_LOOKUP_BLOCK(A) (SQUASHFS_LOOKUP_BYTES(A) / \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_LOOKUP_BLOCK_OFFSET(A) (SQUASHFS_LOOKUP_BYTES(A) % \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_LOOKUP_BLOCKS(A) ((SQUASHFS_LOOKUP_BYTES(A) + \
+ SQUASHFS_METADATA_SIZE - 1) / \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_LOOKUP_BLOCK_BYTES(A) (SQUASHFS_LOOKUP_BLOCKS(A) *\
+ sizeof(u64))
+
+/* uid/gid lookup table defines */
+#define SQUASHFS_ID_BYTES(A) ((A) * sizeof(unsigned int))
+
+#define SQUASHFS_ID_BLOCK(A) (SQUASHFS_ID_BYTES(A) / \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_ID_BLOCK_OFFSET(A) (SQUASHFS_ID_BYTES(A) % \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_ID_BLOCKS(A) ((SQUASHFS_ID_BYTES(A) + \
+ SQUASHFS_METADATA_SIZE - 1) / \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_ID_BLOCK_BYTES(A) (SQUASHFS_ID_BLOCKS(A) *\
+ sizeof(u64))
+
+/* cached data constants for filesystem */
+#define SQUASHFS_CACHED_BLKS 8
+
+#define SQUASHFS_MAX_FILE_SIZE_LOG 64
+
+#define SQUASHFS_MAX_FILE_SIZE (1LL << \
+ (SQUASHFS_MAX_FILE_SIZE_LOG - 2))
+
+#define SQUASHFS_MARKER_BYTE 0xff
+
+/* meta index cache */
+#define SQUASHFS_META_INDEXES (SQUASHFS_METADATA_SIZE / sizeof(unsigned int))
+#define SQUASHFS_META_ENTRIES 127
+#define SQUASHFS_META_SLOTS 8
+
+struct meta_entry {
+ u64 data_block;
+ unsigned int index_block;
+ unsigned short offset;
+ unsigned short pad;
+};
+
+struct meta_index {
+ unsigned int inode_number;
+ unsigned int offset;
+ unsigned short entries;
+ unsigned short skip;
+ unsigned short locked;
+ unsigned short pad;
+ struct meta_entry meta_entry[SQUASHFS_META_ENTRIES];
+};
+
+
+/*
+ * definitions for structures on disk
+ */
+#define ZLIB_COMPRESSION 1
+
+struct squashfs_super_block {
+ __le32 s_magic;
+ __le32 inodes;
+ __le32 mkfs_time;
+ __le32 block_size;
+ __le32 fragments;
+ __le16 compression;
+ __le16 block_log;
+ __le16 flags;
+ __le16 no_ids;
+ __le16 s_major;
+ __le16 s_minor;
+ __le64 root_inode;
+ __le64 bytes_used;
+ __le64 id_table_start;
+ __le64 xattr_table_start;
+ __le64 inode_table_start;
+ __le64 directory_table_start;
+ __le64 fragment_table_start;
+ __le64 lookup_table_start;
+};
+
+struct squashfs_dir_index {
+ __le32 index;
+ __le32 start_block;
+ __le32 size;
+ unsigned char name[0];
+};
+
+struct squashfs_base_inode {
+ __le16 inode_type;
+ __le16 mode;
+ __le16 uid;
+ __le16 guid;
+ __le32 mtime;
+ __le32 inode_number;
+};
+
+struct squashfs_ipc_inode {
+ __le16 inode_type;
+ __le16 mode;
+ __le16 uid;
+ __le16 guid;
+ __le32 mtime;
+ __le32 inode_number;
+ __le32 nlink;
+};
+
+struct squashfs_dev_inode {
+ __le16 inode_type;
+ __le16 mode;
+ __le16 uid;
+ __le16 guid;
+ __le32 mtime;
+ __le32 inode_number;
+ __le32 nlink;
+ __le32 rdev;
+};
+
+struct squashfs_symlink_inode {
+ __le16 inode_type;
+ __le16 mode;
+ __le16 uid;
+ __le16 guid;
+ __le32 mtime;
+ __le32 inode_number;
+ __le32 nlink;
+ __le32 symlink_size;
+ char symlink[0];
+};
+
+struct squashfs_reg_inode {
+ __le16 inode_type;
+ __le16 mode;
+ __le16 uid;
+ __le16 guid;
+ __le32 mtime;
+ __le32 inode_number;
+ __le32 start_block;
+ __le32 fragment;
+ __le32 offset;
+ __le32 file_size;
+ __le16 block_list[0];
+};
+
+struct squashfs_lreg_inode {
+ __le16 inode_type;
+ __le16 mode;
+ __le16 uid;
+ __le16 guid;
+ __le32 mtime;
+ __le32 inode_number;
+ __le64 start_block;
+ __le64 file_size;
+ __le64 sparse;
+ __le32 nlink;
+ __le32 fragment;
+ __le32 offset;
+ __le32 xattr;
+ __le16 block_list[0];
+};
+
+struct squashfs_dir_inode {
+ __le16 inode_type;
+ __le16 mode;
+ __le16 uid;
+ __le16 guid;
+ __le32 mtime;
+ __le32 inode_number;
+ __le32 start_block;
+ __le32 nlink;
+ __le16 file_size;
+ __le16 offset;
+ __le32 parent_inode;
+};
+
+struct squashfs_ldir_inode {
+ __le16 inode_type;
+ __le16 mode;
+ __le16 uid;
+ __le16 guid;
+ __le32 mtime;
+ __le32 inode_number;
+ __le32 nlink;
+ __le32 file_size;
+ __le32 start_block;
+ __le32 parent_inode;
+ __le16 i_count;
+ __le16 offset;
+ __le32 xattr;
+ struct squashfs_dir_index index[0];
+};
+
+union squashfs_inode {
+ struct squashfs_base_inode base;
+ struct squashfs_dev_inode dev;
+ struct squashfs_symlink_inode symlink;
+ struct squashfs_reg_inode reg;
+ struct squashfs_lreg_inode lreg;
+ struct squashfs_dir_inode dir;
+ struct squashfs_ldir_inode ldir;
+ struct squashfs_ipc_inode ipc;
+};
+
+struct squashfs_dir_entry {
+ __le16 offset;
+ __le16 inode_number;
+ __le16 type;
+ __le16 size;
+ char name[0];
+};
+
+struct squashfs_dir_header {
+ __le32 count;
+ __le32 start_block;
+ __le32 inode_number;
+};
+
+struct squashfs_fragment_entry {
+ __le64 start_block;
+ __le32 size;
+ unsigned int unused;
+};
+
+#endif
diff --git a/squashfs-tools/kernel/fs/squashfs/squashfs_fs_i.h b/squashfs-tools/kernel/fs/squashfs/squashfs_fs_i.h
new file mode 100644
index 0000000..fbfca30
--- /dev/null
+++ b/squashfs-tools/kernel/fs/squashfs/squashfs_fs_i.h
@@ -0,0 +1,45 @@
+#ifndef SQUASHFS_FS_I
+#define SQUASHFS_FS_I
+/*
+ * Squashfs
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ * Phillip Lougher <phillip@lougher.demon.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * squashfs_fs_i.h
+ */
+
+struct squashfs_inode_info {
+ u64 start;
+ int offset;
+ union {
+ struct {
+ u64 fragment_block;
+ int fragment_size;
+ int fragment_offset;
+ u64 block_list_start;
+ };
+ struct {
+ u64 dir_idx_start;
+ int dir_idx_offset;
+ int dir_idx_cnt;
+ int parent;
+ };
+ };
+ struct inode vfs_inode;
+};
+#endif
diff --git a/squashfs-tools/kernel/fs/squashfs/squashfs_fs_sb.h b/squashfs-tools/kernel/fs/squashfs/squashfs_fs_sb.h
new file mode 100644
index 0000000..c8c6561
--- /dev/null
+++ b/squashfs-tools/kernel/fs/squashfs/squashfs_fs_sb.h
@@ -0,0 +1,76 @@
+#ifndef SQUASHFS_FS_SB
+#define SQUASHFS_FS_SB
+/*
+ * Squashfs
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ * Phillip Lougher <phillip@lougher.demon.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * squashfs_fs_sb.h
+ */
+
+#include "squashfs_fs.h"
+
+struct squashfs_cache {
+ char *name;
+ int entries;
+ int next_blk;
+ int num_waiters;
+ int unused;
+ int block_size;
+ int pages;
+ spinlock_t lock;
+ wait_queue_head_t wait_queue;
+ struct squashfs_cache_entry *entry;
+};
+
+struct squashfs_cache_entry {
+ u64 block;
+ int length;
+ int refcount;
+ u64 next_index;
+ int pending;
+ int error;
+ int num_waiters;
+ wait_queue_head_t wait_queue;
+ struct squashfs_cache *cache;
+ void **data;
+};
+
+struct squashfs_sb_info {
+ int devblksize;
+ int devblksize_log2;
+ struct squashfs_cache *block_cache;
+ struct squashfs_cache *fragment_cache;
+ struct squashfs_cache *read_page;
+ int next_meta_index;
+ __le64 *id_table;
+ __le64 *fragment_index;
+ unsigned int *fragment_index_2;
+ struct mutex read_data_mutex;
+ struct mutex meta_index_mutex;
+ struct meta_index *meta_index;
+ z_stream stream;
+ __le64 *inode_lookup_table;
+ u64 inode_table;
+ u64 directory_table;
+ unsigned int block_size;
+ unsigned short block_log;
+ long long bytes_used;
+ unsigned int inodes;
+};
+#endif
diff --git a/squashfs-tools/kernel/fs/squashfs/super.c b/squashfs-tools/kernel/fs/squashfs/super.c
new file mode 100644
index 0000000..a0466d7
--- /dev/null
+++ b/squashfs-tools/kernel/fs/squashfs/super.c
@@ -0,0 +1,440 @@
+/*
+ * Squashfs - a compressed read only filesystem for Linux
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ * Phillip Lougher <phillip@lougher.demon.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * super.c
+ */
+
+/*
+ * This file implements code to read the superblock, read and initialise
+ * in-memory structures at mount time, and all the VFS glue code to register
+ * the filesystem.
+ */
+
+#include <linux/fs.h>
+#include <linux/vfs.h>
+#include <linux/slab.h>
+#include <linux/mutex.h>
+#include <linux/pagemap.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/zlib.h>
+
+#include "squashfs_fs.h"
+#include "squashfs_fs_sb.h"
+#include "squashfs_fs_i.h"
+#include "squashfs.h"
+
+static struct file_system_type squashfs_fs_type;
+static struct super_operations squashfs_super_ops;
+
+static int supported_squashfs_filesystem(short major, short minor, short comp)
+{
+ if (major < SQUASHFS_MAJOR) {
+ ERROR("Major/Minor mismatch, older Squashfs %d.%d "
+ "filesystems are unsupported\n", major, minor);
+ return -EINVAL;
+ } else if (major > SQUASHFS_MAJOR || minor > SQUASHFS_MINOR) {
+ ERROR("Major/Minor mismatch, trying to mount newer "
+ "%d.%d filesystem\n", major, minor);
+ ERROR("Please update your kernel\n");
+ return -EINVAL;
+ }
+
+ if (comp != ZLIB_COMPRESSION)
+ return -EINVAL;
+
+ return 0;
+}
+
+
+static int squashfs_fill_super(struct super_block *sb, void *data, int silent)
+{
+ struct squashfs_sb_info *msblk;
+ struct squashfs_super_block *sblk = NULL;
+ char b[BDEVNAME_SIZE];
+ struct inode *root;
+ long long root_inode;
+ unsigned short flags;
+ unsigned int fragments;
+ u64 lookup_table_start;
+ int err;
+
+ TRACE("Entered squashfs_fill_superblock\n");
+
+ sb->s_fs_info = kzalloc(sizeof(*msblk), GFP_KERNEL);
+ if (sb->s_fs_info == NULL) {
+ ERROR("Failed to allocate squashfs_sb_info\n");
+ return -ENOMEM;
+ }
+ msblk = sb->s_fs_info;
+
+ msblk->stream.workspace = kmalloc(zlib_inflate_workspacesize(),
+ GFP_KERNEL);
+ if (msblk->stream.workspace == NULL) {
+ ERROR("Failed to allocate zlib workspace\n");
+ goto failure;
+ }
+
+ sblk = kzalloc(sizeof(*sblk), GFP_KERNEL);
+ if (sblk == NULL) {
+ ERROR("Failed to allocate squashfs_super_block\n");
+ goto failure;
+ }
+
+ msblk->devblksize = sb_min_blocksize(sb, BLOCK_SIZE);
+ msblk->devblksize_log2 = ffz(~msblk->devblksize);
+
+ mutex_init(&msblk->read_data_mutex);
+ mutex_init(&msblk->meta_index_mutex);
+
+ /*
+ * msblk->bytes_used is checked in squashfs_read_table to ensure reads
+ * are not beyond filesystem end. But as we're using
+ * squashfs_read_table here to read the superblock (including the value
+ * of bytes_used) we need to set it to an initial sensible dummy value
+ */
+ msblk->bytes_used = sizeof(*sblk);
+ err = squashfs_read_table(sb, sblk, SQUASHFS_START, sizeof(*sblk));
+
+ if (err < 0) {
+ ERROR("unable to read squashfs_super_block\n");
+ goto failed_mount;
+ }
+
+ /* Check it is a SQUASHFS superblock */
+ sb->s_magic = le32_to_cpu(sblk->s_magic);
+ if (sb->s_magic != SQUASHFS_MAGIC) {
+ if (!silent)
+ ERROR("Can't find a SQUASHFS superblock on %s\n",
+ bdevname(sb->s_bdev, b));
+ err = -EINVAL;
+ goto failed_mount;
+ }
+
+ /* Check the MAJOR & MINOR versions and compression type */
+ err = supported_squashfs_filesystem(le16_to_cpu(sblk->s_major),
+ le16_to_cpu(sblk->s_minor),
+ le16_to_cpu(sblk->compression));
+ if (err < 0)
+ goto failed_mount;
+
+ err = -EINVAL;
+
+ /*
+ * Check if there's xattrs in the filesystem. These are not
+ * supported in this version, so warn that they will be ignored.
+ */
+ if (le64_to_cpu(sblk->xattr_table_start) != SQUASHFS_INVALID_BLK)
+ ERROR("Xattrs in filesystem, these will be ignored\n");
+
+ /* Check the filesystem does not extend beyond the end of the
+ block device */
+ msblk->bytes_used = le64_to_cpu(sblk->bytes_used);
+ if (msblk->bytes_used < 0 || msblk->bytes_used >
+ i_size_read(sb->s_bdev->bd_inode))
+ goto failed_mount;
+
+ /* Check block size for sanity */
+ msblk->block_size = le32_to_cpu(sblk->block_size);
+ if (msblk->block_size > SQUASHFS_FILE_MAX_SIZE)
+ goto failed_mount;
+
+ msblk->block_log = le16_to_cpu(sblk->block_log);
+ if (msblk->block_log > SQUASHFS_FILE_MAX_LOG)
+ goto failed_mount;
+
+ /* Check the root inode for sanity */
+ root_inode = le64_to_cpu(sblk->root_inode);
+ if (SQUASHFS_INODE_OFFSET(root_inode) > SQUASHFS_METADATA_SIZE)
+ goto failed_mount;
+
+ msblk->inode_table = le64_to_cpu(sblk->inode_table_start);
+ msblk->directory_table = le64_to_cpu(sblk->directory_table_start);
+ msblk->inodes = le32_to_cpu(sblk->inodes);
+ flags = le16_to_cpu(sblk->flags);
+
+ TRACE("Found valid superblock on %s\n", bdevname(sb->s_bdev, b));
+ TRACE("Inodes are %scompressed\n", SQUASHFS_UNCOMPRESSED_INODES(flags)
+ ? "un" : "");
+ TRACE("Data is %scompressed\n", SQUASHFS_UNCOMPRESSED_DATA(flags)
+ ? "un" : "");
+ TRACE("Filesystem size %lld bytes\n", msblk->bytes_used);
+ TRACE("Block size %d\n", msblk->block_size);
+ TRACE("Number of inodes %d\n", msblk->inodes);
+ TRACE("Number of fragments %d\n", le32_to_cpu(sblk->fragments));
+ TRACE("Number of ids %d\n", le16_to_cpu(sblk->no_ids));
+ TRACE("sblk->inode_table_start %llx\n", msblk->inode_table);
+ TRACE("sblk->directory_table_start %llx\n", msblk->directory_table);
+ TRACE("sblk->fragment_table_start %llx\n",
+ (u64) le64_to_cpu(sblk->fragment_table_start));
+ TRACE("sblk->id_table_start %llx\n",
+ (u64) le64_to_cpu(sblk->id_table_start));
+
+ sb->s_maxbytes = MAX_LFS_FILESIZE;
+ sb->s_flags |= MS_RDONLY;
+ sb->s_op = &squashfs_super_ops;
+
+ err = -ENOMEM;
+
+ msblk->block_cache = squashfs_cache_init("metadata",
+ SQUASHFS_CACHED_BLKS, SQUASHFS_METADATA_SIZE);
+ if (msblk->block_cache == NULL)
+ goto failed_mount;
+
+ /* Allocate read_page block */
+ msblk->read_page = squashfs_cache_init("data", 1, msblk->block_size);
+ if (msblk->read_page == NULL) {
+ ERROR("Failed to allocate read_page block\n");
+ goto failed_mount;
+ }
+
+ /* Allocate and read id index table */
+ msblk->id_table = squashfs_read_id_index_table(sb,
+ le64_to_cpu(sblk->id_table_start), le16_to_cpu(sblk->no_ids));
+ if (IS_ERR(msblk->id_table)) {
+ err = PTR_ERR(msblk->id_table);
+ msblk->id_table = NULL;
+ goto failed_mount;
+ }
+
+ fragments = le32_to_cpu(sblk->fragments);
+ if (fragments == 0)
+ goto allocate_lookup_table;
+
+ msblk->fragment_cache = squashfs_cache_init("fragment",
+ SQUASHFS_CACHED_FRAGMENTS, msblk->block_size);
+ if (msblk->fragment_cache == NULL) {
+ err = -ENOMEM;
+ goto failed_mount;
+ }
+
+ /* Allocate and read fragment index table */
+ msblk->fragment_index = squashfs_read_fragment_index_table(sb,
+ le64_to_cpu(sblk->fragment_table_start), fragments);
+ if (IS_ERR(msblk->fragment_index)) {
+ err = PTR_ERR(msblk->fragment_index);
+ msblk->fragment_index = NULL;
+ goto failed_mount;
+ }
+
+allocate_lookup_table:
+ lookup_table_start = le64_to_cpu(sblk->lookup_table_start);
+ if (lookup_table_start == SQUASHFS_INVALID_BLK)
+ goto allocate_root;
+
+ /* Allocate and read inode lookup table */
+ msblk->inode_lookup_table = squashfs_read_inode_lookup_table(sb,
+ lookup_table_start, msblk->inodes);
+ if (IS_ERR(msblk->inode_lookup_table)) {
+ err = PTR_ERR(msblk->inode_lookup_table);
+ msblk->inode_lookup_table = NULL;
+ goto failed_mount;
+ }
+
+ sb->s_export_op = &squashfs_export_ops;
+
+allocate_root:
+ root = new_inode(sb);
+ if (!root) {
+ err = -ENOMEM;
+ goto failed_mount;
+ }
+
+ err = squashfs_read_inode(root, root_inode);
+ if (err) {
+ iget_failed(root);
+ goto failed_mount;
+ }
+ insert_inode_hash(root);
+
+ sb->s_root = d_alloc_root(root);
+ if (sb->s_root == NULL) {
+ ERROR("Root inode create failed\n");
+ err = -ENOMEM;
+ iput(root);
+ goto failed_mount;
+ }
+
+ TRACE("Leaving squashfs_fill_super\n");
+ kfree(sblk);
+ return 0;
+
+failed_mount:
+ squashfs_cache_delete(msblk->block_cache);
+ squashfs_cache_delete(msblk->fragment_cache);
+ squashfs_cache_delete(msblk->read_page);
+ kfree(msblk->inode_lookup_table);
+ kfree(msblk->fragment_index);
+ kfree(msblk->id_table);
+ kfree(msblk->stream.workspace);
+ kfree(sb->s_fs_info);
+ sb->s_fs_info = NULL;
+ kfree(sblk);
+ return err;
+
+failure:
+ kfree(msblk->stream.workspace);
+ kfree(sb->s_fs_info);
+ sb->s_fs_info = NULL;
+ return -ENOMEM;
+}
+
+
+static int squashfs_statfs(struct dentry *dentry, struct kstatfs *buf)
+{
+ struct squashfs_sb_info *msblk = dentry->d_sb->s_fs_info;
+
+ TRACE("Entered squashfs_statfs\n");
+
+ buf->f_type = SQUASHFS_MAGIC;
+ buf->f_bsize = msblk->block_size;
+ buf->f_blocks = ((msblk->bytes_used - 1) >> msblk->block_log) + 1;
+ buf->f_bfree = buf->f_bavail = 0;
+ buf->f_files = msblk->inodes;
+ buf->f_ffree = 0;
+ buf->f_namelen = SQUASHFS_NAME_LEN;
+
+ return 0;
+}
+
+
+static int squashfs_remount(struct super_block *sb, int *flags, char *data)
+{
+ *flags |= MS_RDONLY;
+ return 0;
+}
+
+
+static void squashfs_put_super(struct super_block *sb)
+{
+ if (sb->s_fs_info) {
+ struct squashfs_sb_info *sbi = sb->s_fs_info;
+ squashfs_cache_delete(sbi->block_cache);
+ squashfs_cache_delete(sbi->fragment_cache);
+ squashfs_cache_delete(sbi->read_page);
+ kfree(sbi->id_table);
+ kfree(sbi->fragment_index);
+ kfree(sbi->meta_index);
+ kfree(sbi->stream.workspace);
+ kfree(sb->s_fs_info);
+ sb->s_fs_info = NULL;
+ }
+}
+
+
+static int squashfs_get_sb(struct file_system_type *fs_type, int flags,
+ const char *dev_name, void *data,
+ struct vfsmount *mnt)
+{
+ return get_sb_bdev(fs_type, flags, dev_name, data, squashfs_fill_super,
+ mnt);
+}
+
+
+static struct kmem_cache *squashfs_inode_cachep;
+
+
+static void init_once(void *foo)
+{
+ struct squashfs_inode_info *ei = foo;
+
+ inode_init_once(&ei->vfs_inode);
+}
+
+
+static int __init init_inodecache(void)
+{
+ squashfs_inode_cachep = kmem_cache_create("squashfs_inode_cache",
+ sizeof(struct squashfs_inode_info), 0,
+ SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT, init_once);
+
+ return squashfs_inode_cachep ? 0 : -ENOMEM;
+}
+
+
+static void destroy_inodecache(void)
+{
+ kmem_cache_destroy(squashfs_inode_cachep);
+}
+
+
+static int __init init_squashfs_fs(void)
+{
+ int err = init_inodecache();
+
+ if (err)
+ return err;
+
+ err = register_filesystem(&squashfs_fs_type);
+ if (err) {
+ destroy_inodecache();
+ return err;
+ }
+
+ printk(KERN_INFO "squashfs: version 4.0 (2009/01/03) "
+ "Phillip Lougher\n");
+
+ return 0;
+}
+
+
+static void __exit exit_squashfs_fs(void)
+{
+ unregister_filesystem(&squashfs_fs_type);
+ destroy_inodecache();
+}
+
+
+static struct inode *squashfs_alloc_inode(struct super_block *sb)
+{
+ struct squashfs_inode_info *ei =
+ kmem_cache_alloc(squashfs_inode_cachep, GFP_KERNEL);
+
+ return ei ? &ei->vfs_inode : NULL;
+}
+
+
+static void squashfs_destroy_inode(struct inode *inode)
+{
+ kmem_cache_free(squashfs_inode_cachep, squashfs_i(inode));
+}
+
+
+static struct file_system_type squashfs_fs_type = {
+ .owner = THIS_MODULE,
+ .name = "squashfs",
+ .get_sb = squashfs_get_sb,
+ .kill_sb = kill_block_super,
+ .fs_flags = FS_REQUIRES_DEV
+};
+
+static struct super_operations squashfs_super_ops = {
+ .alloc_inode = squashfs_alloc_inode,
+ .destroy_inode = squashfs_destroy_inode,
+ .statfs = squashfs_statfs,
+ .put_super = squashfs_put_super,
+ .remount_fs = squashfs_remount
+};
+
+module_init(init_squashfs_fs);
+module_exit(exit_squashfs_fs);
+MODULE_DESCRIPTION("squashfs 4.0, a compressed read-only filesystem");
+MODULE_AUTHOR("Phillip Lougher <phillip@lougher.demon.co.uk>");
+MODULE_LICENSE("GPL");
diff --git a/squashfs-tools/kernel/fs/squashfs/symlink.c b/squashfs-tools/kernel/fs/squashfs/symlink.c
new file mode 100644
index 0000000..83d8788
--- /dev/null
+++ b/squashfs-tools/kernel/fs/squashfs/symlink.c
@@ -0,0 +1,118 @@
+/*
+ * Squashfs - a compressed read only filesystem for Linux
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ * Phillip Lougher <phillip@lougher.demon.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * symlink.c
+ */
+
+/*
+ * This file implements code to handle symbolic links.
+ *
+ * The data contents of symbolic links are stored inside the symbolic
+ * link inode within the inode table. This allows the normally small symbolic
+ * link to be compressed as part of the inode table, achieving much greater
+ * compression than if the symbolic link was compressed individually.
+ */
+
+#include <linux/fs.h>
+#include <linux/vfs.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <linux/pagemap.h>
+#include <linux/zlib.h>
+
+#include "squashfs_fs.h"
+#include "squashfs_fs_sb.h"
+#include "squashfs_fs_i.h"
+#include "squashfs.h"
+
+static int squashfs_symlink_readpage(struct file *file, struct page *page)
+{
+ struct inode *inode = page->mapping->host;
+ struct super_block *sb = inode->i_sb;
+ struct squashfs_sb_info *msblk = sb->s_fs_info;
+ int index = page->index << PAGE_CACHE_SHIFT;
+ u64 block = squashfs_i(inode)->start;
+ int offset = squashfs_i(inode)->offset;
+ int length = min_t(int, i_size_read(inode) - index, PAGE_CACHE_SIZE);
+ int bytes, copied;
+ void *pageaddr;
+ struct squashfs_cache_entry *entry;
+
+ TRACE("Entered squashfs_symlink_readpage, page index %ld, start block "
+ "%llx, offset %x\n", page->index, block, offset);
+
+ /*
+ * Skip index bytes into symlink metadata.
+ */
+ if (index) {
+ bytes = squashfs_read_metadata(sb, NULL, &block, &offset,
+ index);
+ if (bytes < 0) {
+ ERROR("Unable to read symlink [%llx:%x]\n",
+ squashfs_i(inode)->start,
+ squashfs_i(inode)->offset);
+ goto error_out;
+ }
+ }
+
+ /*
+ * Read length bytes from symlink metadata. Squashfs_read_metadata
+ * is not used here because it can sleep and we want to use
+ * kmap_atomic to map the page. Instead call the underlying
+ * squashfs_cache_get routine. As length bytes may overlap metadata
+ * blocks, we may need to call squashfs_cache_get multiple times.
+ */
+ for (bytes = 0; bytes < length; offset = 0, bytes += copied) {
+ entry = squashfs_cache_get(sb, msblk->block_cache, block, 0);
+ if (entry->error) {
+ ERROR("Unable to read symlink [%llx:%x]\n",
+ squashfs_i(inode)->start,
+ squashfs_i(inode)->offset);
+ squashfs_cache_put(entry);
+ goto error_out;
+ }
+
+ pageaddr = kmap_atomic(page, KM_USER0);
+ copied = squashfs_copy_data(pageaddr + bytes, entry, offset,
+ length - bytes);
+ if (copied == length - bytes)
+ memset(pageaddr + length, 0, PAGE_CACHE_SIZE - length);
+ else
+ block = entry->next_index;
+ kunmap_atomic(pageaddr, KM_USER0);
+ squashfs_cache_put(entry);
+ }
+
+ flush_dcache_page(page);
+ SetPageUptodate(page);
+ unlock_page(page);
+ return 0;
+
+error_out:
+ SetPageError(page);
+ unlock_page(page);
+ return 0;
+}
+
+
+const struct address_space_operations squashfs_symlink_aops = {
+ .readpage = squashfs_symlink_readpage
+};
diff --git a/squashfs-tools/kernel/include/linux/squashfs_fs.h b/squashfs-tools/kernel/include/linux/squashfs_fs.h
new file mode 100644
index 0000000..eef85b1
--- /dev/null
+++ b/squashfs-tools/kernel/include/linux/squashfs_fs.h
@@ -0,0 +1,380 @@
+#ifndef SQUASHFS_FS
+#define SQUASHFS_FS
+/*
+ * Squashfs
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ * Phillip Lougher <phillip@lougher.demon.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * squashfs_fs.h
+ */
+
+#define SQUASHFS_CACHED_FRAGMENTS CONFIG_SQUASHFS_FRAGMENT_CACHE_SIZE
+#define SQUASHFS_MAJOR 4
+#define SQUASHFS_MINOR 0
+#define SQUASHFS_MAGIC 0x73717368
+#define SQUASHFS_START 0
+
+/* size of metadata (inode and directory) blocks */
+#define SQUASHFS_METADATA_SIZE 8192
+#define SQUASHFS_METADATA_LOG 13
+
+/* default size of data blocks */
+#define SQUASHFS_FILE_SIZE 131072
+#define SQUASHFS_FILE_LOG 17
+
+#define SQUASHFS_FILE_MAX_SIZE 1048576
+
+/* Max number of uids and gids */
+#define SQUASHFS_IDS 65536
+
+/* Max length of filename (not 255) */
+#define SQUASHFS_NAME_LEN 256
+
+#define SQUASHFS_INVALID_FRAG (0xffffffffU)
+#define SQUASHFS_INVALID_BLK (-1LL)
+
+/* Filesystem flags */
+#define SQUASHFS_NOI 0
+#define SQUASHFS_NOD 1
+#define SQUASHFS_NOF 3
+#define SQUASHFS_NO_FRAG 4
+#define SQUASHFS_ALWAYS_FRAG 5
+#define SQUASHFS_DUPLICATE 6
+#define SQUASHFS_EXPORT 7
+
+#define SQUASHFS_BIT(flag, bit) ((flag >> bit) & 1)
+
+#define SQUASHFS_UNCOMPRESSED_INODES(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_NOI)
+
+#define SQUASHFS_UNCOMPRESSED_DATA(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_NOD)
+
+#define SQUASHFS_UNCOMPRESSED_FRAGMENTS(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_NOF)
+
+#define SQUASHFS_NO_FRAGMENTS(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_NO_FRAG)
+
+#define SQUASHFS_ALWAYS_FRAGMENTS(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_ALWAYS_FRAG)
+
+#define SQUASHFS_DUPLICATES(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_DUPLICATE)
+
+#define SQUASHFS_EXPORTABLE(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_EXPORT)
+
+/* Max number of types and file types */
+#define SQUASHFS_DIR_TYPE 1
+#define SQUASHFS_REG_TYPE 2
+#define SQUASHFS_SYMLINK_TYPE 3
+#define SQUASHFS_BLKDEV_TYPE 4
+#define SQUASHFS_CHRDEV_TYPE 5
+#define SQUASHFS_FIFO_TYPE 6
+#define SQUASHFS_SOCKET_TYPE 7
+#define SQUASHFS_LDIR_TYPE 8
+#define SQUASHFS_LREG_TYPE 9
+#define SQUASHFS_LSYMLINK_TYPE 10
+#define SQUASHFS_LBLKDEV_TYPE 11
+#define SQUASHFS_LCHRDEV_TYPE 12
+#define SQUASHFS_LFIFO_TYPE 13
+#define SQUASHFS_LSOCKET_TYPE 14
+
+/* Flag whether block is compressed or uncompressed, bit is set if block is
+ * uncompressed */
+#define SQUASHFS_COMPRESSED_BIT (1 << 15)
+
+#define SQUASHFS_COMPRESSED_SIZE(B) (((B) & ~SQUASHFS_COMPRESSED_BIT) ? \
+ (B) & ~SQUASHFS_COMPRESSED_BIT : SQUASHFS_COMPRESSED_BIT)
+
+#define SQUASHFS_COMPRESSED(B) (!((B) & SQUASHFS_COMPRESSED_BIT))
+
+#define SQUASHFS_COMPRESSED_BIT_BLOCK (1 << 24)
+
+#define SQUASHFS_COMPRESSED_SIZE_BLOCK(B) ((B) & \
+ ~SQUASHFS_COMPRESSED_BIT_BLOCK)
+
+#define SQUASHFS_COMPRESSED_BLOCK(B) (!((B) & SQUASHFS_COMPRESSED_BIT_BLOCK))
+
+/*
+ * Inode number ops. Inodes consist of a compressed block number, and an
+ * uncompressed offset within that block
+ */
+#define SQUASHFS_INODE_BLK(A) ((unsigned int) ((A) >> 16))
+
+#define SQUASHFS_INODE_OFFSET(A) ((unsigned int) ((A) & 0xffff))
+
+#define SQUASHFS_MKINODE(A, B) ((long long)(((long long) (A)\
+ << 16) + (B)))
+
+/* Translate between VFS mode and squashfs mode */
+#define SQUASHFS_MODE(A) ((A) & 0xfff)
+
+/* fragment and fragment table defines */
+#define SQUASHFS_FRAGMENT_BYTES(A) \
+ ((A) * sizeof(struct squashfs_fragment_entry))
+
+#define SQUASHFS_FRAGMENT_INDEX(A) (SQUASHFS_FRAGMENT_BYTES(A) / \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_FRAGMENT_INDEX_OFFSET(A) (SQUASHFS_FRAGMENT_BYTES(A) % \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_FRAGMENT_INDEXES(A) ((SQUASHFS_FRAGMENT_BYTES(A) + \
+ SQUASHFS_METADATA_SIZE - 1) / \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_FRAGMENT_INDEX_BYTES(A) (SQUASHFS_FRAGMENT_INDEXES(A) *\
+ sizeof(long long))
+
+/* inode lookup table defines */
+#define SQUASHFS_LOOKUP_BYTES(A) ((A) * sizeof(long long))
+
+#define SQUASHFS_LOOKUP_BLOCK(A) (SQUASHFS_LOOKUP_BYTES(A) / \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_LOOKUP_BLOCK_OFFSET(A) (SQUASHFS_LOOKUP_BYTES(A) % \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_LOOKUP_BLOCKS(A) ((SQUASHFS_LOOKUP_BYTES(A) + \
+ SQUASHFS_METADATA_SIZE - 1) / \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_LOOKUP_BLOCK_BYTES(A) (SQUASHFS_LOOKUP_BLOCKS(A) *\
+ sizeof(long long))
+
+/* uid/gid lookup table defines */
+#define SQUASHFS_ID_BYTES(A) ((A) * sizeof(unsigned int))
+
+#define SQUASHFS_ID_BLOCK(A) (SQUASHFS_ID_BYTES(A) / \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_ID_BLOCK_OFFSET(A) (SQUASHFS_ID_BYTES(A) % \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_ID_BLOCKS(A) ((SQUASHFS_ID_BYTES(A) + \
+ SQUASHFS_METADATA_SIZE - 1) / \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_ID_BLOCK_BYTES(A) (SQUASHFS_ID_BLOCKS(A) *\
+ sizeof(long long))
+
+/* cached data constants for filesystem */
+#define SQUASHFS_CACHED_BLKS 8
+
+#define SQUASHFS_MAX_FILE_SIZE_LOG 64
+
+#define SQUASHFS_MAX_FILE_SIZE (1LL << \
+ (SQUASHFS_MAX_FILE_SIZE_LOG - 2))
+
+#define SQUASHFS_MARKER_BYTE 0xff
+
+/* meta index cache */
+#define SQUASHFS_META_INDEXES (SQUASHFS_METADATA_SIZE / sizeof(unsigned int))
+#define SQUASHFS_META_ENTRIES 127
+#define SQUASHFS_META_SLOTS 8
+
+struct meta_entry {
+ long long data_block;
+ unsigned int index_block;
+ unsigned short offset;
+ unsigned short pad;
+};
+
+struct meta_index {
+ unsigned int inode_number;
+ unsigned int offset;
+ unsigned short entries;
+ unsigned short skip;
+ unsigned short locked;
+ unsigned short pad;
+ struct meta_entry meta_entry[SQUASHFS_META_ENTRIES];
+};
+
+
+/*
+ * definitions for structures on disk
+ */
+#define ZLIB_COMPRESSION 1
+
+struct squashfs_super_block {
+ __le32 s_magic;
+ __le32 inodes;
+ __le32 mkfs_time;
+ __le32 block_size;
+ __le32 fragments;
+ __le16 compression;
+ __le16 block_log;
+ __le16 flags;
+ __le16 no_ids;
+ __le16 s_major;
+ __le16 s_minor;
+ __le64 root_inode;
+ __le64 bytes_used;
+ __le64 id_table_start;
+ __le64 xattr_table_start;
+ __le64 inode_table_start;
+ __le64 directory_table_start;
+ __le64 fragment_table_start;
+ __le64 lookup_table_start;
+};
+
+struct squashfs_dir_index {
+ __le32 index;
+ __le32 start_block;
+ __le32 size;
+ unsigned char name[0];
+};
+
+struct squashfs_base_inode {
+ __le16 inode_type;
+ __le16 mode;
+ __le16 uid;
+ __le16 guid;
+ __le32 mtime;
+ __le32 inode_number;
+};
+
+struct squashfs_ipc_inode {
+ __le16 inode_type;
+ __le16 mode;
+ __le16 uid;
+ __le16 guid;
+ __le32 mtime;
+ __le32 inode_number;
+ __le32 nlink;
+};
+
+struct squashfs_dev_inode {
+ __le16 inode_type;
+ __le16 mode;
+ __le16 uid;
+ __le16 guid;
+ __le32 mtime;
+ __le32 inode_number;
+ __le32 nlink;
+ __le32 rdev;
+};
+
+struct squashfs_symlink_inode {
+ __le16 inode_type;
+ __le16 mode;
+ __le16 uid;
+ __le16 guid;
+ __le32 mtime;
+ __le32 inode_number;
+ __le32 nlink;
+ __le32 symlink_size;
+ char symlink[0];
+};
+
+struct squashfs_reg_inode {
+ __le16 inode_type;
+ __le16 mode;
+ __le16 uid;
+ __le16 guid;
+ __le32 mtime;
+ __le32 inode_number;
+ __le32 start_block;
+ __le32 fragment;
+ __le32 offset;
+ __le32 file_size;
+ __le16 block_list[0];
+};
+
+struct squashfs_lreg_inode {
+ __le16 inode_type;
+ __le16 mode;
+ __le16 uid;
+ __le16 guid;
+ __le32 mtime;
+ __le32 inode_number;
+ __le64 start_block;
+ __le64 file_size;
+ __le64 sparse;
+ __le32 nlink;
+ __le32 fragment;
+ __le32 offset;
+ __le32 xattr;
+ __le16 block_list[0];
+};
+
+struct squashfs_dir_inode {
+ __le16 inode_type;
+ __le16 mode;
+ __le16 uid;
+ __le16 guid;
+ __le32 mtime;
+ __le32 inode_number;
+ __le32 start_block;
+ __le32 nlink;
+ __le16 file_size;
+ __le16 offset;
+ __le32 parent_inode;
+};
+
+struct squashfs_ldir_inode {
+ __le16 inode_type;
+ __le16 mode;
+ __le16 uid;
+ __le16 guid;
+ __le32 mtime;
+ __le32 inode_number;
+ __le32 nlink;
+ __le32 file_size;
+ __le32 start_block;
+ __le32 parent_inode;
+ __le16 i_count;
+ __le16 offset;
+ __le32 xattr;
+ struct squashfs_dir_index index[0];
+};
+
+union squashfs_inode {
+ struct squashfs_base_inode base;
+ struct squashfs_dev_inode dev;
+ struct squashfs_symlink_inode symlink;
+ struct squashfs_reg_inode reg;
+ struct squashfs_lreg_inode lreg;
+ struct squashfs_dir_inode dir;
+ struct squashfs_ldir_inode ldir;
+ struct squashfs_ipc_inode ipc;
+};
+
+struct squashfs_dir_entry {
+ __le16 offset;
+ __le16 inode_number;
+ __le16 type;
+ __le16 size;
+ char name[0];
+};
+
+struct squashfs_dir_header {
+ __le32 count;
+ __le32 start_block;
+ __le32 inode_number;
+};
+
+struct squashfs_fragment_entry {
+ __le64 start_block;
+ __le32 size;
+ unsigned int unused;
+};
+
+#endif
diff --git a/squashfs-tools/kernel/include/linux/squashfs_fs_i.h b/squashfs-tools/kernel/include/linux/squashfs_fs_i.h
new file mode 100644
index 0000000..f78e6f8
--- /dev/null
+++ b/squashfs-tools/kernel/include/linux/squashfs_fs_i.h
@@ -0,0 +1,45 @@
+#ifndef SQUASHFS_FS_I
+#define SQUASHFS_FS_I
+/*
+ * Squashfs
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ * Phillip Lougher <phillip@lougher.demon.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * squashfs_fs_i.h
+ */
+
+struct squashfs_inode_info {
+ long long start;
+ int offset;
+ union {
+ struct {
+ long long fragment_block;
+ int fragment_size;
+ int fragment_offset;
+ long long block_list_start;
+ };
+ struct {
+ long long dir_idx_start;
+ int dir_idx_offset;
+ int dir_idx_cnt;
+ int parent;
+ };
+ };
+ struct inode vfs_inode;
+};
+#endif
diff --git a/squashfs-tools/kernel/include/linux/squashfs_fs_sb.h b/squashfs-tools/kernel/include/linux/squashfs_fs_sb.h
new file mode 100644
index 0000000..cc9fd5d
--- /dev/null
+++ b/squashfs-tools/kernel/include/linux/squashfs_fs_sb.h
@@ -0,0 +1,76 @@
+#ifndef SQUASHFS_FS_SB
+#define SQUASHFS_FS_SB
+/*
+ * Squashfs
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ * Phillip Lougher <phillip@lougher.demon.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * squashfs_fs_sb.h
+ */
+
+#include "squashfs_fs.h"
+
+struct squashfs_cache_entry {
+ long long block;
+ int length;
+ int locked;
+ long long next_index;
+ char pending;
+ char error;
+ int waiting;
+ wait_queue_head_t wait_queue;
+ char *data;
+};
+
+struct squashfs_cache {
+ char *name;
+ int entries;
+ int block_size;
+ int next_blk;
+ int waiting;
+ int unused;
+ int use_vmalloc;
+ spinlock_t lock;
+ wait_queue_head_t wait_queue;
+ struct squashfs_cache_entry entry[0];
+};
+
+struct squashfs_sb_info {
+ int devblksize;
+ int devblksize_log2;
+ struct squashfs_cache *block_cache;
+ struct squashfs_cache *fragment_cache;
+ int next_meta_index;
+ __le64 *id_table;
+ __le64 *fragment_index;
+ unsigned int *fragment_index_2;
+ char *read_page;
+ struct mutex read_data_mutex;
+ struct mutex read_page_mutex;
+ struct mutex meta_index_mutex;
+ struct meta_index *meta_index;
+ z_stream stream;
+ __le64 *inode_lookup_table;
+ long long inode_table;
+ long long directory_table;
+ unsigned int block_size;
+ unsigned short block_log;
+ long long bytes_used;
+ unsigned int inodes;
+};
+#endif
diff --git a/squashfs-tools/squashfs-tools/Android.mk b/squashfs-tools/squashfs-tools/Android.mk
new file mode 100644
index 0000000..79b411b
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/Android.mk
@@ -0,0 +1,42 @@
+# Copyright (C) 2015 The Android Open Source Project
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+# squashfs-tools depends on Linux Kernel specific headers (e.g. sysinfo.h).
+LOCAL_MODULE_HOST_OS := linux darwin
+
+# The LOCAL_MODULE name is referenced by the code. Don't change it.
+LOCAL_MODULE := mksquashfs
+
+LOCAL_SRC_FILES := \
+ mksquashfs.c \
+ read_fs.c \
+ action.c \
+ swap.c \
+ pseudo.c \
+ compressor.c \
+ sort.c \
+ progressbar.c \
+ read_file.c \
+ info.c \
+ restore.c \
+ process_fragments.c \
+ caches-queues-lists.c \
+ xattr.c \
+ read_xattrs.c \
+ gzip_wrapper.c \
+ android.c \
+ lz4_wrapper.c
+
+LOCAL_CFLAGS := -I -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_GNU_SOURCE -Wall \
+ -DCOMP_DEFAULT="\"lz4\"" -DGZIP_SUPPORT -DLZ4_SUPPORT -DXATTR_SUPPORT -DXATTR_DEFAULT \
+ -Wno-unused-parameter
+
+LOCAL_LDLIBS := -lpthread -lm -lz
+
+LOCAL_SHARED_LIBRARIES := libcutils libselinux
+LOCAL_STATIC_LIBRARIES := liblz4
+
+include $(BUILD_HOST_EXECUTABLE)
diff --git a/squashfs-tools/squashfs-tools/Makefile b/squashfs-tools/squashfs-tools/Makefile
new file mode 100644
index 0000000..52d2582
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/Makefile
@@ -0,0 +1,305 @@
+###############################################
+# Compression build options #
+###############################################
+#
+#
+############# Building gzip support ###########
+#
+# Gzip support is by default enabled, and the compression type default
+# (COMP_DEFAULT) is gzip.
+#
+# If you don't want/need gzip support then comment out the GZIP SUPPORT line
+# below, and change COMP_DEFAULT to one of the compression types you have
+# selected.
+#
+# Obviously, you must select at least one of the available gzip, lzma, lzo
+# compression types.
+#
+GZIP_SUPPORT = 1
+
+########### Building XZ support #############
+#
+# LZMA2 compression.
+#
+# XZ Utils liblzma (http://tukaani.org/xz/) is supported
+#
+# To build using XZ Utils liblzma - install the library and uncomment
+# the XZ_SUPPORT line below.
+#
+#XZ_SUPPORT = 1
+
+
+############ Building LZO support ##############
+#
+# The LZO library (http://www.oberhumer.com/opensource/lzo/) is supported.
+#
+# To build using the LZO library - install the library and uncomment the
+# LZO_SUPPORT line below. If needed, uncomment and set LZO_DIR to the
+# installation prefix.
+#
+#LZO_SUPPORT = 1
+#LZO_DIR = /usr/local
+
+
+########### Building LZ4 support #############
+#
+# Yann Collet's LZ4 tools are supported
+# LZ4 homepage: http://fastcompression.blogspot.com/p/lz4.html
+# LZ4 source repository: http://code.google.com/p/lz4
+#
+# To build configure the tools using cmake to build shared libraries,
+# install and uncomment
+# the LZ4_SUPPORT line below.
+#
+#LZ4_SUPPORT = 1
+
+
+########### Building LZMA support #############
+#
+# LZMA1 compression.
+#
+# LZMA1 compression is deprecated, and the newer and better XZ (LZMA2)
+# compression should be used in preference.
+#
+# Both XZ Utils liblzma (http://tukaani.org/xz/) and LZMA SDK
+# (http://www.7-zip.org/sdk.html) are supported
+#
+# To build using XZ Utils liblzma - install the library and uncomment
+# the LZMA_XZ_SUPPORT line below.
+#
+# To build using the LZMA SDK (4.65 used in development, other versions may
+# work) - download and unpack it, uncomment and set LZMA_DIR to unpacked source,
+# and uncomment the LZMA_SUPPORT line below.
+#
+#LZMA_XZ_SUPPORT = 1
+#LZMA_SUPPORT = 1
+#LZMA_DIR = ../../../../LZMA/lzma465
+
+######## Specifying default compression ########
+#
+# The next line specifies which compression algorithm is used by default
+# in Mksquashfs. Obviously the compression algorithm must have been
+# selected to be built
+#
+COMP_DEFAULT = gzip
+
+###############################################
+# Extended attribute (XATTRs) build options #
+###############################################
+#
+# Building XATTR support for Mksquashfs and Unsquashfs
+#
+# If your C library or build/target environment doesn't support XATTRs then
+# comment out the next line to build Mksquashfs and Unsquashfs without XATTR
+# support
+XATTR_SUPPORT = 1
+
+# Select whether you wish xattrs to be stored by Mksquashfs and extracted
+# by Unsquashfs by default. If selected users can disable xattr support by
+# using the -no-xattrs option
+#
+# If unselected, Mksquashfs/Unsquashfs won't store and extract xattrs by
+# default. Users can enable xattrs by using the -xattrs option.
+XATTR_DEFAULT = 1
+
+
+###############################################
+# End of BUILD options section #
+###############################################
+
+INCLUDEDIR = -I.
+INSTALL_DIR = /usr/local/bin
+
+MKSQUASHFS_OBJS = mksquashfs.o read_fs.o action.o swap.o pseudo.o compressor.o \
+ sort.o progressbar.o read_file.o info.o restore.o process_fragments.o \
+ caches-queues-lists.o
+
+UNSQUASHFS_OBJS = unsquashfs.o unsquash-1.o unsquash-2.o unsquash-3.o \
+ unsquash-4.o swap.o compressor.o unsquashfs_info.o
+
+CFLAGS ?= -O2
+CFLAGS += $(EXTRA_CFLAGS) $(INCLUDEDIR) -D_FILE_OFFSET_BITS=64 \
+ -D_LARGEFILE_SOURCE -D_GNU_SOURCE -DCOMP_DEFAULT=\"$(COMP_DEFAULT)\" \
+ -Wall
+
+LIBS = -lpthread -lm
+ifeq ($(GZIP_SUPPORT),1)
+CFLAGS += -DGZIP_SUPPORT
+MKSQUASHFS_OBJS += gzip_wrapper.o
+UNSQUASHFS_OBJS += gzip_wrapper.o
+LIBS += -lz
+COMPRESSORS += gzip
+endif
+
+ifeq ($(LZMA_SUPPORT),1)
+LZMA_OBJS = $(LZMA_DIR)/C/Alloc.o $(LZMA_DIR)/C/LzFind.o \
+ $(LZMA_DIR)/C/LzmaDec.o $(LZMA_DIR)/C/LzmaEnc.o $(LZMA_DIR)/C/LzmaLib.o
+INCLUDEDIR += -I$(LZMA_DIR)/C
+CFLAGS += -DLZMA_SUPPORT
+MKSQUASHFS_OBJS += lzma_wrapper.o $(LZMA_OBJS)
+UNSQUASHFS_OBJS += lzma_wrapper.o $(LZMA_OBJS)
+COMPRESSORS += lzma
+endif
+
+ifeq ($(LZMA_XZ_SUPPORT),1)
+CFLAGS += -DLZMA_SUPPORT
+MKSQUASHFS_OBJS += lzma_xz_wrapper.o
+UNSQUASHFS_OBJS += lzma_xz_wrapper.o
+LIBS += -llzma
+COMPRESSORS += lzma
+endif
+
+ifeq ($(XZ_SUPPORT),1)
+CFLAGS += -DXZ_SUPPORT
+MKSQUASHFS_OBJS += xz_wrapper.o
+UNSQUASHFS_OBJS += xz_wrapper.o
+LIBS += -llzma
+COMPRESSORS += xz
+endif
+
+ifeq ($(LZO_SUPPORT),1)
+CFLAGS += -DLZO_SUPPORT
+ifdef LZO_DIR
+INCLUDEDIR += -I$(LZO_DIR)/include
+LZO_LIBDIR = -L$(LZO_DIR)/lib
+endif
+MKSQUASHFS_OBJS += lzo_wrapper.o
+UNSQUASHFS_OBJS += lzo_wrapper.o
+LIBS += $(LZO_LIBDIR) -llzo2
+COMPRESSORS += lzo
+endif
+
+ifeq ($(LZ4_SUPPORT),1)
+CFLAGS += -DLZ4_SUPPORT
+MKSQUASHFS_OBJS += lz4_wrapper.o
+UNSQUASHFS_OBJS += lz4_wrapper.o
+LIBS += -llz4
+COMPRESSORS += lz4
+endif
+
+ifeq ($(XATTR_SUPPORT),1)
+ifeq ($(XATTR_DEFAULT),1)
+CFLAGS += -DXATTR_SUPPORT -DXATTR_DEFAULT
+else
+CFLAGS += -DXATTR_SUPPORT
+endif
+MKSQUASHFS_OBJS += xattr.o read_xattrs.o
+UNSQUASHFS_OBJS += read_xattrs.o unsquashfs_xattr.o
+endif
+
+#
+# If LZMA_SUPPORT is specified then LZMA_DIR must be specified too
+#
+ifeq ($(LZMA_SUPPORT),1)
+ifndef LZMA_DIR
+$(error "LZMA_SUPPORT requires LZMA_DIR to be also defined")
+endif
+endif
+
+#
+# Both LZMA_XZ_SUPPORT and LZMA_SUPPORT cannot be specified
+#
+ifeq ($(LZMA_XZ_SUPPORT),1)
+ifeq ($(LZMA_SUPPORT),1)
+$(error "Both LZMA_XZ_SUPPORT and LZMA_SUPPORT cannot be specified")
+endif
+endif
+
+#
+# At least one compressor must have been selected
+#
+ifndef COMPRESSORS
+$(error "No compressor selected! Select one or more of GZIP, LZMA, XZ, LZO or \
+ LZ4!")
+endif
+
+#
+# COMP_DEFAULT must be a selected compressor
+#
+ifeq (, $(findstring $(COMP_DEFAULT), $(COMPRESSORS)))
+$(error "COMP_DEFAULT is set to ${COMP_DEFAULT}, which isn't selected to be \
+ built!")
+endif
+
+.PHONY: all
+all: mksquashfs unsquashfs
+
+mksquashfs: $(MKSQUASHFS_OBJS)
+ $(CC) $(LDFLAGS) $(EXTRA_LDFLAGS) $(MKSQUASHFS_OBJS) $(LIBS) -o $@
+
+mksquashfs.o: Makefile mksquashfs.c squashfs_fs.h squashfs_swap.h mksquashfs.h \
+ sort.h pseudo.h compressor.h xattr.h action.h error.h progressbar.h \
+ info.h caches-queues-lists.h read_fs.h restore.h process_fragments.h
+
+read_fs.o: read_fs.c squashfs_fs.h squashfs_swap.h compressor.h xattr.h \
+ error.h mksquashfs.h
+
+sort.o: sort.c squashfs_fs.h mksquashfs.h sort.h error.h progressbar.h
+
+swap.o: swap.c
+
+pseudo.o: pseudo.c pseudo.h error.h progressbar.h
+
+compressor.o: Makefile compressor.c compressor.h squashfs_fs.h
+
+xattr.o: xattr.c squashfs_fs.h squashfs_swap.h mksquashfs.h xattr.h error.h \
+ progressbar.h
+
+read_xattrs.o: read_xattrs.c squashfs_fs.h squashfs_swap.h xattr.h error.h
+
+action.o: action.c squashfs_fs.h mksquashfs.h action.h error.h
+
+progressbar.o: progressbar.c error.h
+
+read_file.o: read_file.c error.h
+
+info.o: info.c squashfs_fs.h mksquashfs.h error.h progressbar.h \
+ caches-queues-lists.h
+
+restore.o: restore.c caches-queues-lists.h squashfs_fs.h mksquashfs.h error.h \
+ progressbar.h info.h
+
+process_fragments.o: process_fragments.c process_fragments.h
+
+caches-queues-lists.o: caches-queues-lists.c error.h caches-queues-lists.h
+
+gzip_wrapper.o: gzip_wrapper.c squashfs_fs.h gzip_wrapper.h compressor.h
+
+lzma_wrapper.o: lzma_wrapper.c compressor.h squashfs_fs.h
+
+lzma_xz_wrapper.o: lzma_xz_wrapper.c compressor.h squashfs_fs.h
+
+lzo_wrapper.o: lzo_wrapper.c squashfs_fs.h lzo_wrapper.h compressor.h
+
+lz4_wrapper.o: lz4_wrapper.c squashfs_fs.h lz4_wrapper.h compressor.h
+
+xz_wrapper.o: xz_wrapper.c squashfs_fs.h xz_wrapper.h compressor.h
+
+unsquashfs: $(UNSQUASHFS_OBJS)
+ $(CC) $(LDFLAGS) $(EXTRA_LDFLAGS) $(UNSQUASHFS_OBJS) $(LIBS) -o $@
+
+unsquashfs.o: unsquashfs.h unsquashfs.c squashfs_fs.h squashfs_swap.h \
+ squashfs_compat.h xattr.h read_fs.h compressor.h
+
+unsquash-1.o: unsquashfs.h unsquash-1.c squashfs_fs.h squashfs_compat.h
+
+unsquash-2.o: unsquashfs.h unsquash-2.c squashfs_fs.h squashfs_compat.h
+
+unsquash-3.o: unsquashfs.h unsquash-3.c squashfs_fs.h squashfs_compat.h
+
+unsquash-4.o: unsquashfs.h unsquash-4.c squashfs_fs.h squashfs_swap.h \
+ read_fs.h
+
+unsquashfs_xattr.o: unsquashfs_xattr.c unsquashfs.h squashfs_fs.h xattr.h
+
+unsquashfs_info.o: unsquashfs.h squashfs_fs.h
+
+.PHONY: clean
+clean:
+ -rm -f *.o mksquashfs unsquashfs
+
+.PHONY: install
+install: mksquashfs unsquashfs
+ mkdir -p $(INSTALL_DIR)
+ cp mksquashfs $(INSTALL_DIR)
+ cp unsquashfs $(INSTALL_DIR)
diff --git a/squashfs-tools/squashfs-tools/action.c b/squashfs-tools/squashfs-tools/action.c
new file mode 100644
index 0000000..7e43f17
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/action.c
@@ -0,0 +1,3273 @@
+/*
+ * Create a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2011, 2012, 2013, 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * action.c
+ */
+
+#include <fcntl.h>
+#include <dirent.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <fnmatch.h>
+#include <pwd.h>
+#include <grp.h>
+#include <sys/wait.h>
+#include <regex.h>
+#include <limits.h>
+#include <errno.h>
+
+#ifndef FNM_EXTMATCH /* glibc extension */
+ #define FNM_EXTMATCH 0
+#endif
+
+#include "squashfs_fs.h"
+#include "mksquashfs.h"
+#include "action.h"
+#include "error.h"
+
+/*
+ * code to parse actions
+ */
+
+static char *cur_ptr, *source;
+static struct action *fragment_spec = NULL;
+static struct action *exclude_spec = NULL;
+static struct action *empty_spec = NULL;
+static struct action *move_spec = NULL;
+static struct action *prune_spec = NULL;
+static struct action *other_spec = NULL;
+static int fragment_count = 0;
+static int exclude_count = 0;
+static int empty_count = 0;
+static int move_count = 0;
+static int prune_count = 0;
+static int other_count = 0;
+static struct action_entry *parsing_action;
+
+static struct file_buffer *def_fragment = NULL;
+
+static struct token_entry token_table[] = {
+ { "(", TOK_OPEN_BRACKET, 1, },
+ { ")", TOK_CLOSE_BRACKET, 1 },
+ { "&&", TOK_AND, 2 },
+ { "||", TOK_OR, 2 },
+ { "!", TOK_NOT, 1 },
+ { ",", TOK_COMMA, 1 },
+ { "@", TOK_AT, 1},
+ { " ", TOK_WHITE_SPACE, 1 },
+ { "\t ", TOK_WHITE_SPACE, 1 },
+ { "", -1, 0 }
+};
+
+
+static struct test_entry test_table[];
+
+static struct action_entry action_table[];
+
+static struct expr *parse_expr(int subexp);
+
+extern char *pathname(struct dir_ent *);
+
+extern char *subpathname(struct dir_ent *);
+
+extern int read_file(char *filename, char *type, int (parse_line)(char *));
+
+/*
+ * Lexical analyser
+ */
+#define STR_SIZE 256
+
+static int get_token(char **string)
+{
+ /* string buffer */
+ static char *str = NULL;
+ static int size = 0;
+
+ char *str_ptr;
+ int cur_size, i, quoted;
+
+ while (1) {
+ if (*cur_ptr == '\0')
+ return TOK_EOF;
+ for (i = 0; token_table[i].token != -1; i++)
+ if (strncmp(cur_ptr, token_table[i].string,
+ token_table[i].size) == 0)
+ break;
+ if (token_table[i].token != TOK_WHITE_SPACE)
+ break;
+ cur_ptr ++;
+ }
+
+ if (token_table[i].token != -1) {
+ cur_ptr += token_table[i].size;
+ return token_table[i].token;
+ }
+
+ /* string */
+ if(str == NULL) {
+ str = malloc(STR_SIZE);
+ if(str == NULL)
+ MEM_ERROR();
+ size = STR_SIZE;
+ }
+
+ /* Initialise string being read */
+ str_ptr = str;
+ cur_size = 0;
+ quoted = 0;
+
+ while(1) {
+ while(*cur_ptr == '"') {
+ cur_ptr ++;
+ quoted = !quoted;
+ }
+
+ if(*cur_ptr == '\0') {
+ /* inside quoted string EOF, otherwise end of string */
+ if(quoted)
+ return TOK_EOF;
+ else
+ break;
+ }
+
+ if(!quoted) {
+ for(i = 0; token_table[i].token != -1; i++)
+ if (strncmp(cur_ptr, token_table[i].string,
+ token_table[i].size) == 0)
+ break;
+ if (token_table[i].token != -1)
+ break;
+ }
+
+ if(*cur_ptr == '\\') {
+ cur_ptr ++;
+ if(*cur_ptr == '\0')
+ return TOK_EOF;
+ }
+
+ if(cur_size + 2 > size) {
+ char *tmp;
+
+ size = (cur_size + 1 + STR_SIZE) & ~(STR_SIZE - 1);
+
+ tmp = realloc(str, size);
+ if(tmp == NULL)
+ MEM_ERROR();
+
+ str_ptr = str_ptr - str + tmp;
+ str = tmp;
+ }
+
+ *str_ptr ++ = *cur_ptr ++;
+ cur_size ++;
+ }
+
+ *str_ptr = '\0';
+ *string = str;
+ return TOK_STRING;
+}
+
+
+static int peek_token(char **string)
+{
+ char *saved = cur_ptr;
+ int token = get_token(string);
+
+ cur_ptr = saved;
+
+ return token;
+}
+
+
+/*
+ * Expression parser
+ */
+static void free_parse_tree(struct expr *expr)
+{
+ if(expr->type == ATOM_TYPE) {
+ int i;
+
+ for(i = 0; i < expr->atom.test->args; i++)
+ free(expr->atom.argv[i]);
+
+ free(expr->atom.argv);
+ } else if (expr->type == UNARY_TYPE)
+ free_parse_tree(expr->unary_op.expr);
+ else {
+ free_parse_tree(expr->expr_op.lhs);
+ free_parse_tree(expr->expr_op.rhs);
+ }
+
+ free(expr);
+}
+
+
+static struct expr *create_expr(struct expr *lhs, int op, struct expr *rhs)
+{
+ struct expr *expr;
+
+ if (rhs == NULL) {
+ free_parse_tree(lhs);
+ return NULL;
+ }
+
+ expr = malloc(sizeof(*expr));
+ if (expr == NULL)
+ MEM_ERROR();
+
+ expr->type = OP_TYPE;
+ expr->expr_op.lhs = lhs;
+ expr->expr_op.rhs = rhs;
+ expr->expr_op.op = op;
+
+ return expr;
+}
+
+
+static struct expr *create_unary_op(struct expr *lhs, int op)
+{
+ struct expr *expr;
+
+ if (lhs == NULL)
+ return NULL;
+
+ expr = malloc(sizeof(*expr));
+ if (expr == NULL)
+ MEM_ERROR();
+
+ expr->type = UNARY_TYPE;
+ expr->unary_op.expr = lhs;
+ expr->unary_op.op = op;
+
+ return expr;
+}
+
+
+static struct expr *parse_test(char *name)
+{
+ char *string, **argv = NULL;
+ int token, args = 0;
+ int i;
+ struct test_entry *test;
+ struct expr *expr;
+
+ for (i = 0; test_table[i].args != -1; i++)
+ if (strcmp(name, test_table[i].name) == 0)
+ break;
+
+ test = &test_table[i];
+
+ if (test->args == -1) {
+ SYNTAX_ERROR("Non-existent test \"%s\"\n", name);
+ return NULL;
+ }
+
+ if(parsing_action->type == EXCLUDE_ACTION && !test->exclude_ok) {
+ fprintf(stderr, "Failed to parse action \"%s\"\n", source);
+ fprintf(stderr, "Test \"%s\" cannot be used in exclude "
+ "actions\n", name);
+ fprintf(stderr, "Use prune action instead ...\n");
+ return NULL;
+ }
+
+ expr = malloc(sizeof(*expr));
+ if (expr == NULL)
+ MEM_ERROR();
+
+ expr->type = ATOM_TYPE;
+
+ expr->atom.test = test;
+ expr->atom.data = NULL;
+
+ /*
+ * If the test has no arguments, then go straight to checking if there's
+ * enough arguments
+ */
+ token = peek_token(&string);
+
+ if (token != TOK_OPEN_BRACKET)
+ goto skip_args;
+
+ get_token(&string);
+
+ /*
+ * speculatively read all the arguments, and then see if the
+ * number of arguments read is the number expected, this handles
+ * tests with a variable number of arguments
+ */
+ token = get_token(&string);
+ if (token == TOK_CLOSE_BRACKET)
+ goto skip_args;
+
+ while(1) {
+ if (token != TOK_STRING) {
+ SYNTAX_ERROR("Unexpected token \"%s\", expected "
+ "argument\n", TOK_TO_STR(token, string));
+ goto failed;
+ }
+
+ argv = realloc(argv, (args + 1) * sizeof(char *));
+ if (argv == NULL)
+ MEM_ERROR();
+
+ argv[args ++ ] = strdup(string);
+
+ token = get_token(&string);
+
+ if (token == TOK_CLOSE_BRACKET)
+ break;
+
+ if (token != TOK_COMMA) {
+ SYNTAX_ERROR("Unexpected token \"%s\", expected "
+ "\",\" or \")\"\n", TOK_TO_STR(token, string));
+ goto failed;
+ }
+ token = get_token(&string);
+ }
+
+skip_args:
+ /*
+ * expected number of arguments?
+ */
+ if(test->args != -2 && args != test->args) {
+ SYNTAX_ERROR("Unexpected number of arguments, expected %d, "
+ "got %d\n", test->args, args);
+ goto failed;
+ }
+
+ expr->atom.args = args;
+ expr->atom.argv = argv;
+
+ if (test->parse_args) {
+ int res = test->parse_args(test, &expr->atom);
+
+ if (res == 0)
+ goto failed;
+ }
+
+ return expr;
+
+failed:
+ free(argv);
+ free(expr);
+ return NULL;
+}
+
+
+static struct expr *get_atom()
+{
+ char *string;
+ int token = get_token(&string);
+
+ switch(token) {
+ case TOK_NOT:
+ return create_unary_op(get_atom(), token);
+ case TOK_OPEN_BRACKET:
+ return parse_expr(1);
+ case TOK_STRING:
+ return parse_test(string);
+ default:
+ SYNTAX_ERROR("Unexpected token \"%s\", expected test "
+ "operation, \"!\", or \"(\"\n",
+ TOK_TO_STR(token, string));
+ return NULL;
+ }
+}
+
+
+static struct expr *parse_expr(int subexp)
+{
+ struct expr *expr = get_atom();
+
+ while (expr) {
+ char *string;
+ int op = get_token(&string);
+
+ if (op == TOK_EOF) {
+ if (subexp) {
+ free_parse_tree(expr);
+ SYNTAX_ERROR("Expected \"&&\", \"||\" or "
+ "\")\", got EOF\n");
+ return NULL;
+ }
+ break;
+ }
+
+ if (op == TOK_CLOSE_BRACKET) {
+ if (!subexp) {
+ free_parse_tree(expr);
+ SYNTAX_ERROR("Unexpected \")\", expected "
+ "\"&&\", \"!!\" or EOF\n");
+ return NULL;
+ }
+ break;
+ }
+
+ if (op != TOK_AND && op != TOK_OR) {
+ free_parse_tree(expr);
+ SYNTAX_ERROR("Unexpected token \"%s\", expected "
+ "\"&&\" or \"||\"\n", TOK_TO_STR(op, string));
+ return NULL;
+ }
+
+ expr = create_expr(expr, op, get_atom());
+ }
+
+ return expr;
+}
+
+
+/*
+ * Action parser
+ */
+int parse_action(char *s, int verbose)
+{
+ char *string, **argv = NULL;
+ int i, token, args = 0;
+ struct expr *expr;
+ struct action_entry *action;
+ void *data = NULL;
+ struct action **spec_list;
+ int spec_count;
+
+ cur_ptr = source = s;
+ token = get_token(&string);
+
+ if (token != TOK_STRING) {
+ SYNTAX_ERROR("Unexpected token \"%s\", expected name\n",
+ TOK_TO_STR(token, string));
+ return 0;
+ }
+
+ for (i = 0; action_table[i].args != -1; i++)
+ if (strcmp(string, action_table[i].name) == 0)
+ break;
+
+ if (action_table[i].args == -1) {
+ SYNTAX_ERROR("Non-existent action \"%s\"\n", string);
+ return 0;
+ }
+
+ action = &action_table[i];
+
+ token = get_token(&string);
+
+ if (token == TOK_AT)
+ goto skip_args;
+
+ if (token != TOK_OPEN_BRACKET) {
+ SYNTAX_ERROR("Unexpected token \"%s\", expected \"(\"\n",
+ TOK_TO_STR(token, string));
+ goto failed;
+ }
+
+ /*
+ * speculatively read all the arguments, and then see if the
+ * number of arguments read is the number expected, this handles
+ * actions with a variable number of arguments
+ */
+ token = get_token(&string);
+ if (token == TOK_CLOSE_BRACKET)
+ goto skip_args;
+
+ while (1) {
+ if (token != TOK_STRING) {
+ SYNTAX_ERROR("Unexpected token \"%s\", expected "
+ "argument\n", TOK_TO_STR(token, string));
+ goto failed;
+ }
+
+ argv = realloc(argv, (args + 1) * sizeof(char *));
+ if (argv == NULL)
+ MEM_ERROR();
+
+ argv[args ++] = strdup(string);
+
+ token = get_token(&string);
+
+ if (token == TOK_CLOSE_BRACKET)
+ break;
+
+ if (token != TOK_COMMA) {
+ SYNTAX_ERROR("Unexpected token \"%s\", expected "
+ "\",\" or \")\"\n", TOK_TO_STR(token, string));
+ goto failed;
+ }
+ token = get_token(&string);
+ }
+
+skip_args:
+ /*
+ * expected number of arguments?
+ */
+ if(action->args != -2 && args != action->args) {
+ SYNTAX_ERROR("Unexpected number of arguments, expected %d, "
+ "got %d\n", action->args, args);
+ goto failed;
+ }
+
+ if (action->parse_args) {
+ int res = action->parse_args(action, args, argv, &data);
+
+ if (res == 0)
+ goto failed;
+ }
+
+ if (token == TOK_CLOSE_BRACKET)
+ token = get_token(&string);
+
+ if (token != TOK_AT) {
+ SYNTAX_ERROR("Unexpected token \"%s\", expected \"@\"\n",
+ TOK_TO_STR(token, string));
+ goto failed;
+ }
+
+ parsing_action = action;
+ expr = parse_expr(0);
+
+ if (expr == NULL)
+ goto failed;
+
+ /*
+ * choose action list and increment action counter
+ */
+ switch(action->type) {
+ case FRAGMENT_ACTION:
+ spec_count = fragment_count ++;
+ spec_list = &fragment_spec;
+ break;
+ case EXCLUDE_ACTION:
+ spec_count = exclude_count ++;
+ spec_list = &exclude_spec;
+ break;
+ case EMPTY_ACTION:
+ spec_count = empty_count ++;
+ spec_list = &empty_spec;
+ break;
+ case MOVE_ACTION:
+ spec_count = move_count ++;
+ spec_list = &move_spec;
+ break;
+ case PRUNE_ACTION:
+ spec_count = prune_count ++;
+ spec_list = &prune_spec;
+ break;
+ default:
+ spec_count = other_count ++;
+ spec_list = &other_spec;
+ }
+
+ *spec_list = realloc(*spec_list, (spec_count + 1) *
+ sizeof(struct action));
+ if (*spec_list == NULL)
+ MEM_ERROR();
+
+ (*spec_list)[spec_count].type = action->type;
+ (*spec_list)[spec_count].action = action;
+ (*spec_list)[spec_count].args = args;
+ (*spec_list)[spec_count].argv = argv;
+ (*spec_list)[spec_count].expr = expr;
+ (*spec_list)[spec_count].data = data;
+ (*spec_list)[spec_count].verbose = verbose;
+
+ return 1;
+
+failed:
+ free(argv);
+ return 0;
+}
+
+
+/*
+ * Evaluate expressions
+ */
+
+#define ALLOC_SZ 128
+
+#define LOG_ENABLE 0
+#define LOG_DISABLE 1
+#define LOG_PRINT 2
+#define LOG_ENABLED 3
+
+char *_expr_log(char *string, int cmnd)
+{
+ static char *expr_msg = NULL;
+ static int cur_size = 0, alloc_size = 0;
+ int size;
+
+ switch(cmnd) {
+ case LOG_ENABLE:
+ expr_msg = malloc(ALLOC_SZ);
+ alloc_size = ALLOC_SZ;
+ cur_size = 0;
+ return expr_msg;
+ case LOG_DISABLE:
+ free(expr_msg);
+ alloc_size = cur_size = 0;
+ return expr_msg = NULL;
+ case LOG_ENABLED:
+ return expr_msg;
+ default:
+ if(expr_msg == NULL)
+ return NULL;
+ break;
+ }
+
+ /* if string is empty append '\0' */
+ size = strlen(string) ? : 1;
+
+ if(alloc_size - cur_size < size) {
+ /* buffer too small, expand */
+ alloc_size = (cur_size + size + ALLOC_SZ - 1) & ~(ALLOC_SZ - 1);
+
+ expr_msg = realloc(expr_msg, alloc_size);
+ if(expr_msg == NULL)
+ MEM_ERROR();
+ }
+
+ memcpy(expr_msg + cur_size, string, size);
+ cur_size += size;
+
+ return expr_msg;
+}
+
+
+char *expr_log_cmnd(int cmnd)
+{
+ return _expr_log(NULL, cmnd);
+}
+
+
+char *expr_log(char *string)
+{
+ return _expr_log(string, LOG_PRINT);
+}
+
+
+void expr_log_atom(struct atom *atom)
+{
+ int i;
+
+ if(atom->test->handle_logging)
+ return;
+
+ expr_log(atom->test->name);
+
+ if(atom->args) {
+ expr_log("(");
+ for(i = 0; i < atom->args; i++) {
+ expr_log(atom->argv[i]);
+ if (i + 1 < atom->args)
+ expr_log(",");
+ }
+ expr_log(")");
+ }
+}
+
+
+void expr_log_match(int match)
+{
+ if(match)
+ expr_log("=True");
+ else
+ expr_log("=False");
+}
+
+
+static int eval_expr_log(struct expr *expr, struct action_data *action_data)
+{
+ int match;
+
+ switch (expr->type) {
+ case ATOM_TYPE:
+ expr_log_atom(&expr->atom);
+ match = expr->atom.test->fn(&expr->atom, action_data);
+ expr_log_match(match);
+ break;
+ case UNARY_TYPE:
+ expr_log("!");
+ match = !eval_expr_log(expr->unary_op.expr, action_data);
+ break;
+ default:
+ expr_log("(");
+ match = eval_expr_log(expr->expr_op.lhs, action_data);
+
+ if ((expr->expr_op.op == TOK_AND && match) ||
+ (expr->expr_op.op == TOK_OR && !match)) {
+ expr_log(token_table[expr->expr_op.op].string);
+ match = eval_expr_log(expr->expr_op.rhs, action_data);
+ }
+ expr_log(")");
+ break;
+ }
+
+ return match;
+}
+
+
+static int eval_expr(struct expr *expr, struct action_data *action_data)
+{
+ int match;
+
+ switch (expr->type) {
+ case ATOM_TYPE:
+ match = expr->atom.test->fn(&expr->atom, action_data);
+ break;
+ case UNARY_TYPE:
+ match = !eval_expr(expr->unary_op.expr, action_data);
+ break;
+ default:
+ match = eval_expr(expr->expr_op.lhs, action_data);
+
+ if ((expr->expr_op.op == TOK_AND && match) ||
+ (expr->expr_op.op == TOK_OR && !match))
+ match = eval_expr(expr->expr_op.rhs, action_data);
+ break;
+ }
+
+ return match;
+}
+
+
+static int eval_expr_top(struct action *action, struct action_data *action_data)
+{
+ if(action->verbose) {
+ int match, n;
+
+ expr_log_cmnd(LOG_ENABLE);
+
+ if(action_data->subpath)
+ expr_log(action_data->subpath);
+
+ expr_log("=");
+ expr_log(action->action->name);
+
+ if(action->args) {
+ expr_log("(");
+ for (n = 0; n < action->args; n++) {
+ expr_log(action->argv[n]);
+ if(n + 1 < action->args)
+ expr_log(",");
+ }
+ expr_log(")");
+ }
+
+ expr_log("@");
+
+ match = eval_expr_log(action->expr, action_data);
+
+ /*
+ * Print the evaluated expression log, if the
+ * result matches the logging specified
+ */
+ if((match && (action->verbose & ACTION_LOG_TRUE)) || (!match
+ && (action->verbose & ACTION_LOG_FALSE)))
+ progressbar_info("%s\n", expr_log(""));
+
+ expr_log_cmnd(LOG_DISABLE);
+
+ return match;
+ } else
+ return eval_expr(action->expr, action_data);
+}
+
+
+/*
+ * Read action file, passing each line to parse_action() for
+ * parsing.
+ *
+ * One action per line, of the form
+ * action(arg1,arg2)@expr(arg1,arg2)....
+ *
+ * Actions can be split across multiple lines using "\".
+ *
+ * Blank lines and comment lines indicated by # are supported.
+ */
+int parse_action_true(char *s)
+{
+ return parse_action(s, ACTION_LOG_TRUE);
+}
+
+
+int parse_action_false(char *s)
+{
+ return parse_action(s, ACTION_LOG_FALSE);
+}
+
+
+int parse_action_verbose(char *s)
+{
+ return parse_action(s, ACTION_LOG_VERBOSE);
+}
+
+
+int parse_action_nonverbose(char *s)
+{
+ return parse_action(s, ACTION_LOG_NONE);
+}
+
+
+int read_action_file(char *filename, int verbose)
+{
+ switch(verbose) {
+ case ACTION_LOG_TRUE:
+ return read_file(filename, "action", parse_action_true);
+ case ACTION_LOG_FALSE:
+ return read_file(filename, "action", parse_action_false);
+ case ACTION_LOG_VERBOSE:
+ return read_file(filename, "action", parse_action_verbose);
+ default:
+ return read_file(filename, "action", parse_action_nonverbose);
+ }
+}
+
+
+/*
+ * helper to evaluate whether action/test acts on this file type
+ */
+static int file_type_match(int st_mode, int type)
+{
+ switch(type) {
+ case ACTION_DIR:
+ return S_ISDIR(st_mode);
+ case ACTION_REG:
+ return S_ISREG(st_mode);
+ case ACTION_ALL:
+ return S_ISREG(st_mode) || S_ISDIR(st_mode) ||
+ S_ISCHR(st_mode) || S_ISBLK(st_mode) ||
+ S_ISFIFO(st_mode) || S_ISSOCK(st_mode);
+ case ACTION_LNK:
+ return S_ISLNK(st_mode);
+ case ACTION_ALL_LNK:
+ default:
+ return 1;
+ }
+}
+
+
+/*
+ * General action evaluation code
+ */
+int actions()
+{
+ return other_count;
+}
+
+
+void eval_actions(struct dir_info *root, struct dir_ent *dir_ent)
+{
+ int i, match;
+ struct action_data action_data;
+ int st_mode = dir_ent->inode->buf.st_mode;
+
+ action_data.name = dir_ent->name;
+ action_data.pathname = strdup(pathname(dir_ent));
+ action_data.subpath = strdup(subpathname(dir_ent));
+ action_data.buf = &dir_ent->inode->buf;
+ action_data.depth = dir_ent->our_dir->depth;
+ action_data.dir_ent = dir_ent;
+ action_data.root = root;
+
+ for (i = 0; i < other_count; i++) {
+ struct action *action = &other_spec[i];
+
+ if (!file_type_match(st_mode, action->action->file_types))
+ /* action does not operate on this file type */
+ continue;
+
+ match = eval_expr_top(action, &action_data);
+
+ if (match)
+ action->action->run_action(action, dir_ent);
+ }
+
+ free(action_data.pathname);
+ free(action_data.subpath);
+}
+
+
+/*
+ * Fragment specific action code
+ */
+void *eval_frag_actions(struct dir_info *root, struct dir_ent *dir_ent)
+{
+ int i, match;
+ struct action_data action_data;
+
+ action_data.name = dir_ent->name;
+ action_data.pathname = strdup(pathname(dir_ent));
+ action_data.subpath = strdup(subpathname(dir_ent));
+ action_data.buf = &dir_ent->inode->buf;
+ action_data.depth = dir_ent->our_dir->depth;
+ action_data.dir_ent = dir_ent;
+ action_data.root = root;
+
+ for (i = 0; i < fragment_count; i++) {
+ match = eval_expr_top(&fragment_spec[i], &action_data);
+ if (match) {
+ free(action_data.pathname);
+ free(action_data.subpath);
+ return &fragment_spec[i].data;
+ }
+ }
+
+ free(action_data.pathname);
+ free(action_data.subpath);
+ return &def_fragment;
+}
+
+
+void *get_frag_action(void *fragment)
+{
+ struct action *spec_list_end = &fragment_spec[fragment_count];
+ struct action *action;
+
+ if (fragment == NULL)
+ return &def_fragment;
+
+ if (fragment_count == 0)
+ return NULL;
+
+ if (fragment == &def_fragment)
+ action = &fragment_spec[0] - 1;
+ else
+ action = fragment - offsetof(struct action, data);
+
+ if (++action == spec_list_end)
+ return NULL;
+
+ return &action->data;
+}
+
+
+/*
+ * Exclude specific action code
+ */
+int exclude_actions()
+{
+ return exclude_count;
+}
+
+
+int eval_exclude_actions(char *name, char *pathname, char *subpath,
+ struct stat *buf, int depth, struct dir_ent *dir_ent)
+{
+ int i, match = 0;
+ struct action_data action_data;
+
+ action_data.name = name;
+ action_data.pathname = pathname;
+ action_data.subpath = subpath;
+ action_data.buf = buf;
+ action_data.depth = depth;
+ action_data.dir_ent = dir_ent;
+
+ for (i = 0; i < exclude_count && !match; i++)
+ match = eval_expr_top(&exclude_spec[i], &action_data);
+
+ return match;
+}
+
+
+/*
+ * Fragment specific action code
+ */
+static void frag_action(struct action *action, struct dir_ent *dir_ent)
+{
+ struct inode_info *inode = dir_ent->inode;
+
+ inode->no_fragments = 0;
+}
+
+static void no_frag_action(struct action *action, struct dir_ent *dir_ent)
+{
+ struct inode_info *inode = dir_ent->inode;
+
+ inode->no_fragments = 1;
+}
+
+static void always_frag_action(struct action *action, struct dir_ent *dir_ent)
+{
+ struct inode_info *inode = dir_ent->inode;
+
+ inode->always_use_fragments = 1;
+}
+
+static void no_always_frag_action(struct action *action, struct dir_ent *dir_ent)
+{
+ struct inode_info *inode = dir_ent->inode;
+
+ inode->always_use_fragments = 0;
+}
+
+
+/*
+ * Compression specific action code
+ */
+static void comp_action(struct action *action, struct dir_ent *dir_ent)
+{
+ struct inode_info *inode = dir_ent->inode;
+
+ inode->noD = inode->noF = 0;
+}
+
+static void uncomp_action(struct action *action, struct dir_ent *dir_ent)
+{
+ struct inode_info *inode = dir_ent->inode;
+
+ inode->noD = inode->noF = 1;
+}
+
+
+/*
+ * Uid/gid specific action code
+ */
+static long long parse_uid(char *arg) {
+ char *b;
+ long long uid = strtoll(arg, &b, 10);
+
+ if (*b == '\0') {
+ if (uid < 0 || uid >= (1LL << 32)) {
+ SYNTAX_ERROR("Uid out of range\n");
+ return -1;
+ }
+ } else {
+ struct passwd *passwd = getpwnam(arg);
+
+ if (passwd)
+ uid = passwd->pw_uid;
+ else {
+ SYNTAX_ERROR("Invalid uid or unknown user\n");
+ return -1;
+ }
+ }
+
+ return uid;
+}
+
+
+static long long parse_gid(char *arg) {
+ char *b;
+ long long gid = strtoll(arg, &b, 10);
+
+ if (*b == '\0') {
+ if (gid < 0 || gid >= (1LL << 32)) {
+ SYNTAX_ERROR("Gid out of range\n");
+ return -1;
+ }
+ } else {
+ struct group *group = getgrnam(arg);
+
+ if (group)
+ gid = group->gr_gid;
+ else {
+ SYNTAX_ERROR("Invalid gid or unknown group\n");
+ return -1;
+ }
+ }
+
+ return gid;
+}
+
+
+static int parse_uid_args(struct action_entry *action, int args, char **argv,
+ void **data)
+{
+ long long uid;
+ struct uid_info *uid_info;
+
+ uid = parse_uid(argv[0]);
+ if (uid == -1)
+ return 0;
+
+ uid_info = malloc(sizeof(struct uid_info));
+ if (uid_info == NULL)
+ MEM_ERROR();
+
+ uid_info->uid = uid;
+ *data = uid_info;
+
+ return 1;
+}
+
+
+static int parse_gid_args(struct action_entry *action, int args, char **argv,
+ void **data)
+{
+ long long gid;
+ struct gid_info *gid_info;
+
+ gid = parse_gid(argv[0]);
+ if (gid == -1)
+ return 0;
+
+ gid_info = malloc(sizeof(struct gid_info));
+ if (gid_info == NULL)
+ MEM_ERROR();
+
+ gid_info->gid = gid;
+ *data = gid_info;
+
+ return 1;
+}
+
+
+static int parse_guid_args(struct action_entry *action, int args, char **argv,
+ void **data)
+{
+ long long uid, gid;
+ struct guid_info *guid_info;
+
+ uid = parse_uid(argv[0]);
+ if (uid == -1)
+ return 0;
+
+ gid = parse_gid(argv[1]);
+ if (gid == -1)
+ return 0;
+
+ guid_info = malloc(sizeof(struct guid_info));
+ if (guid_info == NULL)
+ MEM_ERROR();
+
+ guid_info->uid = uid;
+ guid_info->gid = gid;
+ *data = guid_info;
+
+ return 1;
+}
+
+
+static void uid_action(struct action *action, struct dir_ent *dir_ent)
+{
+ struct inode_info *inode = dir_ent->inode;
+ struct uid_info *uid_info = action->data;
+
+ inode->buf.st_uid = uid_info->uid;
+}
+
+static void gid_action(struct action *action, struct dir_ent *dir_ent)
+{
+ struct inode_info *inode = dir_ent->inode;
+ struct gid_info *gid_info = action->data;
+
+ inode->buf.st_gid = gid_info->gid;
+}
+
+static void guid_action(struct action *action, struct dir_ent *dir_ent)
+{
+ struct inode_info *inode = dir_ent->inode;
+ struct guid_info *guid_info = action->data;
+
+ inode->buf.st_uid = guid_info->uid;
+ inode->buf.st_gid = guid_info->gid;
+
+}
+
+
+/*
+ * Mode specific action code
+ */
+static int parse_octal_mode_args(int args, char **argv,
+ void **data)
+{
+ int n, bytes;
+ unsigned int mode;
+ struct mode_data *mode_data;
+
+ /* octal mode number? */
+ n = sscanf(argv[0], "%o%n", &mode, &bytes);
+ if (n == 0)
+ return -1; /* not an octal number arg */
+
+
+ /* check there's no trailing junk */
+ if (argv[0][bytes] != '\0') {
+ SYNTAX_ERROR("Unexpected trailing bytes after octal "
+ "mode number\n");
+ return 0; /* bad octal number arg */
+ }
+
+ /* check there's only one argument */
+ if (args > 1) {
+ SYNTAX_ERROR("Octal mode number is first argument, "
+ "expected one argument, got %d\n", args);
+ return 0; /* bad octal number arg */
+ }
+
+ /* check mode is within range */
+ if (mode > 07777) {
+ SYNTAX_ERROR("Octal mode %o is out of range\n", mode);
+ return 0; /* bad octal number arg */
+ }
+
+ mode_data = malloc(sizeof(struct mode_data));
+ if (mode_data == NULL)
+ MEM_ERROR();
+
+ mode_data->operation = ACTION_MODE_OCT;
+ mode_data->mode = mode;
+ mode_data->next = NULL;
+ *data = mode_data;
+
+ return 1;
+}
+
+
+/*
+ * Parse symbolic mode of format [ugoa]*[[+-=]PERMS]+
+ * PERMS = [rwxXst]+ or [ugo]
+ */
+static int parse_sym_mode_arg(char *arg, struct mode_data **head,
+ struct mode_data **cur)
+{
+ struct mode_data *mode_data;
+ int mode;
+ int mask = 0;
+ int op;
+ char X;
+
+ if (arg[0] != 'u' && arg[0] != 'g' && arg[0] != 'o' && arg[0] != 'a') {
+ /* no ownership specifiers, default to a */
+ mask = 0777;
+ goto parse_operation;
+ }
+
+ /* parse ownership specifiers */
+ while(1) {
+ switch(*arg) {
+ case 'u':
+ mask |= 04700;
+ break;
+ case 'g':
+ mask |= 02070;
+ break;
+ case 'o':
+ mask |= 01007;
+ break;
+ case 'a':
+ mask = 07777;
+ break;
+ default:
+ goto parse_operation;
+ }
+ arg ++;
+ }
+
+parse_operation:
+ /* trap a symbolic mode with just an ownership specification */
+ if(*arg == '\0') {
+ SYNTAX_ERROR("Expected one of '+', '-' or '=', got EOF\n");
+ goto failed;
+ }
+
+ while(*arg != '\0') {
+ mode = 0;
+ X = 0;
+
+ switch(*arg) {
+ case '+':
+ op = ACTION_MODE_ADD;
+ break;
+ case '-':
+ op = ACTION_MODE_REM;
+ break;
+ case '=':
+ op = ACTION_MODE_SET;
+ break;
+ default:
+ SYNTAX_ERROR("Expected one of '+', '-' or '=', got "
+ "'%c'\n", *arg);
+ goto failed;
+ }
+
+ arg ++;
+
+ /* Parse PERMS */
+ if (*arg == 'u' || *arg == 'g' || *arg == 'o') {
+ /* PERMS = [ugo] */
+ mode = - *arg;
+ arg ++;
+ } else {
+ /* PERMS = [rwxXst]* */
+ while(1) {
+ switch(*arg) {
+ case 'r':
+ mode |= 0444;
+ break;
+ case 'w':
+ mode |= 0222;
+ break;
+ case 'x':
+ mode |= 0111;
+ break;
+ case 's':
+ mode |= 06000;
+ break;
+ case 't':
+ mode |= 01000;
+ break;
+ case 'X':
+ X = 1;
+ break;
+ case '+':
+ case '-':
+ case '=':
+ case '\0':
+ mode &= mask;
+ goto perms_parsed;
+ default:
+ SYNTAX_ERROR("Unrecognised permission "
+ "'%c'\n", *arg);
+ goto failed;
+ }
+
+ arg ++;
+ }
+ }
+
+perms_parsed:
+ mode_data = malloc(sizeof(*mode_data));
+ if (mode_data == NULL)
+ MEM_ERROR();
+
+ mode_data->operation = op;
+ mode_data->mode = mode;
+ mode_data->mask = mask;
+ mode_data->X = X;
+ mode_data->next = NULL;
+
+ if (*cur) {
+ (*cur)->next = mode_data;
+ *cur = mode_data;
+ } else
+ *head = *cur = mode_data;
+ }
+
+ return 1;
+
+failed:
+ return 0;
+}
+
+
+static int parse_sym_mode_args(struct action_entry *action, int args,
+ char **argv, void **data)
+{
+ int i, res = 1;
+ struct mode_data *head = NULL, *cur = NULL;
+
+ for (i = 0; i < args && res; i++)
+ res = parse_sym_mode_arg(argv[i], &head, &cur);
+
+ *data = head;
+
+ return res;
+}
+
+
+static int parse_mode_args(struct action_entry *action, int args,
+ char **argv, void **data)
+{
+ int res;
+
+ if (args == 0) {
+ SYNTAX_ERROR("Mode action expects one or more arguments\n");
+ return 0;
+ }
+
+ res = parse_octal_mode_args(args, argv, data);
+ if(res >= 0)
+ /* Got an octal mode argument */
+ return res;
+ else /* not an octal mode argument */
+ return parse_sym_mode_args(action, args, argv, data);
+}
+
+
+static int mode_execute(struct mode_data *mode_data, int st_mode)
+{
+ int mode = 0;
+
+ for (;mode_data; mode_data = mode_data->next) {
+ if (mode_data->mode < 0) {
+ /* 'u', 'g' or 'o' */
+ switch(-mode_data->mode) {
+ case 'u':
+ mode = (st_mode >> 6) & 07;
+ break;
+ case 'g':
+ mode = (st_mode >> 3) & 07;
+ break;
+ case 'o':
+ mode = st_mode & 07;
+ break;
+ }
+ mode = ((mode << 6) | (mode << 3) | mode) &
+ mode_data->mask;
+ } else if (mode_data->X &&
+ ((st_mode & S_IFMT) == S_IFDIR ||
+ (st_mode & 0111)))
+ /* X permission, only takes effect if inode is a
+ * directory or x is set for some owner */
+ mode = mode_data->mode | (0111 & mode_data->mask);
+ else
+ mode = mode_data->mode;
+
+ switch(mode_data->operation) {
+ case ACTION_MODE_OCT:
+ st_mode = (st_mode & S_IFMT) | mode;
+ break;
+ case ACTION_MODE_SET:
+ st_mode = (st_mode & ~mode_data->mask) | mode;
+ break;
+ case ACTION_MODE_ADD:
+ st_mode |= mode;
+ break;
+ case ACTION_MODE_REM:
+ st_mode &= ~mode;
+ }
+ }
+
+ return st_mode;
+}
+
+
+static void mode_action(struct action *action, struct dir_ent *dir_ent)
+{
+ dir_ent->inode->buf.st_mode = mode_execute(action->data,
+ dir_ent->inode->buf.st_mode);
+}
+
+
+/*
+ * Empty specific action code
+ */
+int empty_actions()
+{
+ return empty_count;
+}
+
+
+static int parse_empty_args(struct action_entry *action, int args,
+ char **argv, void **data)
+{
+ struct empty_data *empty_data;
+ int val;
+
+ if (args >= 2) {
+ SYNTAX_ERROR("Empty action expects zero or one argument\n");
+ return 0;
+ }
+
+ if (args == 0 || strcmp(argv[0], "all") == 0)
+ val = EMPTY_ALL;
+ else if (strcmp(argv[0], "source") == 0)
+ val = EMPTY_SOURCE;
+ else if (strcmp(argv[0], "excluded") == 0)
+ val = EMPTY_EXCLUDED;
+ else {
+ SYNTAX_ERROR("Empty action expects zero arguments, or one"
+ "argument containing \"all\", \"source\", or \"excluded\""
+ "\n");
+ return 0;
+ }
+
+ empty_data = malloc(sizeof(*empty_data));
+ if (empty_data == NULL)
+ MEM_ERROR();
+
+ empty_data->val = val;
+ *data = empty_data;
+
+ return 1;
+}
+
+
+int eval_empty_actions(struct dir_info *root, struct dir_ent *dir_ent)
+{
+ int i, match = 0;
+ struct action_data action_data;
+ struct empty_data *data;
+ struct dir_info *dir = dir_ent->dir;
+
+ /*
+ * Empty action only works on empty directories
+ */
+ if (dir->count != 0)
+ return 0;
+
+ action_data.name = dir_ent->name;
+ action_data.pathname = strdup(pathname(dir_ent));
+ action_data.subpath = strdup(subpathname(dir_ent));
+ action_data.buf = &dir_ent->inode->buf;
+ action_data.depth = dir_ent->our_dir->depth;
+ action_data.dir_ent = dir_ent;
+ action_data.root = root;
+
+ for (i = 0; i < empty_count && !match; i++) {
+ data = empty_spec[i].data;
+
+ /*
+ * determine the cause of the empty directory and evaluate
+ * the empty action specified. Three empty actions:
+ * - EMPTY_SOURCE: empty action triggers only if the directory
+ * was originally empty, i.e directories that are empty
+ * only due to excluding are ignored.
+ * - EMPTY_EXCLUDED: empty action triggers only if the directory
+ * is empty because of excluding, i.e. directories that
+ * were originally empty are ignored.
+ * - EMPTY_ALL (the default): empty action triggers if the
+ * directory is empty, irrespective of the reason, i.e.
+ * the directory could have been originally empty or could
+ * be empty due to excluding.
+ */
+ if ((data->val == EMPTY_EXCLUDED && !dir->excluded) ||
+ (data->val == EMPTY_SOURCE && dir->excluded))
+ continue;
+
+ match = eval_expr_top(&empty_spec[i], &action_data);
+ }
+
+ free(action_data.pathname);
+ free(action_data.subpath);
+
+ return match;
+}
+
+
+/*
+ * Move specific action code
+ */
+static struct move_ent *move_list = NULL;
+
+
+int move_actions()
+{
+ return move_count;
+}
+
+
+static char *move_pathname(struct move_ent *move)
+{
+ struct dir_info *dest;
+ char *name, *pathname;
+ int res;
+
+ dest = (move->ops & ACTION_MOVE_MOVE) ?
+ move->dest : move->dir_ent->our_dir;
+ name = (move->ops & ACTION_MOVE_RENAME) ?
+ move->name : move->dir_ent->name;
+
+ if(dest->subpath[0] != '\0')
+ res = asprintf(&pathname, "%s/%s", dest->subpath, name);
+ else
+ res = asprintf(&pathname, "/%s", name);
+
+ if(res == -1)
+ BAD_ERROR("asprintf failed in move_pathname\n");
+
+ return pathname;
+}
+
+
+static char *get_comp(char **pathname)
+{
+ char *path = *pathname, *start;
+
+ while(*path == '/')
+ path ++;
+
+ if(*path == '\0')
+ return NULL;
+
+ start = path;
+ while(*path != '/' && *path != '\0')
+ path ++;
+
+ *pathname = path;
+ return strndup(start, path - start);
+}
+
+
+static struct dir_ent *lookup_comp(char *comp, struct dir_info *dest)
+{
+ struct dir_ent *dir_ent;
+
+ for(dir_ent = dest->list; dir_ent; dir_ent = dir_ent->next)
+ if(strcmp(comp, dir_ent->name) == 0)
+ break;
+
+ return dir_ent;
+}
+
+
+void eval_move(struct action_data *action_data, struct move_ent *move,
+ struct dir_info *root, struct dir_ent *dir_ent, char *pathname)
+{
+ struct dir_info *dest, *source = dir_ent->our_dir;
+ struct dir_ent *comp_ent;
+ char *comp, *path = pathname;
+
+ /*
+ * Walk pathname to get the destination directory
+ *
+ * Like the mv command, if the last component exists and it
+ * is a directory, then move the file into that directory,
+ * otherwise, move the file into parent directory of the last
+ * component and rename to the last component.
+ */
+ if (pathname[0] == '/')
+ /* absolute pathname, walk from root directory */
+ dest = root;
+ else
+ /* relative pathname, walk from current directory */
+ dest = source;
+
+ for(comp = get_comp(&pathname); comp; free(comp),
+ comp = get_comp(&pathname)) {
+
+ if (strcmp(comp, ".") == 0)
+ continue;
+
+ if (strcmp(comp, "..") == 0) {
+ /* if we're in the root directory then ignore */
+ if(dest->depth > 1)
+ dest = dest->dir_ent->our_dir;
+ continue;
+ }
+
+ /*
+ * Look up comp in current directory, if it exists and it is a
+ * directory continue walking the pathname, otherwise exit,
+ * we've walked as far as we can go, normally this is because
+ * we've arrived at the leaf component which we are going to
+ * rename source to
+ */
+ comp_ent = lookup_comp(comp, dest);
+ if (comp_ent == NULL || (comp_ent->inode->buf.st_mode & S_IFMT)
+ != S_IFDIR)
+ break;
+
+ dest = comp_ent->dir;
+ }
+
+ if(comp) {
+ /* Leaf component? If so we're renaming to this */
+ char *remainder = get_comp(&pathname);
+ free(remainder);
+
+ if(remainder) {
+ /*
+ * trying to move source to a subdirectory of
+ * comp, but comp either doesn't exist, or it isn't
+ * a directory, which is impossible
+ */
+ if (comp_ent == NULL)
+ ERROR("Move action: cannot move %s to %s, no "
+ "such directory %s\n",
+ action_data->subpath, path, comp);
+ else
+ ERROR("Move action: cannot move %s to %s, %s "
+ "is not a directory\n",
+ action_data->subpath, path, comp);
+ free(comp);
+ return;
+ }
+
+ /*
+ * Multiple move actions triggering on one file can be merged
+ * if one is a RENAME and the other is a MOVE. Multiple RENAMEs
+ * can only merge if they're doing the same thing
+ */
+ if(move->ops & ACTION_MOVE_RENAME) {
+ if(strcmp(comp, move->name) != 0) {
+ char *conf_path = move_pathname(move);
+ ERROR("Move action: Cannot move %s to %s, "
+ "conflicting move, already moving "
+ "to %s via another move action!\n",
+ action_data->subpath, path, conf_path);
+ free(conf_path);
+ free(comp);
+ return;
+ }
+ free(comp);
+ } else {
+ move->name = comp;
+ move->ops |= ACTION_MOVE_RENAME;
+ }
+ }
+
+ if(dest != source) {
+ /*
+ * Multiple move actions triggering on one file can be merged
+ * if one is a RENAME and the other is a MOVE. Multiple MOVEs
+ * can only merge if they're doing the same thing
+ */
+ if(move->ops & ACTION_MOVE_MOVE) {
+ if(dest != move->dest) {
+ char *conf_path = move_pathname(move);
+ ERROR("Move action: Cannot move %s to %s, "
+ "conflicting move, already moving "
+ "to %s via another move action!\n",
+ action_data->subpath, path, conf_path);
+ free(conf_path);
+ return;
+ }
+ } else {
+ move->dest = dest;
+ move->ops |= ACTION_MOVE_MOVE;
+ }
+ }
+}
+
+
+static int subdirectory(struct dir_info *source, struct dir_info *dest)
+{
+ if(source == NULL)
+ return 0;
+
+ return strlen(source->subpath) <= strlen(dest->subpath) &&
+ (dest->subpath[strlen(source->subpath)] == '/' ||
+ dest->subpath[strlen(source->subpath)] == '\0') &&
+ strncmp(source->subpath, dest->subpath,
+ strlen(source->subpath)) == 0;
+}
+
+
+void eval_move_actions(struct dir_info *root, struct dir_ent *dir_ent)
+{
+ int i;
+ struct action_data action_data;
+ struct move_ent *move = NULL;
+
+ action_data.name = dir_ent->name;
+ action_data.pathname = strdup(pathname(dir_ent));
+ action_data.subpath = strdup(subpathname(dir_ent));
+ action_data.buf = &dir_ent->inode->buf;
+ action_data.depth = dir_ent->our_dir->depth;
+ action_data.dir_ent = dir_ent;
+ action_data.root = root;
+
+ /*
+ * Evaluate each move action against the current file. For any
+ * move actions that match don't actually perform the move now, but,
+ * store it, and execute all the stored move actions together once the
+ * directory scan is complete. This is done to ensure each separate
+ * move action does not nondeterministically interfere with other move
+ * actions. Each move action is considered to act independently, and
+ * each move action sees the directory tree in the same state.
+ */
+ for (i = 0; i < move_count; i++) {
+ struct action *action = &move_spec[i];
+ int match = eval_expr_top(action, &action_data);
+
+ if(match) {
+ if(move == NULL) {
+ move = malloc(sizeof(*move));
+ if(move == NULL)
+ MEM_ERROR();
+
+ move->ops = 0;
+ move->dir_ent = dir_ent;
+ }
+ eval_move(&action_data, move, root, dir_ent,
+ action->argv[0]);
+ }
+ }
+
+ if(move) {
+ struct dir_ent *comp_ent;
+ struct dir_info *dest;
+ char *name;
+
+ /*
+ * Move contains the result of all triggered move actions.
+ * Check the destination doesn't already exist
+ */
+ if(move->ops == 0) {
+ free(move);
+ goto finish;
+ }
+
+ dest = (move->ops & ACTION_MOVE_MOVE) ?
+ move->dest : dir_ent->our_dir;
+ name = (move->ops & ACTION_MOVE_RENAME) ?
+ move->name : dir_ent->name;
+ comp_ent = lookup_comp(name, dest);
+ if(comp_ent) {
+ char *conf_path = move_pathname(move);
+ ERROR("Move action: Cannot move %s to %s, "
+ "destination already exists\n",
+ action_data.subpath, conf_path);
+ free(conf_path);
+ free(move);
+ goto finish;
+ }
+
+ /*
+ * If we're moving a directory, check we're not moving it to a
+ * subdirectory of itself
+ */
+ if(subdirectory(dir_ent->dir, dest)) {
+ char *conf_path = move_pathname(move);
+ ERROR("Move action: Cannot move %s to %s, this is a "
+ "subdirectory of itself\n",
+ action_data.subpath, conf_path);
+ free(conf_path);
+ free(move);
+ goto finish;
+ }
+ move->next = move_list;
+ move_list = move;
+ }
+
+finish:
+ free(action_data.pathname);
+ free(action_data.subpath);
+}
+
+
+static void move_dir(struct dir_ent *dir_ent)
+{
+ struct dir_info *dir = dir_ent->dir;
+ struct dir_ent *comp_ent;
+
+ /* update our directory's subpath name */
+ free(dir->subpath);
+ dir->subpath = strdup(subpathname(dir_ent));
+
+ /* recursively update the subpaths of any sub-directories */
+ for(comp_ent = dir->list; comp_ent; comp_ent = comp_ent->next)
+ if(comp_ent->dir)
+ move_dir(comp_ent);
+}
+
+
+static void move_file(struct move_ent *move_ent)
+{
+ struct dir_ent *dir_ent = move_ent->dir_ent;
+
+ if(move_ent->ops & ACTION_MOVE_MOVE) {
+ struct dir_ent *comp_ent, *prev = NULL;
+ struct dir_info *source = dir_ent->our_dir,
+ *dest = move_ent->dest;
+ char *filename = pathname(dir_ent);
+
+ /*
+ * If we're moving a directory, check we're not moving it to a
+ * subdirectory of itself
+ */
+ if(subdirectory(dir_ent->dir, dest)) {
+ char *conf_path = move_pathname(move_ent);
+ ERROR("Move action: Cannot move %s to %s, this is a "
+ "subdirectory of itself\n",
+ subpathname(dir_ent), conf_path);
+ free(conf_path);
+ return;
+ }
+
+ /* Remove the file from source directory */
+ for(comp_ent = source->list; comp_ent != dir_ent;
+ prev = comp_ent, comp_ent = comp_ent->next);
+
+ if(prev)
+ prev->next = comp_ent->next;
+ else
+ source->list = comp_ent->next;
+
+ source->count --;
+ if((comp_ent->inode->buf.st_mode & S_IFMT) == S_IFDIR)
+ source->directory_count --;
+
+ /* Add the file to dest directory */
+ comp_ent->next = dest->list;
+ dest->list = comp_ent;
+ comp_ent->our_dir = dest;
+
+ dest->count ++;
+ if((comp_ent->inode->buf.st_mode & S_IFMT) == S_IFDIR)
+ dest->directory_count ++;
+
+ /*
+ * We've moved the file, and so we can't now use the
+ * parent directory's pathname to calculate the pathname
+ */
+ if(dir_ent->nonstandard_pathname == NULL) {
+ dir_ent->nonstandard_pathname = strdup(filename);
+ if(dir_ent->source_name) {
+ free(dir_ent->source_name);
+ dir_ent->source_name = NULL;
+ }
+ }
+ }
+
+ if(move_ent->ops & ACTION_MOVE_RENAME) {
+ /*
+ * If we're using name in conjunction with the parent
+ * directory's pathname to calculate the pathname, we need
+ * to use source_name to override. Otherwise it's already being
+ * over-ridden
+ */
+ if(dir_ent->nonstandard_pathname == NULL &&
+ dir_ent->source_name == NULL)
+ dir_ent->source_name = dir_ent->name;
+ else
+ free(dir_ent->name);
+
+ dir_ent->name = move_ent->name;
+ }
+
+ if(dir_ent->dir)
+ /*
+ * dir_ent is a directory, and we have to recursively fix-up
+ * its subpath, and the subpaths of all of its sub-directories
+ */
+ move_dir(dir_ent);
+}
+
+
+void do_move_actions()
+{
+ while(move_list) {
+ struct move_ent *temp = move_list;
+ struct dir_info *dest = (move_list->ops & ACTION_MOVE_MOVE) ?
+ move_list->dest : move_list->dir_ent->our_dir;
+ char *name = (move_list->ops & ACTION_MOVE_RENAME) ?
+ move_list->name : move_list->dir_ent->name;
+ struct dir_ent *comp_ent = lookup_comp(name, dest);
+ if(comp_ent) {
+ char *conf_path = move_pathname(move_list);
+ ERROR("Move action: Cannot move %s to %s, "
+ "destination already exists\n",
+ subpathname(move_list->dir_ent), conf_path);
+ free(conf_path);
+ } else
+ move_file(move_list);
+
+ move_list = move_list->next;
+ free(temp);
+ }
+}
+
+
+/*
+ * Prune specific action code
+ */
+int prune_actions()
+{
+ return prune_count;
+}
+
+
+int eval_prune_actions(struct dir_info *root, struct dir_ent *dir_ent)
+{
+ int i, match = 0;
+ struct action_data action_data;
+
+ action_data.name = dir_ent->name;
+ action_data.pathname = strdup(pathname(dir_ent));
+ action_data.subpath = strdup(subpathname(dir_ent));
+ action_data.buf = &dir_ent->inode->buf;
+ action_data.depth = dir_ent->our_dir->depth;
+ action_data.dir_ent = dir_ent;
+ action_data.root = root;
+
+ for (i = 0; i < prune_count && !match; i++)
+ match = eval_expr_top(&prune_spec[i], &action_data);
+
+ free(action_data.pathname);
+ free(action_data.subpath);
+
+ return match;
+}
+
+
+/*
+ * Noop specific action code
+ */
+static void noop_action(struct action *action, struct dir_ent *dir_ent)
+{
+}
+
+
+/*
+ * General test evaluation code
+ */
+
+/*
+ * A number can be of the form [range]number[size]
+ * [range] is either:
+ * '<' or '-', match on less than number
+ * '>' or '+', match on greater than number
+ * '' (nothing), match on exactly number
+ * [size] is either:
+ * '' (nothing), number
+ * 'k' or 'K', number * 2^10
+ * 'm' or 'M', number * 2^20
+ * 'g' or 'G', number * 2^30
+ */
+static int parse_number(char *start, long long *size, int *range, char **error)
+{
+ char *end;
+ long long number;
+
+ if (*start == '>' || *start == '+') {
+ *range = NUM_GREATER;
+ start ++;
+ } else if (*start == '<' || *start == '-') {
+ *range = NUM_LESS;
+ start ++;
+ } else
+ *range = NUM_EQ;
+
+ errno = 0; /* To enable failure after call to be determined */
+ number = strtoll(start, &end, 10);
+
+ if((errno == ERANGE && (number == LLONG_MAX || number == LLONG_MIN))
+ || (errno != 0 && number == 0)) {
+ /* long long underflow or overflow in conversion, or other
+ * conversion error.
+ * Note: we don't check for LLONG_MIN and LLONG_MAX only
+ * because strtoll can validly return that if the
+ * user used these values
+ */
+ *error = "Long long underflow, overflow or other conversion "
+ "error";
+ return 0;
+ }
+
+ if (end == start) {
+ /* Couldn't read any number */
+ *error = "Number expected";
+ return 0;
+ }
+
+ switch (end[0]) {
+ case 'g':
+ case 'G':
+ number *= 1024;
+ case 'm':
+ case 'M':
+ number *= 1024;
+ case 'k':
+ case 'K':
+ number *= 1024;
+
+ if (end[1] != '\0') {
+ *error = "Trailing junk after size specifier";
+ return 0;
+ }
+
+ break;
+ case '\0':
+ break;
+ default:
+ *error = "Trailing junk after number";
+ return 0;
+ }
+
+ *size = number;
+
+ return 1;
+}
+
+
+static int parse_number_arg(struct test_entry *test, struct atom *atom)
+{
+ struct test_number_arg *number;
+ long long size;
+ int range;
+ char *error;
+ int res = parse_number(atom->argv[0], &size, &range, &error);
+
+ if (res == 0) {
+ TEST_SYNTAX_ERROR(test, 0, "%s\n", error);
+ return 0;
+ }
+
+ number = malloc(sizeof(*number));
+ if (number == NULL)
+ MEM_ERROR();
+
+ number->range = range;
+ number->size = size;
+
+ atom->data = number;
+
+ return 1;
+}
+
+
+static int parse_range_args(struct test_entry *test, struct atom *atom)
+{
+ struct test_range_args *range;
+ long long start, end;
+ int type;
+ int res;
+ char *error;
+
+ res = parse_number(atom->argv[0], &start, &type, &error);
+ if (res == 0) {
+ TEST_SYNTAX_ERROR(test, 0, "%s\n", error);
+ return 0;
+ }
+
+ if (type != NUM_EQ) {
+ TEST_SYNTAX_ERROR(test, 0, "Range specifier (<, >, -, +) not "
+ "expected\n");
+ return 0;
+ }
+
+ res = parse_number(atom->argv[1], &end, &type, &error);
+ if (res == 0) {
+ TEST_SYNTAX_ERROR(test, 1, "%s\n", error);
+ return 0;
+ }
+
+ if (type != NUM_EQ) {
+ TEST_SYNTAX_ERROR(test, 1, "Range specifier (<, >, -, +) not "
+ "expected\n");
+ return 0;
+ }
+
+ range = malloc(sizeof(*range));
+ if (range == NULL)
+ MEM_ERROR();
+
+ range->start = start;
+ range->end = end;
+
+ atom->data = range;
+
+ return 1;
+}
+
+
+/*
+ * Generic test code macro
+ */
+#define TEST_FN(NAME, MATCH, CODE) \
+static int NAME##_fn(struct atom *atom, struct action_data *action_data) \
+{ \
+ /* test operates on MATCH file types only */ \
+ if (!file_type_match(action_data->buf->st_mode, MATCH)) \
+ return 0; \
+ \
+ CODE \
+}
+
+/*
+ * Generic test code macro testing VAR for size (eq, less than, greater than)
+ */
+#define TEST_VAR_FN(NAME, MATCH, VAR) TEST_FN(NAME, MATCH, \
+ { \
+ int match = 0; \
+ struct test_number_arg *number = atom->data; \
+ \
+ switch (number->range) { \
+ case NUM_EQ: \
+ match = VAR == number->size; \
+ break; \
+ case NUM_LESS: \
+ match = VAR < number->size; \
+ break; \
+ case NUM_GREATER: \
+ match = VAR > number->size; \
+ break; \
+ } \
+ \
+ return match; \
+ })
+
+
+/*
+ * Generic test code macro testing VAR for range [x, y] (value between x and y
+ * inclusive).
+ */
+#define TEST_VAR_RANGE_FN(NAME, MATCH, VAR) TEST_FN(NAME##_range, MATCH, \
+ { \
+ struct test_range_args *range = atom->data; \
+ \
+ return range->start <= VAR && VAR <= range->end; \
+ })
+
+
+/*
+ * Name, Pathname and Subpathname test specific code
+ */
+
+/*
+ * Add a leading "/" if subpathname and pathname lacks it
+ */
+static int check_pathname(struct test_entry *test, struct atom *atom)
+{
+ int res;
+ char *name;
+
+ if(atom->argv[0][0] != '/') {
+ res = asprintf(&name, "/%s", atom->argv[0]);
+ if(res == -1)
+ BAD_ERROR("asprintf failed in check_pathname\n");
+
+ free(atom->argv[0]);
+ atom->argv[0] = name;
+ }
+
+ return 1;
+}
+
+
+TEST_FN(name, ACTION_ALL_LNK, \
+ return fnmatch(atom->argv[0], action_data->name,
+ FNM_PATHNAME|FNM_PERIOD|FNM_EXTMATCH) == 0;)
+
+TEST_FN(pathname, ACTION_ALL_LNK, \
+ return fnmatch(atom->argv[0], action_data->subpath,
+ FNM_PATHNAME|FNM_PERIOD|FNM_EXTMATCH) == 0;)
+
+
+static int count_components(char *path)
+{
+ int count;
+
+ for (count = 0; *path != '\0'; count ++) {
+ while (*path == '/')
+ path ++;
+
+ while (*path != '\0' && *path != '/')
+ path ++;
+ }
+
+ return count;
+}
+
+
+static char *get_start(char *s, int n)
+{
+ int count;
+ char *path = s;
+
+ for (count = 0; *path != '\0' && count < n; count ++) {
+ while (*path == '/')
+ path ++;
+
+ while (*path != '\0' && *path != '/')
+ path ++;
+ }
+
+ if (count == n)
+ *path = '\0';
+
+ return s;
+}
+
+
+static int subpathname_fn(struct atom *atom, struct action_data *action_data)
+{
+ char *path = strdup(action_data->subpath);
+ int is_match = fnmatch(atom->argv[0], get_start(path,
+ count_components(atom->argv[0])),
+ FNM_PATHNAME|FNM_PERIOD|FNM_EXTMATCH) == 0;
+ free(path);
+ return is_match;
+}
+
+/*
+ * Inode attribute test operations using generic
+ * TEST_VAR_FN(test name, file scope, attribute name) macro.
+ * This is for tests that do not need to be specially handled in any way.
+ * They just take a variable and compare it against a number.
+ */
+TEST_VAR_FN(filesize, ACTION_REG, action_data->buf->st_size)
+
+TEST_VAR_FN(dirsize, ACTION_DIR, action_data->buf->st_size)
+
+TEST_VAR_FN(size, ACTION_ALL_LNK, action_data->buf->st_size)
+
+TEST_VAR_FN(inode, ACTION_ALL_LNK, action_data->buf->st_ino)
+
+TEST_VAR_FN(nlink, ACTION_ALL_LNK, action_data->buf->st_nlink)
+
+TEST_VAR_FN(fileblocks, ACTION_REG, action_data->buf->st_blocks)
+
+TEST_VAR_FN(dirblocks, ACTION_DIR, action_data->buf->st_blocks)
+
+TEST_VAR_FN(blocks, ACTION_ALL_LNK, action_data->buf->st_blocks)
+
+TEST_VAR_FN(dircount, ACTION_DIR, action_data->dir_ent->dir->count)
+
+TEST_VAR_FN(depth, ACTION_ALL_LNK, action_data->depth)
+
+TEST_VAR_RANGE_FN(filesize, ACTION_REG, action_data->buf->st_size)
+
+TEST_VAR_RANGE_FN(dirsize, ACTION_DIR, action_data->buf->st_size)
+
+TEST_VAR_RANGE_FN(size, ACTION_ALL_LNK, action_data->buf->st_size)
+
+TEST_VAR_RANGE_FN(inode, ACTION_ALL_LNK, action_data->buf->st_ino)
+
+TEST_VAR_RANGE_FN(nlink, ACTION_ALL_LNK, action_data->buf->st_nlink)
+
+TEST_VAR_RANGE_FN(fileblocks, ACTION_REG, action_data->buf->st_blocks)
+
+TEST_VAR_RANGE_FN(dirblocks, ACTION_DIR, action_data->buf->st_blocks)
+
+TEST_VAR_RANGE_FN(blocks, ACTION_ALL_LNK, action_data->buf->st_blocks)
+
+TEST_VAR_RANGE_FN(gid, ACTION_ALL_LNK, action_data->buf->st_gid)
+
+TEST_VAR_RANGE_FN(uid, ACTION_ALL_LNK, action_data->buf->st_uid)
+
+TEST_VAR_RANGE_FN(depth, ACTION_ALL_LNK, action_data->depth)
+
+TEST_VAR_RANGE_FN(dircount, ACTION_DIR, action_data->dir_ent->dir->count)
+
+/*
+ * uid specific test code
+ */
+TEST_VAR_FN(uid, ACTION_ALL_LNK, action_data->buf->st_uid)
+
+static int parse_uid_arg(struct test_entry *test, struct atom *atom)
+{
+ struct test_number_arg *number;
+ long long size;
+ int range;
+ char *error;
+
+ if(parse_number(atom->argv[0], &size, &range, &error)) {
+ /* managed to fully parse argument as a number */
+ if(size < 0 || size > (((long long) 1 << 32) - 1)) {
+ TEST_SYNTAX_ERROR(test, 1, "Numeric uid out of "
+ "range\n");
+ return 0;
+ }
+ } else {
+ /* couldn't parse (fully) as a number, is it a user name? */
+ struct passwd *uid = getpwnam(atom->argv[0]);
+ if(uid) {
+ size = uid->pw_uid;
+ range = NUM_EQ;
+ } else {
+ TEST_SYNTAX_ERROR(test, 1, "Invalid uid or unknown "
+ "user\n");
+ return 0;
+ }
+ }
+
+ number = malloc(sizeof(*number));
+ if(number == NULL)
+ MEM_ERROR();
+
+ number->range = range;
+ number->size= size;
+
+ atom->data = number;
+
+ return 1;
+}
+
+
+/*
+ * gid specific test code
+ */
+TEST_VAR_FN(gid, ACTION_ALL_LNK, action_data->buf->st_gid)
+
+static int parse_gid_arg(struct test_entry *test, struct atom *atom)
+{
+ struct test_number_arg *number;
+ long long size;
+ int range;
+ char *error;
+
+ if(parse_number(atom->argv[0], &size, &range, &error)) {
+ /* managed to fully parse argument as a number */
+ if(size < 0 || size > (((long long) 1 << 32) - 1)) {
+ TEST_SYNTAX_ERROR(test, 1, "Numeric gid out of "
+ "range\n");
+ return 0;
+ }
+ } else {
+ /* couldn't parse (fully) as a number, is it a group name? */
+ struct group *gid = getgrnam(atom->argv[0]);
+ if(gid) {
+ size = gid->gr_gid;
+ range = NUM_EQ;
+ } else {
+ TEST_SYNTAX_ERROR(test, 1, "Invalid gid or unknown "
+ "group\n");
+ return 0;
+ }
+ }
+
+ number = malloc(sizeof(*number));
+ if(number == NULL)
+ MEM_ERROR();
+
+ number->range = range;
+ number->size= size;
+
+ atom->data = number;
+
+ return 1;
+}
+
+
+/*
+ * Type test specific code
+ */
+struct type_entry type_table[] = {
+ { S_IFSOCK, 's' },
+ { S_IFLNK, 'l' },
+ { S_IFREG, 'f' },
+ { S_IFBLK, 'b' },
+ { S_IFDIR, 'd' },
+ { S_IFCHR, 'c' },
+ { S_IFIFO, 'p' },
+ { 0, 0 },
+};
+
+
+static int parse_type_arg(struct test_entry *test, struct atom *atom)
+{
+ int i;
+
+ if (strlen(atom->argv[0]) != 1)
+ goto failed;
+
+ for(i = 0; type_table[i].type != 0; i++)
+ if (type_table[i].type == atom->argv[0][0])
+ break;
+
+ atom->data = &type_table[i];
+
+ if(type_table[i].type != 0)
+ return 1;
+
+failed:
+ TEST_SYNTAX_ERROR(test, 0, "Unexpected file type, expected 'f', 'd', "
+ "'c', 'b', 'l', 's' or 'p'\n");
+ return 0;
+}
+
+
+static int type_fn(struct atom *atom, struct action_data *action_data)
+{
+ struct type_entry *type = atom->data;
+
+ return (action_data->buf->st_mode & S_IFMT) == type->value;
+}
+
+
+/*
+ * True test specific code
+ */
+static int true_fn(struct atom *atom, struct action_data *action_data)
+{
+ return 1;
+}
+
+
+/*
+ * False test specific code
+ */
+static int false_fn(struct atom *atom, struct action_data *action_data)
+{
+ return 0;
+}
+
+
+/*
+ * File test specific code
+ */
+static int parse_file_arg(struct test_entry *test, struct atom *atom)
+{
+ int res;
+ regex_t *preg = malloc(sizeof(regex_t));
+
+ if (preg == NULL)
+ MEM_ERROR();
+
+ res = regcomp(preg, atom->argv[0], REG_EXTENDED);
+ if (res) {
+ char str[1024]; /* overflow safe */
+
+ regerror(res, preg, str, 1024);
+ free(preg);
+ TEST_SYNTAX_ERROR(test, 0, "invalid regex \"%s\" because "
+ "\"%s\"\n", atom->argv[0], str);
+ return 0;
+ }
+
+ atom->data = preg;
+
+ return 1;
+}
+
+
+static int file_fn(struct atom *atom, struct action_data *action_data)
+{
+ int child, res, size = 0, status;
+ int pipefd[2];
+ char *buffer = NULL;
+ regex_t *preg = atom->data;
+
+ res = pipe(pipefd);
+ if (res == -1)
+ BAD_ERROR("file_fn pipe failed\n");
+
+ child = fork();
+ if (child == -1)
+ BAD_ERROR("file_fn fork_failed\n");
+
+ if (child == 0) {
+ /*
+ * Child process
+ * Connect stdout to pipefd[1] and execute file command
+ */
+ close(STDOUT_FILENO);
+ res = dup(pipefd[1]);
+ if (res == -1)
+ exit(EXIT_FAILURE);
+
+ execlp("file", "file", "-b", action_data->pathname,
+ (char *) NULL);
+ exit(EXIT_FAILURE);
+ }
+
+ /*
+ * Parent process. Read stdout from file command
+ */
+ close(pipefd[1]);
+
+ do {
+ buffer = realloc(buffer, size + 512);
+ if (buffer == NULL)
+ MEM_ERROR();
+
+ res = read_bytes(pipefd[0], buffer + size, 512);
+
+ if (res == -1)
+ BAD_ERROR("file_fn pipe read error\n");
+
+ size += 512;
+
+ } while (res == 512);
+
+ size = size + res - 512;
+
+ buffer[size] = '\0';
+
+ res = waitpid(child, &status, 0);
+
+ if (res == -1)
+ BAD_ERROR("file_fn waitpid failed\n");
+
+ if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
+ BAD_ERROR("file_fn file returned error\n");
+
+ close(pipefd[0]);
+
+ res = regexec(preg, buffer, (size_t) 0, NULL, 0);
+
+ free(buffer);
+
+ return res == 0;
+}
+
+
+/*
+ * Exec test specific code
+ */
+static int exec_fn(struct atom *atom, struct action_data *action_data)
+{
+ int child, i, res, status;
+
+ child = fork();
+ if (child == -1)
+ BAD_ERROR("exec_fn fork_failed\n");
+
+ if (child == 0) {
+ /*
+ * Child process
+ * redirect stdin, stdout & stderr to /dev/null and
+ * execute atom->argv[0]
+ */
+ int fd = open("/dev/null", O_RDWR);
+ if(fd == -1)
+ exit(EXIT_FAILURE);
+
+ close(STDIN_FILENO);
+ close(STDOUT_FILENO);
+ close(STDERR_FILENO);
+ for(i = 0; i < 3; i++) {
+ res = dup(fd);
+ if (res == -1)
+ exit(EXIT_FAILURE);
+ }
+ close(fd);
+
+ /*
+ * Create environment variables
+ * NAME: name of file
+ * PATHNAME: pathname of file relative to squashfs root
+ * SOURCE_PATHNAME: the pathname of the file in the source
+ * directory
+ */
+ res = setenv("NAME", action_data->name, 1);
+ if(res == -1)
+ exit(EXIT_FAILURE);
+
+ res = setenv("PATHNAME", action_data->subpath, 1);
+ if(res == -1)
+ exit(EXIT_FAILURE);
+
+ res = setenv("SOURCE_PATHNAME", action_data->pathname, 1);
+ if(res == -1)
+ exit(EXIT_FAILURE);
+
+ execl("/bin/sh", "sh", "-c", atom->argv[0], (char *) NULL);
+ exit(EXIT_FAILURE);
+ }
+
+ /*
+ * Parent process.
+ */
+
+ res = waitpid(child, &status, 0);
+
+ if (res == -1)
+ BAD_ERROR("exec_fn waitpid failed\n");
+
+ return WIFEXITED(status) ? WEXITSTATUS(status) == 0 : 0;
+}
+
+
+/*
+ * Symbolic link specific test code
+ */
+
+/*
+ * Walk the supplied pathname and return the directory entry corresponding
+ * to the pathname. If any symlinks are encountered whilst walking the
+ * pathname, then recursively walk these, to obtain the fully
+ * dereferenced canonicalised directory entry.
+ *
+ * If follow_path fails to walk a pathname either because a component
+ * doesn't exist, it is a non directory component when a directory
+ * component is expected, a symlink with an absolute path is encountered,
+ * or a symlink is encountered which cannot be recursively walked due to
+ * the above failures, then return NULL.
+ */
+static struct dir_ent *follow_path(struct dir_info *dir, char *pathname)
+{
+ char *comp, *path = pathname;
+ struct dir_ent *dir_ent = NULL;
+
+ /* We cannot follow absolute paths */
+ if(pathname[0] == '/')
+ return NULL;
+
+ for(comp = get_comp(&path); comp; free(comp), comp = get_comp(&path)) {
+ if(strcmp(comp, ".") == 0)
+ continue;
+
+ if(strcmp(comp, "..") == 0) {
+ /* Move to parent if we're not in the root directory */
+ if(dir->depth > 1) {
+ dir = dir->dir_ent->our_dir;
+ dir_ent = NULL; /* lazily eval at loop exit */
+ continue;
+ } else
+ /* Failed to walk pathname */
+ return NULL;
+ }
+
+ /* Lookup comp in current directory */
+ dir_ent = lookup_comp(comp, dir);
+ if(dir_ent == NULL)
+ /* Doesn't exist, failed to walk pathname */
+ return NULL;
+
+ if((dir_ent->inode->buf.st_mode & S_IFMT) == S_IFLNK) {
+ /* Symbolic link, try to walk it */
+ dir_ent = follow_path(dir, dir_ent->inode->symlink);
+ if(dir_ent == NULL)
+ /* Failed to follow symlink */
+ return NULL;
+ }
+
+ if((dir_ent->inode->buf.st_mode & S_IFMT) != S_IFDIR)
+ /* Cannot walk further */
+ break;
+
+ dir = dir_ent->dir;
+ }
+
+ /* We will have exited the loop either because we've processed
+ * all the components, which means we've successfully walked the
+ * pathname, or because we've hit a non-directory, in which case
+ * it's success if this is the leaf component */
+ if(comp) {
+ free(comp);
+ comp = get_comp(&path);
+ free(comp);
+ if(comp != NULL)
+ /* Not a leaf component */
+ return NULL;
+ } else {
+ /* Fully walked pathname, dir_ent contains correct value unless
+ * we've walked to the parent ("..") in which case we need
+ * to resolve it here */
+ if(!dir_ent)
+ dir_ent = dir->dir_ent;
+ }
+
+ return dir_ent;
+}
+
+
+static int exists_fn(struct atom *atom, struct action_data *action_data)
+{
+ /*
+ * Test if a symlink exists within the output filesystem, that is,
+ * the symlink has a relative path, and the relative path refers
+ * to an entry within the output filesystem.
+ *
+ * This test function evaluates the path for symlinks - that is it
+ * follows any symlinks in the path (and any symlinks that it contains
+ * etc.), to discover the fully dereferenced canonicalised relative
+ * path.
+ *
+ * If any symlinks within the path do not exist or are absolute
+ * then the symlink is considered to not exist, as it cannot be
+ * fully dereferenced.
+ *
+ * exists operates on symlinks only, other files by definition
+ * exist
+ */
+ if (!file_type_match(action_data->buf->st_mode, ACTION_LNK))
+ return 1;
+
+ /* dereference the symlink, and return TRUE if it exists */
+ return follow_path(action_data->dir_ent->our_dir,
+ action_data->dir_ent->inode->symlink) ? 1 : 0;
+}
+
+
+static int absolute_fn(struct atom *atom, struct action_data *action_data)
+{
+ /*
+ * Test if a symlink has an absolute path, which by definition
+ * means the symbolic link may be broken (even if the absolute path
+ * does point into the filesystem being squashed, because the resultant
+ * filesystem can be mounted/unsquashed anywhere, it is unlikely the
+ * absolute path will still point to the right place). If you know that
+ * an absolute symlink will point to the right place then you don't need
+ * to use this function, and/or these symlinks can be excluded by
+ * use of other test operators.
+ *
+ * absolute operates on symlinks only, other files by definition
+ * don't have problems
+ */
+ if (!file_type_match(action_data->buf->st_mode, ACTION_LNK))
+ return 0;
+
+ return action_data->dir_ent->inode->symlink[0] == '/';
+}
+
+
+static int parse_expr_argX(struct test_entry *test, struct atom *atom,
+ int argno)
+{
+ /* Call parse_expr to parse argument, which should be an expression */
+
+ /* save the current parser state */
+ char *save_cur_ptr = cur_ptr;
+ char *save_source = source;
+
+ cur_ptr = source = atom->argv[argno];
+ atom->data = parse_expr(0);
+
+ cur_ptr = save_cur_ptr;
+ source = save_source;
+
+ if(atom->data == NULL) {
+ /* parse_expr(0) will have reported the exact syntax error,
+ * but, because we recursively evaluated the expression, it
+ * will have been reported without the context of the stat
+ * test(). So here additionally report our failure to parse
+ * the expression in the stat() test to give context */
+ TEST_SYNTAX_ERROR(test, 0, "Failed to parse expression\n");
+ return 0;
+ }
+
+ return 1;
+}
+
+
+static int parse_expr_arg0(struct test_entry *test, struct atom *atom)
+{
+ return parse_expr_argX(test, atom, 0);
+}
+
+
+static int parse_expr_arg1(struct test_entry *test, struct atom *atom)
+{
+ return parse_expr_argX(test, atom, 1);
+}
+
+
+static int stat_fn(struct atom *atom, struct action_data *action_data)
+{
+ struct stat buf;
+ struct action_data eval_action;
+ int match, res;
+
+ /* evaluate the expression using the context of the inode
+ * pointed to by the symlink. This allows the inode attributes
+ * of the file pointed to by the symlink to be evaluated, rather
+ * than the symlink itself.
+ *
+ * Note, stat() deliberately does not evaluate the pathname, name or
+ * depth of the symlink, these are left with the symlink values.
+ * This allows stat() to be used on any symlink, rather than
+ * just symlinks which are contained (if the symlink is *not*
+ * contained then pathname, name and depth are meaningless as they
+ * are relative to the filesystem being squashed). */
+
+ /* if this isn't a symlink then stat will just return the current
+ * information, i.e. stat(expr) == expr. This is harmless and
+ * is better than returning TRUE or FALSE in a non symlink case */
+ res = stat(action_data->pathname, &buf);
+ if(res == -1) {
+ if(expr_log_cmnd(LOG_ENABLED)) {
+ expr_log(atom->test->name);
+ expr_log("(");
+ expr_log_match(0);
+ expr_log(")");
+ }
+ return 0;
+ }
+
+ /* fill in the inode values of the file pointed to by the
+ * symlink, but, leave everything else the same */
+ memcpy(&eval_action, action_data, sizeof(struct action_data));
+ eval_action.buf = &buf;
+
+ if(expr_log_cmnd(LOG_ENABLED)) {
+ expr_log(atom->test->name);
+ expr_log("(");
+ match = eval_expr_log(atom->data, &eval_action);
+ expr_log(")");
+ } else
+ match = eval_expr(atom->data, &eval_action);
+
+ return match;
+}
+
+
+static int readlink_fn(struct atom *atom, struct action_data *action_data)
+{
+ int match = 0;
+ struct dir_ent *dir_ent;
+ struct action_data eval_action;
+
+ /* Dereference the symlink and evaluate the expression in the
+ * context of the file pointed to by the symlink.
+ * All attributes are updated to refer to the file that is pointed to.
+ * Thus the inode attributes, pathname, name and depth all refer to
+ * the dereferenced file, and not the symlink.
+ *
+ * If the symlink cannot be dereferenced because it doesn't exist in
+ * the output filesystem, or due to some other failure to
+ * walk the pathname (see follow_path above), then FALSE is returned.
+ *
+ * If you wish to evaluate the inode attributes of symlinks which
+ * exist in the source filestem (but not in the output filesystem then
+ * use stat instead (see above).
+ *
+ * readlink operates on symlinks only */
+ if (!file_type_match(action_data->buf->st_mode, ACTION_LNK))
+ goto finish;
+
+ /* dereference the symlink, and get the directory entry it points to */
+ dir_ent = follow_path(action_data->dir_ent->our_dir,
+ action_data->dir_ent->inode->symlink);
+ if(dir_ent == NULL)
+ goto finish;
+
+ eval_action.name = dir_ent->name;
+ eval_action.pathname = strdup(pathname(dir_ent));
+ eval_action.subpath = strdup(subpathname(dir_ent));
+ eval_action.buf = &dir_ent->inode->buf;
+ eval_action.depth = dir_ent->our_dir->depth;
+ eval_action.dir_ent = dir_ent;
+ eval_action.root = action_data->root;
+
+ if(expr_log_cmnd(LOG_ENABLED)) {
+ expr_log(atom->test->name);
+ expr_log("(");
+ match = eval_expr_log(atom->data, &eval_action);
+ expr_log(")");
+ } else
+ match = eval_expr(atom->data, &eval_action);
+
+ free(eval_action.pathname);
+ free(eval_action.subpath);
+
+ return match;
+
+finish:
+ if(expr_log_cmnd(LOG_ENABLED)) {
+ expr_log(atom->test->name);
+ expr_log("(");
+ expr_log_match(0);
+ expr_log(")");
+ }
+
+ return 0;
+}
+
+
+static int eval_fn(struct atom *atom, struct action_data *action_data)
+{
+ int match;
+ char *path = atom->argv[0];
+ struct dir_ent *dir_ent = action_data->dir_ent;
+ struct stat *buf = action_data->buf;
+ struct action_data eval_action;
+
+ /* Follow path (arg1) and evaluate the expression (arg2)
+ * in the context of the file discovered. All attributes are updated
+ * to refer to the file that is pointed to.
+ *
+ * This test operation allows you to add additional context to the
+ * evaluation of the file being scanned, such as "if current file is
+ * XXX and the parent is YYY, then ..." Often times you need or
+ * want to test a combination of file status
+ *
+ * If the file referenced by the path does not exist in
+ * the output filesystem, or some other failure is experienced in
+ * walking the path (see follow_path above), then FALSE is returned.
+ *
+ * If you wish to evaluate the inode attributes of files which
+ * exist in the source filestem (but not in the output filesystem then
+ * use stat instead (see above). */
+
+ /* try to follow path, and get the directory entry it points to */
+ if(path[0] == '/') {
+ /* absolute, walk from root - first skip the leading / */
+ while(path[0] == '/')
+ path ++;
+ if(path[0] == '\0')
+ dir_ent = action_data->root->dir_ent;
+ else
+ dir_ent = follow_path(action_data->root, path);
+ } else {
+ /* relative, if first component is ".." walk from parent,
+ * otherwise walk from dir_ent.
+ * Note: this has to be handled here because follow_path
+ * will quite correctly refuse to execute ".." on anything
+ * which isn't a directory */
+ if(strncmp(path, "..", 2) == 0 && (path[2] == '\0' ||
+ path[2] == '/')) {
+ /* walk from parent */
+ path += 2;
+ while(path[0] == '/')
+ path ++;
+ if(path[0] == '\0')
+ dir_ent = dir_ent->our_dir->dir_ent;
+ else
+ dir_ent = follow_path(dir_ent->our_dir, path);
+ } else if(!file_type_match(buf->st_mode, ACTION_DIR))
+ dir_ent = NULL;
+ else
+ dir_ent = follow_path(dir_ent->dir, path);
+ }
+
+ if(dir_ent == NULL) {
+ if(expr_log_cmnd(LOG_ENABLED)) {
+ expr_log(atom->test->name);
+ expr_log("(");
+ expr_log(atom->argv[0]);
+ expr_log(",");
+ expr_log_match(0);
+ expr_log(")");
+ }
+
+ return 0;
+ }
+
+ eval_action.name = dir_ent->name;
+ eval_action.pathname = strdup(pathname(dir_ent));
+ eval_action.subpath = strdup(subpathname(dir_ent));
+ eval_action.buf = &dir_ent->inode->buf;
+ eval_action.depth = dir_ent->our_dir->depth;
+ eval_action.dir_ent = dir_ent;
+ eval_action.root = action_data->root;
+
+ if(expr_log_cmnd(LOG_ENABLED)) {
+ expr_log(atom->test->name);
+ expr_log("(");
+ expr_log(eval_action.subpath);
+ expr_log(",");
+ match = eval_expr_log(atom->data, &eval_action);
+ expr_log(")");
+ } else
+ match = eval_expr(atom->data, &eval_action);
+
+ free(eval_action.pathname);
+ free(eval_action.subpath);
+
+ return match;
+}
+
+
+/*
+ * Perm specific test code
+ */
+static int parse_perm_args(struct test_entry *test, struct atom *atom)
+{
+ int res = 1, mode, op, i;
+ char *arg;
+ struct mode_data *head = NULL, *cur = NULL;
+ struct perm_data *perm_data;
+
+ if(atom->args == 0) {
+ TEST_SYNTAX_ERROR(test, 0, "One or more arguments expected\n");
+ return 0;
+ }
+
+ switch(atom->argv[0][0]) {
+ case '-':
+ op = PERM_ALL;
+ arg = atom->argv[0] + 1;
+ break;
+ case '/':
+ op = PERM_ANY;
+ arg = atom->argv[0] + 1;
+ break;
+ default:
+ op = PERM_EXACT;
+ arg = atom->argv[0];
+ break;
+ }
+
+ /* try to parse as an octal number */
+ res = parse_octal_mode_args(atom->args, atom->argv, (void **) &head);
+ if(res == -1) {
+ /* parse as sym mode argument */
+ for(i = 0; i < atom->args && res; i++, arg = atom->argv[i])
+ res = parse_sym_mode_arg(arg, &head, &cur);
+ }
+
+ if (res == 0)
+ goto finish;
+
+ /*
+ * Evaluate the symbolic mode against a permission of 0000 octal
+ */
+ mode = mode_execute(head, 0);
+
+ perm_data = malloc(sizeof(struct perm_data));
+ if (perm_data == NULL)
+ MEM_ERROR();
+
+ perm_data->op = op;
+ perm_data->mode = mode;
+
+ atom->data = perm_data;
+
+finish:
+ while(head) {
+ struct mode_data *tmp = head;
+ head = head->next;
+ free(tmp);
+ }
+
+ return res;
+}
+
+
+static int perm_fn(struct atom *atom, struct action_data *action_data)
+{
+ struct perm_data *perm_data = atom->data;
+ struct stat *buf = action_data->buf;
+
+ switch(perm_data->op) {
+ case PERM_EXACT:
+ return (buf->st_mode & ~S_IFMT) == perm_data->mode;
+ case PERM_ALL:
+ return (buf->st_mode & perm_data->mode) == perm_data->mode;
+ case PERM_ANY:
+ default:
+ /*
+ * if no permission bits are set in perm_data->mode match
+ * on any file, this is to be consistent with find, which
+ * does this to be consistent with the behaviour of
+ * -perm -000
+ */
+ return perm_data->mode == 0 || (buf->st_mode & perm_data->mode);
+ }
+}
+
+
+#ifdef SQUASHFS_TRACE
+static void dump_parse_tree(struct expr *expr)
+{
+ int i;
+
+ if(expr->type == ATOM_TYPE) {
+ printf("%s", expr->atom.test->name);
+ if(expr->atom.args) {
+ printf("(");
+ for(i = 0; i < expr->atom.args; i++) {
+ printf("%s", expr->atom.argv[i]);
+ if (i + 1 < expr->atom.args)
+ printf(",");
+ }
+ printf(")");
+ }
+ } else if (expr->type == UNARY_TYPE) {
+ printf("%s", token_table[expr->unary_op.op].string);
+ dump_parse_tree(expr->unary_op.expr);
+ } else {
+ printf("(");
+ dump_parse_tree(expr->expr_op.lhs);
+ printf("%s", token_table[expr->expr_op.op].string);
+ dump_parse_tree(expr->expr_op.rhs);
+ printf(")");
+ }
+}
+
+
+void dump_action_list(struct action *spec_list, int spec_count)
+{
+ int i;
+
+ for (i = 0; i < spec_count; i++) {
+ printf("%s", spec_list[i].action->name);
+ if (spec_list[i].args) {
+ int n;
+
+ printf("(");
+ for (n = 0; n < spec_list[i].args; n++) {
+ printf("%s", spec_list[i].argv[n]);
+ if (n + 1 < spec_list[i].args)
+ printf(",");
+ }
+ printf(")");
+ }
+ printf("=");
+ dump_parse_tree(spec_list[i].expr);
+ printf("\n");
+ }
+}
+
+
+void dump_actions()
+{
+ dump_action_list(exclude_spec, exclude_count);
+ dump_action_list(fragment_spec, fragment_count);
+ dump_action_list(other_spec, other_count);
+ dump_action_list(move_spec, move_count);
+ dump_action_list(empty_spec, empty_count);
+}
+#else
+void dump_actions()
+{
+}
+#endif
+
+
+static struct test_entry test_table[] = {
+ { "name", 1, name_fn, NULL, 1},
+ { "pathname", 1, pathname_fn, check_pathname, 1, 0},
+ { "subpathname", 1, subpathname_fn, check_pathname, 1, 0},
+ { "filesize", 1, filesize_fn, parse_number_arg, 1, 0},
+ { "dirsize", 1, dirsize_fn, parse_number_arg, 1, 0},
+ { "size", 1, size_fn, parse_number_arg, 1, 0},
+ { "inode", 1, inode_fn, parse_number_arg, 1, 0},
+ { "nlink", 1, nlink_fn, parse_number_arg, 1, 0},
+ { "fileblocks", 1, fileblocks_fn, parse_number_arg, 1, 0},
+ { "dirblocks", 1, dirblocks_fn, parse_number_arg, 1, 0},
+ { "blocks", 1, blocks_fn, parse_number_arg, 1, 0},
+ { "gid", 1, gid_fn, parse_gid_arg, 1, 0},
+ { "uid", 1, uid_fn, parse_uid_arg, 1, 0},
+ { "depth", 1, depth_fn, parse_number_arg, 1, 0},
+ { "dircount", 1, dircount_fn, parse_number_arg, 0, 0},
+ { "filesize_range", 2, filesize_range_fn, parse_range_args, 1, 0},
+ { "dirsize_range", 2, dirsize_range_fn, parse_range_args, 1, 0},
+ { "size_range", 2, size_range_fn, parse_range_args, 1, 0},
+ { "inode_range", 2, inode_range_fn, parse_range_args, 1, 0},
+ { "nlink_range", 2, nlink_range_fn, parse_range_args, 1, 0},
+ { "fileblocks_range", 2, fileblocks_range_fn, parse_range_args, 1, 0},
+ { "dirblocks_range", 2, dirblocks_range_fn, parse_range_args, 1, 0},
+ { "blocks_range", 2, blocks_range_fn, parse_range_args, 1, 0},
+ { "gid_range", 2, gid_range_fn, parse_range_args, 1, 0},
+ { "uid_range", 2, uid_range_fn, parse_range_args, 1, 0},
+ { "depth_range", 2, depth_range_fn, parse_range_args, 1, 0},
+ { "dircount_range", 2, dircount_range_fn, parse_range_args, 0, 0},
+ { "type", 1, type_fn, parse_type_arg, 1, 0},
+ { "true", 0, true_fn, NULL, 1, 0},
+ { "false", 0, false_fn, NULL, 1, 0},
+ { "file", 1, file_fn, parse_file_arg, 1, 0},
+ { "exec", 1, exec_fn, NULL, 1, 0},
+ { "exists", 0, exists_fn, NULL, 0, 0},
+ { "absolute", 0, absolute_fn, NULL, 0, 0},
+ { "stat", 1, stat_fn, parse_expr_arg0, 1, 1},
+ { "readlink", 1, readlink_fn, parse_expr_arg0, 0, 1},
+ { "eval", 2, eval_fn, parse_expr_arg1, 0, 1},
+ { "perm", -2, perm_fn, parse_perm_args, 1, 0},
+ { "", -1 }
+};
+
+
+static struct action_entry action_table[] = {
+ { "fragment", FRAGMENT_ACTION, 1, ACTION_REG, NULL, NULL},
+ { "exclude", EXCLUDE_ACTION, 0, ACTION_ALL_LNK, NULL, NULL},
+ { "fragments", FRAGMENTS_ACTION, 0, ACTION_REG, NULL, frag_action},
+ { "no-fragments", NO_FRAGMENTS_ACTION, 0, ACTION_REG, NULL,
+ no_frag_action},
+ { "always-use-fragments", ALWAYS_FRAGS_ACTION, 0, ACTION_REG, NULL,
+ always_frag_action},
+ { "dont-always-use-fragments", NO_ALWAYS_FRAGS_ACTION, 0, ACTION_REG,
+ NULL, no_always_frag_action},
+ { "compressed", COMPRESSED_ACTION, 0, ACTION_REG, NULL, comp_action},
+ { "uncompressed", UNCOMPRESSED_ACTION, 0, ACTION_REG, NULL,
+ uncomp_action},
+ { "uid", UID_ACTION, 1, ACTION_ALL_LNK, parse_uid_args, uid_action},
+ { "gid", GID_ACTION, 1, ACTION_ALL_LNK, parse_gid_args, gid_action},
+ { "guid", GUID_ACTION, 2, ACTION_ALL_LNK, parse_guid_args, guid_action},
+ { "mode", MODE_ACTION, -2, ACTION_ALL, parse_mode_args, mode_action },
+ { "empty", EMPTY_ACTION, -2, ACTION_DIR, parse_empty_args, NULL},
+ { "move", MOVE_ACTION, 1, ACTION_ALL_LNK, NULL, NULL},
+ { "prune", PRUNE_ACTION, 0, ACTION_ALL_LNK, NULL, NULL},
+ { "chmod", MODE_ACTION, -2, ACTION_ALL, parse_mode_args, mode_action },
+ { "noop", NOOP_ACTION, 0, ACTION_ALL, NULL, noop_action },
+ { "", 0, -1, 0, NULL, NULL}
+};
diff --git a/squashfs-tools/squashfs-tools/action.h b/squashfs-tools/squashfs-tools/action.h
new file mode 100644
index 0000000..0a8de7c
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/action.h
@@ -0,0 +1,328 @@
+#ifndef ACTION_H
+#define ACTION_H
+/*
+ * Create a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2011, 2012, 2013, 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * action.h
+ */
+
+/*
+ * Lexical analyser definitions
+ */
+#define TOK_OPEN_BRACKET 0
+#define TOK_CLOSE_BRACKET 1
+#define TOK_AND 2
+#define TOK_OR 3
+#define TOK_NOT 4
+#define TOK_COMMA 5
+#define TOK_AT 6
+#define TOK_WHITE_SPACE 7
+#define TOK_STRING 8
+#define TOK_EOF 9
+
+#define TOK_TO_STR(OP, S) ({ \
+ char *s; \
+ switch(OP) { \
+ case TOK_EOF: \
+ s = "EOF"; \
+ break; \
+ case TOK_STRING: \
+ s = S; \
+ break; \
+ default: \
+ s = token_table[OP].string; \
+ break; \
+ } \
+ s; \
+})
+
+
+struct token_entry {
+ char *string;
+ int token;
+ int size;
+};
+
+/*
+ * Expression parser definitions
+ */
+#define OP_TYPE 0
+#define ATOM_TYPE 1
+#define UNARY_TYPE 2
+
+#define SYNTAX_ERROR(S, ARGS...) { \
+ char *src = strdup(source); \
+ src[cur_ptr - source] = '\0'; \
+ fprintf(stderr, "Failed to parse action \"%s\"\n", source); \
+ fprintf(stderr, "Syntax error: "S, ##ARGS); \
+ fprintf(stderr, "Got here \"%s\"\n", src); \
+ free(src); \
+}
+
+#define TEST_SYNTAX_ERROR(TEST, ARG, S, ARGS...) { \
+ char *src = strdup(source); \
+ src[cur_ptr - source] = '\0'; \
+ fprintf(stderr, "Failed to parse action \"%s\"\n", source); \
+ fprintf(stderr, "Syntax error in \"%s()\", arg %d: "S, TEST->name, \
+ ARG, ##ARGS); \
+ fprintf(stderr, "Got here \"%s\"\n", src); \
+ free(src); \
+}
+
+struct expr;
+
+struct expr_op {
+ struct expr *lhs;
+ struct expr *rhs;
+ int op;
+};
+
+
+struct atom {
+ struct test_entry *test;
+ int args;
+ char **argv;
+ void *data;
+};
+
+
+struct unary_op {
+ struct expr *expr;
+ int op;
+};
+
+
+struct expr {
+ int type;
+ union {
+ struct atom atom;
+ struct expr_op expr_op;
+ struct unary_op unary_op;
+ };
+};
+
+/*
+ * Test operation definitions
+ */
+#define NUM_EQ 1
+#define NUM_LESS 2
+#define NUM_GREATER 3
+
+struct test_number_arg {
+ long long size;
+ int range;
+};
+
+struct test_range_args {
+ long long start;
+ long long end;
+};
+
+struct action;
+struct action_data;
+
+struct test_entry {
+ char *name;
+ int args;
+ int (*fn)(struct atom *, struct action_data *);
+ int (*parse_args)(struct test_entry *, struct atom *);
+ int exclude_ok;
+ int handle_logging;
+};
+
+
+/*
+ * Type test specific definitions
+ */
+struct type_entry {
+ int value;
+ char type;
+};
+
+
+/*
+ * Action definitions
+ */
+#define FRAGMENT_ACTION 0
+#define EXCLUDE_ACTION 1
+#define FRAGMENTS_ACTION 2
+#define NO_FRAGMENTS_ACTION 3
+#define ALWAYS_FRAGS_ACTION 4
+#define NO_ALWAYS_FRAGS_ACTION 5
+#define COMPRESSED_ACTION 6
+#define UNCOMPRESSED_ACTION 7
+#define UID_ACTION 8
+#define GID_ACTION 9
+#define GUID_ACTION 10
+#define MODE_ACTION 11
+#define EMPTY_ACTION 12
+#define MOVE_ACTION 13
+#define PRUNE_ACTION 14
+#define NOOP_ACTION 15
+
+/*
+ * Define what file types each action operates over
+ */
+#define ACTION_DIR 1
+#define ACTION_REG 2
+#define ACTION_ALL_LNK 3
+#define ACTION_ALL 4
+#define ACTION_LNK 5
+
+
+/*
+ * Action logging requested, specified by the various
+ * -action, -true-action, -false-action and -verbose-action
+ * options
+ */
+#define ACTION_LOG_NONE 0
+#define ACTION_LOG_TRUE 1
+#define ACTION_LOG_FALSE 2
+#define ACTION_LOG_VERBOSE ACTION_LOG_TRUE | ACTION_LOG_FALSE
+
+struct action_entry {
+ char *name;
+ int type;
+ int args;
+ int file_types;
+ int (*parse_args)(struct action_entry *, int, char **, void **);
+ void (*run_action)(struct action *, struct dir_ent *);
+};
+
+
+struct action_data {
+ int depth;
+ char *name;
+ char *pathname;
+ char *subpath;
+ struct stat *buf;
+ struct dir_ent *dir_ent;
+ struct dir_info *root;
+};
+
+
+struct action {
+ int type;
+ struct action_entry *action;
+ int args;
+ char **argv;
+ struct expr *expr;
+ void *data;
+ int verbose;
+};
+
+
+/*
+ * Uid/gid action specific definitions
+ */
+struct uid_info {
+ uid_t uid;
+};
+
+struct gid_info {
+ gid_t gid;
+};
+
+struct guid_info {
+ uid_t uid;
+ gid_t gid;
+};
+
+
+/*
+ * Mode action specific definitions
+ */
+#define ACTION_MODE_SET 0
+#define ACTION_MODE_ADD 1
+#define ACTION_MODE_REM 2
+#define ACTION_MODE_OCT 3
+
+struct mode_data {
+ struct mode_data *next;
+ int operation;
+ int mode;
+ unsigned int mask;
+ char X;
+};
+
+
+/*
+ * Empty action specific definitions
+ */
+#define EMPTY_ALL 0
+#define EMPTY_SOURCE 1
+#define EMPTY_EXCLUDED 2
+
+struct empty_data {
+ int val;
+};
+
+
+/*
+ * Move action specific definitions
+ */
+#define ACTION_MOVE_RENAME 1
+#define ACTION_MOVE_MOVE 2
+
+struct move_ent {
+ int ops;
+ struct dir_ent *dir_ent;
+ char *name;
+ struct dir_info *dest;
+ struct move_ent *next;
+};
+
+
+/*
+ * Perm test function specific definitions
+ */
+#define PERM_ALL 1
+#define PERM_ANY 2
+#define PERM_EXACT 3
+
+struct perm_data {
+ int op;
+ int mode;
+};
+
+
+/*
+ * External function definitions
+ */
+extern int parse_action(char *, int verbose);
+extern void dump_actions();
+extern void *eval_frag_actions(struct dir_info *, struct dir_ent *);
+extern void *get_frag_action(void *);
+extern int eval_exclude_actions(char *, char *, char *, struct stat *, int,
+ struct dir_ent *);
+extern void eval_actions(struct dir_info *, struct dir_ent *);
+extern int eval_empty_actions(struct dir_info *, struct dir_ent *dir_ent);
+extern void eval_move_actions(struct dir_info *, struct dir_ent *);
+extern int eval_prune_actions(struct dir_info *, struct dir_ent *);
+extern void do_move_actions();
+extern int read_bytes(int, void *, int);
+extern int actions();
+extern int move_actions();
+extern int empty_actions();
+extern int read_action_file(char *, int);
+extern int exclude_actions();
+extern int prune_actions();
+#endif
diff --git a/squashfs-tools/squashfs-tools/android.c b/squashfs-tools/squashfs-tools/android.c
new file mode 100644
index 0000000..eeef2aa
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/android.c
@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* This file is used to define the properties of the filesystem
+** images generated by build tools (mkbootfs and mkyaffs2image) and
+** by the device side of adb.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+
+#include <selinux/label.h>
+#include <selinux/selinux.h>
+
+#include "android.h"
+#include "private/android_filesystem_config.h"
+#include "private/canned_fs_config.h"
+
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
+
+void alloc_mounted_path(const char *mount_point, const char *subpath, char **mounted_path) {
+ *mounted_path = malloc(strlen(mount_point) + strlen(subpath) + 1);
+ if (*mounted_path == NULL) {
+ perror("Malloc Failure.");
+ exit(EXIT_FAILURE);
+ }
+ strcpy(*mounted_path, mount_point);
+ strcat(*mounted_path, subpath);
+}
+
+void android_fs_config(fs_config_func_t fs_config_func, const char *path, struct stat *stat,
+ const char *target_out_path, uint64_t *capabilities) {
+ // filesystem_config does not preserve file type bits
+ mode_t stat_file_type_mask = stat->st_mode & S_IFMT;
+ if (fs_config_func)
+ fs_config_func(path, S_ISDIR(stat->st_mode), target_out_path,
+ &stat->st_uid, &stat->st_gid, &stat->st_mode, capabilities);
+ stat->st_mode |= stat_file_type_mask;
+}
+
+
+struct selabel_handle *get_sehnd(const char *context_file) {
+ struct selinux_opt seopts[] = {
+ {
+ .type = SELABEL_OPT_PATH,
+ .value = context_file
+ }
+ };
+ struct selabel_handle *sehnd =
+ selabel_open(SELABEL_CTX_FILE, seopts, ARRAY_SIZE(seopts));
+
+ if (!sehnd) {
+ perror("Error running selabel_open.");
+ exit(EXIT_FAILURE);
+ }
+ return sehnd;
+}
+
+
+char *set_selabel(const char *path, unsigned int mode, struct selabel_handle *sehnd) {
+ char *secontext;
+ if (sehnd != NULL) {
+ int full_name_size = strlen(path) + 2;
+ char* full_name = (char*) malloc(full_name_size);
+ if (full_name == NULL) {
+ perror("Malloc Failure.");
+ exit(EXIT_FAILURE);
+ }
+
+ full_name[0] = '/';
+ strncpy(full_name + 1, path, full_name_size - 1);
+
+ if (selabel_lookup(sehnd, &secontext, full_name, mode)) {
+ secontext = strdup("u:object_r:unlabeled:s0");
+ }
+
+ free(full_name);
+ return secontext;
+ }
+ perror("Selabel handle is NULL.");
+ exit(EXIT_FAILURE);
+}
+
+struct vfs_cap_data set_caps(uint64_t capabilities) {
+ struct vfs_cap_data cap_data;
+ memset(&cap_data, 0, sizeof(cap_data));
+
+ if (capabilities == 0)
+ return cap_data;
+
+ cap_data.magic_etc = VFS_CAP_REVISION | VFS_CAP_FLAGS_EFFECTIVE;
+ cap_data.data[0].permitted = (uint32_t) capabilities;
+ cap_data.data[0].inheritable = 0;
+ cap_data.data[1].permitted = (uint32_t) (capabilities >> 32);
+ cap_data.data[1].inheritable = 0;
+
+ return cap_data;
+}
diff --git a/squashfs-tools/squashfs-tools/android.h b/squashfs-tools/squashfs-tools/android.h
new file mode 100644
index 0000000..998f710
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/android.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _ANDROID_H_
+#define _ANDROID_H_
+
+#include <stdint.h>
+typedef void (*fs_config_func_t)(const char *path, int dir, const char *target_out_path,
+ unsigned *uid, unsigned *gid, unsigned *mode, uint64_t *capabilities);
+
+void alloc_mounted_path(const char *mount_point, const char *subpath, char **mounted_path);
+void android_fs_config(fs_config_func_t fs_config_func, const char *path, struct stat *stat, const char *target_out_path, uint64_t *capabilities);
+struct selabel_handle *get_sehnd(const char *context_file);
+char *set_selabel(const char *path, unsigned int mode, struct selabel_handle *sehnd);
+struct vfs_cap_data set_caps(uint64_t capabilities);
+
+#endif
diff --git a/squashfs-tools/squashfs-tools/caches-queues-lists.c b/squashfs-tools/squashfs-tools/caches-queues-lists.c
new file mode 100644
index 0000000..7ad54e8
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/caches-queues-lists.c
@@ -0,0 +1,644 @@
+/*
+ * Create a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2013, 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * caches-queues-lists.c
+ */
+
+#include <pthread.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "error.h"
+#include "caches-queues-lists.h"
+
+extern int add_overflow(int, int);
+extern int multiply_overflow(int, int);
+
+#define TRUE 1
+#define FALSE 0
+
+struct queue *queue_init(int size)
+{
+ struct queue *queue = malloc(sizeof(struct queue));
+
+ if(queue == NULL)
+ MEM_ERROR();
+
+ if(add_overflow(size, 1) ||
+ multiply_overflow(size + 1, sizeof(void *)))
+ BAD_ERROR("Size too large in queue_init\n");
+
+ queue->data = malloc(sizeof(void *) * (size + 1));
+ if(queue->data == NULL)
+ MEM_ERROR();
+
+ queue->size = size + 1;
+ queue->readp = queue->writep = 0;
+ pthread_mutex_init(&queue->mutex, NULL);
+ pthread_cond_init(&queue->empty, NULL);
+ pthread_cond_init(&queue->full, NULL);
+
+ return queue;
+}
+
+
+void queue_put(struct queue *queue, void *data)
+{
+ int nextp;
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &queue->mutex);
+ pthread_mutex_lock(&queue->mutex);
+
+ while((nextp = (queue->writep + 1) % queue->size) == queue->readp)
+ pthread_cond_wait(&queue->full, &queue->mutex);
+
+ queue->data[queue->writep] = data;
+ queue->writep = nextp;
+ pthread_cond_signal(&queue->empty);
+ pthread_cleanup_pop(1);
+}
+
+
+void *queue_get(struct queue *queue)
+{
+ void *data;
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &queue->mutex);
+ pthread_mutex_lock(&queue->mutex);
+
+ while(queue->readp == queue->writep)
+ pthread_cond_wait(&queue->empty, &queue->mutex);
+
+ data = queue->data[queue->readp];
+ queue->readp = (queue->readp + 1) % queue->size;
+ pthread_cond_signal(&queue->full);
+ pthread_cleanup_pop(1);
+
+ return data;
+}
+
+
+int queue_empty(struct queue *queue)
+{
+ int empty;
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &queue->mutex);
+ pthread_mutex_lock(&queue->mutex);
+
+ empty = queue->readp == queue->writep;
+
+ pthread_cleanup_pop(1);
+
+ return empty;
+}
+
+
+void queue_flush(struct queue *queue)
+{
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &queue->mutex);
+ pthread_mutex_lock(&queue->mutex);
+
+ queue->readp = queue->writep;
+
+ pthread_cleanup_pop(1);
+}
+
+
+void dump_queue(struct queue *queue)
+{
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &queue->mutex);
+ pthread_mutex_lock(&queue->mutex);
+
+ printf("\tMax size %d, size %d%s\n", queue->size - 1,
+ queue->readp <= queue->writep ? queue->writep - queue->readp :
+ queue->size - queue->readp + queue->writep,
+ queue->readp == queue->writep ? " (EMPTY)" :
+ ((queue->writep + 1) % queue->size) == queue->readp ?
+ " (FULL)" : "");
+
+ pthread_cleanup_pop(1);
+}
+
+
+/* define seq queue hash tables */
+#define CALCULATE_SEQ_HASH(N) CALCULATE_HASH(N)
+
+/* Called with the seq queue mutex held */
+INSERT_HASH_TABLE(seq, struct seq_queue, CALCULATE_SEQ_HASH, sequence, seq)
+
+/* Called with the cache mutex held */
+REMOVE_HASH_TABLE(seq, struct seq_queue, CALCULATE_SEQ_HASH, sequence, seq);
+
+static unsigned int sequence = 0;
+
+
+struct seq_queue *seq_queue_init()
+{
+ struct seq_queue *queue = malloc(sizeof(struct seq_queue));
+ if(queue == NULL)
+ MEM_ERROR();
+
+ memset(queue, 0, sizeof(struct seq_queue));
+
+ pthread_mutex_init(&queue->mutex, NULL);
+ pthread_cond_init(&queue->wait, NULL);
+
+ return queue;
+}
+
+
+void seq_queue_put(struct seq_queue *queue, struct file_buffer *entry)
+{
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &queue->mutex);
+ pthread_mutex_lock(&queue->mutex);
+
+ insert_seq_hash_table(queue, entry);
+
+ if(entry->fragment)
+ queue->fragment_count ++;
+ else
+ queue->block_count ++;
+
+ if(entry->sequence == sequence)
+ pthread_cond_signal(&queue->wait);
+
+ pthread_cleanup_pop(1);
+}
+
+
+struct file_buffer *seq_queue_get(struct seq_queue *queue)
+{
+ /*
+ * Look-up buffer matching sequence in the queue, if found return
+ * it, otherwise wait until it arrives
+ */
+ int hash = CALCULATE_SEQ_HASH(sequence);
+ struct file_buffer *entry;
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &queue->mutex);
+ pthread_mutex_lock(&queue->mutex);
+
+ while(1) {
+ for(entry = queue->hash_table[hash]; entry;
+ entry = entry->seq_next)
+ if(entry->sequence == sequence)
+ break;
+
+ if(entry) {
+ /*
+ * found the buffer in the queue, decrement the
+ * appropriate count, and remove from hash list
+ */
+ if(entry->fragment)
+ queue->fragment_count --;
+ else
+ queue->block_count --;
+
+ remove_seq_hash_table(queue, entry);
+
+ sequence ++;
+
+ break;
+ }
+
+ /* entry not found, wait for it to arrive */
+ pthread_cond_wait(&queue->wait, &queue->mutex);
+ }
+
+ pthread_cleanup_pop(1);
+
+ return entry;
+}
+
+
+void seq_queue_flush(struct seq_queue *queue)
+{
+ int i;
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &queue->mutex);
+ pthread_mutex_lock(&queue->mutex);
+
+ for(i = 0; i < HASH_SIZE; i++)
+ queue->hash_table[i] = NULL;
+
+ queue->fragment_count = queue->block_count = 0;
+
+ pthread_cleanup_pop(1);
+}
+
+
+void dump_seq_queue(struct seq_queue *queue, int fragment_queue)
+{
+ int size;
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &queue->mutex);
+ pthread_mutex_lock(&queue->mutex);
+
+ size = fragment_queue ? queue->fragment_count : queue->block_count;
+
+ printf("\tMax size unlimited, size %d%s\n", size,
+ size == 0 ? " (EMPTY)" : "");
+
+ pthread_cleanup_pop(1);
+}
+
+
+/* define cache hash tables */
+#define CALCULATE_CACHE_HASH(N) CALCULATE_HASH(llabs(N))
+
+/* Called with the cache mutex held */
+INSERT_HASH_TABLE(cache, struct cache, CALCULATE_CACHE_HASH, index, hash)
+
+/* Called with the cache mutex held */
+REMOVE_HASH_TABLE(cache, struct cache, CALCULATE_CACHE_HASH, index, hash);
+
+/* define cache free list */
+
+/* Called with the cache mutex held */
+INSERT_LIST(free, struct file_buffer)
+
+/* Called with the cache mutex held */
+REMOVE_LIST(free, struct file_buffer)
+
+
+struct cache *cache_init(int buffer_size, int max_buffers, int noshrink_lookup,
+ int first_freelist)
+{
+ struct cache *cache = malloc(sizeof(struct cache));
+
+ if(cache == NULL)
+ MEM_ERROR();
+
+ cache->max_buffers = max_buffers;
+ cache->buffer_size = buffer_size;
+ cache->count = 0;
+ cache->used = 0;
+ cache->free_list = NULL;
+
+ /*
+ * The cache will grow up to max_buffers in size in response to
+ * an increase in readhead/number of buffers in flight. But
+ * once the outstanding buffers gets returned, we can either elect
+ * to shrink the cache, or to put the freed blocks onto a free list.
+ *
+ * For the caches where we want to do lookup (fragment/writer),
+ * a don't shrink policy is best, for the reader cache it
+ * makes no sense to keep buffers around longer than necessary as
+ * we don't do any lookup on those blocks.
+ */
+ cache->noshrink_lookup = noshrink_lookup;
+
+ /*
+ * The default use freelist before growing cache policy behaves
+ * poorly with appending - with many duplicates the caches
+ * do not grow due to the fact that large queues of outstanding
+ * fragments/writer blocks do not occur, leading to small caches
+ * and un-uncessary performance loss to frequent cache
+ * replacement in the small caches. Therefore with appending
+ * change the policy to grow the caches before reusing blocks
+ * from the freelist
+ */
+ cache->first_freelist = first_freelist;
+
+ memset(cache->hash_table, 0, sizeof(struct file_buffer *) * 65536);
+ pthread_mutex_init(&cache->mutex, NULL);
+ pthread_cond_init(&cache->wait_for_free, NULL);
+ pthread_cond_init(&cache->wait_for_unlock, NULL);
+
+ return cache;
+}
+
+
+struct file_buffer *cache_lookup(struct cache *cache, long long index)
+{
+ /* Lookup block in the cache, if found return with usage count
+ * incremented, if not found return NULL */
+ int hash = CALCULATE_CACHE_HASH(index);
+ struct file_buffer *entry;
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &cache->mutex);
+ pthread_mutex_lock(&cache->mutex);
+
+ for(entry = cache->hash_table[hash]; entry; entry = entry->hash_next)
+ if(entry->index == index)
+ break;
+
+ if(entry) {
+ /* found the block in the cache, increment used count and
+ * if necessary remove from free list so it won't disappear
+ */
+ if(entry->used == 0) {
+ remove_free_list(&cache->free_list, entry);
+ cache->used ++;
+ }
+ entry->used ++;
+ }
+
+ pthread_cleanup_pop(1);
+
+ return entry;
+}
+
+
+static struct file_buffer *cache_freelist(struct cache *cache)
+{
+ struct file_buffer *entry = cache->free_list;
+
+ remove_free_list(&cache->free_list, entry);
+
+ /* a block on the free_list is hashed */
+ remove_cache_hash_table(cache, entry);
+
+ cache->used ++;
+ return entry;
+}
+
+
+static struct file_buffer *cache_alloc(struct cache *cache)
+{
+ struct file_buffer *entry = malloc(sizeof(struct file_buffer) +
+ cache->buffer_size);
+ if(entry == NULL)
+ MEM_ERROR();
+
+ entry->cache = cache;
+ entry->free_prev = entry->free_next = NULL;
+ cache->count ++;
+ return entry;
+}
+
+
+static struct file_buffer *_cache_get(struct cache *cache, long long index,
+ int hash)
+{
+ /* Get a free block out of the cache indexed on index. */
+ struct file_buffer *entry = NULL;
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &cache->mutex);
+ pthread_mutex_lock(&cache->mutex);
+
+ while(1) {
+ if(cache->noshrink_lookup) {
+ /* first try to get a block from the free list */
+ if(cache->first_freelist && cache->free_list)
+ entry = cache_freelist(cache);
+ else if(cache->count < cache->max_buffers) {
+ entry = cache_alloc(cache);
+ cache->used ++;
+ } else if(!cache->first_freelist && cache->free_list)
+ entry = cache_freelist(cache);
+ } else { /* shrinking non-lookup cache */
+ if(cache->count < cache->max_buffers) {
+ entry = cache_alloc(cache);
+ if(cache->count > cache->max_count)
+ cache->max_count = cache->count;
+ }
+ }
+
+ if(entry)
+ break;
+
+ /* wait for a block */
+ pthread_cond_wait(&cache->wait_for_free, &cache->mutex);
+ }
+
+ /* initialise block and if hash is set insert into the hash table */
+ entry->used = 1;
+ entry->locked = FALSE;
+ entry->wait_on_unlock = FALSE;
+ entry->error = FALSE;
+ if(hash) {
+ entry->index = index;
+ insert_cache_hash_table(cache, entry);
+ }
+
+ pthread_cleanup_pop(1);
+
+ return entry;
+}
+
+
+struct file_buffer *cache_get(struct cache *cache, long long index)
+{
+ return _cache_get(cache, index, 1);
+}
+
+
+struct file_buffer *cache_get_nohash(struct cache *cache)
+{
+ return _cache_get(cache, 0, 0);
+}
+
+
+void cache_hash(struct file_buffer *entry, long long index)
+{
+ struct cache *cache = entry->cache;
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &cache->mutex);
+ pthread_mutex_lock(&cache->mutex);
+
+ entry->index = index;
+ insert_cache_hash_table(cache, entry);
+
+ pthread_cleanup_pop(1);
+}
+
+
+void cache_block_put(struct file_buffer *entry)
+{
+ struct cache *cache;
+
+ /*
+ * Finished with this cache entry, once the usage count reaches zero it
+ * can be reused.
+ *
+ * If noshrink_lookup is set, put the block onto the free list.
+ * As blocks remain accessible via the hash table they can be found
+ * getting a new lease of life before they are reused.
+ *
+ * if noshrink_lookup is not set then shrink the cache.
+ */
+
+ if(entry == NULL)
+ return;
+
+ cache = entry->cache;
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &cache->mutex);
+ pthread_mutex_lock(&cache->mutex);
+
+ entry->used --;
+ if(entry->used == 0) {
+ if(cache->noshrink_lookup) {
+ insert_free_list(&cache->free_list, entry);
+ cache->used --;
+ } else {
+ free(entry);
+ cache->count --;
+ }
+
+ /* One or more threads may be waiting on this block */
+ pthread_cond_signal(&cache->wait_for_free);
+ }
+
+ pthread_cleanup_pop(1);
+}
+
+
+void dump_cache(struct cache *cache)
+{
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &cache->mutex);
+ pthread_mutex_lock(&cache->mutex);
+
+ if(cache->noshrink_lookup)
+ printf("\tMax buffers %d, Current size %d, Used %d, %s\n",
+ cache->max_buffers, cache->count, cache->used,
+ cache->free_list ? "Free buffers" : "No free buffers");
+ else
+ printf("\tMax buffers %d, Current size %d, Maximum historical "
+ "size %d\n", cache->max_buffers, cache->count,
+ cache->max_count);
+
+ pthread_cleanup_pop(1);
+}
+
+
+struct file_buffer *cache_get_nowait(struct cache *cache, long long index)
+{
+ struct file_buffer *entry = NULL;
+ /*
+ * block doesn't exist, create it, but return it with the
+ * locked flag set, so nothing tries to use it while it doesn't
+ * contain data.
+ *
+ * If there's no space in the cache then return NULL.
+ */
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &cache->mutex);
+ pthread_mutex_lock(&cache->mutex);
+
+ /* first try to get a block from the free list */
+ if(cache->first_freelist && cache->free_list)
+ entry = cache_freelist(cache);
+ else if(cache->count < cache->max_buffers) {
+ entry = cache_alloc(cache);
+ cache->used ++;
+ } else if(!cache->first_freelist && cache->free_list)
+ entry = cache_freelist(cache);
+
+ if(entry) {
+ /* initialise block and insert into the hash table */
+ entry->used = 1;
+ entry->locked = TRUE;
+ entry->wait_on_unlock = FALSE;
+ entry->error = FALSE;
+ entry->index = index;
+ insert_cache_hash_table(cache, entry);
+ }
+
+ pthread_cleanup_pop(1);
+
+ return entry;
+}
+
+
+struct file_buffer *cache_lookup_nowait(struct cache *cache, long long index,
+ char *locked)
+{
+ /*
+ * Lookup block in the cache, if found return it with the locked flag
+ * indicating whether it is currently locked. In both cases increment
+ * the used count.
+ *
+ * If it doesn't exist in the cache return NULL;
+ */
+ int hash = CALCULATE_CACHE_HASH(index);
+ struct file_buffer *entry;
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &cache->mutex);
+ pthread_mutex_lock(&cache->mutex);
+
+ /* first check if the entry already exists */
+ for(entry = cache->hash_table[hash]; entry; entry = entry->hash_next)
+ if(entry->index == index)
+ break;
+
+ if(entry) {
+ if(entry->used == 0) {
+ remove_free_list(&cache->free_list, entry);
+ cache->used ++;
+ }
+ entry->used ++;
+ *locked = entry->locked;
+ }
+
+ pthread_cleanup_pop(1);
+
+ return entry;
+}
+
+
+void cache_wait_unlock(struct file_buffer *buffer)
+{
+ struct cache *cache = buffer->cache;
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &cache->mutex);
+ pthread_mutex_lock(&cache->mutex);
+
+ while(buffer->locked) {
+ /*
+ * another thread is filling this in, wait until it
+ * becomes unlocked. Used has been incremented to ensure it
+ * doesn't get reused. By definition a block can't be
+ * locked and unused, and so we don't need to worry
+ * about it being on the freelist now, but, it may
+ * become unused when unlocked unless used is
+ * incremented
+ */
+ buffer->wait_on_unlock = TRUE;
+ pthread_cond_wait(&cache->wait_for_unlock, &cache->mutex);
+ }
+
+ pthread_cleanup_pop(1);
+}
+
+
+void cache_unlock(struct file_buffer *entry)
+{
+ struct cache *cache = entry->cache;
+
+ /*
+ * Unlock this locked cache entry. If anything is waiting for this
+ * to become unlocked, wake it up.
+ */
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &cache->mutex);
+ pthread_mutex_lock(&cache->mutex);
+
+ entry->locked = FALSE;
+
+ if(entry->wait_on_unlock) {
+ entry->wait_on_unlock = FALSE;
+ pthread_cond_broadcast(&cache->wait_for_unlock);
+ }
+
+ pthread_cleanup_pop(1);
+}
diff --git a/squashfs-tools/squashfs-tools/caches-queues-lists.h b/squashfs-tools/squashfs-tools/caches-queues-lists.h
new file mode 100644
index 0000000..c4dcf28
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/caches-queues-lists.h
@@ -0,0 +1,200 @@
+#ifndef CACHES_QUEUES_LISTS_H
+#define CACHES_QUEUES_LISTS_H
+/*
+ * Create a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2013, 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * caches-queues-lists.h
+ */
+
+#define INSERT_LIST(NAME, TYPE) \
+void insert_##NAME##_list(TYPE **list, TYPE *entry) { \
+ if(*list) { \
+ entry->NAME##_next = *list; \
+ entry->NAME##_prev = (*list)->NAME##_prev; \
+ (*list)->NAME##_prev->NAME##_next = entry; \
+ (*list)->NAME##_prev = entry; \
+ } else { \
+ *list = entry; \
+ entry->NAME##_prev = entry->NAME##_next = entry; \
+ } \
+}
+
+
+#define REMOVE_LIST(NAME, TYPE) \
+void remove_##NAME##_list(TYPE **list, TYPE *entry) { \
+ if(entry->NAME##_prev == entry && entry->NAME##_next == entry) { \
+ /* only this entry in the list */ \
+ *list = NULL; \
+ } else if(entry->NAME##_prev != NULL && entry->NAME##_next != NULL) { \
+ /* more than one entry in the list */ \
+ entry->NAME##_next->NAME##_prev = entry->NAME##_prev; \
+ entry->NAME##_prev->NAME##_next = entry->NAME##_next; \
+ if(*list == entry) \
+ *list = entry->NAME##_next; \
+ } \
+ entry->NAME##_prev = entry->NAME##_next = NULL; \
+}
+
+
+#define INSERT_HASH_TABLE(NAME, TYPE, HASH_FUNCTION, FIELD, LINK) \
+void insert_##NAME##_hash_table(TYPE *container, struct file_buffer *entry) \
+{ \
+ int hash = HASH_FUNCTION(entry->FIELD); \
+\
+ entry->LINK##_next = container->hash_table[hash]; \
+ container->hash_table[hash] = entry; \
+ entry->LINK##_prev = NULL; \
+ if(entry->LINK##_next) \
+ entry->LINK##_next->LINK##_prev = entry; \
+}
+
+
+#define REMOVE_HASH_TABLE(NAME, TYPE, HASH_FUNCTION, FIELD, LINK) \
+void remove_##NAME##_hash_table(TYPE *container, struct file_buffer *entry) \
+{ \
+ if(entry->LINK##_prev) \
+ entry->LINK##_prev->LINK##_next = entry->LINK##_next; \
+ else \
+ container->hash_table[HASH_FUNCTION(entry->FIELD)] = \
+ entry->LINK##_next; \
+ if(entry->LINK##_next) \
+ entry->LINK##_next->LINK##_prev = entry->LINK##_prev; \
+\
+ entry->LINK##_prev = entry->LINK##_next = NULL; \
+}
+
+#define HASH_SIZE 65536
+#define CALCULATE_HASH(n) ((n) & 0xffff)
+
+
+/* struct describing a cache entry passed between threads */
+struct file_buffer {
+ union {
+ long long index;
+ long long sequence;
+ };
+ long long file_size;
+ union {
+ long long block;
+ unsigned short checksum;
+ };
+ struct cache *cache;
+ union {
+ struct file_info *dupl_start;
+ struct file_buffer *hash_next;
+ };
+ union {
+ int duplicate;
+ struct file_buffer *hash_prev;
+ };
+ union {
+ struct {
+ struct file_buffer *free_next;
+ struct file_buffer *free_prev;
+ };
+ struct {
+ struct file_buffer *seq_next;
+ struct file_buffer *seq_prev;
+ };
+ };
+ int size;
+ int c_byte;
+ char used;
+ char fragment;
+ char error;
+ char locked;
+ char wait_on_unlock;
+ char noD;
+ char data[0];
+};
+
+
+/* struct describing queues used to pass data between threads */
+struct queue {
+ int size;
+ int readp;
+ int writep;
+ pthread_mutex_t mutex;
+ pthread_cond_t empty;
+ pthread_cond_t full;
+ void **data;
+};
+
+
+/*
+ * struct describing seq_queues used to pass data between the read
+ * thread and the deflate and main threads
+ */
+struct seq_queue {
+ int fragment_count;
+ int block_count;
+ struct file_buffer *hash_table[HASH_SIZE];
+ pthread_mutex_t mutex;
+ pthread_cond_t wait;
+};
+
+
+/* Cache status struct. Caches are used to keep
+ track of memory buffers passed between different threads */
+struct cache {
+ int max_buffers;
+ int count;
+ int buffer_size;
+ int noshrink_lookup;
+ int first_freelist;
+ union {
+ int used;
+ int max_count;
+ };
+ pthread_mutex_t mutex;
+ pthread_cond_t wait_for_free;
+ pthread_cond_t wait_for_unlock;
+ struct file_buffer *free_list;
+ struct file_buffer *hash_table[HASH_SIZE];
+};
+
+
+extern struct queue *queue_init(int);
+extern void queue_put(struct queue *, void *);
+extern void *queue_get(struct queue *);
+extern int queue_empty(struct queue *);
+extern void queue_flush(struct queue *);
+extern void dump_queue(struct queue *);
+extern struct seq_queue *seq_queue_init();
+extern void seq_queue_put(struct seq_queue *, struct file_buffer *);
+extern void dump_seq_queue(struct seq_queue *, int);
+extern struct file_buffer *seq_queue_get(struct seq_queue *);
+extern void seq_queue_flush(struct seq_queue *);
+extern struct cache *cache_init(int, int, int, int);
+extern struct file_buffer *cache_lookup(struct cache *, long long);
+extern struct file_buffer *cache_get(struct cache *, long long);
+extern struct file_buffer *cache_get_nohash(struct cache *);
+extern void cache_hash(struct file_buffer *, long long);
+extern void cache_block_put(struct file_buffer *);
+extern void dump_cache(struct cache *);
+extern struct file_buffer *cache_get_nowait(struct cache *, long long);
+extern struct file_buffer *cache_lookup_nowait(struct cache *, long long,
+ char *);
+extern void cache_wait_unlock(struct file_buffer *);
+extern void cache_unlock(struct file_buffer *);
+
+extern int first_freelist;
+#endif
diff --git a/squashfs-tools/squashfs-tools/compressor.c b/squashfs-tools/squashfs-tools/compressor.c
new file mode 100644
index 0000000..525e316
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/compressor.c
@@ -0,0 +1,137 @@
+/*
+ *
+ * Copyright (c) 2009, 2010, 2011
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * compressor.c
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include "compressor.h"
+#include "squashfs_fs.h"
+
+#ifndef GZIP_SUPPORT
+static struct compressor gzip_comp_ops = {
+ ZLIB_COMPRESSION, "gzip"
+};
+#else
+extern struct compressor gzip_comp_ops;
+#endif
+
+#ifndef LZMA_SUPPORT
+static struct compressor lzma_comp_ops = {
+ LZMA_COMPRESSION, "lzma"
+};
+#else
+extern struct compressor lzma_comp_ops;
+#endif
+
+#ifndef LZO_SUPPORT
+static struct compressor lzo_comp_ops = {
+ LZO_COMPRESSION, "lzo"
+};
+#else
+extern struct compressor lzo_comp_ops;
+#endif
+
+#ifndef LZ4_SUPPORT
+static struct compressor lz4_comp_ops = {
+ LZ4_COMPRESSION, "lz4"
+};
+#else
+extern struct compressor lz4_comp_ops;
+#endif
+
+#ifndef XZ_SUPPORT
+static struct compressor xz_comp_ops = {
+ XZ_COMPRESSION, "xz"
+};
+#else
+extern struct compressor xz_comp_ops;
+#endif
+
+
+static struct compressor unknown_comp_ops = {
+ 0, "unknown"
+};
+
+
+struct compressor *compressor[] = {
+ &gzip_comp_ops,
+ &lzma_comp_ops,
+ &lzo_comp_ops,
+ &lz4_comp_ops,
+ &xz_comp_ops,
+ &unknown_comp_ops
+};
+
+
+struct compressor *lookup_compressor(char *name)
+{
+ int i;
+
+ for(i = 0; compressor[i]->id; i++)
+ if(strcmp(compressor[i]->name, name) == 0)
+ break;
+
+ return compressor[i];
+}
+
+
+struct compressor *lookup_compressor_id(int id)
+{
+ int i;
+
+ for(i = 0; compressor[i]->id; i++)
+ if(id == compressor[i]->id)
+ break;
+
+ return compressor[i];
+}
+
+
+void display_compressors(char *indent, char *def_comp)
+{
+ int i;
+
+ for(i = 0; compressor[i]->id; i++)
+ if(compressor[i]->supported)
+ fprintf(stderr, "%s\t%s%s\n", indent,
+ compressor[i]->name,
+ strcmp(compressor[i]->name, def_comp) == 0 ?
+ " (default)" : "");
+}
+
+
+void display_compressor_usage(char *def_comp)
+{
+ int i;
+
+ for(i = 0; compressor[i]->id; i++)
+ if(compressor[i]->supported) {
+ char *str = strcmp(compressor[i]->name, def_comp) == 0 ?
+ " (default)" : "";
+ if(compressor[i]->usage) {
+ fprintf(stderr, "\t%s%s\n",
+ compressor[i]->name, str);
+ compressor[i]->usage();
+ } else
+ fprintf(stderr, "\t%s (no options)%s\n",
+ compressor[i]->name, str);
+ }
+}
diff --git a/squashfs-tools/squashfs-tools/compressor.h b/squashfs-tools/squashfs-tools/compressor.h
new file mode 100644
index 0000000..4679d91
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/compressor.h
@@ -0,0 +1,124 @@
+#ifndef COMPRESSOR_H
+#define COMPRESSOR_H
+/*
+ *
+ * Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * compressor.h
+ */
+
+struct compressor {
+ int id;
+ char *name;
+ int supported;
+ int (*init)(void **, int, int);
+ int (*compress)(void *, void *, void *, int, int, int *);
+ int (*uncompress)(void *, void *, int, int, int *);
+ int (*options)(char **, int);
+ int (*options_post)(int);
+ void *(*dump_options)(int, int *);
+ int (*extract_options)(int, void *, int);
+ int (*check_options)(int, void *, int);
+ void (*display_options)(void *, int);
+ void (*usage)();
+};
+
+extern struct compressor *lookup_compressor(char *);
+extern struct compressor *lookup_compressor_id(int);
+extern void display_compressors(char *, char *);
+extern void display_compressor_usage(char *);
+
+static inline int compressor_init(struct compressor *comp, void **stream,
+ int block_size, int datablock)
+{
+ if(comp->init == NULL)
+ return 0;
+ return comp->init(stream, block_size, datablock);
+}
+
+
+static inline int compressor_compress(struct compressor *comp, void *strm,
+ void *dest, void *src, int size, int block_size, int *error)
+{
+ return comp->compress(strm, dest, src, size, block_size, error);
+}
+
+
+static inline int compressor_uncompress(struct compressor *comp, void *dest,
+ void *src, int size, int block_size, int *error)
+{
+ return comp->uncompress(dest, src, size, block_size, error);
+}
+
+
+/*
+ * For the following functions please see the lzo, lz4 or xz
+ * compressors for commented examples of how they are used.
+ */
+static inline int compressor_options(struct compressor *comp, char *argv[],
+ int argc)
+{
+ if(comp->options == NULL)
+ return -1;
+
+ return comp->options(argv, argc);
+}
+
+
+static inline int compressor_options_post(struct compressor *comp, int block_size)
+{
+ if(comp->options_post == NULL)
+ return 0;
+ return comp->options_post(block_size);
+}
+
+
+static inline void *compressor_dump_options(struct compressor *comp,
+ int block_size, int *size)
+{
+ if(comp->dump_options == NULL)
+ return NULL;
+ return comp->dump_options(block_size, size);
+}
+
+
+static inline int compressor_extract_options(struct compressor *comp,
+ int block_size, void *buffer, int size)
+{
+ if(comp->extract_options == NULL)
+ return size ? -1 : 0;
+ return comp->extract_options(block_size, buffer, size);
+}
+
+
+static inline int compressor_check_options(struct compressor *comp,
+ int block_size, void *buffer, int size)
+{
+ if(comp->check_options == NULL)
+ return 0;
+ return comp->check_options(block_size, buffer, size);
+}
+
+
+static inline void compressor_display_options(struct compressor *comp,
+ void *buffer, int size)
+{
+ if(comp->display_options != NULL)
+ comp->display_options(buffer, size);
+}
+#endif
diff --git a/squashfs-tools/squashfs-tools/error.h b/squashfs-tools/squashfs-tools/error.h
new file mode 100644
index 0000000..358ad68
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/error.h
@@ -0,0 +1,90 @@
+#ifndef ERROR_H
+#define ERROR_H
+/*
+ * Create a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2012, 2013, 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * error.h
+ */
+
+extern int exit_on_error;
+
+extern void prep_exit();
+extern void progressbar_error(char *fmt, ...);
+extern void progressbar_info(char *fmt, ...);
+
+#ifdef SQUASHFS_TRACE
+#define TRACE(s, args...) \
+ do { \
+ progressbar_info("squashfs: "s, ## args);\
+ } while(0)
+#else
+#define TRACE(s, args...)
+#endif
+
+#define INFO(s, args...) \
+ do {\
+ if(!silent)\
+ progressbar_info(s, ## args);\
+ } while(0)
+
+#define ERROR(s, args...) \
+ do {\
+ progressbar_error(s, ## args); \
+ } while(0)
+
+#define ERROR_START(s, args...) \
+ do { \
+ disable_progress_bar(); \
+ fprintf(stderr, s, ## args); \
+ } while(0)
+
+#define ERROR_EXIT(s, args...) \
+ do {\
+ if (exit_on_error) { \
+ fprintf(stderr, "\n"); \
+ EXIT_MKSQUASHFS(); \
+ } else { \
+ fprintf(stderr, s, ## args); \
+ enable_progress_bar(); \
+ } \
+ } while(0)
+
+#define EXIT_MKSQUASHFS() \
+ do {\
+ prep_exit();\
+ exit(1);\
+ } while(0)
+
+#define BAD_ERROR(s, args...) \
+ do {\
+ progressbar_error("FATAL ERROR:" s, ##args); \
+ EXIT_MKSQUASHFS();\
+ } while(0)
+
+#define EXIT_UNSQUASH(s, args...) BAD_ERROR(s, ##args)
+
+#define MEM_ERROR() \
+ do {\
+ progressbar_error("FATAL ERROR: Out of memory (%s)\n", \
+ __func__); \
+ EXIT_MKSQUASHFS();\
+ } while(0)
+#endif
diff --git a/squashfs-tools/squashfs-tools/gzip_wrapper.c b/squashfs-tools/squashfs-tools/gzip_wrapper.c
new file mode 100644
index 0000000..076a587
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/gzip_wrapper.c
@@ -0,0 +1,500 @@
+/*
+ * Copyright (c) 2009, 2010, 2013, 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * gzip_wrapper.c
+ *
+ * Support for ZLIB compression http://www.zlib.net
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <zlib.h>
+
+#include "squashfs_fs.h"
+#include "gzip_wrapper.h"
+#include "compressor.h"
+
+static struct strategy strategy[] = {
+ { "default", Z_DEFAULT_STRATEGY, 0 },
+ { "filtered", Z_FILTERED, 0 },
+ { "huffman_only", Z_HUFFMAN_ONLY, 0 },
+ { "run_length_encoded", Z_RLE, 0 },
+ { "fixed", Z_FIXED, 0 },
+ { NULL, 0, 0 }
+};
+
+static int strategy_count = 0;
+
+/* default compression level */
+static int compression_level = GZIP_DEFAULT_COMPRESSION_LEVEL;
+
+/* default window size */
+static int window_size = GZIP_DEFAULT_WINDOW_SIZE;
+
+/*
+ * This function is called by the options parsing code in mksquashfs.c
+ * to parse any -X compressor option.
+ *
+ * This function returns:
+ * >=0 (number of additional args parsed) on success
+ * -1 if the option was unrecognised, or
+ * -2 if the option was recognised, but otherwise bad in
+ * some way (e.g. invalid parameter)
+ *
+ * Note: this function sets internal compressor state, but does not
+ * pass back the results of the parsing other than success/failure.
+ * The gzip_dump_options() function is called later to get the options in
+ * a format suitable for writing to the filesystem.
+ */
+static int gzip_options(char *argv[], int argc)
+{
+ if(strcmp(argv[0], "-Xcompression-level") == 0) {
+ if(argc < 2) {
+ fprintf(stderr, "gzip: -Xcompression-level missing "
+ "compression level\n");
+ fprintf(stderr, "gzip: -Xcompression-level it "
+ "should be 1 >= n <= 9\n");
+ goto failed;
+ }
+
+ compression_level = atoi(argv[1]);
+ if(compression_level < 1 || compression_level > 9) {
+ fprintf(stderr, "gzip: -Xcompression-level invalid, it "
+ "should be 1 >= n <= 9\n");
+ goto failed;
+ }
+
+ return 1;
+ } else if(strcmp(argv[0], "-Xwindow-size") == 0) {
+ if(argc < 2) {
+ fprintf(stderr, "gzip: -Xwindow-size missing window "
+ " size\n");
+ fprintf(stderr, "gzip: -Xwindow-size <window-size>\n");
+ goto failed;
+ }
+
+ window_size = atoi(argv[1]);
+ if(window_size < 8 || window_size > 15) {
+ fprintf(stderr, "gzip: -Xwindow-size invalid, it "
+ "should be 8 >= n <= 15\n");
+ goto failed;
+ }
+
+ return 1;
+ } else if(strcmp(argv[0], "-Xstrategy") == 0) {
+ char *name;
+ int i;
+
+ if(argc < 2) {
+ fprintf(stderr, "gzip: -Xstrategy missing "
+ "strategies\n");
+ goto failed;
+ }
+
+ name = argv[1];
+ while(name[0] != '\0') {
+ for(i = 0; strategy[i].name; i++) {
+ int n = strlen(strategy[i].name);
+ if((strncmp(name, strategy[i].name, n) == 0) &&
+ (name[n] == '\0' ||
+ name[n] == ',')) {
+ if(strategy[i].selected == 0) {
+ strategy[i].selected = 1;
+ strategy_count++;
+ }
+ name += name[n] == ',' ? n + 1 : n;
+ break;
+ }
+ }
+ if(strategy[i].name == NULL) {
+ fprintf(stderr, "gzip: -Xstrategy unrecognised "
+ "strategy\n");
+ goto failed;
+ }
+ }
+
+ return 1;
+ }
+
+ return -1;
+
+failed:
+ return -2;
+}
+
+
+/*
+ * This function is called after all options have been parsed.
+ * It is used to do post-processing on the compressor options using
+ * values that were not expected to be known at option parse time.
+ *
+ * This function returns 0 on successful post processing, or
+ * -1 on error
+ */
+static int gzip_options_post(int block_size)
+{
+ if(strategy_count == 1 && strategy[0].selected) {
+ strategy_count = 0;
+ strategy[0].selected = 0;
+ }
+
+ return 0;
+}
+
+
+/*
+ * This function is called by mksquashfs to dump the parsed
+ * compressor options in a format suitable for writing to the
+ * compressor options field in the filesystem (stored immediately
+ * after the superblock).
+ *
+ * This function returns a pointer to the compression options structure
+ * to be stored (and the size), or NULL if there are no compression
+ * options
+ *
+ */
+static void *gzip_dump_options(int block_size, int *size)
+{
+ static struct gzip_comp_opts comp_opts;
+ int i, strategies = 0;
+
+ /*
+ * If default compression options of:
+ * compression-level: 8 and
+ * window-size: 15 and
+ * strategy_count == 0 then
+ * don't store a compression options structure (this is compatible
+ * with the legacy implementation of GZIP for Squashfs)
+ */
+ if(compression_level == GZIP_DEFAULT_COMPRESSION_LEVEL &&
+ window_size == GZIP_DEFAULT_WINDOW_SIZE &&
+ strategy_count == 0)
+ return NULL;
+
+ for(i = 0; strategy[i].name; i++)
+ strategies |= strategy[i].selected << i;
+
+ comp_opts.compression_level = compression_level;
+ comp_opts.window_size = window_size;
+ comp_opts.strategy = strategies;
+
+ SQUASHFS_INSWAP_COMP_OPTS(&comp_opts);
+
+ *size = sizeof(comp_opts);
+ return &comp_opts;
+}
+
+
+/*
+ * This function is a helper specifically for the append mode of
+ * mksquashfs. Its purpose is to set the internal compressor state
+ * to the stored compressor options in the passed compressor options
+ * structure.
+ *
+ * In effect this function sets up the compressor options
+ * to the same state they were when the filesystem was originally
+ * generated, this is to ensure on appending, the compressor uses
+ * the same compression options that were used to generate the
+ * original filesystem.
+ *
+ * Note, even if there are no compressor options, this function is still
+ * called with an empty compressor structure (size == 0), to explicitly
+ * set the default options, this is to ensure any user supplied
+ * -X options on the appending mksquashfs command line are over-ridden
+ *
+ * This function returns 0 on sucessful extraction of options, and
+ * -1 on error
+ */
+static int gzip_extract_options(int block_size, void *buffer, int size)
+{
+ struct gzip_comp_opts *comp_opts = buffer;
+ int i;
+
+ if(size == 0) {
+ /* Set default values */
+ compression_level = GZIP_DEFAULT_COMPRESSION_LEVEL;
+ window_size = GZIP_DEFAULT_WINDOW_SIZE;
+ strategy_count = 0;
+ return 0;
+ }
+
+ /* we expect a comp_opts structure of sufficient size to be present */
+ if(size < sizeof(*comp_opts))
+ goto failed;
+
+ SQUASHFS_INSWAP_COMP_OPTS(comp_opts);
+
+ /* Check comp_opts structure for correctness */
+ if(comp_opts->compression_level < 1 ||
+ comp_opts->compression_level > 9) {
+ fprintf(stderr, "gzip: bad compression level in "
+ "compression options structure\n");
+ goto failed;
+ }
+ compression_level = comp_opts->compression_level;
+
+ if(comp_opts->window_size < 8 ||
+ comp_opts->window_size > 15) {
+ fprintf(stderr, "gzip: bad window size in "
+ "compression options structure\n");
+ goto failed;
+ }
+ window_size = comp_opts->window_size;
+
+ strategy_count = 0;
+ for(i = 0; strategy[i].name; i++) {
+ if((comp_opts->strategy >> i) & 1) {
+ strategy[i].selected = 1;
+ strategy_count ++;
+ } else
+ strategy[i].selected = 0;
+ }
+
+ return 0;
+
+failed:
+ fprintf(stderr, "gzip: error reading stored compressor options from "
+ "filesystem!\n");
+
+ return -1;
+}
+
+
+void gzip_display_options(void *buffer, int size)
+{
+ struct gzip_comp_opts *comp_opts = buffer;
+ int i, printed;
+
+ /* we expect a comp_opts structure of sufficient size to be present */
+ if(size < sizeof(*comp_opts))
+ goto failed;
+
+ SQUASHFS_INSWAP_COMP_OPTS(comp_opts);
+
+ /* Check comp_opts structure for correctness */
+ if(comp_opts->compression_level < 1 ||
+ comp_opts->compression_level > 9) {
+ fprintf(stderr, "gzip: bad compression level in "
+ "compression options structure\n");
+ goto failed;
+ }
+ printf("\tcompression-level %d\n", comp_opts->compression_level);
+
+ if(comp_opts->window_size < 8 ||
+ comp_opts->window_size > 15) {
+ fprintf(stderr, "gzip: bad window size in "
+ "compression options structure\n");
+ goto failed;
+ }
+ printf("\twindow-size %d\n", comp_opts->window_size);
+
+ for(i = 0, printed = 0; strategy[i].name; i++) {
+ if((comp_opts->strategy >> i) & 1) {
+ if(printed)
+ printf(", ");
+ else
+ printf("\tStrategies selected: ");
+ printf("%s", strategy[i].name);
+ printed = 1;
+ }
+ }
+
+ if(!printed)
+ printf("\tStrategies selected: default\n");
+ else
+ printf("\n");
+
+ return;
+
+failed:
+ fprintf(stderr, "gzip: error reading stored compressor options from "
+ "filesystem!\n");
+}
+
+
+/*
+ * This function is called by mksquashfs to initialise the
+ * compressor, before compress() is called.
+ *
+ * This function returns 0 on success, and
+ * -1 on error
+ */
+static int gzip_init(void **strm, int block_size, int datablock)
+{
+ int i, j, res;
+ struct gzip_stream *stream;
+
+ if(!datablock || !strategy_count) {
+ stream = malloc(sizeof(*stream) + sizeof(struct gzip_strategy));
+ if(stream == NULL)
+ goto failed;
+
+ stream->strategies = 1;
+ stream->strategy[0].strategy = Z_DEFAULT_STRATEGY;
+ } else {
+ stream = malloc(sizeof(*stream) +
+ sizeof(struct gzip_strategy) * strategy_count);
+ if(stream == NULL)
+ goto failed;
+
+ memset(stream->strategy, 0, sizeof(struct gzip_strategy) *
+ strategy_count);
+
+ stream->strategies = strategy_count;
+
+ for(i = 0, j = 0; strategy[i].name; i++) {
+ if(!strategy[i].selected)
+ continue;
+
+ stream->strategy[j].strategy = strategy[i].strategy;
+ if(j) {
+ stream->strategy[j].buffer = malloc(block_size);
+ if(stream->strategy[j].buffer == NULL)
+ goto failed2;
+ }
+ j++;
+ }
+ }
+
+ stream->stream.zalloc = Z_NULL;
+ stream->stream.zfree = Z_NULL;
+ stream->stream.opaque = 0;
+
+ res = deflateInit2(&stream->stream, compression_level, Z_DEFLATED,
+ window_size, 8, stream->strategy[0].strategy);
+ if(res != Z_OK)
+ goto failed2;
+
+ *strm = stream;
+ return 0;
+
+failed2:
+ for(i = 1; i < stream->strategies; i++)
+ free(stream->strategy[i].buffer);
+ free(stream);
+failed:
+ return -1;
+}
+
+
+static int gzip_compress(void *strm, void *d, void *s, int size, int block_size,
+ int *error)
+{
+ int i, res;
+ struct gzip_stream *stream = strm;
+ struct gzip_strategy *selected = NULL;
+
+ stream->strategy[0].buffer = d;
+
+ for(i = 0; i < stream->strategies; i++) {
+ struct gzip_strategy *strategy = &stream->strategy[i];
+
+ res = deflateReset(&stream->stream);
+ if(res != Z_OK)
+ goto failed;
+
+ stream->stream.next_in = s;
+ stream->stream.avail_in = size;
+ stream->stream.next_out = strategy->buffer;
+ stream->stream.avail_out = block_size;
+
+ if(stream->strategies > 1) {
+ res = deflateParams(&stream->stream,
+ compression_level, strategy->strategy);
+ if(res != Z_OK)
+ goto failed;
+ }
+
+ res = deflate(&stream->stream, Z_FINISH);
+ strategy->length = stream->stream.total_out;
+ if(res == Z_STREAM_END) {
+ if(!selected || selected->length > strategy->length)
+ selected = strategy;
+ } else if(res != Z_OK)
+ goto failed;
+ }
+
+ if(!selected)
+ /*
+ * Output buffer overflow. Return out of buffer space
+ */
+ return 0;
+
+ if(selected->buffer != d)
+ memcpy(d, selected->buffer, selected->length);
+
+ return (int) selected->length;
+
+failed:
+ /*
+ * All other errors return failure, with the compressor
+ * specific error code in *error
+ */
+ *error = res;
+ return -1;
+}
+
+
+static int gzip_uncompress(void *d, void *s, int size, int outsize, int *error)
+{
+ int res;
+ unsigned long bytes = outsize;
+
+ res = uncompress(d, &bytes, s, size);
+
+ if(res == Z_OK)
+ return (int) bytes;
+ else {
+ *error = res;
+ return -1;
+ }
+}
+
+
+void gzip_usage()
+{
+ fprintf(stderr, "\t -Xcompression-level <compression-level>\n");
+ fprintf(stderr, "\t\t<compression-level> should be 1 .. 9 (default "
+ "%d)\n", GZIP_DEFAULT_COMPRESSION_LEVEL);
+ fprintf(stderr, "\t -Xwindow-size <window-size>\n");
+ fprintf(stderr, "\t\t<window-size> should be 8 .. 15 (default "
+ "%d)\n", GZIP_DEFAULT_WINDOW_SIZE);
+ fprintf(stderr, "\t -Xstrategy strategy1,strategy2,...,strategyN\n");
+ fprintf(stderr, "\t\tCompress using strategy1,strategy2,...,strategyN"
+ " in turn\n");
+ fprintf(stderr, "\t\tand choose the best compression.\n");
+ fprintf(stderr, "\t\tAvailable strategies: default, filtered, "
+ "huffman_only,\n\t\trun_length_encoded and fixed\n");
+}
+
+
+struct compressor gzip_comp_ops = {
+ .init = gzip_init,
+ .compress = gzip_compress,
+ .uncompress = gzip_uncompress,
+ .options = gzip_options,
+ .options_post = gzip_options_post,
+ .dump_options = gzip_dump_options,
+ .extract_options = gzip_extract_options,
+ .display_options = gzip_display_options,
+ .usage = gzip_usage,
+ .id = ZLIB_COMPRESSION,
+ .name = "gzip",
+ .supported = 1
+};
diff --git a/squashfs-tools/squashfs-tools/gzip_wrapper.h b/squashfs-tools/squashfs-tools/gzip_wrapper.h
new file mode 100644
index 0000000..463e9f4
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/gzip_wrapper.h
@@ -0,0 +1,75 @@
+#ifndef GZIP_WRAPPER_H
+#define GZIP_WRAPPER_H
+/*
+ * Squashfs
+ *
+ * Copyright (c) 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * gzip_wrapper.h
+ *
+ */
+
+#ifndef linux
+#define __BYTE_ORDER BYTE_ORDER
+#define __BIG_ENDIAN BIG_ENDIAN
+#define __LITTLE_ENDIAN LITTLE_ENDIAN
+#else
+#include <endian.h>
+#endif
+
+#if __BYTE_ORDER == __BIG_ENDIAN
+extern unsigned int inswap_le16(unsigned short);
+extern unsigned int inswap_le32(unsigned int);
+
+#define SQUASHFS_INSWAP_COMP_OPTS(s) { \
+ (s)->compression_level = inswap_le32((s)->compression_level); \
+ (s)->window_size = inswap_le16((s)->window_size); \
+ (s)->strategy = inswap_le16((s)->strategy); \
+}
+#else
+#define SQUASHFS_INSWAP_COMP_OPTS(s)
+#endif
+
+/* Default compression */
+#define GZIP_DEFAULT_COMPRESSION_LEVEL 9
+#define GZIP_DEFAULT_WINDOW_SIZE 15
+
+struct gzip_comp_opts {
+ int compression_level;
+ short window_size;
+ short strategy;
+};
+
+struct strategy {
+ char *name;
+ int strategy;
+ int selected;
+};
+
+struct gzip_strategy {
+ int strategy;
+ int length;
+ void *buffer;
+};
+
+struct gzip_stream {
+ z_stream stream;
+ int strategies;
+ struct gzip_strategy strategy[0];
+};
+#endif
diff --git a/squashfs-tools/squashfs-tools/info.c b/squashfs-tools/squashfs-tools/info.c
new file mode 100644
index 0000000..60a3f5a
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/info.c
@@ -0,0 +1,176 @@
+/*
+ * Create a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2013, 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * info.c
+ */
+
+#include <pthread.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <signal.h>
+#include <sys/time.h>
+#include <stdio.h>
+#include <math.h>
+#include <stdarg.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <dirent.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <string.h>
+
+#include "squashfs_fs.h"
+#include "mksquashfs.h"
+#include "error.h"
+#include "progressbar.h"
+#include "caches-queues-lists.h"
+
+static int silent = 0;
+static struct dir_ent *ent = NULL;
+
+pthread_t info_thread;
+
+
+void disable_info()
+{
+ ent = NULL;
+}
+
+
+void update_info(struct dir_ent *dir_ent)
+{
+ ent = dir_ent;
+}
+
+
+void print_filename()
+{
+ struct dir_ent *dir_ent = ent;
+
+ if(dir_ent == NULL)
+ return;
+
+ if(dir_ent->our_dir->subpath[0] != '\0')
+ INFO("%s/%s\n", dir_ent->our_dir->subpath, dir_ent->name);
+ else
+ INFO("/%s\n", dir_ent->name);
+}
+
+
+void dump_state()
+{
+ disable_progress_bar();
+
+ printf("Queue and Cache status dump\n");
+ printf("===========================\n");
+
+ printf("file buffer queue (reader thread -> deflate thread(s))\n");
+ dump_queue(to_deflate);
+
+ printf("uncompressed fragment queue (reader thread -> fragment"
+ " thread(s))\n");
+ dump_queue(to_process_frag);
+
+ printf("processed fragment queue (fragment thread(s) -> main"
+ " thread)\n");
+ dump_seq_queue(to_main, 1);
+
+ printf("compressed block queue (deflate thread(s) -> main thread)\n");
+ dump_seq_queue(to_main, 0);
+
+ printf("uncompressed packed fragment queue (main thread -> fragment"
+ " deflate thread(s))\n");
+ dump_queue(to_frag);
+
+
+ printf("locked frag queue (compressed frags waiting while multi-block"
+ " file is written)\n");
+ dump_queue(locked_fragment);
+
+ printf("compressed block queue (main & fragment deflate threads(s) ->"
+ " writer thread)\n");
+ dump_queue(to_writer);
+
+ printf("read cache (uncompressed blocks read by reader thread)\n");
+ dump_cache(reader_buffer);
+
+ printf("block write cache (compressed blocks waiting for the writer"
+ " thread)\n");
+ dump_cache(bwriter_buffer);
+ printf("fragment write cache (compressed fragments waiting for the"
+ " writer thread)\n");
+ dump_cache(fwriter_buffer);
+
+ printf("fragment cache (frags waiting to be compressed by fragment"
+ " deflate thread(s))\n");
+ dump_cache(fragment_buffer);
+
+ printf("fragment reserve cache (avoids pipeline stall if frag cache"
+ " full in dup check)\n");
+ dump_cache(reserve_cache);
+
+ enable_progress_bar();
+}
+
+
+void *info_thrd(void *arg)
+{
+ sigset_t sigmask;
+ int sig, err, waiting = 0;
+
+ sigemptyset(&sigmask);
+ sigaddset(&sigmask, SIGQUIT);
+ sigaddset(&sigmask, SIGHUP);
+ sigaddset(&sigmask, SIGALRM);
+
+ while(1) {
+ err = sigwait(&sigmask, &sig);
+
+ if(err == -1) {
+ switch(errno) {
+ case EINTR:
+ continue;
+ default:
+ BAD_ERROR("sigwait failed "
+ "because %s\n", strerror(errno));
+ }
+ }
+
+ if(sig == SIGQUIT && !waiting) {
+ print_filename();
+
+ /* set one second interval period, if ^\ received
+ within then, dump queue and cache status */
+ waiting = 1;
+ alarm(1);
+ } else if (sig == SIGQUIT) {
+ dump_state();
+ } else if (sig == SIGALRM) {
+ waiting = 0;
+ }
+ }
+}
+
+
+void init_info()
+{
+ pthread_create(&info_thread, NULL, info_thrd, NULL);
+}
diff --git a/squashfs-tools/squashfs-tools/info.h b/squashfs-tools/squashfs-tools/info.h
new file mode 100644
index 0000000..bcf03a2
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/info.h
@@ -0,0 +1,30 @@
+#ifndef INFO_H
+#define INFO_H
+/*
+ * Create a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2013, 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * info.h
+ */
+
+extern void disable_info();
+extern void update_info(struct dir_ent *);
+extern void init_info();
+#endif
diff --git a/squashfs-tools/squashfs-tools/lz4_wrapper.c b/squashfs-tools/squashfs-tools/lz4_wrapper.c
new file mode 100644
index 0000000..b87cfe0
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/lz4_wrapper.c
@@ -0,0 +1,283 @@
+/*
+ * Copyright (c) 2013
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * lz4_wrapper.c
+ *
+ * Support for LZ4 compression http://fastcompression.blogspot.com/p/lz4.html
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <lz4.h>
+#include <lz4hc.h>
+
+#include "squashfs_fs.h"
+#include "lz4_wrapper.h"
+#include "compressor.h"
+
+static int hc = 0;
+
+/*
+ * This function is called by the options parsing code in mksquashfs.c
+ * to parse any -X compressor option.
+ *
+ * This function returns:
+ * >=0 (number of additional args parsed) on success
+ * -1 if the option was unrecognised, or
+ * -2 if the option was recognised, but otherwise bad in
+ * some way (e.g. invalid parameter)
+ *
+ * Note: this function sets internal compressor state, but does not
+ * pass back the results of the parsing other than success/failure.
+ * The lz4_dump_options() function is called later to get the options in
+ * a format suitable for writing to the filesystem.
+ */
+static int lz4_options(char *argv[], int argc)
+{
+ if(strcmp(argv[0], "-Xhc") == 0) {
+ hc = 1;
+ return 0;
+ }
+
+ return -1;
+}
+
+
+/*
+ * This function is called by mksquashfs to dump the parsed
+ * compressor options in a format suitable for writing to the
+ * compressor options field in the filesystem (stored immediately
+ * after the superblock).
+ *
+ * This function returns a pointer to the compression options structure
+ * to be stored (and the size), or NULL if there are no compression
+ * options
+ *
+ * Currently LZ4 always returns a comp_opts structure, with
+ * the version indicating LZ4_LEGACY stream fomat. This is to
+ * easily accomodate changes in the kernel code to different
+ * stream formats
+ */
+static void *lz4_dump_options(int block_size, int *size)
+{
+ static struct lz4_comp_opts comp_opts;
+
+ comp_opts.version = LZ4_LEGACY;
+ comp_opts.flags = hc ? LZ4_HC : 0;
+ SQUASHFS_INSWAP_COMP_OPTS(&comp_opts);
+
+ *size = sizeof(comp_opts);
+ return &comp_opts;
+}
+
+
+/*
+ * This function is a helper specifically for the append mode of
+ * mksquashfs. Its purpose is to set the internal compressor state
+ * to the stored compressor options in the passed compressor options
+ * structure.
+ *
+ * In effect this function sets up the compressor options
+ * to the same state they were when the filesystem was originally
+ * generated, this is to ensure on appending, the compressor uses
+ * the same compression options that were used to generate the
+ * original filesystem.
+ *
+ * Note, even if there are no compressor options, this function is still
+ * called with an empty compressor structure (size == 0), to explicitly
+ * set the default options, this is to ensure any user supplied
+ * -X options on the appending mksquashfs command line are over-ridden
+ *
+ * This function returns 0 on sucessful extraction of options, and
+ * -1 on error
+ */
+static int lz4_extract_options(int block_size, void *buffer, int size)
+{
+ struct lz4_comp_opts *comp_opts = buffer;
+
+ /* we expect a comp_opts structure to be present */
+ if(size < sizeof(*comp_opts))
+ goto failed;
+
+ SQUASHFS_INSWAP_COMP_OPTS(comp_opts);
+
+ /* we expect the stream format to be LZ4_LEGACY */
+ if(comp_opts->version != LZ4_LEGACY) {
+ fprintf(stderr, "lz4: unknown LZ4 version\n");
+ goto failed;
+ }
+
+ /*
+ * Check compression flags, currently only LZ4_HC ("high compression")
+ * can be set.
+ */
+ if(comp_opts->flags == LZ4_HC)
+ hc = 1;
+ else if(comp_opts->flags != 0) {
+ fprintf(stderr, "lz4: unknown LZ4 flags\n");
+ goto failed;
+ }
+
+ return 0;
+
+failed:
+ fprintf(stderr, "lz4: error reading stored compressor options from "
+ "filesystem!\n");
+
+ return -1;
+}
+
+
+/*
+ * This function is a helper specifically for unsquashfs.
+ * Its purpose is to check that the compression options are
+ * understood by this version of LZ4.
+ *
+ * This is important for LZ4 because the format understood by the
+ * Linux kernel may change from the already obsolete legacy format
+ * currently supported.
+ *
+ * If this does happen, then this version of LZ4 will not be able to decode
+ * the newer format. So we need to check for this.
+ *
+ * This function returns 0 on sucessful checking of options, and
+ * -1 on error
+ */
+static int lz4_check_options(int block_size, void *buffer, int size)
+{
+ struct lz4_comp_opts *comp_opts = buffer;
+
+ /* we expect a comp_opts structure to be present */
+ if(size < sizeof(*comp_opts))
+ goto failed;
+
+ SQUASHFS_INSWAP_COMP_OPTS(comp_opts);
+
+ /* we expect the stream format to be LZ4_LEGACY */
+ if(comp_opts->version != LZ4_LEGACY) {
+ fprintf(stderr, "lz4: unknown LZ4 version\n");
+ goto failed;
+ }
+
+ return 0;
+
+failed:
+ fprintf(stderr, "lz4: error reading stored compressor options from "
+ "filesystem!\n");
+ return -1;
+}
+
+
+void lz4_display_options(void *buffer, int size)
+{
+ struct lz4_comp_opts *comp_opts = buffer;
+
+ /* check passed comp opts struct is of the correct length */
+ if(size < sizeof(*comp_opts))
+ goto failed;
+
+ SQUASHFS_INSWAP_COMP_OPTS(comp_opts);
+
+ /* we expect the stream format to be LZ4_LEGACY */
+ if(comp_opts->version != LZ4_LEGACY) {
+ fprintf(stderr, "lz4: unknown LZ4 version\n");
+ goto failed;
+ }
+
+ /*
+ * Check compression flags, currently only LZ4_HC ("high compression")
+ * can be set.
+ */
+ if(comp_opts->flags & ~LZ4_FLAGS_MASK) {
+ fprintf(stderr, "lz4: unknown LZ4 flags\n");
+ goto failed;
+ }
+
+ if(comp_opts->flags & LZ4_HC)
+ printf("\tHigh Compression option specified (-Xhc)\n");
+
+ return;
+
+failed:
+ fprintf(stderr, "lz4: error reading stored compressor options from "
+ "filesystem!\n");
+}
+
+
+static int lz4_compress(void *strm, void *dest, void *src, int size,
+ int block_size, int *error)
+{
+ int res;
+
+ if(hc)
+ res = LZ4_compressHC_limitedOutput(src, dest, size, block_size);
+ else
+ res = LZ4_compress_limitedOutput(src, dest, size, block_size);
+
+ if(res == 0) {
+ /*
+ * Output buffer overflow. Return out of buffer space
+ */
+ return 0;
+ } else if(res < 0) {
+ /*
+ * All other errors return failure, with the compressor
+ * specific error code in *error
+ */
+ *error = res;
+ return -1;
+ }
+
+ return res;
+}
+
+
+static int lz4_uncompress(void *dest, void *src, int size, int outsize,
+ int *error)
+{
+ int res = LZ4_decompress_safe(src, dest, size, outsize);
+ if(res < 0) {
+ *error = res;
+ return -1;
+ }
+
+ return res;
+}
+
+
+void lz4_usage()
+{
+ fprintf(stderr, "\t -Xhc\n");
+ fprintf(stderr, "\t\tCompress using LZ4 High Compression\n");
+}
+
+
+struct compressor lz4_comp_ops = {
+ .compress = lz4_compress,
+ .uncompress = lz4_uncompress,
+ .options = lz4_options,
+ .dump_options = lz4_dump_options,
+ .extract_options = lz4_extract_options,
+ .check_options = lz4_check_options,
+ .display_options = lz4_display_options,
+ .usage = lz4_usage,
+ .id = LZ4_COMPRESSION,
+ .name = "lz4",
+ .supported = 1
+};
diff --git a/squashfs-tools/squashfs-tools/lz4_wrapper.h b/squashfs-tools/squashfs-tools/lz4_wrapper.h
new file mode 100644
index 0000000..d6638a5
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/lz4_wrapper.h
@@ -0,0 +1,61 @@
+#ifndef LZ4_WRAPPER_H
+#define LZ4_WRAPPER_H
+/*
+ * Squashfs
+ *
+ * Copyright (c) 2013
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * lz4_wrapper.h
+ *
+ */
+
+#ifndef linux
+#define __BYTE_ORDER BYTE_ORDER
+#define __BIG_ENDIAN BIG_ENDIAN
+#define __LITTLE_ENDIAN LITTLE_ENDIAN
+#else
+#include <endian.h>
+#endif
+
+#if __BYTE_ORDER == __BIG_ENDIAN
+extern unsigned int inswap_le32(unsigned int);
+
+#define SQUASHFS_INSWAP_COMP_OPTS(s) { \
+ (s)->version = inswap_le32((s)->version); \
+ (s)->flags = inswap_le32((s)->flags); \
+}
+#else
+#define SQUASHFS_INSWAP_COMP_OPTS(s)
+#endif
+
+/*
+ * Define the various stream formats recognised.
+ * Currently omly legacy stream format is supported by the
+ * kernel
+ */
+#define LZ4_LEGACY 1
+#define LZ4_FLAGS_MASK 1
+
+/* Define the compression flags recognised. */
+#define LZ4_HC 1
+
+struct lz4_comp_opts {
+ int version;
+ int flags;
+};
+#endif
diff --git a/squashfs-tools/squashfs-tools/lzma_wrapper.c b/squashfs-tools/squashfs-tools/lzma_wrapper.c
new file mode 100644
index 0000000..8d64e3d
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/lzma_wrapper.c
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2009, 2010, 2013
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * lzma_wrapper.c
+ *
+ * Support for LZMA1 compression using LZMA SDK (4.65 used in
+ * development, other versions may work) http://www.7-zip.org/sdk.html
+ */
+
+#include <LzmaLib.h>
+
+#include "squashfs_fs.h"
+#include "compressor.h"
+
+#define LZMA_HEADER_SIZE (LZMA_PROPS_SIZE + 8)
+
+static int lzma_compress(void *strm, void *dest, void *src, int size, int block_size,
+ int *error)
+{
+ unsigned char *d = dest;
+ size_t props_size = LZMA_PROPS_SIZE,
+ outlen = block_size - LZMA_HEADER_SIZE;
+ int res;
+
+ res = LzmaCompress(dest + LZMA_HEADER_SIZE, &outlen, src, size, dest,
+ &props_size, 5, block_size, 3, 0, 2, 32, 1);
+
+ if(res == SZ_ERROR_OUTPUT_EOF) {
+ /*
+ * Output buffer overflow. Return out of buffer space error
+ */
+ return 0;
+ }
+
+ if(res != SZ_OK) {
+ /*
+ * All other errors return failure, with the compressor
+ * specific error code in *error
+ */
+ *error = res;
+ return -1;
+ }
+
+ /*
+ * Fill in the 8 byte little endian uncompressed size field in the
+ * LZMA header. 8 bytes is excessively large for squashfs but
+ * this is the standard LZMA header and which is expected by the kernel
+ * code
+ */
+ d[LZMA_PROPS_SIZE] = size & 255;
+ d[LZMA_PROPS_SIZE + 1] = (size >> 8) & 255;
+ d[LZMA_PROPS_SIZE + 2] = (size >> 16) & 255;
+ d[LZMA_PROPS_SIZE + 3] = (size >> 24) & 255;
+ d[LZMA_PROPS_SIZE + 4] = 0;
+ d[LZMA_PROPS_SIZE + 5] = 0;
+ d[LZMA_PROPS_SIZE + 6] = 0;
+ d[LZMA_PROPS_SIZE + 7] = 0;
+
+ /*
+ * Success, return the compressed size. Outlen returned by the LZMA
+ * compressor does not include the LZMA header space
+ */
+ return outlen + LZMA_HEADER_SIZE;
+}
+
+
+static int lzma_uncompress(void *dest, void *src, int size, int outsize,
+ int *error)
+{
+ unsigned char *s = src;
+ size_t outlen, inlen = size - LZMA_HEADER_SIZE;
+ int res;
+
+ outlen = s[LZMA_PROPS_SIZE] |
+ (s[LZMA_PROPS_SIZE + 1] << 8) |
+ (s[LZMA_PROPS_SIZE + 2] << 16) |
+ (s[LZMA_PROPS_SIZE + 3] << 24);
+
+ if(outlen > outsize) {
+ *error = 0;
+ return -1;
+ }
+
+ res = LzmaUncompress(dest, &outlen, src + LZMA_HEADER_SIZE, &inlen, src,
+ LZMA_PROPS_SIZE);
+
+ if(res == SZ_OK)
+ return outlen;
+ else {
+ *error = res;
+ return -1;
+ }
+}
+
+
+struct compressor lzma_comp_ops = {
+ .init = NULL,
+ .compress = lzma_compress,
+ .uncompress = lzma_uncompress,
+ .options = NULL,
+ .usage = NULL,
+ .id = LZMA_COMPRESSION,
+ .name = "lzma",
+ .supported = 1
+};
+
diff --git a/squashfs-tools/squashfs-tools/lzma_xz_wrapper.c b/squashfs-tools/squashfs-tools/lzma_xz_wrapper.c
new file mode 100644
index 0000000..55a6813
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/lzma_xz_wrapper.c
@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) 2010, 2013
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * lzma_xz_wrapper.c
+ *
+ * Support for LZMA1 compression using XZ Utils liblzma http://tukaani.org/xz/
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <lzma.h>
+
+#include "squashfs_fs.h"
+#include "compressor.h"
+
+#define LZMA_PROPS_SIZE 5
+#define LZMA_UNCOMP_SIZE 8
+#define LZMA_HEADER_SIZE (LZMA_PROPS_SIZE + LZMA_UNCOMP_SIZE)
+
+#define LZMA_OPTIONS 5
+#define MEMLIMIT (32 * 1024 * 1024)
+
+static int lzma_compress(void *dummy, void *dest, void *src, int size,
+ int block_size, int *error)
+{
+ unsigned char *d = (unsigned char *) dest;
+ lzma_options_lzma opt;
+ lzma_stream strm = LZMA_STREAM_INIT;
+ int res;
+
+ lzma_lzma_preset(&opt, LZMA_OPTIONS);
+ opt.dict_size = block_size;
+
+ res = lzma_alone_encoder(&strm, &opt);
+ if(res != LZMA_OK) {
+ lzma_end(&strm);
+ goto failed;
+ }
+
+ strm.next_out = dest;
+ strm.avail_out = block_size;
+ strm.next_in = src;
+ strm.avail_in = size;
+
+ res = lzma_code(&strm, LZMA_FINISH);
+ lzma_end(&strm);
+
+ if(res == LZMA_STREAM_END) {
+ /*
+ * Fill in the 8 byte little endian uncompressed size field in
+ * the LZMA header. 8 bytes is excessively large for squashfs
+ * but this is the standard LZMA header and which is expected by
+ * the kernel code
+ */
+
+ d[LZMA_PROPS_SIZE] = size & 255;
+ d[LZMA_PROPS_SIZE + 1] = (size >> 8) & 255;
+ d[LZMA_PROPS_SIZE + 2] = (size >> 16) & 255;
+ d[LZMA_PROPS_SIZE + 3] = (size >> 24) & 255;
+ d[LZMA_PROPS_SIZE + 4] = 0;
+ d[LZMA_PROPS_SIZE + 5] = 0;
+ d[LZMA_PROPS_SIZE + 6] = 0;
+ d[LZMA_PROPS_SIZE + 7] = 0;
+
+ return (int) strm.total_out;
+ }
+
+ if(res == LZMA_OK)
+ /*
+ * Output buffer overflow. Return out of buffer space
+ */
+ return 0;
+
+failed:
+ /*
+ * All other errors return failure, with the compressor
+ * specific error code in *error
+ */
+ *error = res;
+ return -1;
+}
+
+
+static int lzma_uncompress(void *dest, void *src, int size, int outsize,
+ int *error)
+{
+ lzma_stream strm = LZMA_STREAM_INIT;
+ int uncompressed_size = 0, res;
+ unsigned char lzma_header[LZMA_HEADER_SIZE];
+
+ res = lzma_alone_decoder(&strm, MEMLIMIT);
+ if(res != LZMA_OK) {
+ lzma_end(&strm);
+ goto failed;
+ }
+
+ memcpy(lzma_header, src, LZMA_HEADER_SIZE);
+ uncompressed_size = lzma_header[LZMA_PROPS_SIZE] |
+ (lzma_header[LZMA_PROPS_SIZE + 1] << 8) |
+ (lzma_header[LZMA_PROPS_SIZE + 2] << 16) |
+ (lzma_header[LZMA_PROPS_SIZE + 3] << 24);
+
+ if(uncompressed_size > outsize) {
+ res = 0;
+ goto failed;
+ }
+
+ memset(lzma_header + LZMA_PROPS_SIZE, 255, LZMA_UNCOMP_SIZE);
+
+ strm.next_out = dest;
+ strm.avail_out = outsize;
+ strm.next_in = lzma_header;
+ strm.avail_in = LZMA_HEADER_SIZE;
+
+ res = lzma_code(&strm, LZMA_RUN);
+
+ if(res != LZMA_OK || strm.avail_in != 0) {
+ lzma_end(&strm);
+ goto failed;
+ }
+
+ strm.next_in = src + LZMA_HEADER_SIZE;
+ strm.avail_in = size - LZMA_HEADER_SIZE;
+
+ res = lzma_code(&strm, LZMA_FINISH);
+ lzma_end(&strm);
+
+ if(res == LZMA_STREAM_END || (res == LZMA_OK &&
+ strm.total_out >= uncompressed_size && strm.avail_in == 0))
+ return uncompressed_size;
+
+failed:
+ *error = res;
+ return -1;
+}
+
+
+struct compressor lzma_comp_ops = {
+ .init = NULL,
+ .compress = lzma_compress,
+ .uncompress = lzma_uncompress,
+ .options = NULL,
+ .usage = NULL,
+ .id = LZMA_COMPRESSION,
+ .name = "lzma",
+ .supported = 1
+};
+
diff --git a/squashfs-tools/squashfs-tools/lzo_wrapper.c b/squashfs-tools/squashfs-tools/lzo_wrapper.c
new file mode 100644
index 0000000..8c9bf95
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/lzo_wrapper.c
@@ -0,0 +1,439 @@
+/*
+ * Copyright (c) 2013, 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * lzo_wrapper.c
+ *
+ * Support for LZO compression http://www.oberhumer.com/opensource/lzo
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <lzo/lzoconf.h>
+#include <lzo/lzo1x.h>
+
+#include "squashfs_fs.h"
+#include "lzo_wrapper.h"
+#include "compressor.h"
+
+static struct lzo_algorithm lzo[] = {
+ { "lzo1x_1", LZO1X_1_MEM_COMPRESS, lzo1x_1_compress },
+ { "lzo1x_1_11", LZO1X_1_11_MEM_COMPRESS, lzo1x_1_11_compress },
+ { "lzo1x_1_12", LZO1X_1_12_MEM_COMPRESS, lzo1x_1_12_compress },
+ { "lzo1x_1_15", LZO1X_1_15_MEM_COMPRESS, lzo1x_1_15_compress },
+ { "lzo1x_999", LZO1X_999_MEM_COMPRESS, lzo1x_999_wrapper },
+ { NULL, 0, NULL }
+};
+
+/* default LZO compression algorithm and compression level */
+static int algorithm = SQUASHFS_LZO1X_999;
+static int compression_level = SQUASHFS_LZO1X_999_COMP_DEFAULT;
+
+/* user specified compression level */
+static int user_comp_level = -1;
+
+
+/*
+ * This function is called by the options parsing code in mksquashfs.c
+ * to parse any -X compressor option.
+ *
+ * This function returns:
+ * >=0 (number of additional args parsed) on success
+ * -1 if the option was unrecognised, or
+ * -2 if the option was recognised, but otherwise bad in
+ * some way (e.g. invalid parameter)
+ *
+ * Note: this function sets internal compressor state, but does not
+ * pass back the results of the parsing other than success/failure.
+ * The lzo_dump_options() function is called later to get the options in
+ * a format suitable for writing to the filesystem.
+ */
+static int lzo_options(char *argv[], int argc)
+{
+ int i;
+
+ if(strcmp(argv[0], "-Xalgorithm") == 0) {
+ if(argc < 2) {
+ fprintf(stderr, "lzo: -Xalgorithm missing algorithm\n");
+ fprintf(stderr, "lzo: -Xalgorithm <algorithm>\n");
+ goto failed2;
+ }
+
+ for(i = 0; lzo[i].name; i++) {
+ if(strcmp(argv[1], lzo[i].name) == 0) {
+ algorithm = i;
+ return 1;
+ }
+ }
+
+ fprintf(stderr, "lzo: -Xalgorithm unrecognised algorithm\n");
+ goto failed2;
+ } else if(strcmp(argv[0], "-Xcompression-level") == 0) {
+ if(argc < 2) {
+ fprintf(stderr, "lzo: -Xcompression-level missing "
+ "compression level\n");
+ fprintf(stderr, "lzo: -Xcompression-level it "
+ "should be 1 >= n <= 9\n");
+ goto failed;
+ }
+
+ user_comp_level = atoi(argv[1]);
+ if(user_comp_level < 1 || user_comp_level > 9) {
+ fprintf(stderr, "lzo: -Xcompression-level invalid, it "
+ "should be 1 >= n <= 9\n");
+ goto failed;
+ }
+
+ return 1;
+ }
+
+ return -1;
+
+failed:
+ return -2;
+
+failed2:
+ fprintf(stderr, "lzo: compression algorithm should be one of:\n");
+ for(i = 0; lzo[i].name; i++)
+ fprintf(stderr, "\t%s\n", lzo[i].name);
+ return -2;
+}
+
+
+/*
+ * This function is called after all options have been parsed.
+ * It is used to do post-processing on the compressor options using
+ * values that were not expected to be known at option parse time.
+ *
+ * In this case the LZO algorithm may not be known until after the
+ * compression level has been set (-Xalgorithm used after -Xcompression-level)
+ *
+ * This function returns 0 on successful post processing, or
+ * -1 on error
+ */
+static int lzo_options_post(int block_size)
+{
+ /*
+ * Use of compression level only makes sense for
+ * LZO1X_999 algorithm
+ */
+ if(user_comp_level != -1) {
+ if(algorithm != SQUASHFS_LZO1X_999) {
+ fprintf(stderr, "lzo: -Xcompression-level not "
+ "supported by selected %s algorithm\n",
+ lzo[algorithm].name);
+ fprintf(stderr, "lzo: -Xcompression-level is only "
+ "applicable for the lzo1x_999 algorithm\n");
+ goto failed;
+ }
+ compression_level = user_comp_level;
+ }
+
+ return 0;
+
+failed:
+ return -1;
+}
+
+
+/*
+ * This function is called by mksquashfs to dump the parsed
+ * compressor options in a format suitable for writing to the
+ * compressor options field in the filesystem (stored immediately
+ * after the superblock).
+ *
+ * This function returns a pointer to the compression options structure
+ * to be stored (and the size), or NULL if there are no compression
+ * options
+ *
+ */
+static void *lzo_dump_options(int block_size, int *size)
+{
+ static struct lzo_comp_opts comp_opts;
+
+ /*
+ * If default compression options of SQUASHFS_LZO1X_999 and
+ * compression level of SQUASHFS_LZO1X_999_COMP_DEFAULT then
+ * don't store a compression options structure (this is compatible
+ * with the legacy implementation of LZO for Squashfs)
+ */
+ if(algorithm == SQUASHFS_LZO1X_999 &&
+ compression_level == SQUASHFS_LZO1X_999_COMP_DEFAULT)
+ return NULL;
+
+ comp_opts.algorithm = algorithm;
+ comp_opts.compression_level = algorithm == SQUASHFS_LZO1X_999 ?
+ compression_level : 0;
+
+ SQUASHFS_INSWAP_COMP_OPTS(&comp_opts);
+
+ *size = sizeof(comp_opts);
+ return &comp_opts;
+}
+
+
+/*
+ * This function is a helper specifically for the append mode of
+ * mksquashfs. Its purpose is to set the internal compressor state
+ * to the stored compressor options in the passed compressor options
+ * structure.
+ *
+ * In effect this function sets up the compressor options
+ * to the same state they were when the filesystem was originally
+ * generated, this is to ensure on appending, the compressor uses
+ * the same compression options that were used to generate the
+ * original filesystem.
+ *
+ * Note, even if there are no compressor options, this function is still
+ * called with an empty compressor structure (size == 0), to explicitly
+ * set the default options, this is to ensure any user supplied
+ * -X options on the appending mksquashfs command line are over-ridden
+ *
+ * This function returns 0 on sucessful extraction of options, and
+ * -1 on error
+ */
+static int lzo_extract_options(int block_size, void *buffer, int size)
+{
+ struct lzo_comp_opts *comp_opts = buffer;
+
+ if(size == 0) {
+ /* Set default values */
+ algorithm = SQUASHFS_LZO1X_999;
+ compression_level = SQUASHFS_LZO1X_999_COMP_DEFAULT;
+ return 0;
+ }
+
+ /* we expect a comp_opts structure of sufficient size to be present */
+ if(size < sizeof(*comp_opts))
+ goto failed;
+
+ SQUASHFS_INSWAP_COMP_OPTS(comp_opts);
+
+ /* Check comp_opts structure for correctness */
+ switch(comp_opts->algorithm) {
+ case SQUASHFS_LZO1X_1:
+ case SQUASHFS_LZO1X_1_11:
+ case SQUASHFS_LZO1X_1_12:
+ case SQUASHFS_LZO1X_1_15:
+ if(comp_opts->compression_level != 0) {
+ fprintf(stderr, "lzo: bad compression level in "
+ "compression options structure\n");
+ goto failed;
+ }
+ break;
+ case SQUASHFS_LZO1X_999:
+ if(comp_opts->compression_level < 1 ||
+ comp_opts->compression_level > 9) {
+ fprintf(stderr, "lzo: bad compression level in "
+ "compression options structure\n");
+ goto failed;
+ }
+ compression_level = comp_opts->compression_level;
+ break;
+ default:
+ fprintf(stderr, "lzo: bad algorithm in compression options "
+ "structure\n");
+ goto failed;
+ }
+
+ algorithm = comp_opts->algorithm;
+
+ return 0;
+
+failed:
+ fprintf(stderr, "lzo: error reading stored compressor options from "
+ "filesystem!\n");
+
+ return -1;
+}
+
+
+void lzo_display_options(void *buffer, int size)
+{
+ struct lzo_comp_opts *comp_opts = buffer;
+
+ /* we expect a comp_opts structure of sufficient size to be present */
+ if(size < sizeof(*comp_opts))
+ goto failed;
+
+ SQUASHFS_INSWAP_COMP_OPTS(comp_opts);
+
+ /* Check comp_opts structure for correctness */
+ switch(comp_opts->algorithm) {
+ case SQUASHFS_LZO1X_1:
+ case SQUASHFS_LZO1X_1_11:
+ case SQUASHFS_LZO1X_1_12:
+ case SQUASHFS_LZO1X_1_15:
+ printf("\talgorithm %s\n", lzo[comp_opts->algorithm].name);
+ break;
+ case SQUASHFS_LZO1X_999:
+ if(comp_opts->compression_level < 1 ||
+ comp_opts->compression_level > 9) {
+ fprintf(stderr, "lzo: bad compression level in "
+ "compression options structure\n");
+ goto failed;
+ }
+ printf("\talgorithm %s\n", lzo[comp_opts->algorithm].name);
+ printf("\tcompression level %d\n",
+ comp_opts->compression_level);
+ break;
+ default:
+ fprintf(stderr, "lzo: bad algorithm in compression options "
+ "structure\n");
+ goto failed;
+ }
+
+ return;
+
+failed:
+ fprintf(stderr, "lzo: error reading stored compressor options from "
+ "filesystem!\n");
+}
+
+
+/*
+ * This function is called by mksquashfs to initialise the
+ * compressor, before compress() is called.
+ *
+ * This function returns 0 on success, and
+ * -1 on error
+ */
+static int squashfs_lzo_init(void **strm, int block_size, int datablock)
+{
+ struct lzo_stream *stream;
+
+ stream = *strm = malloc(sizeof(struct lzo_stream));
+ if(stream == NULL)
+ goto failed;
+
+ stream->workspace = malloc(lzo[algorithm].size);
+ if(stream->workspace == NULL)
+ goto failed2;
+
+ stream->buffer = malloc(LZO_MAX_EXPANSION(block_size));
+ if(stream->buffer != NULL)
+ return 0;
+
+ free(stream->workspace);
+failed2:
+ free(stream);
+failed:
+ return -1;
+}
+
+
+static int lzo_compress(void *strm, void *dest, void *src, int size,
+ int block_size, int *error)
+{
+ int res;
+ lzo_uint compsize, orig_size = size;
+ struct lzo_stream *stream = strm;
+
+ res = lzo[algorithm].compress(src, size, stream->buffer, &compsize,
+ stream->workspace);
+ if(res != LZO_E_OK)
+ goto failed;
+
+ /* Successful compression, however, we need to check that
+ * the compressed size is not larger than the available
+ * buffer space. Normally in other compressor APIs they take
+ * a destination buffer size, and overflows return an error.
+ * With LZO it lacks a destination size and so we must output
+ * to a temporary buffer large enough to accomodate any
+ * result, and explictly check here for overflow
+ */
+ if(compsize > block_size)
+ return 0;
+
+ res = lzo1x_optimize(stream->buffer, compsize, src, &orig_size, NULL);
+
+ if (res != LZO_E_OK || orig_size != size)
+ goto failed;
+
+ memcpy(dest, stream->buffer, compsize);
+ return compsize;
+
+failed:
+ /* fail, compressor specific error code returned in error */
+ *error = res;
+ return -1;
+}
+
+
+static int lzo_uncompress(void *dest, void *src, int size, int outsize,
+ int *error)
+{
+ int res;
+ lzo_uint outlen = outsize;
+
+ res = lzo1x_decompress_safe(src, size, dest, &outlen, NULL);
+ if(res != LZO_E_OK) {
+ *error = res;
+ return -1;
+ }
+
+ return outlen;
+}
+
+
+void lzo_usage()
+{
+ int i;
+
+ fprintf(stderr, "\t -Xalgorithm <algorithm>\n");
+ fprintf(stderr, "\t\tWhere <algorithm> is one of:\n");
+
+ for(i = 0; lzo[i].name; i++)
+ fprintf(stderr, "\t\t\t%s%s\n", lzo[i].name,
+ i == SQUASHFS_LZO1X_999 ? " (default)" : "");
+
+ fprintf(stderr, "\t -Xcompression-level <compression-level>\n");
+ fprintf(stderr, "\t\t<compression-level> should be 1 .. 9 (default "
+ "%d)\n", SQUASHFS_LZO1X_999_COMP_DEFAULT);
+ fprintf(stderr, "\t\tOnly applies to lzo1x_999 algorithm\n");
+}
+
+
+/*
+ * Helper function for lzo1x_999 compression algorithm.
+ * All other lzo1x_xxx compressors do not take a compression level,
+ * so we need to wrap lzo1x_999 to pass the compression level which
+ * is applicable to it
+ */
+int lzo1x_999_wrapper(const lzo_bytep src, lzo_uint src_len, lzo_bytep dst,
+ lzo_uintp compsize, lzo_voidp workspace)
+{
+ return lzo1x_999_compress_level(src, src_len, dst, compsize,
+ workspace, NULL, 0, 0, compression_level);
+}
+
+
+struct compressor lzo_comp_ops = {
+ .init = squashfs_lzo_init,
+ .compress = lzo_compress,
+ .uncompress = lzo_uncompress,
+ .options = lzo_options,
+ .options_post = lzo_options_post,
+ .dump_options = lzo_dump_options,
+ .extract_options = lzo_extract_options,
+ .display_options = lzo_display_options,
+ .usage = lzo_usage,
+ .id = LZO_COMPRESSION,
+ .name = "lzo",
+ .supported = 1
+};
diff --git a/squashfs-tools/squashfs-tools/lzo_wrapper.h b/squashfs-tools/squashfs-tools/lzo_wrapper.h
new file mode 100644
index 0000000..804e53c
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/lzo_wrapper.h
@@ -0,0 +1,78 @@
+#ifndef LZO_WRAPPER_H
+#define LZO_WRAPPER_H
+/*
+ * Squashfs
+ *
+ * Copyright (c) 2013
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * lzo_wrapper.h
+ *
+ */
+
+#ifndef linux
+#define __BYTE_ORDER BYTE_ORDER
+#define __BIG_ENDIAN BIG_ENDIAN
+#define __LITTLE_ENDIAN LITTLE_ENDIAN
+#else
+#include <endian.h>
+#endif
+
+#if __BYTE_ORDER == __BIG_ENDIAN
+extern unsigned int inswap_le32(unsigned int);
+
+#define SQUASHFS_INSWAP_COMP_OPTS(s) { \
+ (s)->algorithm = inswap_le32((s)->algorithm); \
+ (s)->compression_level = inswap_le32((s)->compression_level); \
+}
+#else
+#define SQUASHFS_INSWAP_COMP_OPTS(s)
+#endif
+
+/* Define the compression flags recognised. */
+#define SQUASHFS_LZO1X_1 0
+#define SQUASHFS_LZO1X_1_11 1
+#define SQUASHFS_LZO1X_1_12 2
+#define SQUASHFS_LZO1X_1_15 3
+#define SQUASHFS_LZO1X_999 4
+
+/* Default compression level used by SQUASHFS_LZO1X_999 */
+#define SQUASHFS_LZO1X_999_COMP_DEFAULT 8
+
+struct lzo_comp_opts {
+ int algorithm;
+ int compression_level;
+};
+
+struct lzo_algorithm {
+ char *name;
+ int size;
+ int (*compress) (const lzo_bytep, lzo_uint, lzo_bytep, lzo_uintp,
+ lzo_voidp);
+};
+
+struct lzo_stream {
+ void *workspace;
+ void *buffer;
+};
+
+#define LZO_MAX_EXPANSION(size) (size + (size / 16) + 64 + 3)
+
+int lzo1x_999_wrapper(const lzo_bytep, lzo_uint, lzo_bytep, lzo_uintp,
+ lzo_voidp);
+
+#endif
diff --git a/squashfs-tools/squashfs-tools/mksquashfs.c b/squashfs-tools/squashfs-tools/mksquashfs.c
new file mode 100644
index 0000000..033bc8e
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/mksquashfs.c
@@ -0,0 +1,6192 @@
+/*
+ * Create a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
+ * 2012, 2013, 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * mksquashfs.c
+ */
+
+#define FALSE 0
+#define TRUE 1
+#define MAX_LINE 16384
+
+#include <pwd.h>
+#include <grp.h>
+#include <time.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <dirent.h>
+#include <string.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <setjmp.h>
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <pthread.h>
+#include <regex.h>
+#include <fnmatch.h>
+#include <sys/wait.h>
+#include <limits.h>
+#include <ctype.h>
+
+#ifndef FNM_EXTMATCH /* glibc extension */
+ #define FNM_EXTMATCH 0
+#endif
+
+#ifndef linux
+#define __BYTE_ORDER BYTE_ORDER
+#define __BIG_ENDIAN BIG_ENDIAN
+#define __LITTLE_ENDIAN LITTLE_ENDIAN
+#include <sys/sysctl.h>
+#else
+#include <endian.h>
+#include <sys/sysinfo.h>
+#endif
+
+#include "squashfs_fs.h"
+#include "squashfs_swap.h"
+#include "mksquashfs.h"
+#include "sort.h"
+#include "pseudo.h"
+#include "compressor.h"
+#include "xattr.h"
+#include "action.h"
+#include "error.h"
+#include "progressbar.h"
+#include "info.h"
+#include "caches-queues-lists.h"
+#include "read_fs.h"
+#include "restore.h"
+#include "process_fragments.h"
+
+/* ANDROID CHANGES START*/
+#ifdef ANDROID
+#include "android.h"
+#include "private/android_filesystem_config.h"
+#include "private/canned_fs_config.h"
+int android_config = FALSE;
+char *context_file = NULL;
+char *mount_point = NULL;
+char *target_out_path = NULL;
+fs_config_func_t fs_config_func = NULL;
+#endif
+/* ANDROID CHANGES END */
+
+int delete = FALSE;
+int fd;
+struct squashfs_super_block sBlk;
+
+/* filesystem flags for building */
+int comp_opts = FALSE;
+int no_xattrs = XATTR_DEF;
+int noX = FALSE;
+int duplicate_checking = TRUE;
+int noF = FALSE;
+int no_fragments = FALSE;
+int always_use_fragments = FALSE;
+int noI = FALSE;
+int noD = FALSE;
+int silent = TRUE;
+int exportable = TRUE;
+int sparse_files = TRUE;
+int old_exclude = TRUE;
+int use_regex = FALSE;
+int nopad = FALSE;
+int exit_on_error = FALSE;
+
+long long global_uid = -1, global_gid = -1;
+
+/* superblock attributes */
+int block_size = SQUASHFS_FILE_SIZE, block_log;
+unsigned int id_count = 0;
+int file_count = 0, sym_count = 0, dev_count = 0, dir_count = 0, fifo_count = 0,
+ sock_count = 0;
+
+/* write position within data section */
+long long bytes = 0, total_bytes = 0;
+
+/* in memory directory table - possibly compressed */
+char *directory_table = NULL;
+unsigned int directory_bytes = 0, directory_size = 0, total_directory_bytes = 0;
+
+/* cached directory table */
+char *directory_data_cache = NULL;
+unsigned int directory_cache_bytes = 0, directory_cache_size = 0;
+
+/* in memory inode table - possibly compressed */
+char *inode_table = NULL;
+unsigned int inode_bytes = 0, inode_size = 0, total_inode_bytes = 0;
+
+/* cached inode table */
+char *data_cache = NULL;
+unsigned int cache_bytes = 0, cache_size = 0, inode_count = 0;
+
+/* inode lookup table */
+squashfs_inode *inode_lookup_table = NULL;
+
+/* in memory directory data */
+#define I_COUNT_SIZE 128
+#define DIR_ENTRIES 32
+#define INODE_HASH_SIZE 65536
+#define INODE_HASH_MASK (INODE_HASH_SIZE - 1)
+#define INODE_HASH(dev, ino) (ino & INODE_HASH_MASK)
+
+struct cached_dir_index {
+ struct squashfs_dir_index index;
+ char *name;
+};
+
+struct directory {
+ unsigned int start_block;
+ unsigned int size;
+ unsigned char *buff;
+ unsigned char *p;
+ unsigned int entry_count;
+ unsigned char *entry_count_p;
+ unsigned int i_count;
+ unsigned int i_size;
+ struct cached_dir_index *index;
+ unsigned char *index_count_p;
+ unsigned int inode_number;
+};
+
+struct inode_info *inode_info[INODE_HASH_SIZE];
+
+/* hash tables used to do fast duplicate searches in duplicate check */
+struct file_info *dupl[65536];
+int dup_files = 0;
+
+/* exclude file handling */
+/* list of exclude dirs/files */
+struct exclude_info {
+ dev_t st_dev;
+ ino_t st_ino;
+};
+
+#define EXCLUDE_SIZE 8192
+int exclude = 0;
+struct exclude_info *exclude_paths = NULL;
+int old_excluded(char *filename, struct stat *buf);
+
+struct path_entry {
+ char *name;
+ regex_t *preg;
+ struct pathname *paths;
+};
+
+struct pathname {
+ int names;
+ struct path_entry *name;
+};
+
+struct pathnames {
+ int count;
+ struct pathname *path[0];
+};
+#define PATHS_ALLOC_SIZE 10
+
+struct pathnames *paths = NULL;
+struct pathname *path = NULL;
+struct pathname *stickypath = NULL;
+int excluded(char *name, struct pathnames *paths, struct pathnames **new);
+
+int fragments = 0;
+
+#define FRAG_SIZE 32768
+
+struct squashfs_fragment_entry *fragment_table = NULL;
+int fragments_outstanding = 0;
+
+int fragments_locked = FALSE;
+
+/* current inode number for directories and non directories */
+unsigned int inode_no = 1;
+unsigned int root_inode_number = 0;
+
+/* list of source dirs/files */
+int source = 0;
+char **source_path;
+
+/* list of root directory entries read from original filesystem */
+int old_root_entries = 0;
+struct old_root_entry_info {
+ char *name;
+ struct inode_info inode;
+};
+struct old_root_entry_info *old_root_entry;
+
+/* restore orignal filesystem state if appending to existing filesystem is
+ * cancelled */
+int appending = FALSE;
+char *sdata_cache, *sdirectory_data_cache, *sdirectory_compressed;
+
+long long sbytes, stotal_bytes;
+
+unsigned int sinode_bytes, scache_bytes, sdirectory_bytes,
+ sdirectory_cache_bytes, sdirectory_compressed_bytes,
+ stotal_inode_bytes, stotal_directory_bytes,
+ sinode_count = 0, sfile_count, ssym_count, sdev_count,
+ sdir_count, sfifo_count, ssock_count, sdup_files;
+int sfragments;
+int threads;
+
+/* flag whether destination file is a block device */
+int block_device = FALSE;
+
+/* flag indicating whether files are sorted using sort list(s) */
+int sorted = FALSE;
+
+/* save destination file name for deleting on error */
+char *destination_file = NULL;
+
+/* recovery file for abnormal exit on appending */
+char *recovery_file = NULL;
+int recover = TRUE;
+
+struct id *id_hash_table[ID_ENTRIES];
+struct id *id_table[SQUASHFS_IDS], *sid_table[SQUASHFS_IDS];
+unsigned int uid_count = 0, guid_count = 0;
+unsigned int sid_count = 0, suid_count = 0, sguid_count = 0;
+
+struct cache *reader_buffer, *fragment_buffer, *reserve_cache;
+struct cache *bwriter_buffer, *fwriter_buffer;
+struct queue *to_reader, *to_deflate, *to_writer, *from_writer,
+ *to_frag, *locked_fragment, *to_process_frag;
+struct seq_queue *to_main;
+pthread_t reader_thread, writer_thread, main_thread;
+pthread_t *deflator_thread, *frag_deflator_thread, *frag_thread;
+pthread_t *restore_thread = NULL;
+pthread_mutex_t fragment_mutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_mutex_t pos_mutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_mutex_t dup_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+/* user options that control parallelisation */
+int processors = -1;
+int bwriter_size;
+
+/* compression operations */
+struct compressor *comp = NULL;
+int compressor_opt_parsed = FALSE;
+void *stream = NULL;
+
+/* xattr stats */
+unsigned int xattr_bytes = 0, total_xattr_bytes = 0;
+
+/* fragment to file mapping used when appending */
+int append_fragments = 0;
+struct append_file **file_mapping;
+
+/* root of the in-core directory structure */
+struct dir_info *root_dir;
+
+static char *read_from_disk(long long start, unsigned int avail_bytes);
+void add_old_root_entry(char *name, squashfs_inode inode, int inode_number,
+ int type);
+struct file_info *duplicate(long long file_size, long long bytes,
+ unsigned int **block_list, long long *start, struct fragment **fragment,
+ struct file_buffer *file_buffer, int blocks, unsigned short checksum,
+ int checksum_flag);
+struct dir_info *dir_scan1(char *, char *, struct pathnames *,
+ struct dir_ent *(_readdir)(struct dir_info *), int);
+void dir_scan2(struct dir_info *dir, struct pseudo *pseudo);
+void dir_scan3(struct dir_info *dir);
+void dir_scan4(struct dir_info *dir);
+void dir_scan5(struct dir_info *dir);
+void dir_scan6(struct dir_info *dir);
+void dir_scan7(squashfs_inode *inode, struct dir_info *dir_info);
+struct file_info *add_non_dup(long long file_size, long long bytes,
+ unsigned int *block_list, long long start, struct fragment *fragment,
+ unsigned short checksum, unsigned short fragment_checksum,
+ int checksum_flag, int checksum_frag_flag);
+long long generic_write_table(int, void *, int, void *, int);
+void restorefs();
+struct dir_info *scan1_opendir(char *pathname, char *subpath, int depth);
+void write_filesystem_tables(struct squashfs_super_block *sBlk, int nopad);
+unsigned short get_checksum_mem(char *buff, int bytes);
+void check_usable_phys_mem(int total_mem);
+
+
+void prep_exit()
+{
+ if(restore_thread) {
+ if(pthread_self() == *restore_thread) {
+ /*
+ * Recursive failure when trying to restore filesystem!
+ * Nothing to do except to exit, otherwise we'll just
+ * appear to hang. The user should be able to restore
+ * from the recovery file (which is why it was added, in
+ * case of catastrophic failure in Mksquashfs)
+ */
+ exit(1);
+ } else {
+ /* signal the restore thread to restore */
+ pthread_kill(*restore_thread, SIGUSR1);
+ pthread_exit(NULL);
+ }
+ } else if(delete) {
+ if(destination_file && !block_device)
+ unlink(destination_file);
+ } else if(recovery_file)
+ unlink(recovery_file);
+}
+
+
+int add_overflow(int a, int b)
+{
+ return (INT_MAX - a) < b;
+}
+
+
+int shift_overflow(int a, int shift)
+{
+ return (INT_MAX >> shift) < a;
+}
+
+
+int multiply_overflow(int a, int multiplier)
+{
+ return (INT_MAX / multiplier) < a;
+}
+
+
+int multiply_overflowll(long long a, int multiplier)
+{
+ return (LLONG_MAX / multiplier) < a;
+}
+
+
+#define MKINODE(A) ((squashfs_inode)(((squashfs_inode) inode_bytes << 16) \
+ + (((char *)A) - data_cache)))
+
+
+void restorefs()
+{
+ ERROR("Exiting - restoring original filesystem!\n\n");
+
+ bytes = sbytes;
+ memcpy(data_cache, sdata_cache, cache_bytes = scache_bytes);
+ memcpy(directory_data_cache, sdirectory_data_cache,
+ sdirectory_cache_bytes);
+ directory_cache_bytes = sdirectory_cache_bytes;
+ inode_bytes = sinode_bytes;
+ directory_bytes = sdirectory_bytes;
+ memcpy(directory_table + directory_bytes, sdirectory_compressed,
+ sdirectory_compressed_bytes);
+ directory_bytes += sdirectory_compressed_bytes;
+ total_bytes = stotal_bytes;
+ total_inode_bytes = stotal_inode_bytes;
+ total_directory_bytes = stotal_directory_bytes;
+ inode_count = sinode_count;
+ file_count = sfile_count;
+ sym_count = ssym_count;
+ dev_count = sdev_count;
+ dir_count = sdir_count;
+ fifo_count = sfifo_count;
+ sock_count = ssock_count;
+ dup_files = sdup_files;
+ fragments = sfragments;
+ id_count = sid_count;
+ restore_xattrs();
+ write_filesystem_tables(&sBlk, nopad);
+ exit(1);
+}
+
+
+void sighandler()
+{
+ EXIT_MKSQUASHFS();
+}
+
+
+int mangle2(void *strm, char *d, char *s, int size,
+ int block_size, int uncompressed, int data_block)
+{
+ int error, c_byte = 0;
+
+ if(!uncompressed) {
+ c_byte = compressor_compress(comp, strm, d, s, size, block_size,
+ &error);
+ if(c_byte == -1)
+ BAD_ERROR("mangle2:: %s compress failed with error "
+ "code %d\n", comp->name, error);
+ }
+
+ if(c_byte == 0 || c_byte >= size) {
+ memcpy(d, s, size);
+ return size | (data_block ? SQUASHFS_COMPRESSED_BIT_BLOCK :
+ SQUASHFS_COMPRESSED_BIT);
+ }
+
+ return c_byte;
+}
+
+
+int mangle(char *d, char *s, int size, int block_size,
+ int uncompressed, int data_block)
+{
+ return mangle2(stream, d, s, size, block_size, uncompressed,
+ data_block);
+}
+
+
+void *get_inode(int req_size)
+{
+ int data_space;
+ unsigned short c_byte;
+
+ while(cache_bytes >= SQUASHFS_METADATA_SIZE) {
+ if((inode_size - inode_bytes) <
+ ((SQUASHFS_METADATA_SIZE << 1)) + 2) {
+ void *it = realloc(inode_table, inode_size +
+ (SQUASHFS_METADATA_SIZE << 1) + 2);
+ if(it == NULL)
+ MEM_ERROR();
+ inode_table = it;
+ inode_size += (SQUASHFS_METADATA_SIZE << 1) + 2;
+ }
+
+ c_byte = mangle(inode_table + inode_bytes + BLOCK_OFFSET,
+ data_cache, SQUASHFS_METADATA_SIZE,
+ SQUASHFS_METADATA_SIZE, noI, 0);
+ TRACE("Inode block @ 0x%x, size %d\n", inode_bytes, c_byte);
+ SQUASHFS_SWAP_SHORTS(&c_byte, inode_table + inode_bytes, 1);
+ inode_bytes += SQUASHFS_COMPRESSED_SIZE(c_byte) + BLOCK_OFFSET;
+ total_inode_bytes += SQUASHFS_METADATA_SIZE + BLOCK_OFFSET;
+ memmove(data_cache, data_cache + SQUASHFS_METADATA_SIZE,
+ cache_bytes - SQUASHFS_METADATA_SIZE);
+ cache_bytes -= SQUASHFS_METADATA_SIZE;
+ }
+
+ data_space = (cache_size - cache_bytes);
+ if(data_space < req_size) {
+ int realloc_size = cache_size == 0 ?
+ ((req_size + SQUASHFS_METADATA_SIZE) &
+ ~(SQUASHFS_METADATA_SIZE - 1)) : req_size -
+ data_space;
+
+ void *dc = realloc(data_cache, cache_size +
+ realloc_size);
+ if(dc == NULL)
+ MEM_ERROR();
+ cache_size += realloc_size;
+ data_cache = dc;
+ }
+
+ cache_bytes += req_size;
+
+ return data_cache + cache_bytes - req_size;
+}
+
+
+int read_bytes(int fd, void *buff, int bytes)
+{
+ int res, count;
+
+ for(count = 0; count < bytes; count += res) {
+ res = read(fd, buff + count, bytes - count);
+ if(res < 1) {
+ if(res == 0)
+ goto bytes_read;
+ else if(errno != EINTR) {
+ ERROR("Read failed because %s\n",
+ strerror(errno));
+ return -1;
+ } else
+ res = 0;
+ }
+ }
+
+bytes_read:
+ return count;
+}
+
+
+int read_fs_bytes(int fd, long long byte, int bytes, void *buff)
+{
+ off_t off = byte;
+ int res = 1;
+
+ TRACE("read_fs_bytes: reading from position 0x%llx, bytes %d\n",
+ byte, bytes);
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &pos_mutex);
+ pthread_mutex_lock(&pos_mutex);
+ if(lseek(fd, off, SEEK_SET) == -1) {
+ ERROR("read_fs_bytes: Lseek on destination failed because %s, "
+ "offset=0x%llx\n", strerror(errno), off);
+ res = 0;
+ } else if(read_bytes(fd, buff, bytes) < bytes) {
+ ERROR("Read on destination failed\n");
+ res = 0;
+ }
+
+ pthread_cleanup_pop(1);
+ return res;
+}
+
+
+int write_bytes(int fd, void *buff, int bytes)
+{
+ int res, count;
+
+ for(count = 0; count < bytes; count += res) {
+ res = write(fd, buff + count, bytes - count);
+ if(res == -1) {
+ if(errno != EINTR) {
+ ERROR("Write failed because %s\n",
+ strerror(errno));
+ return -1;
+ }
+ res = 0;
+ }
+ }
+
+ return 0;
+}
+
+
+void write_destination(int fd, long long byte, int bytes, void *buff)
+{
+ off_t off = byte;
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &pos_mutex);
+ pthread_mutex_lock(&pos_mutex);
+
+ if(lseek(fd, off, SEEK_SET) == -1) {
+ ERROR("write_destination: Lseek on destination "
+ "failed because %s, offset=0x%llx\n", strerror(errno),
+ off);
+ BAD_ERROR("Probably out of space on output %s\n",
+ block_device ? "block device" : "filesystem");
+ }
+
+ if(write_bytes(fd, buff, bytes) == -1)
+ BAD_ERROR("Failed to write to output %s\n",
+ block_device ? "block device" : "filesystem");
+
+ pthread_cleanup_pop(1);
+}
+
+
+long long write_inodes()
+{
+ unsigned short c_byte;
+ int avail_bytes;
+ char *datap = data_cache;
+ long long start_bytes = bytes;
+
+ while(cache_bytes) {
+ if(inode_size - inode_bytes <
+ ((SQUASHFS_METADATA_SIZE << 1) + 2)) {
+ void *it = realloc(inode_table, inode_size +
+ ((SQUASHFS_METADATA_SIZE << 1) + 2));
+ if(it == NULL)
+ MEM_ERROR();
+ inode_size += (SQUASHFS_METADATA_SIZE << 1) + 2;
+ inode_table = it;
+ }
+ avail_bytes = cache_bytes > SQUASHFS_METADATA_SIZE ?
+ SQUASHFS_METADATA_SIZE : cache_bytes;
+ c_byte = mangle(inode_table + inode_bytes + BLOCK_OFFSET, datap,
+ avail_bytes, SQUASHFS_METADATA_SIZE, noI, 0);
+ TRACE("Inode block @ 0x%x, size %d\n", inode_bytes, c_byte);
+ SQUASHFS_SWAP_SHORTS(&c_byte, inode_table + inode_bytes, 1);
+ inode_bytes += SQUASHFS_COMPRESSED_SIZE(c_byte) + BLOCK_OFFSET;
+ total_inode_bytes += avail_bytes + BLOCK_OFFSET;
+ datap += avail_bytes;
+ cache_bytes -= avail_bytes;
+ }
+
+ write_destination(fd, bytes, inode_bytes, inode_table);
+ bytes += inode_bytes;
+
+ return start_bytes;
+}
+
+
+long long write_directories()
+{
+ unsigned short c_byte;
+ int avail_bytes;
+ char *directoryp = directory_data_cache;
+ long long start_bytes = bytes;
+
+ while(directory_cache_bytes) {
+ if(directory_size - directory_bytes <
+ ((SQUASHFS_METADATA_SIZE << 1) + 2)) {
+ void *dt = realloc(directory_table,
+ directory_size + ((SQUASHFS_METADATA_SIZE << 1)
+ + 2));
+ if(dt == NULL)
+ MEM_ERROR();
+ directory_size += (SQUASHFS_METADATA_SIZE << 1) + 2;
+ directory_table = dt;
+ }
+ avail_bytes = directory_cache_bytes > SQUASHFS_METADATA_SIZE ?
+ SQUASHFS_METADATA_SIZE : directory_cache_bytes;
+ c_byte = mangle(directory_table + directory_bytes +
+ BLOCK_OFFSET, directoryp, avail_bytes,
+ SQUASHFS_METADATA_SIZE, noI, 0);
+ TRACE("Directory block @ 0x%x, size %d\n", directory_bytes,
+ c_byte);
+ SQUASHFS_SWAP_SHORTS(&c_byte,
+ directory_table + directory_bytes, 1);
+ directory_bytes += SQUASHFS_COMPRESSED_SIZE(c_byte) +
+ BLOCK_OFFSET;
+ total_directory_bytes += avail_bytes + BLOCK_OFFSET;
+ directoryp += avail_bytes;
+ directory_cache_bytes -= avail_bytes;
+ }
+ write_destination(fd, bytes, directory_bytes, directory_table);
+ bytes += directory_bytes;
+
+ return start_bytes;
+}
+
+
+long long write_id_table()
+{
+ unsigned int id_bytes = SQUASHFS_ID_BYTES(id_count);
+ unsigned int p[id_count];
+ int i;
+
+ TRACE("write_id_table: ids %d, id_bytes %d\n", id_count, id_bytes);
+ for(i = 0; i < id_count; i++) {
+ TRACE("write_id_table: id index %d, id %d", i, id_table[i]->id);
+ SQUASHFS_SWAP_INTS(&id_table[i]->id, p + i, 1);
+ }
+
+ return generic_write_table(id_bytes, p, 0, NULL, noI);
+}
+
+
+struct id *get_id(unsigned int id)
+{
+ int hash = ID_HASH(id);
+ struct id *entry = id_hash_table[hash];
+
+ for(; entry; entry = entry->next)
+ if(entry->id == id)
+ break;
+
+ return entry;
+}
+
+
+struct id *create_id(unsigned int id)
+{
+ int hash = ID_HASH(id);
+ struct id *entry = malloc(sizeof(struct id));
+ if(entry == NULL)
+ MEM_ERROR();
+ entry->id = id;
+ entry->index = id_count ++;
+ entry->flags = 0;
+ entry->next = id_hash_table[hash];
+ id_hash_table[hash] = entry;
+ id_table[entry->index] = entry;
+ return entry;
+}
+
+
+unsigned int get_uid(unsigned int uid)
+{
+ struct id *entry = get_id(uid);
+
+ if(entry == NULL) {
+ if(id_count == SQUASHFS_IDS)
+ BAD_ERROR("Out of uids!\n");
+ entry = create_id(uid);
+ }
+
+ if((entry->flags & ISA_UID) == 0) {
+ entry->flags |= ISA_UID;
+ uid_count ++;
+ }
+
+ return entry->index;
+}
+
+
+unsigned int get_guid(unsigned int guid)
+{
+ struct id *entry = get_id(guid);
+
+ if(entry == NULL) {
+ if(id_count == SQUASHFS_IDS)
+ BAD_ERROR("Out of gids!\n");
+ entry = create_id(guid);
+ }
+
+ if((entry->flags & ISA_GID) == 0) {
+ entry->flags |= ISA_GID;
+ guid_count ++;
+ }
+
+ return entry->index;
+}
+
+
+#define ALLOC_SIZE 128
+
+char *_pathname(struct dir_ent *dir_ent, char *pathname, int *size)
+{
+ if(pathname == NULL) {
+ pathname = malloc(ALLOC_SIZE);
+ if(pathname == NULL)
+ MEM_ERROR();
+ }
+
+ for(;;) {
+ int res = snprintf(pathname, *size, "%s/%s",
+ dir_ent->our_dir->pathname,
+ dir_ent->source_name ? : dir_ent->name);
+
+ if(res < 0)
+ BAD_ERROR("snprintf failed in pathname\n");
+ else if(res >= *size) {
+ /*
+ * pathname is too small to contain the result, so
+ * increase it and try again
+ */
+ *size = (res + ALLOC_SIZE) & ~(ALLOC_SIZE - 1);
+ pathname = realloc(pathname, *size);
+ if(pathname == NULL)
+ MEM_ERROR();
+ } else
+ break;
+ }
+
+ return pathname;
+}
+
+
+char *pathname(struct dir_ent *dir_ent)
+{
+ static char *pathname = NULL;
+ static int size = ALLOC_SIZE;
+
+ if (dir_ent->nonstandard_pathname)
+ return dir_ent->nonstandard_pathname;
+
+ return pathname = _pathname(dir_ent, pathname, &size);
+}
+
+
+char *pathname_reader(struct dir_ent *dir_ent)
+{
+ static char *pathname = NULL;
+ static int size = ALLOC_SIZE;
+
+ if (dir_ent->nonstandard_pathname)
+ return dir_ent->nonstandard_pathname;
+
+ return pathname = _pathname(dir_ent, pathname, &size);
+}
+
+
+char *subpathname(struct dir_ent *dir_ent)
+{
+ static char *subpath = NULL;
+ static int size = ALLOC_SIZE;
+ int res;
+
+ if(subpath == NULL) {
+ subpath = malloc(ALLOC_SIZE);
+ if(subpath == NULL)
+ MEM_ERROR();
+ }
+
+ for(;;) {
+ if(dir_ent->our_dir->subpath[0] != '\0')
+ res = snprintf(subpath, size, "%s/%s",
+ dir_ent->our_dir->subpath, dir_ent->name);
+ else
+ res = snprintf(subpath, size, "/%s", dir_ent->name);
+
+ if(res < 0)
+ BAD_ERROR("snprintf failed in subpathname\n");
+ else if(res >= size) {
+ /*
+ * subpath is too small to contain the result, so
+ * increase it and try again
+ */
+ size = (res + ALLOC_SIZE) & ~(ALLOC_SIZE - 1);
+ subpath = realloc(subpath, size);
+ if(subpath == NULL)
+ MEM_ERROR();
+ } else
+ break;
+ }
+
+ return subpath;
+}
+
+
+static inline unsigned int get_inode_no(struct inode_info *inode)
+{
+ return inode->inode_number;
+}
+
+
+static inline unsigned int get_parent_no(struct dir_info *dir)
+{
+ return dir->depth ? get_inode_no(dir->dir_ent->inode) : inode_no;
+}
+
+
+int create_inode(squashfs_inode *i_no, struct dir_info *dir_info,
+ struct dir_ent *dir_ent, int type, long long byte_size,
+ long long start_block, unsigned int offset, unsigned int *block_list,
+ struct fragment *fragment, struct directory *dir_in, long long sparse)
+{
+ struct stat *buf = &dir_ent->inode->buf;
+ union squashfs_inode_header inode_header;
+ struct squashfs_base_inode_header *base = &inode_header.base;
+ void *inode;
+ char *filename = pathname(dir_ent);
+ int nlink = dir_ent->inode->nlink;
+ int xattr = read_xattrs(dir_ent);
+
+ switch(type) {
+ case SQUASHFS_FILE_TYPE:
+ if(dir_ent->inode->nlink > 1 ||
+ byte_size >= (1LL << 32) ||
+ start_block >= (1LL << 32) ||
+ sparse || IS_XATTR(xattr))
+ type = SQUASHFS_LREG_TYPE;
+ break;
+ case SQUASHFS_DIR_TYPE:
+ if(dir_info->dir_is_ldir || IS_XATTR(xattr))
+ type = SQUASHFS_LDIR_TYPE;
+ break;
+ case SQUASHFS_SYMLINK_TYPE:
+ if(IS_XATTR(xattr))
+ type = SQUASHFS_LSYMLINK_TYPE;
+ break;
+ case SQUASHFS_BLKDEV_TYPE:
+ if(IS_XATTR(xattr))
+ type = SQUASHFS_LBLKDEV_TYPE;
+ break;
+ case SQUASHFS_CHRDEV_TYPE:
+ if(IS_XATTR(xattr))
+ type = SQUASHFS_LCHRDEV_TYPE;
+ break;
+ case SQUASHFS_FIFO_TYPE:
+ if(IS_XATTR(xattr))
+ type = SQUASHFS_LFIFO_TYPE;
+ break;
+ case SQUASHFS_SOCKET_TYPE:
+ if(IS_XATTR(xattr))
+ type = SQUASHFS_LSOCKET_TYPE;
+ break;
+ }
+
+ base->mode = SQUASHFS_MODE(buf->st_mode);
+ base->uid = get_uid((unsigned int) global_uid == -1 ?
+ buf->st_uid : global_uid);
+ base->inode_type = type;
+ base->guid = get_guid((unsigned int) global_gid == -1 ?
+ buf->st_gid : global_gid);
+ base->mtime = buf->st_mtime;
+ base->inode_number = get_inode_no(dir_ent->inode);
+
+ if(type == SQUASHFS_FILE_TYPE) {
+ int i;
+ struct squashfs_reg_inode_header *reg = &inode_header.reg;
+ size_t off = offsetof(struct squashfs_reg_inode_header, block_list);
+
+ inode = get_inode(sizeof(*reg) + offset * sizeof(unsigned int));
+ reg->file_size = byte_size;
+ reg->start_block = start_block;
+ reg->fragment = fragment->index;
+ reg->offset = fragment->offset;
+ SQUASHFS_SWAP_REG_INODE_HEADER(reg, inode);
+ SQUASHFS_SWAP_INTS(block_list, inode + off, offset);
+ TRACE("File inode, file_size %lld, start_block 0x%llx, blocks "
+ "%d, fragment %d, offset %d, size %d\n", byte_size,
+ start_block, offset, fragment->index, fragment->offset,
+ fragment->size);
+ for(i = 0; i < offset; i++)
+ TRACE("Block %d, size %d\n", i, block_list[i]);
+ }
+ else if(type == SQUASHFS_LREG_TYPE) {
+ int i;
+ struct squashfs_lreg_inode_header *reg = &inode_header.lreg;
+ size_t off = offsetof(struct squashfs_lreg_inode_header, block_list);
+
+ inode = get_inode(sizeof(*reg) + offset * sizeof(unsigned int));
+ reg->nlink = nlink;
+ reg->file_size = byte_size;
+ reg->start_block = start_block;
+ reg->fragment = fragment->index;
+ reg->offset = fragment->offset;
+ if(sparse && sparse >= byte_size)
+ sparse = byte_size - 1;
+ reg->sparse = sparse;
+ reg->xattr = xattr;
+ SQUASHFS_SWAP_LREG_INODE_HEADER(reg, inode);
+ SQUASHFS_SWAP_INTS(block_list, inode + off, offset);
+ TRACE("Long file inode, file_size %lld, start_block 0x%llx, "
+ "blocks %d, fragment %d, offset %d, size %d, nlink %d"
+ "\n", byte_size, start_block, offset, fragment->index,
+ fragment->offset, fragment->size, nlink);
+ for(i = 0; i < offset; i++)
+ TRACE("Block %d, size %d\n", i, block_list[i]);
+ }
+ else if(type == SQUASHFS_LDIR_TYPE) {
+ int i;
+ unsigned char *p;
+ struct squashfs_ldir_inode_header *dir = &inode_header.ldir;
+ struct cached_dir_index *index = dir_in->index;
+ unsigned int i_count = dir_in->i_count;
+ unsigned int i_size = dir_in->i_size;
+
+ if(byte_size >= 1 << 27)
+ BAD_ERROR("directory greater than 2^27-1 bytes!\n");
+
+ inode = get_inode(sizeof(*dir) + i_size);
+ dir->inode_type = SQUASHFS_LDIR_TYPE;
+ dir->nlink = dir_ent->dir->directory_count + 2;
+ dir->file_size = byte_size;
+ dir->offset = offset;
+ dir->start_block = start_block;
+ dir->i_count = i_count;
+ dir->parent_inode = get_parent_no(dir_ent->our_dir);
+ dir->xattr = xattr;
+
+ SQUASHFS_SWAP_LDIR_INODE_HEADER(dir, inode);
+ p = inode + offsetof(struct squashfs_ldir_inode_header, index);
+ for(i = 0; i < i_count; i++) {
+ SQUASHFS_SWAP_DIR_INDEX(&index[i].index, p);
+ p += offsetof(struct squashfs_dir_index, name);
+ memcpy(p, index[i].name, index[i].index.size + 1);
+ p += index[i].index.size + 1;
+ }
+ TRACE("Long directory inode, file_size %lld, start_block "
+ "0x%llx, offset 0x%x, nlink %d\n", byte_size,
+ start_block, offset, dir_ent->dir->directory_count + 2);
+ }
+ else if(type == SQUASHFS_DIR_TYPE) {
+ struct squashfs_dir_inode_header *dir = &inode_header.dir;
+
+ inode = get_inode(sizeof(*dir));
+ dir->nlink = dir_ent->dir->directory_count + 2;
+ dir->file_size = byte_size;
+ dir->offset = offset;
+ dir->start_block = start_block;
+ dir->parent_inode = get_parent_no(dir_ent->our_dir);
+ SQUASHFS_SWAP_DIR_INODE_HEADER(dir, inode);
+ TRACE("Directory inode, file_size %lld, start_block 0x%llx, "
+ "offset 0x%x, nlink %d\n", byte_size, start_block,
+ offset, dir_ent->dir->directory_count + 2);
+ }
+ else if(type == SQUASHFS_CHRDEV_TYPE || type == SQUASHFS_BLKDEV_TYPE) {
+ struct squashfs_dev_inode_header *dev = &inode_header.dev;
+ unsigned int major = major(buf->st_rdev);
+ unsigned int minor = minor(buf->st_rdev);
+
+ if(major > 0xfff) {
+ ERROR("Major %d out of range in device node %s, "
+ "truncating to %d\n", major, filename,
+ major & 0xfff);
+ major &= 0xfff;
+ }
+ if(minor > 0xfffff) {
+ ERROR("Minor %d out of range in device node %s, "
+ "truncating to %d\n", minor, filename,
+ minor & 0xfffff);
+ minor &= 0xfffff;
+ }
+ inode = get_inode(sizeof(*dev));
+ dev->nlink = nlink;
+ dev->rdev = (major << 8) | (minor & 0xff) |
+ ((minor & ~0xff) << 12);
+ SQUASHFS_SWAP_DEV_INODE_HEADER(dev, inode);
+ TRACE("Device inode, rdev 0x%x, nlink %d\n", dev->rdev, nlink);
+ }
+ else if(type == SQUASHFS_LCHRDEV_TYPE || type == SQUASHFS_LBLKDEV_TYPE) {
+ struct squashfs_ldev_inode_header *dev = &inode_header.ldev;
+ unsigned int major = major(buf->st_rdev);
+ unsigned int minor = minor(buf->st_rdev);
+
+ if(major > 0xfff) {
+ ERROR("Major %d out of range in device node %s, "
+ "truncating to %d\n", major, filename,
+ major & 0xfff);
+ major &= 0xfff;
+ }
+ if(minor > 0xfffff) {
+ ERROR("Minor %d out of range in device node %s, "
+ "truncating to %d\n", minor, filename,
+ minor & 0xfffff);
+ minor &= 0xfffff;
+ }
+ inode = get_inode(sizeof(*dev));
+ dev->nlink = nlink;
+ dev->rdev = (major << 8) | (minor & 0xff) |
+ ((minor & ~0xff) << 12);
+ dev->xattr = xattr;
+ SQUASHFS_SWAP_LDEV_INODE_HEADER(dev, inode);
+ TRACE("Device inode, rdev 0x%x, nlink %d\n", dev->rdev, nlink);
+ }
+ else if(type == SQUASHFS_SYMLINK_TYPE) {
+ struct squashfs_symlink_inode_header *symlink = &inode_header.symlink;
+ int byte = strlen(dir_ent->inode->symlink);
+ size_t off = offsetof(struct squashfs_symlink_inode_header, symlink);
+
+ inode = get_inode(sizeof(*symlink) + byte);
+ symlink->nlink = nlink;
+ symlink->symlink_size = byte;
+ SQUASHFS_SWAP_SYMLINK_INODE_HEADER(symlink, inode);
+ strncpy(inode + off, dir_ent->inode->symlink, byte);
+ TRACE("Symbolic link inode, symlink_size %d, nlink %d\n", byte,
+ nlink);
+ }
+ else if(type == SQUASHFS_LSYMLINK_TYPE) {
+ struct squashfs_symlink_inode_header *symlink = &inode_header.symlink;
+ int byte = strlen(dir_ent->inode->symlink);
+ size_t off = offsetof(struct squashfs_symlink_inode_header, symlink);
+
+ inode = get_inode(sizeof(*symlink) + byte +
+ sizeof(unsigned int));
+ symlink->nlink = nlink;
+ symlink->symlink_size = byte;
+ SQUASHFS_SWAP_SYMLINK_INODE_HEADER(symlink, inode);
+ strncpy(inode + off, dir_ent->inode->symlink, byte);
+ SQUASHFS_SWAP_INTS(&xattr, inode + off + byte, 1);
+ TRACE("Symbolic link inode, symlink_size %d, nlink %d\n", byte,
+ nlink);
+ }
+ else if(type == SQUASHFS_FIFO_TYPE || type == SQUASHFS_SOCKET_TYPE) {
+ struct squashfs_ipc_inode_header *ipc = &inode_header.ipc;
+
+ inode = get_inode(sizeof(*ipc));
+ ipc->nlink = nlink;
+ SQUASHFS_SWAP_IPC_INODE_HEADER(ipc, inode);
+ TRACE("ipc inode, type %s, nlink %d\n", type ==
+ SQUASHFS_FIFO_TYPE ? "fifo" : "socket", nlink);
+ }
+ else if(type == SQUASHFS_LFIFO_TYPE || type == SQUASHFS_LSOCKET_TYPE) {
+ struct squashfs_lipc_inode_header *ipc = &inode_header.lipc;
+
+ inode = get_inode(sizeof(*ipc));
+ ipc->nlink = nlink;
+ ipc->xattr = xattr;
+ SQUASHFS_SWAP_LIPC_INODE_HEADER(ipc, inode);
+ TRACE("ipc inode, type %s, nlink %d\n", type ==
+ SQUASHFS_FIFO_TYPE ? "fifo" : "socket", nlink);
+ } else
+ BAD_ERROR("Unrecognised inode %d in create_inode\n", type);
+
+ *i_no = MKINODE(inode);
+ inode_count ++;
+
+ TRACE("Created inode 0x%llx, type %d, uid %d, guid %d\n", *i_no, type,
+ base->uid, base->guid);
+
+ return TRUE;
+}
+
+
+void add_dir(squashfs_inode inode, unsigned int inode_number, char *name,
+ int type, struct directory *dir)
+{
+ unsigned char *buff;
+ struct squashfs_dir_entry idir;
+ unsigned int start_block = inode >> 16;
+ unsigned int offset = inode & 0xffff;
+ unsigned int size = strlen(name);
+ size_t name_off = offsetof(struct squashfs_dir_entry, name);
+
+ if(size > SQUASHFS_NAME_LEN) {
+ size = SQUASHFS_NAME_LEN;
+ ERROR("Filename is greater than %d characters, truncating! ..."
+ "\n", SQUASHFS_NAME_LEN);
+ }
+
+ if(dir->p + sizeof(struct squashfs_dir_entry) + size +
+ sizeof(struct squashfs_dir_header)
+ >= dir->buff + dir->size) {
+ buff = realloc(dir->buff, dir->size += SQUASHFS_METADATA_SIZE);
+ if(buff == NULL)
+ MEM_ERROR();
+
+ dir->p = (dir->p - dir->buff) + buff;
+ if(dir->entry_count_p)
+ dir->entry_count_p = (dir->entry_count_p - dir->buff +
+ buff);
+ dir->index_count_p = dir->index_count_p - dir->buff + buff;
+ dir->buff = buff;
+ }
+
+ if(dir->entry_count == 256 || start_block != dir->start_block ||
+ ((dir->entry_count_p != NULL) &&
+ ((dir->p + sizeof(struct squashfs_dir_entry) + size -
+ dir->index_count_p) > SQUASHFS_METADATA_SIZE)) ||
+ ((long long) inode_number - dir->inode_number) > 32767
+ || ((long long) inode_number - dir->inode_number)
+ < -32768) {
+ if(dir->entry_count_p) {
+ struct squashfs_dir_header dir_header;
+
+ if((dir->p + sizeof(struct squashfs_dir_entry) + size -
+ dir->index_count_p) >
+ SQUASHFS_METADATA_SIZE) {
+ if(dir->i_count % I_COUNT_SIZE == 0) {
+ dir->index = realloc(dir->index,
+ (dir->i_count + I_COUNT_SIZE) *
+ sizeof(struct cached_dir_index));
+ if(dir->index == NULL)
+ MEM_ERROR();
+ }
+ dir->index[dir->i_count].index.index =
+ dir->p - dir->buff;
+ dir->index[dir->i_count].index.size = size - 1;
+ dir->index[dir->i_count++].name = name;
+ dir->i_size += sizeof(struct squashfs_dir_index)
+ + size;
+ dir->index_count_p = dir->p;
+ }
+
+ dir_header.count = dir->entry_count - 1;
+ dir_header.start_block = dir->start_block;
+ dir_header.inode_number = dir->inode_number;
+ SQUASHFS_SWAP_DIR_HEADER(&dir_header,
+ dir->entry_count_p);
+
+ }
+
+
+ dir->entry_count_p = dir->p;
+ dir->start_block = start_block;
+ dir->entry_count = 0;
+ dir->inode_number = inode_number;
+ dir->p += sizeof(struct squashfs_dir_header);
+ }
+
+ idir.offset = offset;
+ idir.type = type;
+ idir.size = size - 1;
+ idir.inode_number = ((long long) inode_number - dir->inode_number);
+ SQUASHFS_SWAP_DIR_ENTRY(&idir, dir->p);
+ strncpy((char *) dir->p + name_off, name, size);
+ dir->p += sizeof(struct squashfs_dir_entry) + size;
+ dir->entry_count ++;
+}
+
+
+void write_dir(squashfs_inode *inode, struct dir_info *dir_info,
+ struct directory *dir)
+{
+ unsigned int dir_size = dir->p - dir->buff;
+ int data_space = directory_cache_size - directory_cache_bytes;
+ unsigned int directory_block, directory_offset, i_count, index;
+ unsigned short c_byte;
+
+ if(data_space < dir_size) {
+ int realloc_size = directory_cache_size == 0 ?
+ ((dir_size + SQUASHFS_METADATA_SIZE) &
+ ~(SQUASHFS_METADATA_SIZE - 1)) : dir_size - data_space;
+
+ void *dc = realloc(directory_data_cache,
+ directory_cache_size + realloc_size);
+ if(dc == NULL)
+ MEM_ERROR();
+ directory_cache_size += realloc_size;
+ directory_data_cache = dc;
+ }
+
+ if(dir_size) {
+ struct squashfs_dir_header dir_header;
+
+ dir_header.count = dir->entry_count - 1;
+ dir_header.start_block = dir->start_block;
+ dir_header.inode_number = dir->inode_number;
+ SQUASHFS_SWAP_DIR_HEADER(&dir_header, dir->entry_count_p);
+ memcpy(directory_data_cache + directory_cache_bytes, dir->buff,
+ dir_size);
+ }
+ directory_offset = directory_cache_bytes;
+ directory_block = directory_bytes;
+ directory_cache_bytes += dir_size;
+ i_count = 0;
+ index = SQUASHFS_METADATA_SIZE - directory_offset;
+
+ while(1) {
+ while(i_count < dir->i_count &&
+ dir->index[i_count].index.index < index)
+ dir->index[i_count++].index.start_block =
+ directory_bytes;
+ index += SQUASHFS_METADATA_SIZE;
+
+ if(directory_cache_bytes < SQUASHFS_METADATA_SIZE)
+ break;
+
+ if((directory_size - directory_bytes) <
+ ((SQUASHFS_METADATA_SIZE << 1) + 2)) {
+ void *dt = realloc(directory_table,
+ directory_size + (SQUASHFS_METADATA_SIZE << 1)
+ + 2);
+ if(dt == NULL)
+ MEM_ERROR();
+ directory_size += SQUASHFS_METADATA_SIZE << 1;
+ directory_table = dt;
+ }
+
+ c_byte = mangle(directory_table + directory_bytes +
+ BLOCK_OFFSET, directory_data_cache,
+ SQUASHFS_METADATA_SIZE, SQUASHFS_METADATA_SIZE,
+ noI, 0);
+ TRACE("Directory block @ 0x%x, size %d\n", directory_bytes,
+ c_byte);
+ SQUASHFS_SWAP_SHORTS(&c_byte,
+ directory_table + directory_bytes, 1);
+ directory_bytes += SQUASHFS_COMPRESSED_SIZE(c_byte) +
+ BLOCK_OFFSET;
+ total_directory_bytes += SQUASHFS_METADATA_SIZE + BLOCK_OFFSET;
+ memmove(directory_data_cache, directory_data_cache +
+ SQUASHFS_METADATA_SIZE, directory_cache_bytes -
+ SQUASHFS_METADATA_SIZE);
+ directory_cache_bytes -= SQUASHFS_METADATA_SIZE;
+ }
+
+ create_inode(inode, dir_info, dir_info->dir_ent, SQUASHFS_DIR_TYPE,
+ dir_size + 3, directory_block, directory_offset, NULL, NULL,
+ dir, 0);
+
+#ifdef SQUASHFS_TRACE
+ {
+ unsigned char *dirp;
+ int count;
+
+ TRACE("Directory contents of inode 0x%llx\n", *inode);
+ dirp = dir->buff;
+ while(dirp < dir->p) {
+ char buffer[SQUASHFS_NAME_LEN + 1];
+ struct squashfs_dir_entry idir, *idirp;
+ struct squashfs_dir_header dirh;
+ SQUASHFS_SWAP_DIR_HEADER((struct squashfs_dir_header *) dirp,
+ &dirh);
+ count = dirh.count + 1;
+ dirp += sizeof(struct squashfs_dir_header);
+
+ TRACE("\tStart block 0x%x, count %d\n",
+ dirh.start_block, count);
+
+ while(count--) {
+ idirp = (struct squashfs_dir_entry *) dirp;
+ SQUASHFS_SWAP_DIR_ENTRY(idirp, &idir);
+ strncpy(buffer, idirp->name, idir.size + 1);
+ buffer[idir.size + 1] = '\0';
+ TRACE("\t\tname %s, inode offset 0x%x, type "
+ "%d\n", buffer, idir.offset, idir.type);
+ dirp += sizeof(struct squashfs_dir_entry) + idir.size +
+ 1;
+ }
+ }
+ }
+#endif
+ dir_count ++;
+}
+
+
+static struct file_buffer *get_fragment(struct fragment *fragment)
+{
+ struct squashfs_fragment_entry *disk_fragment;
+ struct file_buffer *buffer, *compressed_buffer;
+ long long start_block;
+ int res, size, index = fragment->index;
+ char locked;
+
+ /*
+ * Lookup fragment block in cache.
+ * If the fragment block doesn't exist, then get the compressed version
+ * from the writer cache or off disk, and decompress it.
+ *
+ * This routine has two things which complicate the code:
+ *
+ * 1. Multiple threads can simultaneously lookup/create the
+ * same buffer. This means a buffer needs to be "locked"
+ * when it is being filled in, to prevent other threads from
+ * using it when it is not ready. This is because we now do
+ * fragment duplicate checking in parallel.
+ * 2. We have two caches which need to be checked for the
+ * presence of fragment blocks: the normal fragment cache
+ * and a "reserve" cache. The reserve cache is used to
+ * prevent an unnecessary pipeline stall when the fragment cache
+ * is full of fragments waiting to be compressed.
+ */
+
+ if(fragment->index == SQUASHFS_INVALID_FRAG)
+ return NULL;
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &dup_mutex);
+ pthread_mutex_lock(&dup_mutex);
+
+again:
+ buffer = cache_lookup_nowait(fragment_buffer, index, &locked);
+ if(buffer) {
+ pthread_mutex_unlock(&dup_mutex);
+ if(locked)
+ /* got a buffer being filled in. Wait for it */
+ cache_wait_unlock(buffer);
+ goto finished;
+ }
+
+ /* not in fragment cache, is it in the reserve cache? */
+ buffer = cache_lookup_nowait(reserve_cache, index, &locked);
+ if(buffer) {
+ pthread_mutex_unlock(&dup_mutex);
+ if(locked)
+ /* got a buffer being filled in. Wait for it */
+ cache_wait_unlock(buffer);
+ goto finished;
+ }
+
+ /* in neither cache, try to get it from the fragment cache */
+ buffer = cache_get_nowait(fragment_buffer, index);
+ if(!buffer) {
+ /*
+ * no room, get it from the reserve cache, this is
+ * dimensioned so it will always have space (no more than
+ * processors + 1 can have an outstanding reserve buffer)
+ */
+ buffer = cache_get_nowait(reserve_cache, index);
+ if(!buffer) {
+ /* failsafe */
+ ERROR("no space in reserve cache\n");
+ goto again;
+ }
+ }
+
+ pthread_mutex_unlock(&dup_mutex);
+
+ compressed_buffer = cache_lookup(fwriter_buffer, index);
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &fragment_mutex);
+ pthread_mutex_lock(&fragment_mutex);
+ disk_fragment = &fragment_table[index];
+ size = SQUASHFS_COMPRESSED_SIZE_BLOCK(disk_fragment->size);
+ start_block = disk_fragment->start_block;
+ pthread_cleanup_pop(1);
+
+ if(SQUASHFS_COMPRESSED_BLOCK(disk_fragment->size)) {
+ int error;
+ char *data;
+
+ if(compressed_buffer)
+ data = compressed_buffer->data;
+ else {
+ data = read_from_disk(start_block, size);
+ if(data == NULL) {
+ ERROR("Failed to read fragment from output"
+ " filesystem\n");
+ BAD_ERROR("Output filesystem corrupted?\n");
+ }
+ }
+
+ res = compressor_uncompress(comp, buffer->data, data, size,
+ block_size, &error);
+ if(res == -1)
+ BAD_ERROR("%s uncompress failed with error code %d\n",
+ comp->name, error);
+ } else if(compressed_buffer)
+ memcpy(buffer->data, compressed_buffer->data, size);
+ else {
+ res = read_fs_bytes(fd, start_block, size, buffer->data);
+ if(res == 0) {
+ ERROR("Failed to read fragment from output "
+ "filesystem\n");
+ BAD_ERROR("Output filesystem corrupted?\n");
+ }
+ }
+
+ cache_unlock(buffer);
+ cache_block_put(compressed_buffer);
+
+finished:
+ pthread_cleanup_pop(0);
+
+ return buffer;
+}
+
+
+unsigned short get_fragment_checksum(struct file_info *file)
+{
+ struct file_buffer *frag_buffer;
+ struct append_file *append;
+ int res, index = file->fragment->index;
+ unsigned short checksum;
+
+ if(index == SQUASHFS_INVALID_FRAG)
+ return 0;
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &dup_mutex);
+ pthread_mutex_lock(&dup_mutex);
+ res = file->have_frag_checksum;
+ checksum = file->fragment_checksum;
+ pthread_cleanup_pop(1);
+
+ if(res)
+ return checksum;
+
+ frag_buffer = get_fragment(file->fragment);
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &dup_mutex);
+
+ for(append = file_mapping[index]; append; append = append->next) {
+ int offset = append->file->fragment->offset;
+ int size = append->file->fragment->size;
+ unsigned short cksum =
+ get_checksum_mem(frag_buffer->data + offset, size);
+
+ if(file == append->file)
+ checksum = cksum;
+
+ pthread_mutex_lock(&dup_mutex);
+ append->file->fragment_checksum = cksum;
+ append->file->have_frag_checksum = TRUE;
+ pthread_mutex_unlock(&dup_mutex);
+ }
+
+ cache_block_put(frag_buffer);
+ pthread_cleanup_pop(0);
+
+ return checksum;
+}
+
+
+void lock_fragments()
+{
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &fragment_mutex);
+ pthread_mutex_lock(&fragment_mutex);
+ fragments_locked = TRUE;
+ pthread_cleanup_pop(1);
+}
+
+
+void unlock_fragments()
+{
+ int frg, size;
+ struct file_buffer *write_buffer;
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &fragment_mutex);
+ pthread_mutex_lock(&fragment_mutex);
+
+ /*
+ * Note queue_empty() is inherently racy with respect to concurrent
+ * queue get and pushes. We avoid this because we're holding the
+ * fragment_mutex which ensures no other threads can be using the
+ * queue at this time.
+ */
+ while(!queue_empty(locked_fragment)) {
+ write_buffer = queue_get(locked_fragment);
+ frg = write_buffer->block;
+ size = SQUASHFS_COMPRESSED_SIZE_BLOCK(fragment_table[frg].size);
+ fragment_table[frg].start_block = bytes;
+ write_buffer->block = bytes;
+ bytes += size;
+ fragments_outstanding --;
+ queue_put(to_writer, write_buffer);
+ TRACE("fragment_locked writing fragment %d, compressed size %d"
+ "\n", frg, size);
+ }
+ fragments_locked = FALSE;
+ pthread_cleanup_pop(1);
+}
+
+/* Called with the fragment_mutex locked */
+void add_pending_fragment(struct file_buffer *write_buffer, int c_byte,
+ int fragment)
+{
+ fragment_table[fragment].size = c_byte;
+ write_buffer->block = fragment;
+
+ queue_put(locked_fragment, write_buffer);
+}
+
+
+void write_fragment(struct file_buffer *fragment)
+{
+ if(fragment == NULL)
+ return;
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &fragment_mutex);
+ pthread_mutex_lock(&fragment_mutex);
+ fragment_table[fragment->block].unused = 0;
+ fragments_outstanding ++;
+ queue_put(to_frag, fragment);
+ pthread_cleanup_pop(1);
+}
+
+
+struct file_buffer *allocate_fragment()
+{
+ struct file_buffer *fragment = cache_get(fragment_buffer, fragments);
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &fragment_mutex);
+ pthread_mutex_lock(&fragment_mutex);
+
+ if(fragments % FRAG_SIZE == 0) {
+ void *ft = realloc(fragment_table, (fragments +
+ FRAG_SIZE) * sizeof(struct squashfs_fragment_entry));
+ if(ft == NULL)
+ MEM_ERROR();
+ fragment_table = ft;
+ }
+
+ fragment->size = 0;
+ fragment->block = fragments ++;
+
+ pthread_cleanup_pop(1);
+
+ return fragment;
+}
+
+
+static struct fragment empty_fragment = {SQUASHFS_INVALID_FRAG, 0, 0};
+
+
+void free_fragment(struct fragment *fragment)
+{
+ if(fragment != &empty_fragment)
+ free(fragment);
+}
+
+
+struct fragment *get_and_fill_fragment(struct file_buffer *file_buffer,
+ struct dir_ent *dir_ent)
+{
+ struct fragment *ffrg;
+ struct file_buffer **fragment;
+
+ if(file_buffer == NULL || file_buffer->size == 0)
+ return &empty_fragment;
+
+ fragment = eval_frag_actions(root_dir, dir_ent);
+
+ if((*fragment) && (*fragment)->size + file_buffer->size > block_size) {
+ write_fragment(*fragment);
+ *fragment = NULL;
+ }
+
+ ffrg = malloc(sizeof(struct fragment));
+ if(ffrg == NULL)
+ MEM_ERROR();
+
+ if(*fragment == NULL)
+ *fragment = allocate_fragment();
+
+ ffrg->index = (*fragment)->block;
+ ffrg->offset = (*fragment)->size;
+ ffrg->size = file_buffer->size;
+ memcpy((*fragment)->data + (*fragment)->size, file_buffer->data,
+ file_buffer->size);
+ (*fragment)->size += file_buffer->size;
+
+ return ffrg;
+}
+
+
+long long generic_write_table(int length, void *buffer, int length2,
+ void *buffer2, int uncompressed)
+{
+ int meta_blocks = (length + SQUASHFS_METADATA_SIZE - 1) /
+ SQUASHFS_METADATA_SIZE;
+ long long *list, start_bytes;
+ int compressed_size, i, list_size = meta_blocks * sizeof(long long);
+ unsigned short c_byte;
+ char cbuffer[(SQUASHFS_METADATA_SIZE << 2) + 2];
+
+#ifdef SQUASHFS_TRACE
+ long long obytes = bytes;
+ int olength = length;
+#endif
+
+ list = malloc(list_size);
+ if(list == NULL)
+ MEM_ERROR();
+
+ for(i = 0; i < meta_blocks; i++) {
+ int avail_bytes = length > SQUASHFS_METADATA_SIZE ?
+ SQUASHFS_METADATA_SIZE : length;
+ c_byte = mangle(cbuffer + BLOCK_OFFSET, buffer + i *
+ SQUASHFS_METADATA_SIZE , avail_bytes,
+ SQUASHFS_METADATA_SIZE, uncompressed, 0);
+ SQUASHFS_SWAP_SHORTS(&c_byte, cbuffer, 1);
+ list[i] = bytes;
+ compressed_size = SQUASHFS_COMPRESSED_SIZE(c_byte) +
+ BLOCK_OFFSET;
+ TRACE("block %d @ 0x%llx, compressed size %d\n", i, bytes,
+ compressed_size);
+ write_destination(fd, bytes, compressed_size, cbuffer);
+ bytes += compressed_size;
+ total_bytes += avail_bytes;
+ length -= avail_bytes;
+ }
+
+ start_bytes = bytes;
+ if(length2) {
+ write_destination(fd, bytes, length2, buffer2);
+ bytes += length2;
+ total_bytes += length2;
+ }
+
+ SQUASHFS_INSWAP_LONG_LONGS(list, meta_blocks);
+ write_destination(fd, bytes, list_size, list);
+ bytes += list_size;
+ total_bytes += list_size;
+
+ TRACE("generic_write_table: total uncompressed %d compressed %lld\n",
+ olength, bytes - obytes);
+
+ free(list);
+
+ return start_bytes;
+}
+
+
+long long write_fragment_table()
+{
+ unsigned int frag_bytes = SQUASHFS_FRAGMENT_BYTES(fragments);
+ int i;
+
+ TRACE("write_fragment_table: fragments %d, frag_bytes %d\n", fragments,
+ frag_bytes);
+ for(i = 0; i < fragments; i++) {
+ TRACE("write_fragment_table: fragment %d, start_block 0x%llx, "
+ "size %d\n", i, fragment_table[i].start_block,
+ fragment_table[i].size);
+ SQUASHFS_INSWAP_FRAGMENT_ENTRY(&fragment_table[i]);
+ }
+
+ return generic_write_table(frag_bytes, fragment_table, 0, NULL, noF);
+}
+
+
+char read_from_file_buffer[SQUASHFS_FILE_MAX_SIZE];
+static char *read_from_disk(long long start, unsigned int avail_bytes)
+{
+ int res;
+
+ res = read_fs_bytes(fd, start, avail_bytes, read_from_file_buffer);
+ if(res == 0)
+ return NULL;
+
+ return read_from_file_buffer;
+}
+
+
+char read_from_file_buffer2[SQUASHFS_FILE_MAX_SIZE];
+char *read_from_disk2(long long start, unsigned int avail_bytes)
+{
+ int res;
+
+ res = read_fs_bytes(fd, start, avail_bytes, read_from_file_buffer2);
+ if(res == 0)
+ return NULL;
+
+ return read_from_file_buffer2;
+}
+
+
+/*
+ * Compute 16 bit BSD checksum over the data
+ */
+unsigned short get_checksum(char *buff, int bytes, unsigned short chksum)
+{
+ unsigned char *b = (unsigned char *) buff;
+
+ while(bytes --) {
+ chksum = (chksum & 1) ? (chksum >> 1) | 0x8000 : chksum >> 1;
+ chksum += *b++;
+ }
+
+ return chksum;
+}
+
+
+unsigned short get_checksum_disk(long long start, long long l,
+ unsigned int *blocks)
+{
+ unsigned short chksum = 0;
+ unsigned int bytes;
+ struct file_buffer *write_buffer;
+ int i;
+
+ for(i = 0; l; i++) {
+ bytes = SQUASHFS_COMPRESSED_SIZE_BLOCK(blocks[i]);
+ if(bytes == 0) /* sparse block */
+ continue;
+ write_buffer = cache_lookup(bwriter_buffer, start);
+ if(write_buffer) {
+ chksum = get_checksum(write_buffer->data, bytes,
+ chksum);
+ cache_block_put(write_buffer);
+ } else {
+ void *data = read_from_disk(start, bytes);
+ if(data == NULL) {
+ ERROR("Failed to checksum data from output"
+ " filesystem\n");
+ BAD_ERROR("Output filesystem corrupted?\n");
+ }
+
+ chksum = get_checksum(data, bytes, chksum);
+ }
+
+ l -= bytes;
+ start += bytes;
+ }
+
+ return chksum;
+}
+
+
+unsigned short get_checksum_mem(char *buff, int bytes)
+{
+ return get_checksum(buff, bytes, 0);
+}
+
+
+unsigned short get_checksum_mem_buffer(struct file_buffer *file_buffer)
+{
+ if(file_buffer == NULL)
+ return 0;
+ else
+ return get_checksum(file_buffer->data, file_buffer->size, 0);
+}
+
+
+#define DUP_HASH(a) (a & 0xffff)
+void add_file(long long start, long long file_size, long long file_bytes,
+ unsigned int *block_listp, int blocks, unsigned int fragment,
+ int offset, int bytes)
+{
+ struct fragment *frg;
+ unsigned int *block_list = block_listp;
+ struct file_info *dupl_ptr = dupl[DUP_HASH(file_size)];
+ struct append_file *append_file;
+ struct file_info *file;
+
+ if(!duplicate_checking || file_size == 0)
+ return;
+
+ for(; dupl_ptr; dupl_ptr = dupl_ptr->next) {
+ if(file_size != dupl_ptr->file_size)
+ continue;
+ if(blocks != 0 && start != dupl_ptr->start)
+ continue;
+ if(fragment != dupl_ptr->fragment->index)
+ continue;
+ if(fragment != SQUASHFS_INVALID_FRAG && (offset !=
+ dupl_ptr->fragment->offset || bytes !=
+ dupl_ptr->fragment->size))
+ continue;
+ return;
+ }
+
+ frg = malloc(sizeof(struct fragment));
+ if(frg == NULL)
+ MEM_ERROR();
+
+ frg->index = fragment;
+ frg->offset = offset;
+ frg->size = bytes;
+
+ file = add_non_dup(file_size, file_bytes, block_list, start, frg, 0, 0,
+ FALSE, FALSE);
+
+ if(fragment == SQUASHFS_INVALID_FRAG)
+ return;
+
+ append_file = malloc(sizeof(struct append_file));
+ if(append_file == NULL)
+ MEM_ERROR();
+
+ append_file->file = file;
+ append_file->next = file_mapping[fragment];
+ file_mapping[fragment] = append_file;
+}
+
+
+int pre_duplicate(long long file_size)
+{
+ struct file_info *dupl_ptr = dupl[DUP_HASH(file_size)];
+
+ for(; dupl_ptr; dupl_ptr = dupl_ptr->next)
+ if(dupl_ptr->file_size == file_size)
+ return TRUE;
+
+ return FALSE;
+}
+
+
+struct file_info *add_non_dup(long long file_size, long long bytes,
+ unsigned int *block_list, long long start, struct fragment *fragment,
+ unsigned short checksum, unsigned short fragment_checksum,
+ int checksum_flag, int checksum_frag_flag)
+{
+ struct file_info *dupl_ptr = malloc(sizeof(struct file_info));
+
+ if(dupl_ptr == NULL)
+ MEM_ERROR();
+
+ dupl_ptr->file_size = file_size;
+ dupl_ptr->bytes = bytes;
+ dupl_ptr->block_list = block_list;
+ dupl_ptr->start = start;
+ dupl_ptr->fragment = fragment;
+ dupl_ptr->checksum = checksum;
+ dupl_ptr->fragment_checksum = fragment_checksum;
+ dupl_ptr->have_frag_checksum = checksum_frag_flag;
+ dupl_ptr->have_checksum = checksum_flag;
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &dup_mutex);
+ pthread_mutex_lock(&dup_mutex);
+ dupl_ptr->next = dupl[DUP_HASH(file_size)];
+ dupl[DUP_HASH(file_size)] = dupl_ptr;
+ dup_files ++;
+ pthread_cleanup_pop(1);
+
+ return dupl_ptr;
+}
+
+
+struct fragment *frag_duplicate(struct file_buffer *file_buffer, char *dont_put)
+{
+ struct file_info *dupl_ptr;
+ struct file_buffer *buffer;
+ struct file_info *dupl_start = file_buffer->dupl_start;
+ long long file_size = file_buffer->file_size;
+ unsigned short checksum = file_buffer->checksum;
+ int res;
+
+ if(file_buffer->duplicate) {
+ TRACE("Found duplicate file, fragment %d, size %d, offset %d, "
+ "checksum 0x%x\n", dupl_start->fragment->index,
+ file_size, dupl_start->fragment->offset, checksum);
+ *dont_put = TRUE;
+ return dupl_start->fragment;
+ } else {
+ *dont_put = FALSE;
+ dupl_ptr = dupl[DUP_HASH(file_size)];
+ }
+
+ for(; dupl_ptr && dupl_ptr != dupl_start; dupl_ptr = dupl_ptr->next) {
+ if(file_size == dupl_ptr->file_size && file_size ==
+ dupl_ptr->fragment->size) {
+ if(get_fragment_checksum(dupl_ptr) == checksum) {
+ buffer = get_fragment(dupl_ptr->fragment);
+ res = memcmp(file_buffer->data, buffer->data +
+ dupl_ptr->fragment->offset, file_size);
+ cache_block_put(buffer);
+ if(res == 0)
+ break;
+ }
+ }
+ }
+
+ if(!dupl_ptr || dupl_ptr == dupl_start)
+ return NULL;
+
+ TRACE("Found duplicate file, fragment %d, size %d, offset %d, "
+ "checksum 0x%x\n", dupl_ptr->fragment->index, file_size,
+ dupl_ptr->fragment->offset, checksum);
+
+ return dupl_ptr->fragment;
+}
+
+
+struct file_info *duplicate(long long file_size, long long bytes,
+ unsigned int **block_list, long long *start, struct fragment **fragment,
+ struct file_buffer *file_buffer, int blocks, unsigned short checksum,
+ int checksum_flag)
+{
+ struct file_info *dupl_ptr = dupl[DUP_HASH(file_size)];
+ int frag_bytes = file_buffer ? file_buffer->size : 0;
+ unsigned short fragment_checksum = file_buffer ?
+ file_buffer->checksum : 0;
+
+ for(; dupl_ptr; dupl_ptr = dupl_ptr->next)
+ if(file_size == dupl_ptr->file_size && bytes == dupl_ptr->bytes
+ && frag_bytes == dupl_ptr->fragment->size) {
+ long long target_start, dup_start = dupl_ptr->start;
+ int block;
+
+ if(memcmp(*block_list, dupl_ptr->block_list, blocks *
+ sizeof(unsigned int)) != 0)
+ continue;
+
+ if(checksum_flag == FALSE) {
+ checksum = get_checksum_disk(*start, bytes,
+ *block_list);
+ checksum_flag = TRUE;
+ }
+
+ if(!dupl_ptr->have_checksum) {
+ dupl_ptr->checksum =
+ get_checksum_disk(dupl_ptr->start,
+ dupl_ptr->bytes, dupl_ptr->block_list);
+ dupl_ptr->have_checksum = TRUE;
+ }
+
+ if(checksum != dupl_ptr->checksum ||
+ fragment_checksum !=
+ get_fragment_checksum(dupl_ptr))
+ continue;
+
+ target_start = *start;
+ for(block = 0; block < blocks; block ++) {
+ int size = SQUASHFS_COMPRESSED_SIZE_BLOCK
+ ((*block_list)[block]);
+ struct file_buffer *target_buffer = NULL;
+ struct file_buffer *dup_buffer = NULL;
+ char *target_data, *dup_data;
+ int res;
+
+ if(size == 0)
+ continue;
+ target_buffer = cache_lookup(bwriter_buffer,
+ target_start);
+ if(target_buffer)
+ target_data = target_buffer->data;
+ else {
+ target_data =
+ read_from_disk(target_start,
+ size);
+ if(target_data == NULL) {
+ ERROR("Failed to read data from"
+ " output filesystem\n");
+ BAD_ERROR("Output filesystem"
+ " corrupted?\n");
+ }
+ }
+
+ dup_buffer = cache_lookup(bwriter_buffer,
+ dup_start);
+ if(dup_buffer)
+ dup_data = dup_buffer->data;
+ else {
+ dup_data = read_from_disk2(dup_start,
+ size);
+ if(dup_data == NULL) {
+ ERROR("Failed to read data from"
+ " output filesystem\n");
+ BAD_ERROR("Output filesystem"
+ " corrupted?\n");
+ }
+ }
+
+ res = memcmp(target_data, dup_data, size);
+ cache_block_put(target_buffer);
+ cache_block_put(dup_buffer);
+ if(res != 0)
+ break;
+ target_start += size;
+ dup_start += size;
+ }
+ if(block == blocks) {
+ struct file_buffer *frag_buffer =
+ get_fragment(dupl_ptr->fragment);
+
+ if(frag_bytes == 0 ||
+ memcmp(file_buffer->data,
+ frag_buffer->data +
+ dupl_ptr->fragment->offset,
+ frag_bytes) == 0) {
+ TRACE("Found duplicate file, start "
+ "0x%llx, size %lld, checksum "
+ "0x%x, fragment %d, size %d, "
+ "offset %d, checksum 0x%x\n",
+ dupl_ptr->start,
+ dupl_ptr->bytes,
+ dupl_ptr->checksum,
+ dupl_ptr->fragment->index,
+ frag_bytes,
+ dupl_ptr->fragment->offset,
+ fragment_checksum);
+ *block_list = dupl_ptr->block_list;
+ *start = dupl_ptr->start;
+ *fragment = dupl_ptr->fragment;
+ cache_block_put(frag_buffer);
+ return 0;
+ }
+ cache_block_put(frag_buffer);
+ }
+ }
+
+
+ return add_non_dup(file_size, bytes, *block_list, *start, *fragment,
+ checksum, fragment_checksum, checksum_flag, TRUE);
+}
+
+
+static inline int is_fragment(struct inode_info *inode)
+{
+ off_t file_size = inode->buf.st_size;
+
+ /*
+ * If this block is to be compressed differently to the
+ * fragment compression then it cannot be a fragment
+ */
+ if(inode->noF != noF)
+ return FALSE;
+
+ return !inode->no_fragments && file_size && (file_size < block_size ||
+ (inode->always_use_fragments && file_size & (block_size - 1)));
+}
+
+
+void put_file_buffer(struct file_buffer *file_buffer)
+{
+ /*
+ * Decide where to send the file buffer:
+ * - compressible non-fragment blocks go to the deflate threads,
+ * - fragments go to the process fragment threads,
+ * - all others go directly to the main thread
+ */
+ if(file_buffer->error) {
+ file_buffer->fragment = 0;
+ seq_queue_put(to_main, file_buffer);
+ } else if (file_buffer->file_size == 0)
+ seq_queue_put(to_main, file_buffer);
+ else if(file_buffer->fragment)
+ queue_put(to_process_frag, file_buffer);
+ else
+ queue_put(to_deflate, file_buffer);
+}
+
+
+static int seq = 0;
+void reader_read_process(struct dir_ent *dir_ent)
+{
+ long long bytes = 0;
+ struct inode_info *inode = dir_ent->inode;
+ struct file_buffer *prev_buffer = NULL, *file_buffer;
+ int status, byte, res, child;
+ int file = pseudo_exec_file(get_pseudo_file(inode->pseudo_id), &child);
+
+ if(!file) {
+ file_buffer = cache_get_nohash(reader_buffer);
+ file_buffer->sequence = seq ++;
+ goto read_err;
+ }
+
+ while(1) {
+ file_buffer = cache_get_nohash(reader_buffer);
+ file_buffer->sequence = seq ++;
+ file_buffer->noD = inode->noD;
+
+ byte = read_bytes(file, file_buffer->data, block_size);
+ if(byte == -1)
+ goto read_err2;
+
+ file_buffer->size = byte;
+ file_buffer->file_size = -1;
+ file_buffer->error = FALSE;
+ file_buffer->fragment = FALSE;
+ bytes += byte;
+
+ if(byte == 0)
+ break;
+
+ /*
+ * Update progress bar size. This is done
+ * on every block rather than waiting for all blocks to be
+ * read incase write_file_process() is running in parallel
+ * with this. Otherwise the current progress bar position
+ * may get ahead of the progress bar size.
+ */
+ progress_bar_size(1);
+
+ if(prev_buffer)
+ put_file_buffer(prev_buffer);
+ prev_buffer = file_buffer;
+ }
+
+ /*
+ * Update inode file size now that the size of the dynamic pseudo file
+ * is known. This is needed for the -info option.
+ */
+ inode->buf.st_size = bytes;
+
+ res = waitpid(child, &status, 0);
+ close(file);
+
+ if(res == -1 || !WIFEXITED(status) || WEXITSTATUS(status) != 0)
+ goto read_err;
+
+ if(prev_buffer == NULL)
+ prev_buffer = file_buffer;
+ else {
+ cache_block_put(file_buffer);
+ seq --;
+ }
+ prev_buffer->file_size = bytes;
+ prev_buffer->fragment = is_fragment(inode);
+ put_file_buffer(prev_buffer);
+
+ return;
+
+read_err2:
+ close(file);
+read_err:
+ if(prev_buffer) {
+ cache_block_put(file_buffer);
+ seq --;
+ file_buffer = prev_buffer;
+ }
+ file_buffer->error = TRUE;
+ put_file_buffer(file_buffer);
+}
+
+
+void reader_read_file(struct dir_ent *dir_ent)
+{
+ struct stat *buf = &dir_ent->inode->buf, buf2;
+ struct file_buffer *file_buffer;
+ int blocks, file, res;
+ long long bytes, read_size;
+ struct inode_info *inode = dir_ent->inode;
+
+ if(inode->read)
+ return;
+
+ inode->read = TRUE;
+again:
+ bytes = 0;
+ read_size = buf->st_size;
+ blocks = (read_size + block_size - 1) >> block_log;
+
+ file = open(pathname_reader(dir_ent), O_RDONLY);
+ if(file == -1) {
+ file_buffer = cache_get_nohash(reader_buffer);
+ file_buffer->sequence = seq ++;
+ goto read_err2;
+ }
+
+ do {
+ file_buffer = cache_get_nohash(reader_buffer);
+ file_buffer->file_size = read_size;
+ file_buffer->sequence = seq ++;
+ file_buffer->noD = inode->noD;
+ file_buffer->error = FALSE;
+
+ /*
+ * Always try to read block_size bytes from the file rather
+ * than expected bytes (which will be less than the block_size
+ * at the file tail) to check that the file hasn't grown
+ * since being stated. If it is longer (or shorter) than
+ * expected, then restat, and try again. Note the special
+ * case where the file is an exact multiple of the block_size
+ * is dealt with later.
+ */
+ file_buffer->size = read_bytes(file, file_buffer->data,
+ block_size);
+ if(file_buffer->size == -1)
+ goto read_err;
+
+ bytes += file_buffer->size;
+
+ if(blocks > 1) {
+ /* non-tail block should be exactly block_size */
+ if(file_buffer->size < block_size)
+ goto restat;
+
+ file_buffer->fragment = FALSE;
+ put_file_buffer(file_buffer);
+ }
+ } while(-- blocks > 0);
+
+ /* Overall size including tail should match */
+ if(read_size != bytes)
+ goto restat;
+
+ if(read_size && read_size % block_size == 0) {
+ /*
+ * Special case where we've not tried to read past the end of
+ * the file. We expect to get EOF, i.e. the file isn't larger
+ * than we expect.
+ */
+ char buffer;
+ int res;
+
+ res = read_bytes(file, &buffer, 1);
+ if(res == -1)
+ goto read_err;
+
+ if(res != 0)
+ goto restat;
+ }
+
+ file_buffer->fragment = is_fragment(inode);
+ put_file_buffer(file_buffer);
+
+ close(file);
+
+ return;
+
+restat:
+ res = fstat(file, &buf2);
+ if(res == -1) {
+ ERROR("Cannot stat dir/file %s because %s\n",
+ pathname_reader(dir_ent), strerror(errno));
+ goto read_err;
+ }
+
+ if(read_size != buf2.st_size) {
+ close(file);
+ memcpy(buf, &buf2, sizeof(struct stat));
+ file_buffer->error = 2;
+ put_file_buffer(file_buffer);
+ goto again;
+ }
+read_err:
+ close(file);
+read_err2:
+ file_buffer->error = TRUE;
+ put_file_buffer(file_buffer);
+}
+
+
+void reader_scan(struct dir_info *dir) {
+ struct dir_ent *dir_ent = dir->list;
+
+ for(; dir_ent; dir_ent = dir_ent->next) {
+ struct stat *buf = &dir_ent->inode->buf;
+ if(dir_ent->inode->root_entry)
+ continue;
+
+ if(IS_PSEUDO_PROCESS(dir_ent->inode)) {
+ reader_read_process(dir_ent);
+ continue;
+ }
+
+ switch(buf->st_mode & S_IFMT) {
+ case S_IFREG:
+ reader_read_file(dir_ent);
+ break;
+ case S_IFDIR:
+ reader_scan(dir_ent->dir);
+ break;
+ }
+ }
+}
+
+
+void *reader(void *arg)
+{
+ if(!sorted)
+ reader_scan(queue_get(to_reader));
+ else {
+ int i;
+ struct priority_entry *entry;
+
+ queue_get(to_reader);
+ for(i = 65535; i >= 0; i--)
+ for(entry = priority_list[i]; entry;
+ entry = entry->next)
+ reader_read_file(entry->dir);
+ }
+
+ pthread_exit(NULL);
+}
+
+
+void *writer(void *arg)
+{
+ while(1) {
+ struct file_buffer *file_buffer = queue_get(to_writer);
+ off_t off;
+
+ if(file_buffer == NULL) {
+ queue_put(from_writer, NULL);
+ continue;
+ }
+
+ off = file_buffer->block;
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &pos_mutex);
+ pthread_mutex_lock(&pos_mutex);
+
+ if(lseek(fd, off, SEEK_SET) == -1) {
+ ERROR("writer: Lseek on destination failed because "
+ "%s, offset=0x%llx\n", strerror(errno), off);
+ BAD_ERROR("Probably out of space on output "
+ "%s\n", block_device ? "block device" :
+ "filesystem");
+ }
+
+ if(write_bytes(fd, file_buffer->data,
+ file_buffer->size) == -1)
+ BAD_ERROR("Failed to write to output %s\n",
+ block_device ? "block device" : "filesystem");
+
+ pthread_cleanup_pop(1);
+
+ cache_block_put(file_buffer);
+ }
+}
+
+
+int all_zero(struct file_buffer *file_buffer)
+{
+ int i;
+ long entries = file_buffer->size / sizeof(long);
+ long *p = (long *) file_buffer->data;
+
+ for(i = 0; i < entries && p[i] == 0; i++);
+
+ if(i == entries) {
+ for(i = file_buffer->size & ~(sizeof(long) - 1);
+ i < file_buffer->size && file_buffer->data[i] == 0;
+ i++);
+
+ return i == file_buffer->size;
+ }
+
+ return 0;
+}
+
+
+void *deflator(void *arg)
+{
+ struct file_buffer *write_buffer = cache_get_nohash(bwriter_buffer);
+ void *stream = NULL;
+ int res;
+
+ res = compressor_init(comp, &stream, block_size, 1);
+ if(res)
+ BAD_ERROR("deflator:: compressor_init failed\n");
+
+ while(1) {
+ struct file_buffer *file_buffer = queue_get(to_deflate);
+
+ if(sparse_files && all_zero(file_buffer)) {
+ file_buffer->c_byte = 0;
+ seq_queue_put(to_main, file_buffer);
+ } else {
+ write_buffer->c_byte = mangle2(stream,
+ write_buffer->data, file_buffer->data,
+ file_buffer->size, block_size,
+ file_buffer->noD, 1);
+ write_buffer->sequence = file_buffer->sequence;
+ write_buffer->file_size = file_buffer->file_size;
+ write_buffer->block = file_buffer->block;
+ write_buffer->size = SQUASHFS_COMPRESSED_SIZE_BLOCK
+ (write_buffer->c_byte);
+ write_buffer->fragment = FALSE;
+ write_buffer->error = FALSE;
+ cache_block_put(file_buffer);
+ seq_queue_put(to_main, write_buffer);
+ write_buffer = cache_get_nohash(bwriter_buffer);
+ }
+ }
+}
+
+
+void *frag_deflator(void *arg)
+{
+ void *stream = NULL;
+ int res;
+
+ res = compressor_init(comp, &stream, block_size, 1);
+ if(res)
+ BAD_ERROR("frag_deflator:: compressor_init failed\n");
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &fragment_mutex);
+
+ while(1) {
+ int c_byte, compressed_size;
+ struct file_buffer *file_buffer = queue_get(to_frag);
+ struct file_buffer *write_buffer =
+ cache_get(fwriter_buffer, file_buffer->block);
+
+ c_byte = mangle2(stream, write_buffer->data, file_buffer->data,
+ file_buffer->size, block_size, noF, 1);
+ compressed_size = SQUASHFS_COMPRESSED_SIZE_BLOCK(c_byte);
+ write_buffer->size = compressed_size;
+ pthread_mutex_lock(&fragment_mutex);
+ if(fragments_locked == FALSE) {
+ fragment_table[file_buffer->block].size = c_byte;
+ fragment_table[file_buffer->block].start_block = bytes;
+ write_buffer->block = bytes;
+ bytes += compressed_size;
+ fragments_outstanding --;
+ queue_put(to_writer, write_buffer);
+ pthread_mutex_unlock(&fragment_mutex);
+ TRACE("Writing fragment %lld, uncompressed size %d, "
+ "compressed size %d\n", file_buffer->block,
+ file_buffer->size, compressed_size);
+ } else {
+ add_pending_fragment(write_buffer, c_byte,
+ file_buffer->block);
+ pthread_mutex_unlock(&fragment_mutex);
+ }
+ cache_block_put(file_buffer);
+ }
+
+ pthread_cleanup_pop(0);
+}
+
+
+struct file_buffer *get_file_buffer()
+{
+ struct file_buffer *file_buffer = seq_queue_get(to_main);
+
+ return file_buffer;
+}
+
+
+void write_file_empty(squashfs_inode *inode, struct dir_ent *dir_ent,
+ struct file_buffer *file_buffer, int *duplicate_file)
+{
+ file_count ++;
+ *duplicate_file = FALSE;
+ cache_block_put(file_buffer);
+ create_inode(inode, NULL, dir_ent, SQUASHFS_FILE_TYPE, 0, 0, 0,
+ NULL, &empty_fragment, NULL, 0);
+}
+
+
+void write_file_frag(squashfs_inode *inode, struct dir_ent *dir_ent,
+ struct file_buffer *file_buffer, int *duplicate_file)
+{
+ int size = file_buffer->file_size;
+ struct fragment *fragment;
+ unsigned short checksum = file_buffer->checksum;
+ char dont_put;
+
+ fragment = frag_duplicate(file_buffer, &dont_put);
+ *duplicate_file = !fragment;
+ if(!fragment) {
+ fragment = get_and_fill_fragment(file_buffer, dir_ent);
+ if(duplicate_checking)
+ add_non_dup(size, 0, NULL, 0, fragment, 0, checksum,
+ TRUE, TRUE);
+ }
+
+ if(dont_put)
+ free(file_buffer);
+ else
+ cache_block_put(file_buffer);
+
+ total_bytes += size;
+ file_count ++;
+
+ inc_progress_bar();
+
+ create_inode(inode, NULL, dir_ent, SQUASHFS_FILE_TYPE, size, 0,
+ 0, NULL, fragment, NULL, 0);
+
+ if(!duplicate_checking)
+ free_fragment(fragment);
+}
+
+
+int write_file_process(squashfs_inode *inode, struct dir_ent *dir_ent,
+ struct file_buffer *read_buffer, int *duplicate_file)
+{
+ long long read_size, file_bytes, start;
+ struct fragment *fragment;
+ unsigned int *block_list = NULL;
+ int block = 0, status;
+ long long sparse = 0;
+ struct file_buffer *fragment_buffer = NULL;
+
+ *duplicate_file = FALSE;
+
+ lock_fragments();
+
+ file_bytes = 0;
+ start = bytes;
+ while (1) {
+ read_size = read_buffer->file_size;
+ if(read_buffer->fragment)
+ fragment_buffer = read_buffer;
+ else {
+ block_list = realloc(block_list, (block + 1) *
+ sizeof(unsigned int));
+ if(block_list == NULL)
+ MEM_ERROR();
+ block_list[block ++] = read_buffer->c_byte;
+ if(read_buffer->c_byte) {
+ read_buffer->block = bytes;
+ bytes += read_buffer->size;
+ cache_hash(read_buffer, read_buffer->block);
+ file_bytes += read_buffer->size;
+ queue_put(to_writer, read_buffer);
+ } else {
+ sparse += read_buffer->size;
+ cache_block_put(read_buffer);
+ }
+ }
+ inc_progress_bar();
+
+ if(read_size != -1)
+ break;
+
+ read_buffer = get_file_buffer();
+ if(read_buffer->error)
+ goto read_err;
+ }
+
+ unlock_fragments();
+ fragment = get_and_fill_fragment(fragment_buffer, dir_ent);
+
+ if(duplicate_checking)
+ add_non_dup(read_size, file_bytes, block_list, start, fragment,
+ 0, fragment_buffer ? fragment_buffer->checksum : 0,
+ FALSE, TRUE);
+ cache_block_put(fragment_buffer);
+ file_count ++;
+ total_bytes += read_size;
+
+ create_inode(inode, NULL, dir_ent, SQUASHFS_FILE_TYPE, read_size, start,
+ block, block_list, fragment, NULL, sparse);
+
+ if(duplicate_checking == FALSE) {
+ free(block_list);
+ free_fragment(fragment);
+ }
+
+ return 0;
+
+read_err:
+ dec_progress_bar(block);
+ status = read_buffer->error;
+ bytes = start;
+ if(!block_device) {
+ int res;
+
+ queue_put(to_writer, NULL);
+ if(queue_get(from_writer) != 0)
+ EXIT_MKSQUASHFS();
+ res = ftruncate(fd, bytes);
+ if(res != 0)
+ BAD_ERROR("Failed to truncate dest file because %s\n",
+ strerror(errno));
+ }
+ unlock_fragments();
+ free(block_list);
+ cache_block_put(read_buffer);
+ return status;
+}
+
+
+int write_file_blocks_dup(squashfs_inode *inode, struct dir_ent *dir_ent,
+ struct file_buffer *read_buffer, int *duplicate_file)
+{
+ int block, thresh;
+ long long read_size = read_buffer->file_size;
+ long long file_bytes, dup_start, start;
+ struct fragment *fragment;
+ struct file_info *dupl_ptr;
+ int blocks = (read_size + block_size - 1) >> block_log;
+ unsigned int *block_list, *block_listp;
+ struct file_buffer **buffer_list;
+ int status;
+ long long sparse = 0;
+ struct file_buffer *fragment_buffer = NULL;
+
+ block_list = malloc(blocks * sizeof(unsigned int));
+ if(block_list == NULL)
+ MEM_ERROR();
+ block_listp = block_list;
+
+ buffer_list = malloc(blocks * sizeof(struct file_buffer *));
+ if(buffer_list == NULL)
+ MEM_ERROR();
+
+ lock_fragments();
+
+ file_bytes = 0;
+ start = dup_start = bytes;
+ thresh = blocks > bwriter_size ? blocks - bwriter_size : 0;
+
+ for(block = 0; block < blocks;) {
+ if(read_buffer->fragment) {
+ block_list[block] = 0;
+ buffer_list[block] = NULL;
+ fragment_buffer = read_buffer;
+ blocks = read_size >> block_log;
+ } else {
+ block_list[block] = read_buffer->c_byte;
+
+ if(read_buffer->c_byte) {
+ read_buffer->block = bytes;
+ bytes += read_buffer->size;
+ file_bytes += read_buffer->size;
+ cache_hash(read_buffer, read_buffer->block);
+ if(block < thresh) {
+ buffer_list[block] = NULL;
+ queue_put(to_writer, read_buffer);
+ } else
+ buffer_list[block] = read_buffer;
+ } else {
+ buffer_list[block] = NULL;
+ sparse += read_buffer->size;
+ cache_block_put(read_buffer);
+ }
+ }
+ inc_progress_bar();
+
+ if(++block < blocks) {
+ read_buffer = get_file_buffer();
+ if(read_buffer->error)
+ goto read_err;
+ }
+ }
+
+ dupl_ptr = duplicate(read_size, file_bytes, &block_listp, &dup_start,
+ &fragment, fragment_buffer, blocks, 0, FALSE);
+
+ if(dupl_ptr) {
+ *duplicate_file = FALSE;
+ for(block = thresh; block < blocks; block ++)
+ if(buffer_list[block])
+ queue_put(to_writer, buffer_list[block]);
+ fragment = get_and_fill_fragment(fragment_buffer, dir_ent);
+ dupl_ptr->fragment = fragment;
+ } else {
+ *duplicate_file = TRUE;
+ for(block = thresh; block < blocks; block ++)
+ cache_block_put(buffer_list[block]);
+ bytes = start;
+ if(thresh && !block_device) {
+ int res;
+
+ queue_put(to_writer, NULL);
+ if(queue_get(from_writer) != 0)
+ EXIT_MKSQUASHFS();
+ res = ftruncate(fd, bytes);
+ if(res != 0)
+ BAD_ERROR("Failed to truncate dest file because"
+ " %s\n", strerror(errno));
+ }
+ }
+
+ unlock_fragments();
+ cache_block_put(fragment_buffer);
+ free(buffer_list);
+ file_count ++;
+ total_bytes += read_size;
+
+ /*
+ * sparse count is needed to ensure squashfs correctly reports a
+ * a smaller block count on stat calls to sparse files. This is
+ * to ensure intelligent applications like cp correctly handle the
+ * file as a sparse file. If the file in the original filesystem isn't
+ * stored as a sparse file then still store it sparsely in squashfs, but
+ * report it as non-sparse on stat calls to preserve semantics
+ */
+ if(sparse && (dir_ent->inode->buf.st_blocks << 9) >= read_size)
+ sparse = 0;
+
+ create_inode(inode, NULL, dir_ent, SQUASHFS_FILE_TYPE, read_size,
+ dup_start, blocks, block_listp, fragment, NULL, sparse);
+
+ if(*duplicate_file == TRUE)
+ free(block_list);
+
+ return 0;
+
+read_err:
+ dec_progress_bar(block);
+ status = read_buffer->error;
+ bytes = start;
+ if(thresh && !block_device) {
+ int res;
+
+ queue_put(to_writer, NULL);
+ if(queue_get(from_writer) != 0)
+ EXIT_MKSQUASHFS();
+ res = ftruncate(fd, bytes);
+ if(res != 0)
+ BAD_ERROR("Failed to truncate dest file because %s\n",
+ strerror(errno));
+ }
+ unlock_fragments();
+ for(blocks = thresh; blocks < block; blocks ++)
+ cache_block_put(buffer_list[blocks]);
+ free(buffer_list);
+ free(block_list);
+ cache_block_put(read_buffer);
+ return status;
+}
+
+
+int write_file_blocks(squashfs_inode *inode, struct dir_ent *dir_ent,
+ struct file_buffer *read_buffer, int *dup)
+{
+ long long read_size = read_buffer->file_size;
+ long long file_bytes, start;
+ struct fragment *fragment;
+ unsigned int *block_list;
+ int block, status;
+ int blocks = (read_size + block_size - 1) >> block_log;
+ long long sparse = 0;
+ struct file_buffer *fragment_buffer = NULL;
+
+ if(pre_duplicate(read_size))
+ return write_file_blocks_dup(inode, dir_ent, read_buffer, dup);
+
+ *dup = FALSE;
+
+ block_list = malloc(blocks * sizeof(unsigned int));
+ if(block_list == NULL)
+ MEM_ERROR();
+
+ lock_fragments();
+
+ file_bytes = 0;
+ start = bytes;
+ for(block = 0; block < blocks;) {
+ if(read_buffer->fragment) {
+ block_list[block] = 0;
+ fragment_buffer = read_buffer;
+ blocks = read_size >> block_log;
+ } else {
+ block_list[block] = read_buffer->c_byte;
+ if(read_buffer->c_byte) {
+ read_buffer->block = bytes;
+ bytes += read_buffer->size;
+ cache_hash(read_buffer, read_buffer->block);
+ file_bytes += read_buffer->size;
+ queue_put(to_writer, read_buffer);
+ } else {
+ sparse += read_buffer->size;
+ cache_block_put(read_buffer);
+ }
+ }
+ inc_progress_bar();
+
+ if(++block < blocks) {
+ read_buffer = get_file_buffer();
+ if(read_buffer->error)
+ goto read_err;
+ }
+ }
+
+ unlock_fragments();
+ fragment = get_and_fill_fragment(fragment_buffer, dir_ent);
+
+ if(duplicate_checking)
+ add_non_dup(read_size, file_bytes, block_list, start, fragment,
+ 0, fragment_buffer ? fragment_buffer->checksum : 0,
+ FALSE, TRUE);
+ cache_block_put(fragment_buffer);
+ file_count ++;
+ total_bytes += read_size;
+
+ /*
+ * sparse count is needed to ensure squashfs correctly reports a
+ * a smaller block count on stat calls to sparse files. This is
+ * to ensure intelligent applications like cp correctly handle the
+ * file as a sparse file. If the file in the original filesystem isn't
+ * stored as a sparse file then still store it sparsely in squashfs, but
+ * report it as non-sparse on stat calls to preserve semantics
+ */
+ if(sparse && (dir_ent->inode->buf.st_blocks << 9) >= read_size)
+ sparse = 0;
+
+ create_inode(inode, NULL, dir_ent, SQUASHFS_FILE_TYPE, read_size, start,
+ blocks, block_list, fragment, NULL, sparse);
+
+ if(duplicate_checking == FALSE) {
+ free(block_list);
+ free_fragment(fragment);
+ }
+
+ return 0;
+
+read_err:
+ dec_progress_bar(block);
+ status = read_buffer->error;
+ bytes = start;
+ if(!block_device) {
+ int res;
+
+ queue_put(to_writer, NULL);
+ if(queue_get(from_writer) != 0)
+ EXIT_MKSQUASHFS();
+ res = ftruncate(fd, bytes);
+ if(res != 0)
+ BAD_ERROR("Failed to truncate dest file because %s\n",
+ strerror(errno));
+ }
+ unlock_fragments();
+ free(block_list);
+ cache_block_put(read_buffer);
+ return status;
+}
+
+
+void write_file(squashfs_inode *inode, struct dir_ent *dir, int *dup)
+{
+ int status;
+ struct file_buffer *read_buffer;
+
+again:
+ read_buffer = get_file_buffer();
+ status = read_buffer->error;
+
+ if(status)
+ cache_block_put(read_buffer);
+ else if(read_buffer->file_size == -1)
+ status = write_file_process(inode, dir, read_buffer, dup);
+ else if(read_buffer->file_size == 0)
+ write_file_empty(inode, dir, read_buffer, dup);
+ else if(read_buffer->fragment && read_buffer->c_byte)
+ write_file_frag(inode, dir, read_buffer, dup);
+ else
+ status = write_file_blocks(inode, dir, read_buffer, dup);
+
+ if(status == 2) {
+ ERROR("File %s changed size while reading filesystem, "
+ "attempting to re-read\n", pathname(dir));
+ goto again;
+ } else if(status == 1) {
+ ERROR_START("Failed to read file %s", pathname(dir));
+ ERROR_EXIT(", creating empty file\n");
+ write_file_empty(inode, dir, NULL, dup);
+ }
+}
+
+
+#define BUFF_SIZE 512
+char *name;
+char *basename_r();
+
+char *getbase(char *pathname)
+{
+ static char *b_buffer = NULL;
+ static int b_size = BUFF_SIZE;
+ char *result;
+
+ if(b_buffer == NULL) {
+ b_buffer = malloc(b_size);
+ if(b_buffer == NULL)
+ MEM_ERROR();
+ }
+
+ while(1) {
+ if(*pathname != '/') {
+ result = getcwd(b_buffer, b_size);
+ if(result == NULL && errno != ERANGE)
+ BAD_ERROR("Getcwd failed in getbase\n");
+
+ /* enough room for pathname + "/" + '\0' terminator? */
+ if(result && strlen(pathname) + 2 <=
+ b_size - strlen(b_buffer)) {
+ strcat(strcat(b_buffer, "/"), pathname);
+ break;
+ }
+ } else if(strlen(pathname) < b_size) {
+ strcpy(b_buffer, pathname);
+ break;
+ }
+
+ /* Buffer not large enough, realloc and try again */
+ b_buffer = realloc(b_buffer, b_size += BUFF_SIZE);
+ if(b_buffer == NULL)
+ MEM_ERROR();
+ }
+
+ name = b_buffer;
+ if(((result = basename_r()) == NULL) || (strcmp(result, "..") == 0))
+ return NULL;
+ else
+ return result;
+}
+
+
+char *basename_r()
+{
+ char *s;
+ char *p;
+ int n = 1;
+
+ for(;;) {
+ s = name;
+ if(*name == '\0')
+ return NULL;
+ if(*name != '/') {
+ while(*name != '\0' && *name != '/') name++;
+ n = name - s;
+ }
+ while(*name == '/') name++;
+ if(strncmp(s, ".", n) == 0)
+ continue;
+ if((*name == '\0') || (strncmp(s, "..", n) == 0) ||
+ ((p = basename_r()) == NULL)) {
+ s[n] = '\0';
+ return s;
+ }
+ if(strcmp(p, "..") == 0)
+ continue;
+ return p;
+ }
+}
+
+
+struct inode_info *lookup_inode3(struct stat *buf, int pseudo, int id,
+ char *symlink, int bytes)
+{
+ int ino_hash = INODE_HASH(buf->st_dev, buf->st_ino);
+ struct inode_info *inode;
+
+ /*
+ * Look-up inode in hash table, if it already exists we have a
+ * hard-link, so increment the nlink count and return it.
+ * Don't do the look-up for directories because we don't hard-link
+ * directories.
+ */
+ if ((buf->st_mode & S_IFMT) != S_IFDIR) {
+ for(inode = inode_info[ino_hash]; inode; inode = inode->next) {
+ if(memcmp(buf, &inode->buf, sizeof(struct stat)) == 0) {
+ inode->nlink ++;
+ return inode;
+ }
+ }
+ }
+
+ inode = malloc(sizeof(struct inode_info) + bytes);
+ if(inode == NULL)
+ MEM_ERROR();
+
+ if(bytes)
+ memcpy(&inode->symlink, symlink, bytes);
+ memcpy(&inode->buf, buf, sizeof(struct stat));
+ inode->read = FALSE;
+ inode->root_entry = FALSE;
+ inode->pseudo_file = pseudo;
+ inode->pseudo_id = id;
+ inode->inode = SQUASHFS_INVALID_BLK;
+ inode->nlink = 1;
+ inode->inode_number = 0;
+
+ /*
+ * Copy filesystem wide defaults into inode, these filesystem
+ * wide defaults may be altered on an individual inode basis by
+ * user specified actions
+ *
+ */
+ inode->no_fragments = no_fragments;
+ inode->always_use_fragments = always_use_fragments;
+ inode->noD = noD;
+ inode->noF = noF;
+
+ inode->next = inode_info[ino_hash];
+ inode_info[ino_hash] = inode;
+
+ return inode;
+}
+
+
+static inline struct inode_info *lookup_inode2(struct stat *buf, int pseudo, int id)
+{
+ return lookup_inode3(buf, pseudo, id, NULL, 0);
+}
+
+
+static inline struct inode_info *lookup_inode(struct stat *buf)
+{
+ return lookup_inode2(buf, 0, 0);
+}
+
+
+static inline void alloc_inode_no(struct inode_info *inode, unsigned int use_this)
+{
+ if (inode->inode_number == 0) {
+ inode->inode_number = use_this ? : inode_no ++;
+ if((inode->buf.st_mode & S_IFMT) == S_IFREG)
+ progress_bar_size((inode->buf.st_size + block_size - 1)
+ >> block_log);
+ }
+}
+
+
+static inline struct dir_ent *create_dir_entry(char *name, char *source_name,
+ char *nonstandard_pathname, struct dir_info *dir)
+{
+ struct dir_ent *dir_ent = malloc(sizeof(struct dir_ent));
+ if(dir_ent == NULL)
+ MEM_ERROR();
+
+ dir_ent->name = name;
+ dir_ent->source_name = source_name;
+ dir_ent->nonstandard_pathname = nonstandard_pathname;
+ dir_ent->our_dir = dir;
+ dir_ent->inode = NULL;
+ dir_ent->next = NULL;
+/* ANDROID CHANGES START*/
+#ifdef ANDROID
+ dir_ent->capabilities = 0;
+#endif
+/* ANDROID CHANGES END */
+
+ return dir_ent;
+}
+
+
+static inline void add_dir_entry(struct dir_ent *dir_ent, struct dir_info *sub_dir,
+ struct inode_info *inode_info)
+{
+ struct dir_info *dir = dir_ent->our_dir;
+
+ if(sub_dir)
+ sub_dir->dir_ent = dir_ent;
+
+/* ANDROID CHANGES START*/
+#ifdef ANDROID
+ if (android_config) {
+ if (mount_point) {
+ char *mounted_path;
+ char *rel_path;
+
+ alloc_mounted_path(mount_point, subpathname(dir_ent), &mounted_path);
+ rel_path = mounted_path;
+ while (rel_path && *rel_path == '/')
+ rel_path++;
+ android_fs_config(fs_config_func, rel_path, &inode_info->buf, target_out_path, &dir_ent->capabilities);
+ free(mounted_path);
+ } else {
+ android_fs_config(fs_config_func, pathname(dir_ent), &inode_info->buf, target_out_path, &dir_ent->capabilities);
+ }
+ }
+#endif
+/* ANDROID CHANGES END */
+
+ dir_ent->inode = inode_info;
+ dir_ent->dir = sub_dir;
+
+ dir_ent->next = dir->list;
+ dir->list = dir_ent;
+ dir->count++;
+}
+
+static inline void add_dir_entry2(char *name, char *source_name,
+ char *nonstandard_pathname, struct dir_info *sub_dir,
+ struct inode_info *inode_info, struct dir_info *dir)
+{
+ struct dir_ent *dir_ent = create_dir_entry(name, source_name,
+ nonstandard_pathname, dir);
+
+
+ add_dir_entry(dir_ent, sub_dir, inode_info);
+}
+
+
+static inline void free_dir_entry(struct dir_ent *dir_ent)
+{
+ if(dir_ent->name)
+ free(dir_ent->name);
+
+ if(dir_ent->source_name)
+ free(dir_ent->source_name);
+
+ if(dir_ent->nonstandard_pathname)
+ free(dir_ent->nonstandard_pathname);
+
+ /* if this entry has been associated with an inode, then we need
+ * to update the inode nlink count. Orphaned inodes are harmless, and
+ * is easier to leave them than go to the bother of deleting them */
+ if(dir_ent->inode && !dir_ent->inode->root_entry)
+ dir_ent->inode->nlink --;
+
+ free(dir_ent);
+}
+
+
+static inline void add_excluded(struct dir_info *dir)
+{
+ dir->excluded ++;
+}
+
+
+void dir_scan(squashfs_inode *inode, char *pathname,
+ struct dir_ent *(_readdir)(struct dir_info *), int progress)
+{
+ struct stat buf;
+ struct dir_ent *dir_ent;
+/* ANDROID CHANGES START*/
+#ifdef ANDROID
+ uint64_t caps = 0;
+#endif
+/* ANDROID CHANGES END */
+
+ root_dir = dir_scan1(pathname, "", paths, _readdir, 1);
+ if(root_dir == NULL)
+ return;
+
+ /* Create root directory dir_ent and associated inode, and connect
+ * it to the root directory dir_info structure */
+ dir_ent = create_dir_entry("", NULL, pathname,
+ scan1_opendir("", "", 0));
+
+ if(pathname[0] == '\0') {
+ /*
+ * dummy top level directory, if multiple sources specified on
+ * command line
+ */
+ memset(&buf, 0, sizeof(buf));
+ buf.st_mode = S_IRWXU | S_IRWXG | S_IRWXO | S_IFDIR;
+ buf.st_uid = getuid();
+ buf.st_gid = getgid();
+ buf.st_mtime = time(NULL);
+ buf.st_dev = 0;
+ buf.st_ino = 0;
+ dir_ent->inode = lookup_inode2(&buf, PSEUDO_FILE_OTHER, 0);
+ } else {
+ if(lstat(pathname, &buf) == -1)
+ /* source directory has disappeared? */
+ BAD_ERROR("Cannot stat source directory %s because %s\n",
+ pathname, strerror(errno));
+/* ANDROID CHANGES START*/
+#ifdef ANDROID
+ if (android_config) {
+ if (mount_point)
+ android_fs_config(fs_config_func, mount_point, &buf, target_out_path, &caps);
+ else
+ android_fs_config(fs_config_func, pathname, &buf, target_out_path, &caps);
+ }
+#endif
+/* ANDROID CHANGES END */
+ dir_ent->inode = lookup_inode(&buf);
+ }
+
+/* ANDROID CHANGES START*/
+#ifdef ANDROID
+ dir_ent->capabilities = caps;
+#endif
+/* ANDROID CHANGES END */
+
+ dir_ent->dir = root_dir;
+ root_dir->dir_ent = dir_ent;
+
+ /*
+ * Process most actions and any pseudo files
+ */
+ if(actions() || get_pseudo())
+ dir_scan2(root_dir, get_pseudo());
+
+ /*
+ * Process move actions
+ */
+ if(move_actions()) {
+ dir_scan3(root_dir);
+ do_move_actions();
+ }
+
+ /*
+ * Process prune actions
+ */
+ if(prune_actions())
+ dir_scan4(root_dir);
+
+ /*
+ * Process empty actions
+ */
+ if(empty_actions())
+ dir_scan5(root_dir);
+
+ /*
+ * Sort directories and compute the inode numbers
+ */
+ dir_scan6(root_dir);
+
+ alloc_inode_no(dir_ent->inode, root_inode_number);
+
+ eval_actions(root_dir, dir_ent);
+
+ if(sorted)
+ generate_file_priorities(root_dir, 0,
+ &root_dir->dir_ent->inode->buf);
+
+ if(appending) {
+ sigset_t sigmask;
+
+ restore_thread = init_restore_thread();
+ sigemptyset(&sigmask);
+ sigaddset(&sigmask, SIGINT);
+ sigaddset(&sigmask, SIGTERM);
+ sigaddset(&sigmask, SIGUSR1);
+ if(pthread_sigmask(SIG_BLOCK, &sigmask, NULL) == -1)
+ BAD_ERROR("Failed to set signal mask\n");
+ write_destination(fd, SQUASHFS_START, 4, "\0\0\0\0");
+ }
+
+ queue_put(to_reader, root_dir);
+
+ set_progressbar_state(progress);
+
+ if(sorted)
+ sort_files_and_write(root_dir);
+
+ dir_scan7(inode, root_dir);
+ dir_ent->inode->inode = *inode;
+ dir_ent->inode->type = SQUASHFS_DIR_TYPE;
+}
+
+
+/*
+ * dir_scan1 routines...
+ * These scan the source directories into memory for processing.
+ * Exclude actions are processed here (in contrast to the other actions)
+ * because they affect what is scanned.
+ */
+struct dir_info *scan1_opendir(char *pathname, char *subpath, int depth)
+{
+ struct dir_info *dir;
+
+ dir = malloc(sizeof(struct dir_info));
+ if(dir == NULL)
+ MEM_ERROR();
+
+ if(pathname[0] != '\0') {
+ dir->linuxdir = opendir(pathname);
+ if(dir->linuxdir == NULL) {
+ free(dir);
+ return NULL;
+ }
+ }
+
+ dir->pathname = strdup(pathname);
+ dir->subpath = strdup(subpath);
+ dir->count = 0;
+ dir->directory_count = 0;
+ dir->dir_is_ldir = TRUE;
+ dir->list = NULL;
+ dir->depth = depth;
+ dir->excluded = 0;
+
+ return dir;
+}
+
+
+struct dir_ent *scan1_encomp_readdir(struct dir_info *dir)
+{
+ static int index = 0;
+
+ if(dir->count < old_root_entries) {
+ int i;
+
+ for(i = 0; i < old_root_entries; i++) {
+ if(old_root_entry[i].inode.type == SQUASHFS_DIR_TYPE)
+ dir->directory_count ++;
+ add_dir_entry2(old_root_entry[i].name, NULL, NULL, NULL,
+ &old_root_entry[i].inode, dir);
+ }
+ }
+
+ while(index < source) {
+ char *basename = NULL;
+ char *dir_name = getbase(source_path[index]);
+ int pass = 1, res;
+
+ if(dir_name == NULL) {
+ ERROR_START("Bad source directory %s",
+ source_path[index]);
+ ERROR_EXIT(" - skipping ...\n");
+ index ++;
+ continue;
+ }
+ dir_name = strdup(dir_name);
+ for(;;) {
+ struct dir_ent *dir_ent = dir->list;
+
+ for(; dir_ent && strcmp(dir_ent->name, dir_name) != 0;
+ dir_ent = dir_ent->next);
+ if(dir_ent == NULL)
+ break;
+ ERROR("Source directory entry %s already used! - trying"
+ " ", dir_name);
+ if(pass == 1)
+ basename = dir_name;
+ else
+ free(dir_name);
+ res = asprintf(&dir_name, "%s_%d", basename, pass++);
+ if(res == -1)
+ BAD_ERROR("asprintf failed in "
+ "scan1_encomp_readdir\n");
+ ERROR("%s\n", dir_name);
+ }
+ return create_dir_entry(dir_name, basename,
+ strdup(source_path[index ++]), dir);
+ }
+ return NULL;
+}
+
+
+struct dir_ent *scan1_single_readdir(struct dir_info *dir)
+{
+ struct dirent *d_name;
+ int i;
+
+ if(dir->count < old_root_entries) {
+ for(i = 0; i < old_root_entries; i++) {
+ if(old_root_entry[i].inode.type == SQUASHFS_DIR_TYPE)
+ dir->directory_count ++;
+ add_dir_entry2(old_root_entry[i].name, NULL, NULL, NULL,
+ &old_root_entry[i].inode, dir);
+ }
+ }
+
+ if((d_name = readdir(dir->linuxdir)) != NULL) {
+ char *basename = NULL;
+ char *dir_name = strdup(d_name->d_name);
+ int pass = 1, res;
+
+ for(;;) {
+ struct dir_ent *dir_ent = dir->list;
+
+ for(; dir_ent && strcmp(dir_ent->name, dir_name) != 0;
+ dir_ent = dir_ent->next);
+ if(dir_ent == NULL)
+ break;
+ ERROR("Source directory entry %s already used! - trying"
+ " ", dir_name);
+ if (pass == 1)
+ basename = dir_name;
+ else
+ free(dir_name);
+ res = asprintf(&dir_name, "%s_%d", d_name->d_name, pass++);
+ if(res == -1)
+ BAD_ERROR("asprintf failed in "
+ "scan1_single_readdir\n");
+ ERROR("%s\n", dir_name);
+ }
+ return create_dir_entry(dir_name, basename, NULL, dir);
+ }
+
+ return NULL;
+}
+
+
+struct dir_ent *scan1_readdir(struct dir_info *dir)
+{
+ struct dirent *d_name = readdir(dir->linuxdir);
+
+ return d_name ?
+ create_dir_entry(strdup(d_name->d_name), NULL, NULL, dir) :
+ NULL;
+}
+
+
+void scan1_freedir(struct dir_info *dir)
+{
+ if(dir->pathname[0] != '\0')
+ closedir(dir->linuxdir);
+}
+
+
+struct dir_info *dir_scan1(char *filename, char *subpath,
+ struct pathnames *paths,
+ struct dir_ent *(_readdir)(struct dir_info *), int depth)
+{
+ struct dir_info *dir = scan1_opendir(filename, subpath, depth);
+ struct dir_ent *dir_ent;
+
+ if(dir == NULL) {
+ ERROR_START("Could not open %s", filename);
+ ERROR_EXIT(", skipping...\n");
+ return NULL;
+ }
+
+ while((dir_ent = _readdir(dir))) {
+ struct dir_info *sub_dir;
+ struct stat buf;
+ struct pathnames *new = NULL;
+ char *filename = pathname(dir_ent);
+ char *subpath = NULL;
+ char *dir_name = dir_ent->name;
+
+ if(strcmp(dir_name, ".") == 0 || strcmp(dir_name, "..") == 0) {
+ free_dir_entry(dir_ent);
+ continue;
+ }
+
+ if(lstat(filename, &buf) == -1) {
+ ERROR_START("Cannot stat dir/file %s because %s",
+ filename, strerror(errno));
+ ERROR_EXIT(", ignoring\n");
+ free_dir_entry(dir_ent);
+ continue;
+ }
+
+ if((buf.st_mode & S_IFMT) != S_IFREG &&
+ (buf.st_mode & S_IFMT) != S_IFDIR &&
+ (buf.st_mode & S_IFMT) != S_IFLNK &&
+ (buf.st_mode & S_IFMT) != S_IFCHR &&
+ (buf.st_mode & S_IFMT) != S_IFBLK &&
+ (buf.st_mode & S_IFMT) != S_IFIFO &&
+ (buf.st_mode & S_IFMT) != S_IFSOCK) {
+ ERROR_START("File %s has unrecognised filetype %d",
+ filename, buf.st_mode & S_IFMT);
+ ERROR_EXIT(", ignoring\n");
+ free_dir_entry(dir_ent);
+ continue;
+ }
+
+ if((old_exclude && old_excluded(filename, &buf)) ||
+ (!old_exclude && excluded(dir_name, paths, &new))) {
+ add_excluded(dir);
+ free_dir_entry(dir_ent);
+ continue;
+ }
+
+ if(exclude_actions()) {
+ subpath = subpathname(dir_ent);
+
+ if(eval_exclude_actions(dir_name, filename, subpath,
+ &buf, depth, dir_ent)) {
+ add_excluded(dir);
+ free_dir_entry(dir_ent);
+ continue;
+ }
+ }
+
+ switch(buf.st_mode & S_IFMT) {
+ case S_IFDIR:
+ if(subpath == NULL)
+ subpath = subpathname(dir_ent);
+
+ sub_dir = dir_scan1(filename, subpath, new,
+ scan1_readdir, depth + 1);
+ if(sub_dir) {
+ dir->directory_count ++;
+ add_dir_entry(dir_ent, sub_dir,
+ lookup_inode(&buf));
+ } else
+ free_dir_entry(dir_ent);
+ break;
+ case S_IFLNK: {
+ int byte;
+ static char buff[65536]; /* overflow safe */
+
+ byte = readlink(filename, buff, 65536);
+ if(byte == -1) {
+ ERROR_START("Failed to read symlink %s",
+ filename);
+ ERROR_EXIT(", ignoring\n");
+ } else if(byte == 65536) {
+ ERROR_START("Symlink %s is greater than 65536 "
+ "bytes!", filename);
+ ERROR_EXIT(", ignoring\n");
+ } else {
+ /* readlink doesn't 0 terminate the returned
+ * path */
+ buff[byte] = '\0';
+ add_dir_entry(dir_ent, NULL, lookup_inode3(&buf,
+ 0, 0, buff, byte + 1));
+ }
+ break;
+ }
+ default:
+ add_dir_entry(dir_ent, NULL, lookup_inode(&buf));
+ }
+
+ free(new);
+ }
+
+ scan1_freedir(dir);
+
+ return dir;
+}
+
+
+/*
+ * dir_scan2 routines...
+ * This processes most actions and any pseudo files
+ */
+struct dir_ent *scan2_readdir(struct dir_info *dir, struct dir_ent *dir_ent)
+{
+ if (dir_ent == NULL)
+ dir_ent = dir->list;
+ else
+ dir_ent = dir_ent->next;
+
+ for(; dir_ent && dir_ent->inode->root_entry; dir_ent = dir_ent->next);
+
+ return dir_ent;
+}
+
+
+struct dir_ent *scan2_lookup(struct dir_info *dir, char *name)
+{
+ struct dir_ent *dir_ent = dir->list;
+
+ for(; dir_ent && strcmp(dir_ent->name, name) != 0;
+ dir_ent = dir_ent->next);
+
+ return dir_ent;
+}
+
+
+void dir_scan2(struct dir_info *dir, struct pseudo *pseudo)
+{
+ struct dir_ent *dir_ent = NULL;
+ struct pseudo_entry *pseudo_ent;
+ struct stat buf;
+ static int pseudo_ino = 1;
+
+ while((dir_ent = scan2_readdir(dir, dir_ent)) != NULL) {
+ struct inode_info *inode_info = dir_ent->inode;
+ struct stat *buf = &inode_info->buf;
+ char *name = dir_ent->name;
+
+ eval_actions(root_dir, dir_ent);
+
+ if((buf->st_mode & S_IFMT) == S_IFDIR)
+ dir_scan2(dir_ent->dir, pseudo_subdir(name, pseudo));
+ }
+
+ while((pseudo_ent = pseudo_readdir(pseudo)) != NULL) {
+ dir_ent = scan2_lookup(dir, pseudo_ent->name);
+ if(pseudo_ent->dev->type == 'm') {
+ struct stat *buf;
+ if(dir_ent == NULL) {
+ ERROR_START("Pseudo modify file \"%s\" does "
+ "not exist in source filesystem.",
+ pseudo_ent->pathname);
+ ERROR_EXIT(" Ignoring.\n");
+ continue;
+ }
+ if(dir_ent->inode->root_entry) {
+ ERROR_START("Pseudo modify file \"%s\" is a "
+ "pre-existing file in the filesystem "
+ "being appended to. It cannot be "\
+ "modified.", pseudo_ent->pathname);
+ ERROR_EXIT(" Ignoring.\n");
+ continue;
+ }
+ buf = &dir_ent->inode->buf;
+ buf->st_mode = (buf->st_mode & S_IFMT) |
+ pseudo_ent->dev->mode;
+ buf->st_uid = pseudo_ent->dev->uid;
+ buf->st_gid = pseudo_ent->dev->gid;
+ continue;
+ }
+
+ if(dir_ent) {
+ if(dir_ent->inode->root_entry) {
+ ERROR_START("Pseudo file \"%s\" is a "
+ "pre-existing file in the filesystem "
+ "being appended to.",
+ pseudo_ent->pathname);
+ ERROR_EXIT(" Ignoring.\n");
+ } else {
+ ERROR_START("Pseudo file \"%s\" exists in "
+ "source filesystem \"%s\".",
+ pseudo_ent->pathname,
+ pathname(dir_ent));
+ ERROR_EXIT("\nIgnoring, exclude it (-e/-ef) to "
+ "override.\n");
+ }
+ continue;
+ }
+
+ memset(&buf, 0, sizeof(buf));
+ buf.st_mode = pseudo_ent->dev->mode;
+ buf.st_uid = pseudo_ent->dev->uid;
+ buf.st_gid = pseudo_ent->dev->gid;
+ buf.st_rdev = makedev(pseudo_ent->dev->major,
+ pseudo_ent->dev->minor);
+ buf.st_mtime = time(NULL);
+ buf.st_ino = pseudo_ino ++;
+
+ if(pseudo_ent->dev->type == 'd') {
+ struct dir_ent *dir_ent =
+ create_dir_entry(pseudo_ent->name, NULL,
+ pseudo_ent->pathname, dir);
+ char *subpath = strdup(subpathname(dir_ent));
+ struct dir_info *sub_dir = scan1_opendir("", subpath,
+ dir->depth + 1);
+ if(sub_dir == NULL) {
+ ERROR_START("Could not create pseudo directory "
+ "\"%s\"", pseudo_ent->pathname);
+ ERROR_EXIT(", skipping...\n");
+ free(subpath);
+ pseudo_ino --;
+ continue;
+ }
+ dir_scan2(sub_dir, pseudo_ent->pseudo);
+ dir->directory_count ++;
+ add_dir_entry(dir_ent, sub_dir,
+ lookup_inode2(&buf, PSEUDO_FILE_OTHER, 0));
+ } else if(pseudo_ent->dev->type == 'f') {
+ add_dir_entry2(pseudo_ent->name, NULL,
+ pseudo_ent->pathname, NULL,
+ lookup_inode2(&buf, PSEUDO_FILE_PROCESS,
+ pseudo_ent->dev->pseudo_id), dir);
+ } else {
+ add_dir_entry2(pseudo_ent->name, NULL,
+ pseudo_ent->pathname, NULL,
+ lookup_inode2(&buf, PSEUDO_FILE_OTHER, 0), dir);
+ }
+ }
+}
+
+
+/*
+ * dir_scan3 routines...
+ * This processes the move action
+ */
+void dir_scan3(struct dir_info *dir)
+{
+ struct dir_ent *dir_ent = NULL;
+
+ while((dir_ent = scan2_readdir(dir, dir_ent)) != NULL) {
+
+ eval_move_actions(root_dir, dir_ent);
+
+ if((dir_ent->inode->buf.st_mode & S_IFMT) == S_IFDIR)
+ dir_scan3(dir_ent->dir);
+ }
+}
+
+
+/*
+ * dir_scan4 routines...
+ * This processes the prune action. This action is designed to do fine
+ * grained tuning of the in-core directory structure after the exclude,
+ * move and pseudo actions have been performed. This allows complex
+ * tests to be performed which are impossible at exclude time (i.e.
+ * tests which rely on the in-core directory structure)
+ */
+void free_dir(struct dir_info *dir)
+{
+ struct dir_ent *dir_ent = dir->list;
+
+ while(dir_ent) {
+ struct dir_ent *tmp = dir_ent;
+
+ if((dir_ent->inode->buf.st_mode & S_IFMT) == S_IFDIR)
+ free_dir(dir_ent->dir);
+
+ dir_ent = dir_ent->next;
+ free_dir_entry(tmp);
+ }
+
+ free(dir->pathname);
+ free(dir->subpath);
+ free(dir);
+}
+
+
+void dir_scan4(struct dir_info *dir)
+{
+ struct dir_ent *dir_ent = dir->list, *prev = NULL;
+
+ while(dir_ent) {
+ if(dir_ent->inode->root_entry) {
+ prev = dir_ent;
+ dir_ent = dir_ent->next;
+ continue;
+ }
+
+ if((dir_ent->inode->buf.st_mode & S_IFMT) == S_IFDIR)
+ dir_scan4(dir_ent->dir);
+
+ if(eval_prune_actions(root_dir, dir_ent)) {
+ struct dir_ent *tmp = dir_ent;
+
+ if((dir_ent->inode->buf.st_mode & S_IFMT) == S_IFDIR) {
+ free_dir(dir_ent->dir);
+ dir->directory_count --;
+ }
+
+ dir->count --;
+
+ /* remove dir_ent from list */
+ dir_ent = dir_ent->next;
+ if(prev)
+ prev->next = dir_ent;
+ else
+ dir->list = dir_ent;
+
+ /* free it */
+ free_dir_entry(tmp);
+
+ add_excluded(dir);
+ continue;
+ }
+
+ prev = dir_ent;
+ dir_ent = dir_ent->next;
+ }
+}
+
+
+/*
+ * dir_scan5 routines...
+ * This processes the empty action. This action has to be processed after
+ * all other actions because the previous exclude and move actions and the
+ * pseudo actions affect whether a directory is empty
+ */
+void dir_scan5(struct dir_info *dir)
+{
+ struct dir_ent *dir_ent = dir->list, *prev = NULL;
+
+ while(dir_ent) {
+ if(dir_ent->inode->root_entry) {
+ prev = dir_ent;
+ dir_ent = dir_ent->next;
+ continue;
+ }
+
+ if((dir_ent->inode->buf.st_mode & S_IFMT) == S_IFDIR) {
+ dir_scan5(dir_ent->dir);
+
+ if(eval_empty_actions(root_dir, dir_ent)) {
+ struct dir_ent *tmp = dir_ent;
+
+ /*
+ * delete sub-directory, this is by definition
+ * empty
+ */
+ free(dir_ent->dir->pathname);
+ free(dir_ent->dir->subpath);
+ free(dir_ent->dir);
+
+ /* remove dir_ent from list */
+ dir_ent = dir_ent->next;
+ if(prev)
+ prev->next = dir_ent;
+ else
+ dir->list = dir_ent;
+
+ /* free it */
+ free_dir_entry(tmp);
+
+ /* update counts */
+ dir->directory_count --;
+ dir->count --;
+ add_excluded(dir);
+ continue;
+ }
+ }
+
+ prev = dir_ent;
+ dir_ent = dir_ent->next;
+ }
+}
+
+
+/*
+ * dir_scan6 routines...
+ * This sorts every directory and computes the inode numbers
+ */
+
+/*
+ * Bottom up linked list merge sort.
+ *
+ * Qsort and other O(n log n) algorithms work well with arrays but not
+ * linked lists. Merge sort another O(n log n) sort algorithm on the other hand
+ * is not ideal for arrays (as it needs an additonal n storage locations
+ * as sorting is not done in place), but it is ideal for linked lists because
+ * it doesn't require any extra storage,
+ */
+void sort_directory(struct dir_info *dir)
+{
+ struct dir_ent *cur, *l1, *l2, *next;
+ int len1, len2, stride = 1;
+
+ if(dir->list == NULL || dir->count < 2)
+ return;
+
+ /*
+ * We can consider our linked-list to be made up of stride length
+ * sublists. Eacn iteration around this loop merges adjacent
+ * stride length sublists into larger 2*stride sublists. We stop
+ * when stride becomes equal to the entire list.
+ *
+ * Initially stride = 1 (by definition a sublist of 1 is sorted), and
+ * these 1 element sublists are merged into 2 element sublists, which
+ * are then merged into 4 element sublists and so on.
+ */
+ do {
+ l2 = dir->list; /* head of current linked list */
+ cur = NULL; /* empty output list */
+
+ /*
+ * Iterate through the linked list, merging adjacent sublists.
+ * On each interation l2 points to the next sublist pair to be
+ * merged (if there's only one sublist left this is simply added
+ * to the output list)
+ */
+ while(l2) {
+ l1 = l2;
+ for(len1 = 0; l2 && len1 < stride; len1 ++, l2 = l2->next);
+ len2 = stride;
+
+ /*
+ * l1 points to first sublist.
+ * l2 points to second sublist.
+ * Merge them onto the output list
+ */
+ while(len1 && l2 && len2) {
+ if(strcmp(l1->name, l2->name) <= 0) {
+ next = l1;
+ l1 = l1->next;
+ len1 --;
+ } else {
+ next = l2;
+ l2 = l2->next;
+ len2 --;
+ }
+
+ if(cur) {
+ cur->next = next;
+ cur = next;
+ } else
+ dir->list = cur = next;
+ }
+ /*
+ * One sublist is now empty, copy the other one onto the
+ * output list
+ */
+ for(; len1; len1 --, l1 = l1->next) {
+ if(cur) {
+ cur->next = l1;
+ cur = l1;
+ } else
+ dir->list = cur = l1;
+ }
+ for(; l2 && len2; len2 --, l2 = l2->next) {
+ if(cur) {
+ cur->next = l2;
+ cur = l2;
+ } else
+ dir->list = cur = l2;
+ }
+ }
+ cur->next = NULL;
+ stride = stride << 1;
+ } while(stride < dir->count);
+}
+
+
+void dir_scan6(struct dir_info *dir)
+{
+ struct dir_ent *dir_ent;
+ unsigned int byte_count = 0;
+
+ sort_directory(dir);
+
+ for(dir_ent = dir->list; dir_ent; dir_ent = dir_ent->next) {
+ byte_count += strlen(dir_ent->name) +
+ sizeof(struct squashfs_dir_entry);
+
+ if(dir_ent->inode->root_entry)
+ continue;
+
+ alloc_inode_no(dir_ent->inode, 0);
+
+ if((dir_ent->inode->buf.st_mode & S_IFMT) == S_IFDIR)
+ dir_scan6(dir_ent->dir);
+ }
+
+ if((dir->count < 257 && byte_count < SQUASHFS_METADATA_SIZE))
+ dir->dir_is_ldir = FALSE;
+}
+
+
+/*
+ * dir_scan6 routines...
+ * This generates the filesystem metadata and writes it out to the destination
+ */
+void scan7_init_dir(struct directory *dir)
+{
+ dir->buff = malloc(SQUASHFS_METADATA_SIZE);
+ if(dir->buff == NULL)
+ MEM_ERROR();
+
+ dir->size = SQUASHFS_METADATA_SIZE;
+ dir->p = dir->index_count_p = dir->buff;
+ dir->entry_count = 256;
+ dir->entry_count_p = NULL;
+ dir->index = NULL;
+ dir->i_count = dir->i_size = 0;
+}
+
+
+struct dir_ent *scan7_readdir(struct directory *dir, struct dir_info *dir_info,
+ struct dir_ent *dir_ent)
+{
+ if (dir_ent == NULL)
+ dir_ent = dir_info->list;
+ else
+ dir_ent = dir_ent->next;
+
+ for(; dir_ent && dir_ent->inode->root_entry; dir_ent = dir_ent->next)
+ add_dir(dir_ent->inode->inode, dir_ent->inode->inode_number,
+ dir_ent->name, dir_ent->inode->type, dir);
+
+ return dir_ent;
+}
+
+
+void scan7_freedir(struct directory *dir)
+{
+ if(dir->index)
+ free(dir->index);
+ free(dir->buff);
+}
+
+
+void dir_scan7(squashfs_inode *inode, struct dir_info *dir_info)
+{
+ int squashfs_type;
+ int duplicate_file;
+ struct directory dir;
+ struct dir_ent *dir_ent = NULL;
+
+ scan7_init_dir(&dir);
+
+ while((dir_ent = scan7_readdir(&dir, dir_info, dir_ent)) != NULL) {
+ struct stat *buf = &dir_ent->inode->buf;
+
+ update_info(dir_ent);
+
+ if(dir_ent->inode->inode == SQUASHFS_INVALID_BLK) {
+ switch(buf->st_mode & S_IFMT) {
+ case S_IFREG:
+ squashfs_type = SQUASHFS_FILE_TYPE;
+ write_file(inode, dir_ent,
+ &duplicate_file);
+ INFO("file %s, uncompressed size %lld "
+ "bytes %s\n",
+ subpathname(dir_ent),
+ (long long) buf->st_size,
+ duplicate_file ? "DUPLICATE" :
+ "");
+ break;
+
+ case S_IFDIR:
+ squashfs_type = SQUASHFS_DIR_TYPE;
+ dir_scan7(inode, dir_ent->dir);
+ break;
+
+ case S_IFLNK:
+ squashfs_type = SQUASHFS_SYMLINK_TYPE;
+ create_inode(inode, NULL, dir_ent,
+ squashfs_type, 0, 0, 0, NULL,
+ NULL, NULL, 0);
+ INFO("symbolic link %s inode 0x%llx\n",
+ subpathname(dir_ent), *inode);
+ sym_count ++;
+ break;
+
+ case S_IFCHR:
+ squashfs_type = SQUASHFS_CHRDEV_TYPE;
+ create_inode(inode, NULL, dir_ent,
+ squashfs_type, 0, 0, 0, NULL,
+ NULL, NULL, 0);
+ INFO("character device %s inode 0x%llx"
+ "\n", subpathname(dir_ent),
+ *inode);
+ dev_count ++;
+ break;
+
+ case S_IFBLK:
+ squashfs_type = SQUASHFS_BLKDEV_TYPE;
+ create_inode(inode, NULL, dir_ent,
+ squashfs_type, 0, 0, 0, NULL,
+ NULL, NULL, 0);
+ INFO("block device %s inode 0x%llx\n",
+ subpathname(dir_ent), *inode);
+ dev_count ++;
+ break;
+
+ case S_IFIFO:
+ squashfs_type = SQUASHFS_FIFO_TYPE;
+ create_inode(inode, NULL, dir_ent,
+ squashfs_type, 0, 0, 0, NULL,
+ NULL, NULL, 0);
+ INFO("fifo %s inode 0x%llx\n",
+ subpathname(dir_ent), *inode);
+ fifo_count ++;
+ break;
+
+ case S_IFSOCK:
+ squashfs_type = SQUASHFS_SOCKET_TYPE;
+ create_inode(inode, NULL, dir_ent,
+ squashfs_type, 0, 0, 0, NULL,
+ NULL, NULL, 0);
+ INFO("unix domain socket %s inode "
+ "0x%llx\n",
+ subpathname(dir_ent), *inode);
+ sock_count ++;
+ break;
+
+ default:
+ BAD_ERROR("%s unrecognised file type, "
+ "mode is %x\n",
+ subpathname(dir_ent),
+ buf->st_mode);
+ }
+ dir_ent->inode->inode = *inode;
+ dir_ent->inode->type = squashfs_type;
+ } else {
+ *inode = dir_ent->inode->inode;
+ squashfs_type = dir_ent->inode->type;
+ switch(squashfs_type) {
+ case SQUASHFS_FILE_TYPE:
+ if(!sorted)
+ INFO("file %s, uncompressed "
+ "size %lld bytes LINK"
+ "\n",
+ subpathname(dir_ent),
+ (long long)
+ buf->st_size);
+ break;
+ case SQUASHFS_SYMLINK_TYPE:
+ INFO("symbolic link %s inode 0x%llx "
+ "LINK\n", subpathname(dir_ent),
+ *inode);
+ break;
+ case SQUASHFS_CHRDEV_TYPE:
+ INFO("character device %s inode 0x%llx "
+ "LINK\n", subpathname(dir_ent),
+ *inode);
+ break;
+ case SQUASHFS_BLKDEV_TYPE:
+ INFO("block device %s inode 0x%llx "
+ "LINK\n", subpathname(dir_ent),
+ *inode);
+ break;
+ case SQUASHFS_FIFO_TYPE:
+ INFO("fifo %s inode 0x%llx LINK\n",
+ subpathname(dir_ent), *inode);
+ break;
+ case SQUASHFS_SOCKET_TYPE:
+ INFO("unix domain socket %s inode "
+ "0x%llx LINK\n",
+ subpathname(dir_ent), *inode);
+ break;
+ }
+ }
+
+ add_dir(*inode, get_inode_no(dir_ent->inode), dir_ent->name,
+ squashfs_type, &dir);
+ }
+
+ write_dir(inode, dir_info, &dir);
+ INFO("directory %s inode 0x%llx\n", subpathname(dir_info->dir_ent),
+ *inode);
+
+ scan7_freedir(&dir);
+}
+
+
+unsigned int slog(unsigned int block)
+{
+ int i;
+
+ for(i = 12; i <= 20; i++)
+ if(block == (1 << i))
+ return i;
+ return 0;
+}
+
+
+int old_excluded(char *filename, struct stat *buf)
+{
+ int i;
+
+ for(i = 0; i < exclude; i++)
+ if((exclude_paths[i].st_dev == buf->st_dev) &&
+ (exclude_paths[i].st_ino == buf->st_ino))
+ return TRUE;
+ return FALSE;
+}
+
+
+#define ADD_ENTRY(buf) \
+ if(exclude % EXCLUDE_SIZE == 0) { \
+ exclude_paths = realloc(exclude_paths, (exclude + EXCLUDE_SIZE) \
+ * sizeof(struct exclude_info)); \
+ if(exclude_paths == NULL) \
+ MEM_ERROR(); \
+ } \
+ exclude_paths[exclude].st_dev = buf.st_dev; \
+ exclude_paths[exclude++].st_ino = buf.st_ino;
+int old_add_exclude(char *path)
+{
+ int i;
+ char *filename;
+ struct stat buf;
+
+ if(path[0] == '/' || strncmp(path, "./", 2) == 0 ||
+ strncmp(path, "../", 3) == 0) {
+ if(lstat(path, &buf) == -1) {
+ ERROR_START("Cannot stat exclude dir/file %s because "
+ "%s", path, strerror(errno));
+ ERROR_EXIT(", ignoring\n");
+ return TRUE;
+ }
+ ADD_ENTRY(buf);
+ return TRUE;
+ }
+
+ for(i = 0; i < source; i++) {
+ int res = asprintf(&filename, "%s/%s", source_path[i], path);
+ if(res == -1)
+ BAD_ERROR("asprintf failed in old_add_exclude\n");
+ if(lstat(filename, &buf) == -1) {
+ if(!(errno == ENOENT || errno == ENOTDIR)) {
+ ERROR_START("Cannot stat exclude dir/file %s "
+ "because %s", filename, strerror(errno));
+ ERROR_EXIT(", ignoring\n");
+ }
+ free(filename);
+ continue;
+ }
+ free(filename);
+ ADD_ENTRY(buf);
+ }
+ return TRUE;
+}
+
+
+void add_old_root_entry(char *name, squashfs_inode inode, int inode_number,
+ int type)
+{
+ old_root_entry = realloc(old_root_entry,
+ sizeof(struct old_root_entry_info) * (old_root_entries + 1));
+ if(old_root_entry == NULL)
+ MEM_ERROR();
+
+ old_root_entry[old_root_entries].name = strdup(name);
+ old_root_entry[old_root_entries].inode.inode = inode;
+ old_root_entry[old_root_entries].inode.inode_number = inode_number;
+ old_root_entry[old_root_entries].inode.type = type;
+ old_root_entry[old_root_entries++].inode.root_entry = TRUE;
+}
+
+
+void initialise_threads(int readq, int fragq, int bwriteq, int fwriteq,
+ int freelst, char *destination_file)
+{
+ int i;
+ sigset_t sigmask, old_mask;
+ int total_mem = readq;
+ int reader_size;
+ int fragment_size;
+ int fwriter_size;
+ /*
+ * bwriter_size is global because it is needed in
+ * write_file_blocks_dup()
+ */
+
+ /*
+ * Never allow the total size of the queues to be larger than
+ * physical memory
+ *
+ * When adding together the possibly user supplied values, make
+ * sure they've not been deliberately contrived to overflow an int
+ */
+ if(add_overflow(total_mem, fragq))
+ BAD_ERROR("Queue sizes rediculously too large\n");
+ total_mem += fragq;
+ if(add_overflow(total_mem, bwriteq))
+ BAD_ERROR("Queue sizes rediculously too large\n");
+ total_mem += bwriteq;
+ if(add_overflow(total_mem, fwriteq))
+ BAD_ERROR("Queue sizes rediculously too large\n");
+ total_mem += fwriteq;
+
+ check_usable_phys_mem(total_mem);
+
+ /*
+ * convert from queue size in Mbytes to queue size in
+ * blocks.
+ *
+ * This isn't going to overflow an int unless there exists
+ * systems with more than 8 Petabytes of RAM!
+ */
+ reader_size = readq << (20 - block_log);
+ fragment_size = fragq << (20 - block_log);
+ bwriter_size = bwriteq << (20 - block_log);
+ fwriter_size = fwriteq << (20 - block_log);
+
+ /*
+ * setup signal handlers for the main thread, these cleanup
+ * deleting the destination file, if appending the
+ * handlers for SIGTERM and SIGINT will be replaced with handlers
+ * allowing the user to press ^C twice to restore the existing
+ * filesystem.
+ *
+ * SIGUSR1 is an internal signal, which is used by the sub-threads
+ * to tell the main thread to terminate, deleting the destination file,
+ * or if necessary restoring the filesystem on appending
+ */
+ signal(SIGTERM, sighandler);
+ signal(SIGINT, sighandler);
+ signal(SIGUSR1, sighandler);
+
+ /* block SIGQUIT and SIGHUP, these are handled by the info thread */
+ sigemptyset(&sigmask);
+ sigaddset(&sigmask, SIGQUIT);
+ sigaddset(&sigmask, SIGHUP);
+ sigaddset(&sigmask, SIGALRM);
+ if(pthread_sigmask(SIG_BLOCK, &sigmask, NULL) == -1)
+ BAD_ERROR("Failed to set signal mask in intialise_threads\n");
+
+ /*
+ * temporarily block these signals, so the created sub-threads
+ * will ignore them, ensuring the main thread handles them
+ */
+ sigemptyset(&sigmask);
+ sigaddset(&sigmask, SIGINT);
+ sigaddset(&sigmask, SIGTERM);
+ sigaddset(&sigmask, SIGUSR1);
+ if(pthread_sigmask(SIG_BLOCK, &sigmask, &old_mask) == -1)
+ BAD_ERROR("Failed to set signal mask in intialise_threads\n");
+
+ if(processors == -1) {
+#ifndef linux
+ int mib[2];
+ size_t len = sizeof(processors);
+
+ mib[0] = CTL_HW;
+#ifdef HW_AVAILCPU
+ mib[1] = HW_AVAILCPU;
+#else
+ mib[1] = HW_NCPU;
+#endif
+
+ if(sysctl(mib, 2, &processors, &len, NULL, 0) == -1) {
+ ERROR_START("Failed to get number of available "
+ "processors.");
+ ERROR_EXIT(" Defaulting to 1\n");
+ processors = 1;
+ }
+#else
+ processors = sysconf(_SC_NPROCESSORS_ONLN);
+#endif
+ }
+
+ if(multiply_overflow(processors, 3) ||
+ multiply_overflow(processors * 3, sizeof(pthread_t)))
+ BAD_ERROR("Processors too large\n");
+
+ deflator_thread = malloc(processors * 3 * sizeof(pthread_t));
+ if(deflator_thread == NULL)
+ MEM_ERROR();
+
+ frag_deflator_thread = &deflator_thread[processors];
+ frag_thread = &frag_deflator_thread[processors];
+
+ to_reader = queue_init(1);
+ to_deflate = queue_init(reader_size);
+ to_process_frag = queue_init(reader_size);
+ to_writer = queue_init(bwriter_size + fwriter_size);
+ from_writer = queue_init(1);
+ to_frag = queue_init(fragment_size);
+ locked_fragment = queue_init(fragment_size);
+ to_main = seq_queue_init();
+ reader_buffer = cache_init(block_size, reader_size, 0, 0);
+ bwriter_buffer = cache_init(block_size, bwriter_size, 1, freelst);
+ fwriter_buffer = cache_init(block_size, fwriter_size, 1, freelst);
+ fragment_buffer = cache_init(block_size, fragment_size, 1, 0);
+ reserve_cache = cache_init(block_size, processors + 1, 1, 0);
+ pthread_create(&reader_thread, NULL, reader, NULL);
+ pthread_create(&writer_thread, NULL, writer, NULL);
+ init_progress_bar();
+ init_info();
+
+ for(i = 0; i < processors; i++) {
+ if(pthread_create(&deflator_thread[i], NULL, deflator, NULL))
+ BAD_ERROR("Failed to create thread\n");
+ if(pthread_create(&frag_deflator_thread[i], NULL, frag_deflator,
+ NULL) != 0)
+ BAD_ERROR("Failed to create thread\n");
+ if(pthread_create(&frag_thread[i], NULL, frag_thrd,
+ (void *) destination_file) != 0)
+ BAD_ERROR("Failed to create thread\n");
+ }
+
+ main_thread = pthread_self();
+
+ printf("Parallel mksquashfs: Using %d processor%s\n", processors,
+ processors == 1 ? "" : "s");
+
+ /* Restore the signal mask for the main thread */
+ if(pthread_sigmask(SIG_SETMASK, &old_mask, NULL) == -1)
+ BAD_ERROR("Failed to set signal mask in intialise_threads\n");
+}
+
+
+long long write_inode_lookup_table()
+{
+ int i, inode_number, lookup_bytes = SQUASHFS_LOOKUP_BYTES(inode_count);
+ void *it;
+
+ if(inode_count == sinode_count)
+ goto skip_inode_hash_table;
+
+ it = realloc(inode_lookup_table, lookup_bytes);
+ if(it == NULL)
+ MEM_ERROR();
+ inode_lookup_table = it;
+
+ for(i = 0; i < INODE_HASH_SIZE; i ++) {
+ struct inode_info *inode;
+
+ for(inode = inode_info[i]; inode; inode = inode->next) {
+
+ inode_number = get_inode_no(inode);
+
+ /* The empty action will produce orphaned inode
+ * entries in the inode_info[] table. These
+ * entries because they are orphaned will not be
+ * allocated an inode number in dir_scan5(), so
+ * skip any entries with the default dummy inode
+ * number of 0 */
+ if(inode_number == 0)
+ continue;
+
+ SQUASHFS_SWAP_LONG_LONGS(&inode->inode,
+ &inode_lookup_table[inode_number - 1], 1);
+
+ }
+ }
+
+skip_inode_hash_table:
+ return generic_write_table(lookup_bytes, inode_lookup_table, 0, NULL,
+ noI);
+}
+
+
+char *get_component(char *target, char **targname)
+{
+ char *start;
+
+ while(*target == '/')
+ target ++;
+
+ start = target;
+ while(*target != '/' && *target != '\0')
+ target ++;
+
+ *targname = strndup(start, target - start);
+
+ while(*target == '/')
+ target ++;
+
+ return target;
+}
+
+
+void free_path(struct pathname *paths)
+{
+ int i;
+
+ for(i = 0; i < paths->names; i++) {
+ if(paths->name[i].paths)
+ free_path(paths->name[i].paths);
+ free(paths->name[i].name);
+ if(paths->name[i].preg) {
+ regfree(paths->name[i].preg);
+ free(paths->name[i].preg);
+ }
+ }
+
+ free(paths);
+}
+
+
+struct pathname *add_path(struct pathname *paths, char *target, char *alltarget)
+{
+ char *targname;
+ int i, error;
+
+ target = get_component(target, &targname);
+
+ if(paths == NULL) {
+ paths = malloc(sizeof(struct pathname));
+ if(paths == NULL)
+ MEM_ERROR();
+
+ paths->names = 0;
+ paths->name = NULL;
+ }
+
+ for(i = 0; i < paths->names; i++)
+ if(strcmp(paths->name[i].name, targname) == 0)
+ break;
+
+ if(i == paths->names) {
+ /* allocate new name entry */
+ paths->names ++;
+ paths->name = realloc(paths->name, (i + 1) *
+ sizeof(struct path_entry));
+ if(paths->name == NULL)
+ MEM_ERROR();
+ paths->name[i].name = targname;
+ paths->name[i].paths = NULL;
+ if(use_regex) {
+ paths->name[i].preg = malloc(sizeof(regex_t));
+ if(paths->name[i].preg == NULL)
+ MEM_ERROR();
+ error = regcomp(paths->name[i].preg, targname,
+ REG_EXTENDED|REG_NOSUB);
+ if(error) {
+ char str[1024]; /* overflow safe */
+
+ regerror(error, paths->name[i].preg, str, 1024);
+ BAD_ERROR("invalid regex %s in export %s, "
+ "because %s\n", targname, alltarget,
+ str);
+ }
+ } else
+ paths->name[i].preg = NULL;
+
+ if(target[0] == '\0')
+ /* at leaf pathname component */
+ paths->name[i].paths = NULL;
+ else
+ /* recurse adding child components */
+ paths->name[i].paths = add_path(NULL, target,
+ alltarget);
+ } else {
+ /* existing matching entry */
+ free(targname);
+
+ if(paths->name[i].paths == NULL) {
+ /* No sub-directory which means this is the leaf
+ * component of a pre-existing exclude which subsumes
+ * the exclude currently being added, in which case stop
+ * adding components */
+ } else if(target[0] == '\0') {
+ /* at leaf pathname component and child components exist
+ * from more specific excludes, delete as they're
+ * subsumed by this exclude */
+ free_path(paths->name[i].paths);
+ paths->name[i].paths = NULL;
+ } else
+ /* recurse adding child components */
+ add_path(paths->name[i].paths, target, alltarget);
+ }
+
+ return paths;
+}
+
+
+void add_exclude(char *target)
+{
+
+ if(target[0] == '/' || strncmp(target, "./", 2) == 0 ||
+ strncmp(target, "../", 3) == 0)
+ BAD_ERROR("/, ./ and ../ prefixed excludes not supported with "
+ "-wildcards or -regex options\n");
+ else if(strncmp(target, "... ", 4) == 0)
+ stickypath = add_path(stickypath, target + 4, target + 4);
+ else
+ path = add_path(path, target, target);
+}
+
+
+void display_path(int depth, struct pathname *paths)
+{
+ int i, n;
+
+ if(paths == NULL)
+ return;
+
+ for(i = 0; i < paths->names; i++) {
+ for(n = 0; n < depth; n++)
+ printf("\t");
+ printf("%d: %s\n", depth, paths->name[i].name);
+ display_path(depth + 1, paths->name[i].paths);
+ }
+}
+
+
+void display_path2(struct pathname *paths, char *string)
+{
+ int i;
+ char *path;
+
+ if(paths == NULL) {
+ printf("%s\n", string);
+ return;
+ }
+
+ for(i = 0; i < paths->names; i++) {
+ int res = asprintf(&path, "%s/%s", string, paths->name[i].name);
+ if(res == -1)
+ BAD_ERROR("asprintf failed in display_path2\n");
+ display_path2(paths->name[i].paths, path);
+ free(path);
+ }
+}
+
+
+struct pathnames *add_subdir(struct pathnames *paths, struct pathname *path)
+{
+ int count = paths == NULL ? 0 : paths->count;
+
+ if(count % PATHS_ALLOC_SIZE == 0) {
+ paths = realloc(paths, sizeof(struct pathnames) +
+ (count + PATHS_ALLOC_SIZE) * sizeof(struct pathname *));
+ if(paths == NULL)
+ MEM_ERROR();
+ }
+
+ paths->path[count] = path;
+ paths->count = count + 1;
+ return paths;
+}
+
+
+int excluded_match(char *name, struct pathname *path, struct pathnames **new)
+{
+ int i;
+
+ for(i = 0; i < path->names; i++) {
+ int match = use_regex ?
+ regexec(path->name[i].preg, name, (size_t) 0,
+ NULL, 0) == 0 :
+ fnmatch(path->name[i].name, name,
+ FNM_PATHNAME|FNM_PERIOD|FNM_EXTMATCH) == 0;
+
+ if(match) {
+ if(path->name[i].paths == NULL || new == NULL)
+ /* match on a leaf component, any subdirectories
+ * in the filesystem should be excluded */
+ return TRUE;
+ else
+ /* match on a non-leaf component, add any
+ * subdirectories to the new set of
+ * subdirectories to scan for this name */
+ *new = add_subdir(*new, path->name[i].paths);
+ }
+ }
+
+ return FALSE;
+}
+
+
+int excluded(char *name, struct pathnames *paths, struct pathnames **new)
+{
+ int n;
+
+ if(stickypath && excluded_match(name, stickypath, NULL))
+ return TRUE;
+
+ for(n = 0; paths && n < paths->count; n++) {
+ int res = excluded_match(name, paths->path[n], new);
+ if(res) {
+ free(*new);
+ *new = NULL;
+ return TRUE;
+ }
+ }
+
+ /*
+ * Either:
+ * - no matching names found, return empty new search set, or
+ * - one or more matches with sub-directories found (no leaf matches),
+ * in which case return new search set.
+ *
+ * In either case return FALSE as we don't want to exclude this entry
+ */
+ return FALSE;
+}
+
+
+void process_exclude_file(char *argv)
+{
+ FILE *fd;
+ char buffer[MAX_LINE + 1]; /* overflow safe */
+ char *filename;
+
+ fd = fopen(argv, "r");
+ if(fd == NULL)
+ BAD_ERROR("Failed to open exclude file \"%s\" because %s\n",
+ argv, strerror(errno));
+
+ while(fgets(filename = buffer, MAX_LINE + 1, fd) != NULL) {
+ int len = strlen(filename);
+
+ if(len == MAX_LINE && filename[len - 1] != '\n')
+ /* line too large */
+ BAD_ERROR("Line too long when reading "
+ "exclude file \"%s\", larger than %d "
+ "bytes\n", argv, MAX_LINE);
+
+ /*
+ * Remove '\n' terminator if it exists (the last line
+ * in the file may not be '\n' terminated)
+ */
+ if(len && filename[len - 1] == '\n')
+ filename[len - 1] = '\0';
+
+ /* Skip any leading whitespace */
+ while(isspace(*filename))
+ filename ++;
+
+ /* if comment line, skip */
+ if(*filename == '#')
+ continue;
+
+ /*
+ * check for initial backslash, to accommodate
+ * filenames with leading space or leading # character
+ */
+ if(*filename == '\\')
+ filename ++;
+
+ /* if line is now empty after skipping characters, skip it */
+ if(*filename == '\0')
+ continue;
+
+ if(old_exclude)
+ old_add_exclude(filename);
+ else
+ add_exclude(filename);
+ }
+
+ if(ferror(fd))
+ BAD_ERROR("Reading exclude file \"%s\" failed because %s\n",
+ argv, strerror(errno));
+
+ fclose(fd);
+}
+
+
+#define RECOVER_ID "Squashfs recovery file v1.0\n"
+#define RECOVER_ID_SIZE 28
+
+void write_recovery_data(struct squashfs_super_block *sBlk)
+{
+ int res, recoverfd, bytes = sBlk->bytes_used - sBlk->inode_table_start;
+ pid_t pid = getpid();
+ char *metadata;
+ char header[] = RECOVER_ID;
+
+ if(recover == FALSE) {
+ printf("No recovery data option specified.\n");
+ printf("Skipping saving recovery file.\n\n");
+ return;
+ }
+
+ metadata = malloc(bytes);
+ if(metadata == NULL)
+ MEM_ERROR();
+
+ res = read_fs_bytes(fd, sBlk->inode_table_start, bytes, metadata);
+ if(res == 0) {
+ ERROR("Failed to read append filesystem metadata\n");
+ BAD_ERROR("Filesystem corrupted?\n");
+ }
+
+ res = asprintf(&recovery_file, "squashfs_recovery_%s_%d",
+ getbase(destination_file), pid);
+ if(res == -1)
+ MEM_ERROR();
+
+ recoverfd = open(recovery_file, O_CREAT | O_TRUNC | O_RDWR, S_IRWXU);
+ if(recoverfd == -1)
+ BAD_ERROR("Failed to create recovery file, because %s. "
+ "Aborting\n", strerror(errno));
+
+ if(write_bytes(recoverfd, header, RECOVER_ID_SIZE) == -1)
+ BAD_ERROR("Failed to write recovery file, because %s\n",
+ strerror(errno));
+
+ if(write_bytes(recoverfd, sBlk, sizeof(struct squashfs_super_block)) == -1)
+ BAD_ERROR("Failed to write recovery file, because %s\n",
+ strerror(errno));
+
+ if(write_bytes(recoverfd, metadata, bytes) == -1)
+ BAD_ERROR("Failed to write recovery file, because %s\n",
+ strerror(errno));
+
+ close(recoverfd);
+ free(metadata);
+
+ printf("Recovery file \"%s\" written\n", recovery_file);
+ printf("If Mksquashfs aborts abnormally (i.e. power failure), run\n");
+ printf("mksquashfs dummy %s -recover %s\n", destination_file,
+ recovery_file);
+ printf("to restore filesystem\n\n");
+}
+
+
+void read_recovery_data(char *recovery_file, char *destination_file)
+{
+ int fd, recoverfd, bytes;
+ struct squashfs_super_block orig_sBlk, sBlk;
+ char *metadata;
+ int res;
+ struct stat buf;
+ char header[] = RECOVER_ID;
+ char header2[RECOVER_ID_SIZE];
+
+ recoverfd = open(recovery_file, O_RDONLY);
+ if(recoverfd == -1)
+ BAD_ERROR("Failed to open recovery file because %s\n",
+ strerror(errno));
+
+ if(stat(destination_file, &buf) == -1)
+ BAD_ERROR("Failed to stat destination file, because %s\n",
+ strerror(errno));
+
+ fd = open(destination_file, O_RDWR);
+ if(fd == -1)
+ BAD_ERROR("Failed to open destination file because %s\n",
+ strerror(errno));
+
+ res = read_bytes(recoverfd, header2, RECOVER_ID_SIZE);
+ if(res == -1)
+ BAD_ERROR("Failed to read recovery file, because %s\n",
+ strerror(errno));
+ if(res < RECOVER_ID_SIZE)
+ BAD_ERROR("Recovery file appears to be truncated\n");
+ if(strncmp(header, header2, RECOVER_ID_SIZE) !=0 )
+ BAD_ERROR("Not a recovery file\n");
+
+ res = read_bytes(recoverfd, &sBlk, sizeof(struct squashfs_super_block));
+ if(res == -1)
+ BAD_ERROR("Failed to read recovery file, because %s\n",
+ strerror(errno));
+ if(res < sizeof(struct squashfs_super_block))
+ BAD_ERROR("Recovery file appears to be truncated\n");
+
+ res = read_fs_bytes(fd, 0, sizeof(struct squashfs_super_block), &orig_sBlk);
+ if(res == 0) {
+ ERROR("Failed to read superblock from output filesystem\n");
+ BAD_ERROR("Output filesystem is empty!\n");
+ }
+
+ if(memcmp(((char *) &sBlk) + 4, ((char *) &orig_sBlk) + 4,
+ sizeof(struct squashfs_super_block) - 4) != 0)
+ BAD_ERROR("Recovery file and destination file do not seem to "
+ "match\n");
+
+ bytes = sBlk.bytes_used - sBlk.inode_table_start;
+
+ metadata = malloc(bytes);
+ if(metadata == NULL)
+ MEM_ERROR();
+
+ res = read_bytes(recoverfd, metadata, bytes);
+ if(res == -1)
+ BAD_ERROR("Failed to read recovery file, because %s\n",
+ strerror(errno));
+ if(res < bytes)
+ BAD_ERROR("Recovery file appears to be truncated\n");
+
+ write_destination(fd, 0, sizeof(struct squashfs_super_block), &sBlk);
+
+ write_destination(fd, sBlk.inode_table_start, bytes, metadata);
+
+ close(recoverfd);
+ close(fd);
+
+ printf("Successfully wrote recovery file \"%s\". Exiting\n",
+ recovery_file);
+
+ exit(0);
+}
+
+
+void write_filesystem_tables(struct squashfs_super_block *sBlk, int nopad)
+{
+ int i;
+
+ sBlk->fragments = fragments;
+ sBlk->no_ids = id_count;
+ sBlk->inode_table_start = write_inodes();
+ sBlk->directory_table_start = write_directories();
+ sBlk->fragment_table_start = write_fragment_table();
+ sBlk->lookup_table_start = exportable ? write_inode_lookup_table() :
+ SQUASHFS_INVALID_BLK;
+ sBlk->id_table_start = write_id_table();
+ sBlk->xattr_id_table_start = write_xattrs();
+
+ TRACE("sBlk->inode_table_start 0x%llx\n", sBlk->inode_table_start);
+ TRACE("sBlk->directory_table_start 0x%llx\n",
+ sBlk->directory_table_start);
+ TRACE("sBlk->fragment_table_start 0x%llx\n", sBlk->fragment_table_start);
+ if(exportable)
+ TRACE("sBlk->lookup_table_start 0x%llx\n",
+ sBlk->lookup_table_start);
+
+ sBlk->bytes_used = bytes;
+
+ sBlk->compression = comp->id;
+
+ SQUASHFS_INSWAP_SUPER_BLOCK(sBlk);
+ write_destination(fd, SQUASHFS_START, sizeof(*sBlk), sBlk);
+
+ if(!nopad && (i = bytes & (4096 - 1))) {
+ char temp[4096] = {0};
+ write_destination(fd, bytes, 4096 - i, temp);
+ }
+
+ close(fd);
+
+ if(recovery_file)
+ unlink(recovery_file);
+
+ total_bytes += total_inode_bytes + total_directory_bytes +
+ sizeof(struct squashfs_super_block) + total_xattr_bytes;
+
+ printf("\n%sSquashfs %d.%d filesystem, %s compressed, data block size"
+ " %d\n", exportable ? "Exportable " : "", SQUASHFS_MAJOR,
+ SQUASHFS_MINOR, comp->name, block_size);
+ printf("\t%s data, %s metadata, %s fragments, %s xattrs\n",
+ noD ? "uncompressed" : "compressed", noI ? "uncompressed" :
+ "compressed", no_fragments ? "no" : noF ? "uncompressed" :
+ "compressed", no_xattrs ? "no" : noX ? "uncompressed" :
+ "compressed");
+ printf("\tduplicates are %sremoved\n", duplicate_checking ? "" :
+ "not ");
+ printf("Filesystem size %.2f Kbytes (%.2f Mbytes)\n", bytes / 1024.0,
+ bytes / (1024.0 * 1024.0));
+ printf("\t%.2f%% of uncompressed filesystem size (%.2f Kbytes)\n",
+ ((float) bytes / total_bytes) * 100.0, total_bytes / 1024.0);
+ printf("Inode table size %d bytes (%.2f Kbytes)\n",
+ inode_bytes, inode_bytes / 1024.0);
+ printf("\t%.2f%% of uncompressed inode table size (%d bytes)\n",
+ ((float) inode_bytes / total_inode_bytes) * 100.0,
+ total_inode_bytes);
+ printf("Directory table size %d bytes (%.2f Kbytes)\n",
+ directory_bytes, directory_bytes / 1024.0);
+ printf("\t%.2f%% of uncompressed directory table size (%d bytes)\n",
+ ((float) directory_bytes / total_directory_bytes) * 100.0,
+ total_directory_bytes);
+ if(total_xattr_bytes) {
+ printf("Xattr table size %d bytes (%.2f Kbytes)\n",
+ xattr_bytes, xattr_bytes / 1024.0);
+ printf("\t%.2f%% of uncompressed xattr table size (%d bytes)\n",
+ ((float) xattr_bytes / total_xattr_bytes) * 100.0,
+ total_xattr_bytes);
+ }
+ if(duplicate_checking)
+ printf("Number of duplicate files found %d\n", file_count -
+ dup_files);
+ else
+ printf("No duplicate files removed\n");
+ printf("Number of inodes %d\n", inode_count);
+ printf("Number of files %d\n", file_count);
+ if(!no_fragments)
+ printf("Number of fragments %d\n", fragments);
+ printf("Number of symbolic links %d\n", sym_count);
+ printf("Number of device nodes %d\n", dev_count);
+ printf("Number of fifo nodes %d\n", fifo_count);
+ printf("Number of socket nodes %d\n", sock_count);
+ printf("Number of directories %d\n", dir_count);
+ printf("Number of ids (unique uids + gids) %d\n", id_count);
+ printf("Number of uids %d\n", uid_count);
+
+ for(i = 0; i < id_count; i++) {
+ if(id_table[i]->flags & ISA_UID) {
+ struct passwd *user = getpwuid(id_table[i]->id);
+ printf("\t%s (%d)\n", user == NULL ? "unknown" :
+ user->pw_name, id_table[i]->id);
+ }
+ }
+
+ printf("Number of gids %d\n", guid_count);
+
+ for(i = 0; i < id_count; i++) {
+ if(id_table[i]->flags & ISA_GID) {
+ struct group *group = getgrgid(id_table[i]->id);
+ printf("\t%s (%d)\n", group == NULL ? "unknown" :
+ group->gr_name, id_table[i]->id);
+ }
+ }
+}
+
+
+int parse_numberll(char *start, long long *res, int size)
+{
+ char *end;
+ long long number;
+
+ errno = 0; /* To distinguish success/failure after call */
+
+ number = strtoll(start, &end, 10);
+
+ /*
+ * check for strtoll underflow or overflow in conversion, and other
+ * errors.
+ */
+ if((errno == ERANGE && (number == LLONG_MIN || number == LLONG_MAX)) ||
+ (errno != 0 && number == 0))
+ return 0;
+
+ /* reject negative numbers as invalid */
+ if(number < 0)
+ return 0;
+
+ if(size) {
+ /*
+ * Check for multiplier and trailing junk.
+ * But first check that a number exists before the
+ * multiplier
+ */
+ if(end == start)
+ return 0;
+
+ switch(end[0]) {
+ case 'g':
+ case 'G':
+ if(multiply_overflowll(number, 1073741824))
+ return 0;
+ number *= 1073741824;
+
+ if(end[1] != '\0')
+ /* trailing junk after multiplier, but
+ * allow it to be "bytes" */
+ if(strcmp(end + 1, "bytes"))
+ return 0;
+
+ break;
+ case 'm':
+ case 'M':
+ if(multiply_overflowll(number, 1048576))
+ return 0;
+ number *= 1048576;
+
+ if(end[1] != '\0')
+ /* trailing junk after multiplier, but
+ * allow it to be "bytes" */
+ if(strcmp(end + 1, "bytes"))
+ return 0;
+
+ break;
+ case 'k':
+ case 'K':
+ if(multiply_overflowll(number, 1024))
+ return 0;
+ number *= 1024;
+
+ if(end[1] != '\0')
+ /* trailing junk after multiplier, but
+ * allow it to be "bytes" */
+ if(strcmp(end + 1, "bytes"))
+ return 0;
+
+ break;
+ case '\0':
+ break;
+ default:
+ /* trailing junk after number */
+ return 0;
+ }
+ } else if(end[0] != '\0')
+ /* trailing junk after number */
+ return 0;
+
+ *res = number;
+ return 1;
+}
+
+
+int parse_number(char *start, int *res, int size)
+{
+ long long number;
+
+ if(!parse_numberll(start, &number, size))
+ return 0;
+
+ /* check if long result will overflow signed int */
+ if(number > INT_MAX)
+ return 0;
+
+ *res = (int) number;
+ return 1;
+}
+
+
+int parse_num(char *arg, int *res)
+{
+ return parse_number(arg, res, 0);
+}
+
+
+int get_physical_memory()
+{
+ int phys_mem;
+#ifndef linux
+ #ifdef HW_MEMSIZE
+ #define SYSCTL_PHYSMEM HW_MEMSIZE
+ #elif defined(HW_PHYSMEM64)
+ #define SYSCTL_PHYSMEM HW_PHYSMEM64
+ #else
+ #define SYSCTL_PHYSMEM HW_PHYSMEM
+ #endif
+
+ int mib[2];
+ uint64_t sysctl_physmem = 0;
+ size_t sysctl_len = sizeof(sysctl_physmem);
+
+ mib[0] = CTL_HW;
+ mib[1] = SYSCTL_PHYSMEM;
+
+ if(sysctl(mib, 2, &sysctl_physmem, &sysctl_len, NULL, 0) == 0) {
+ /* some systems use 32-bit values, work with what we're given */
+ if (sysctl_len == 4)
+ sysctl_physmem = *(uint32_t*)&sysctl_physmem;
+ phys_mem = sysctl_physmem >> 20;
+ } else {
+ ERROR_START("Failed to get amount of available "
+ "memory.");
+ ERROR_EXIT(" Defaulting to least viable amount\n");
+ phys_mem = SQUASHFS_LOWMEM;
+ }
+ #undef SYSCTL_PHYSMEM
+#else
+ /* Long longs are used here because with PAE, a 32-bit
+ machine can have more than 4GB of physical memory */
+
+ long long num_pages = sysconf(_SC_PHYS_PAGES);
+ long long page_size = sysconf(_SC_PAGESIZE);
+ phys_mem = num_pages * page_size >> 20;
+ if(num_pages == -1 || page_size == -1)
+ return 0;
+
+#endif
+
+ if(phys_mem < SQUASHFS_LOWMEM)
+ BAD_ERROR("Mksquashfs requires more physical memory than is "
+ "available!\n");
+
+ return phys_mem;
+}
+
+
+void check_usable_phys_mem(int total_mem)
+{
+ /*
+ * We want to allow users to use as much of their physical
+ * memory as they wish. However, for practical reasons there are
+ * limits which need to be imposed, to protect users from themselves
+ * and to prevent people from using Mksquashfs as a DOS attack by using
+ * all physical memory. Mksquashfs uses memory to cache data from disk
+ * to optimise performance. It is pointless to ask it to use more
+ * than 75% of physical memory, as this causes thrashing and it is thus
+ * self-defeating.
+ */
+ int mem = get_physical_memory();
+
+ mem = (mem >> 1) + (mem >> 2); /* 75% */
+
+ if(total_mem > mem && mem) {
+ ERROR("Total memory requested is more than 75%% of physical "
+ "memory.\n");
+ ERROR("Mksquashfs uses memory to cache data from disk to "
+ "optimise performance.\n");
+ ERROR("It is pointless to ask it to use more than this amount "
+ "of memory, as this\n");
+ ERROR("causes thrashing and it is thus self-defeating.\n");
+ BAD_ERROR("Requested memory size too large\n");
+ }
+
+ if(sizeof(void *) == 4 && total_mem > 2048) {
+ /*
+ * If we're running on a kernel with PAE or on a 64-bit kernel,
+ * then the 75% physical memory limit can still easily exceed
+ * the addressable memory by this process.
+ *
+ * Due to the typical kernel/user-space split (1GB/3GB, or
+ * 2GB/2GB), we have to conservatively assume the 32-bit
+ * processes can only address 2-3GB. So refuse if the user
+ * tries to allocate more than 2GB.
+ */
+ ERROR("Total memory requested may exceed maximum "
+ "addressable memory by this process\n");
+ BAD_ERROR("Requested memory size too large\n");
+ }
+}
+
+
+int get_default_phys_mem()
+{
+ /*
+ * get_physical_memory() relies on /proc being mounted.
+ * If it fails, issue a warning, and use
+ * SQUASHFS_LOWMEM / SQUASHFS_TAKE as default,
+ * and allow a larger value to be set with -mem.
+ */
+ int mem = get_physical_memory();
+
+ if(mem == 0) {
+ mem = SQUASHFS_LOWMEM / SQUASHFS_TAKE;
+
+ ERROR("Warning: Cannot get size of physical memory, probably "
+ "because /proc is missing.\n");
+ ERROR("Warning: Defaulting to minimal use of %d Mbytes, use "
+ "-mem to set a better value,\n", mem);
+ ERROR("Warning: or fix /proc.\n");
+ } else
+ mem /= SQUASHFS_TAKE;
+
+ if(sizeof(void *) == 4 && mem > 640) {
+ /*
+ * If we're running on a kernel with PAE or on a 64-bit kernel,
+ * the default memory usage can exceed the addressable
+ * memory by this process.
+ * Due to the typical kernel/user-space split (1GB/3GB, or
+ * 2GB/2GB), we have to conservatively assume the 32-bit
+ * processes can only address 2-3GB. So limit the default
+ * usage to 640M, which gives room for other data.
+ */
+ mem = 640;
+ }
+
+ return mem;
+}
+
+
+void calculate_queue_sizes(int mem, int *readq, int *fragq, int *bwriteq,
+ int *fwriteq)
+{
+ *readq = mem / SQUASHFS_READQ_MEM;
+ *bwriteq = mem / SQUASHFS_BWRITEQ_MEM;
+ *fwriteq = mem / SQUASHFS_FWRITEQ_MEM;
+ *fragq = mem - *readq - *bwriteq - *fwriteq;
+}
+
+
+#define VERSION() \
+ printf("mksquashfs version 4.3-git (2014/09/12)\n");\
+ printf("copyright (C) 2014 Phillip Lougher "\
+ "<phillip@squashfs.org.uk>\n\n"); \
+ printf("This program is free software; you can redistribute it and/or"\
+ "\n");\
+ printf("modify it under the terms of the GNU General Public License"\
+ "\n");\
+ printf("as published by the Free Software Foundation; either version "\
+ "2,\n");\
+ printf("or (at your option) any later version.\n\n");\
+ printf("This program is distributed in the hope that it will be "\
+ "useful,\n");\
+ printf("but WITHOUT ANY WARRANTY; without even the implied warranty "\
+ "of\n");\
+ printf("MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the"\
+ "\n");\
+ printf("GNU General Public License for more details.\n");
+int main(int argc, char *argv[])
+{
+ struct stat buf, source_buf;
+ int res, i;
+ char *b, *root_name = NULL;
+ int keep_as_directory = FALSE;
+ squashfs_inode inode;
+ int readq;
+ int fragq;
+ int bwriteq;
+ int fwriteq;
+ int total_mem = get_default_phys_mem();
+ int progress = TRUE;
+ int force_progress = FALSE;
+ struct file_buffer **fragment = NULL;
+/* ANDROID CHANGES START*/
+#ifdef ANDROID
+ const char *fs_config_file = NULL;
+#endif
+/* ANDROID CHANGES END */
+
+ if(argc > 1 && strcmp(argv[1], "-version") == 0) {
+ VERSION();
+ exit(0);
+ }
+
+ block_log = slog(block_size);
+ calculate_queue_sizes(total_mem, &readq, &fragq, &bwriteq, &fwriteq);
+
+ for(i = 1; i < argc && argv[i][0] != '-'; i++);
+ if(i < 3)
+ goto printOptions;
+ source_path = argv + 1;
+ source = i - 2;
+
+ /*
+ * Scan the command line for -comp xxx option, this is to ensure
+ * any -X compressor specific options are passed to the
+ * correct compressor
+ */
+ for(; i < argc; i++) {
+ struct compressor *prev_comp = comp;
+
+ if(strcmp(argv[i], "-comp") == 0) {
+ if(++i == argc) {
+ ERROR("%s: -comp missing compression type\n",
+ argv[0]);
+ exit(1);
+ }
+ comp = lookup_compressor(argv[i]);
+ if(!comp->supported) {
+ ERROR("%s: Compressor \"%s\" is not supported!"
+ "\n", argv[0], argv[i]);
+ ERROR("%s: Compressors available:\n", argv[0]);
+ display_compressors("", COMP_DEFAULT);
+ exit(1);
+ }
+ if(prev_comp != NULL && prev_comp != comp) {
+ ERROR("%s: -comp multiple conflicting -comp"
+ " options specified on command line"
+ ", previously %s, now %s\n", argv[0],
+ prev_comp->name, comp->name);
+ exit(1);
+ }
+ compressor_opt_parsed = 1;
+
+ } else if(strcmp(argv[i], "-e") == 0)
+ break;
+ else if(strcmp(argv[i], "-root-becomes") == 0 ||
+ strcmp(argv[i], "-ef") == 0 ||
+ strcmp(argv[i], "-pf") == 0 ||
+ strcmp(argv[i], "-vaf") == 0 ||
+ strcmp(argv[i], "-comp") == 0)
+ i++;
+ }
+
+ /*
+ * if no -comp option specified lookup default compressor. Note the
+ * Makefile ensures the default compressor has been built, and so we
+ * don't need to to check for failure here
+ */
+ if(comp == NULL)
+ comp = lookup_compressor(COMP_DEFAULT);
+
+ for(i = source + 2; i < argc; i++) {
+ if(strcmp(argv[i], "-action") == 0 ||
+ strcmp(argv[i], "-a") ==0) {
+ if(++i == argc) {
+ ERROR("%s: %s missing action\n",
+ argv[0], argv[i - 1]);
+ exit(1);
+ }
+ res = parse_action(argv[i], ACTION_LOG_NONE);
+ if(res == 0)
+ exit(1);
+
+ } else if(strcmp(argv[i], "-verbose-action") == 0 ||
+ strcmp(argv[i], "-va") ==0) {
+ if(++i == argc) {
+ ERROR("%s: %s missing action\n",
+ argv[0], argv[i - 1]);
+ exit(1);
+ }
+ res = parse_action(argv[i], ACTION_LOG_VERBOSE);
+ if(res == 0)
+ exit(1);
+
+ } else if(strcmp(argv[i], "-true-action") == 0 ||
+ strcmp(argv[i], "-ta") ==0) {
+ if(++i == argc) {
+ ERROR("%s: %s missing action\n",
+ argv[0], argv[i - 1]);
+ exit(1);
+ }
+ res = parse_action(argv[i], ACTION_LOG_TRUE);
+ if(res == 0)
+ exit(1);
+
+ } else if(strcmp(argv[i], "-false-action") == 0 ||
+ strcmp(argv[i], "-fa") ==0) {
+ if(++i == argc) {
+ ERROR("%s: %s missing action\n",
+ argv[0], argv[i - 1]);
+ exit(1);
+ }
+ res = parse_action(argv[i], ACTION_LOG_FALSE);
+ if(res == 0)
+ exit(1);
+
+ } else if(strcmp(argv[i], "-action-file") == 0 ||
+ strcmp(argv[i], "-af") ==0) {
+ if(++i == argc) {
+ ERROR("%s: %s missing filename\n", argv[0],
+ argv[i - 1]);
+ exit(1);
+ }
+ if(read_action_file(argv[i], ACTION_LOG_NONE) == FALSE)
+ exit(1);
+
+ } else if(strcmp(argv[i], "-verbose-action-file") == 0 ||
+ strcmp(argv[i], "-vaf") ==0) {
+ if(++i == argc) {
+ ERROR("%s: %s missing filename\n", argv[0],
+ argv[i - 1]);
+ exit(1);
+ }
+ if(read_action_file(argv[i], ACTION_LOG_VERBOSE) == FALSE)
+ exit(1);
+
+ } else if(strcmp(argv[i], "-true-action-file") == 0 ||
+ strcmp(argv[i], "-taf") ==0) {
+ if(++i == argc) {
+ ERROR("%s: %s missing filename\n", argv[0],
+ argv[i - 1]);
+ exit(1);
+ }
+ if(read_action_file(argv[i], ACTION_LOG_TRUE) == FALSE)
+ exit(1);
+
+ } else if(strcmp(argv[i], "-false-action-file") == 0 ||
+ strcmp(argv[i], "-faf") ==0) {
+ if(++i == argc) {
+ ERROR("%s: %s missing filename\n", argv[0],
+ argv[i - 1]);
+ exit(1);
+ }
+ if(read_action_file(argv[i], ACTION_LOG_FALSE) == FALSE)
+ exit(1);
+
+ } else if(strcmp(argv[i], "-comp") == 0)
+ /* parsed previously */
+ i++;
+
+ else if(strncmp(argv[i], "-X", 2) == 0) {
+ int args;
+
+ if(strcmp(argv[i] + 2, "help") == 0)
+ goto print_compressor_options;
+
+ args = compressor_options(comp, argv + i, argc - i);
+ if(args < 0) {
+ if(args == -1) {
+ ERROR("%s: Unrecognised compressor"
+ " option %s\n", argv[0],
+ argv[i]);
+ if(!compressor_opt_parsed)
+ ERROR("%s: Did you forget to"
+ " specify -comp?\n",
+ argv[0]);
+print_compressor_options:
+ ERROR("%s: selected compressor \"%s\""
+ ". Options supported: %s\n",
+ argv[0], comp->name,
+ comp->usage ? "" : "none");
+ if(comp->usage)
+ comp->usage();
+ }
+ exit(1);
+ }
+ i += args;
+
+ } else if(strcmp(argv[i], "-pf") == 0) {
+ if(++i == argc) {
+ ERROR("%s: -pf missing filename\n", argv[0]);
+ exit(1);
+ }
+ if(read_pseudo_file(argv[i]) == FALSE)
+ exit(1);
+ } else if(strcmp(argv[i], "-p") == 0) {
+ if(++i == argc) {
+ ERROR("%s: -p missing pseudo file definition\n",
+ argv[0]);
+ exit(1);
+ }
+ if(read_pseudo_def(argv[i]) == FALSE)
+ exit(1);
+ } else if(strcmp(argv[i], "-recover") == 0) {
+ if(++i == argc) {
+ ERROR("%s: -recover missing recovery file\n",
+ argv[0]);
+ exit(1);
+ }
+ read_recovery_data(argv[i], argv[source + 1]);
+ } else if(strcmp(argv[i], "-no-recovery") == 0)
+ recover = FALSE;
+ else if(strcmp(argv[i], "-wildcards") == 0) {
+ old_exclude = FALSE;
+ use_regex = FALSE;
+ } else if(strcmp(argv[i], "-regex") == 0) {
+ old_exclude = FALSE;
+ use_regex = TRUE;
+ } else if(strcmp(argv[i], "-no-sparse") == 0)
+ sparse_files = FALSE;
+ else if(strcmp(argv[i], "-no-progress") == 0)
+ progress = FALSE;
+ else if(strcmp(argv[i], "-progress") == 0)
+ force_progress = TRUE;
+ else if(strcmp(argv[i], "-no-exports") == 0)
+ exportable = FALSE;
+ else if(strcmp(argv[i], "-processors") == 0) {
+ if((++i == argc) || !parse_num(argv[i], &processors)) {
+ ERROR("%s: -processors missing or invalid "
+ "processor number\n", argv[0]);
+ exit(1);
+ }
+ if(processors < 1) {
+ ERROR("%s: -processors should be 1 or larger\n",
+ argv[0]);
+ exit(1);
+ }
+ } else if(strcmp(argv[i], "-read-queue") == 0) {
+ if((++i == argc) || !parse_num(argv[i], &readq)) {
+ ERROR("%s: -read-queue missing or invalid "
+ "queue size\n", argv[0]);
+ exit(1);
+ }
+ if(readq < 1) {
+ ERROR("%s: -read-queue should be 1 megabyte or "
+ "larger\n", argv[0]);
+ exit(1);
+ }
+ } else if(strcmp(argv[i], "-write-queue") == 0) {
+ if((++i == argc) || !parse_num(argv[i], &bwriteq)) {
+ ERROR("%s: -write-queue missing or invalid "
+ "queue size\n", argv[0]);
+ exit(1);
+ }
+ if(bwriteq < 2) {
+ ERROR("%s: -write-queue should be 2 megabytes "
+ "or larger\n", argv[0]);
+ exit(1);
+ }
+ fwriteq = bwriteq >> 1;
+ bwriteq -= fwriteq;
+ } else if(strcmp(argv[i], "-fragment-queue") == 0) {
+ if((++i == argc) || !parse_num(argv[i], &fragq)) {
+ ERROR("%s: -fragment-queue missing or invalid "
+ "queue size\n", argv[0]);
+ exit(1);
+ }
+ if(fragq < 1) {
+ ERROR("%s: -fragment-queue should be 1 "
+ "megabyte or larger\n", argv[0]);
+ exit(1);
+ }
+ } else if(strcmp(argv[i], "-mem") == 0) {
+ long long number;
+
+ if((++i == argc) ||
+ !parse_numberll(argv[i], &number, 1)) {
+ ERROR("%s: -mem missing or invalid mem size\n",
+ argv[0]);
+ exit(1);
+ }
+
+ /*
+ * convert from bytes to Mbytes, ensuring the value
+ * does not overflow a signed int
+ */
+ if(number >= (1LL << 51)) {
+ ERROR("%s: -mem invalid mem size\n", argv[0]);
+ exit(1);
+ }
+
+ total_mem = number / 1048576;
+ if(total_mem < (SQUASHFS_LOWMEM / SQUASHFS_TAKE)) {
+ ERROR("%s: -mem should be %d Mbytes or "
+ "larger\n", argv[0],
+ SQUASHFS_LOWMEM / SQUASHFS_TAKE);
+ exit(1);
+ }
+ calculate_queue_sizes(total_mem, &readq, &fragq,
+ &bwriteq, &fwriteq);
+ } else if(strcmp(argv[i], "-b") == 0) {
+ if(++i == argc) {
+ ERROR("%s: -b missing block size\n", argv[0]);
+ exit(1);
+ }
+ if(!parse_number(argv[i], &block_size, 1)) {
+ ERROR("%s: -b invalid block size\n", argv[0]);
+ exit(1);
+ }
+ if((block_log = slog(block_size)) == 0) {
+ ERROR("%s: -b block size not power of two or "
+ "not between 4096 and 1Mbyte\n",
+ argv[0]);
+ exit(1);
+ }
+ } else if(strcmp(argv[i], "-ef") == 0) {
+ if(++i == argc) {
+ ERROR("%s: -ef missing filename\n", argv[0]);
+ exit(1);
+ }
+ } else if(strcmp(argv[i], "-no-duplicates") == 0)
+ duplicate_checking = FALSE;
+
+ else if(strcmp(argv[i], "-no-fragments") == 0)
+ no_fragments = TRUE;
+
+ else if(strcmp(argv[i], "-always-use-fragments") == 0)
+ always_use_fragments = TRUE;
+
+ else if(strcmp(argv[i], "-sort") == 0) {
+ if(++i == argc) {
+ ERROR("%s: -sort missing filename\n", argv[0]);
+ exit(1);
+ }
+ } else if(strcmp(argv[i], "-all-root") == 0 ||
+ strcmp(argv[i], "-root-owned") == 0)
+ global_uid = global_gid = 0;
+
+ else if(strcmp(argv[i], "-force-uid") == 0) {
+ if(++i == argc) {
+ ERROR("%s: -force-uid missing uid or user\n",
+ argv[0]);
+ exit(1);
+ }
+ if((global_uid = strtoll(argv[i], &b, 10)), *b =='\0') {
+ if(global_uid < 0 || global_uid >
+ (((long long) 1 << 32) - 1)) {
+ ERROR("%s: -force-uid uid out of range"
+ "\n", argv[0]);
+ exit(1);
+ }
+ } else {
+ struct passwd *uid = getpwnam(argv[i]);
+ if(uid)
+ global_uid = uid->pw_uid;
+ else {
+ ERROR("%s: -force-uid invalid uid or "
+ "unknown user\n", argv[0]);
+ exit(1);
+ }
+ }
+ } else if(strcmp(argv[i], "-force-gid") == 0) {
+ if(++i == argc) {
+ ERROR("%s: -force-gid missing gid or group\n",
+ argv[0]);
+ exit(1);
+ }
+ if((global_gid = strtoll(argv[i], &b, 10)), *b =='\0') {
+ if(global_gid < 0 || global_gid >
+ (((long long) 1 << 32) - 1)) {
+ ERROR("%s: -force-gid gid out of range"
+ "\n", argv[0]);
+ exit(1);
+ }
+ } else {
+ struct group *gid = getgrnam(argv[i]);
+ if(gid)
+ global_gid = gid->gr_gid;
+ else {
+ ERROR("%s: -force-gid invalid gid or "
+ "unknown group\n", argv[0]);
+ exit(1);
+ }
+ }
+ } else if(strcmp(argv[i], "-noI") == 0 ||
+ strcmp(argv[i], "-noInodeCompression") == 0)
+ noI = TRUE;
+
+ else if(strcmp(argv[i], "-noD") == 0 ||
+ strcmp(argv[i], "-noDataCompression") == 0)
+ noD = TRUE;
+
+ else if(strcmp(argv[i], "-noF") == 0 ||
+ strcmp(argv[i], "-noFragmentCompression") == 0)
+ noF = TRUE;
+
+ else if(strcmp(argv[i], "-noX") == 0 ||
+ strcmp(argv[i], "-noXattrCompression") == 0)
+ noX = TRUE;
+
+ else if(strcmp(argv[i], "-no-xattrs") == 0)
+ no_xattrs = TRUE;
+
+ else if(strcmp(argv[i], "-xattrs") == 0)
+ no_xattrs = FALSE;
+
+/* ANDROID CHANGES START*/
+#ifdef ANDROID
+ else if(strcmp(argv[i], "-context-file") == 0) {
+ if(++i == argc) {
+ ERROR("%s: -context-file: missing file name\n",
+ argv[0]);
+ exit(1);
+ }
+ context_file = argv[i];
+ }
+ else if(strcmp(argv[i], "-fs-config-file") == 0) {
+ if(++i == argc) {
+ ERROR("%s: -fs-config-file: missing file name\n",
+ argv[0]);
+ exit(1);
+ }
+ fs_config_file = argv[i];
+ }
+#endif
+/* ANDROID CHANGES END */
+ else if(strcmp(argv[i], "-nopad") == 0)
+ nopad = TRUE;
+
+ else if(strcmp(argv[i], "-info") == 0)
+ silent = FALSE;
+
+ else if(strcmp(argv[i], "-e") == 0)
+ break;
+
+ else if(strcmp(argv[i], "-noappend") == 0)
+ delete = TRUE;
+
+ else if(strcmp(argv[i], "-keep-as-directory") == 0)
+ keep_as_directory = TRUE;
+/* ANDROID CHANGES START*/
+#ifdef ANDROID
+ else if(strcmp(argv[i], "-android-fs-config") == 0)
+ android_config = TRUE;
+ else if(strcmp(argv[i], "-mount-point") == 0) {
+ if(++i == argc) {
+ ERROR("%s: -mount-point: missing mount point name\n",
+ argv[0]);
+ exit(1);
+ }
+ mount_point = argv[i];
+ }
+ else if(strcmp(argv[i], "-product-out") == 0) {
+ if(++i == argc) {
+ ERROR("%s: -product-out: missing path name\n",
+ argv[0]);
+ exit(1);
+ }
+ target_out_path = argv[i];
+ }
+#endif
+/* ANDROID CHANGES END */
+
+ else if(strcmp(argv[i], "-exit-on-error") == 0)
+ exit_on_error = TRUE;
+
+ else if(strcmp(argv[i], "-root-becomes") == 0) {
+ if(++i == argc) {
+ ERROR("%s: -root-becomes: missing name\n",
+ argv[0]);
+ exit(1);
+ }
+ root_name = argv[i];
+ } else if(strcmp(argv[i], "-version") == 0) {
+ VERSION();
+ } else {
+ ERROR("%s: invalid option\n\n", argv[0]);
+printOptions:
+ ERROR("SYNTAX:%s source1 source2 ... dest [options] "
+ "[-e list of exclude\ndirs/files]\n", argv[0]);
+ ERROR("\nFilesystem build options:\n");
+ ERROR("-comp <comp>\t\tselect <comp> compression\n");
+ ERROR("\t\t\tCompressors available:\n");
+ display_compressors("\t\t\t", COMP_DEFAULT);
+ ERROR("-b <block_size>\t\tset data block to "
+ "<block_size>. Default 128 Kbytes\n");
+ ERROR("\t\t\tOptionally a suffix of K or M can be"
+ " given to specify\n\t\t\tKbytes or Mbytes"
+ " respectively\n");
+ ERROR("-no-exports\t\tdon't make the filesystem "
+ "exportable via NFS\n");
+ ERROR("-no-sparse\t\tdon't detect sparse files\n");
+ ERROR("-no-xattrs\t\tdon't store extended attributes"
+ NOXOPT_STR "\n");
+ ERROR("-xattrs\t\t\tstore extended attributes" XOPT_STR
+ "\n");
+/* ANDROID CHANGES START*/
+#ifdef ANDROID
+ ERROR("-context-file <file>\tApply selinux security "
+ "xattrs from context-file instead\n\t\t\t"
+ "of reading xattrs from file system\n");
+ ERROR("-fs-config-file <file>\tAndroid specific "
+ "filesystem config file\n");
+#endif
+/* ANDROID CHANGES END */
+ ERROR("-noI\t\t\tdo not compress inode table\n");
+ ERROR("-noD\t\t\tdo not compress data blocks\n");
+ ERROR("-noF\t\t\tdo not compress fragment blocks\n");
+ ERROR("-noX\t\t\tdo not compress extended "
+ "attributes\n");
+ ERROR("-no-fragments\t\tdo not use fragments\n");
+ ERROR("-always-use-fragments\tuse fragment blocks for "
+ "files larger than block size\n");
+ ERROR("-no-duplicates\t\tdo not perform duplicate "
+ "checking\n");
+ ERROR("-all-root\t\tmake all files owned by root\n");
+ ERROR("-force-uid uid\t\tset all file uids to uid\n");
+ ERROR("-force-gid gid\t\tset all file gids to gid\n");
+ ERROR("-nopad\t\t\tdo not pad filesystem to a multiple "
+ "of 4K\n");
+ ERROR("-keep-as-directory\tif one source directory is "
+ "specified, create a root\n");
+ ERROR("\t\t\tdirectory containing that directory, "
+ "rather than the\n");
+ ERROR("\t\t\tcontents of the directory\n");
+/* ANDROID CHANGES START*/
+#ifdef ANDROID
+ ERROR("-android-fs-config\tuse android fs config "
+ "for mode, uid, and gids of inodes\n");
+ ERROR("-mount-point <name>\tNeed to be provided when "
+ "android-fs-config or context-file\n\t\t\tare "
+ "enabled and source directory is not mount point\n");
+ ERROR("-product-out <path>\tPRODUCT_OUT directory to "
+ "read device specific FS rules files from\n");
+#endif
+/* ANDROID CHANGES END */
+ ERROR("\nFilesystem filter options:\n");
+ ERROR("-p <pseudo-definition>\tAdd pseudo file "
+ "definition\n");
+ ERROR("-pf <pseudo-file>\tAdd list of pseudo file "
+ "definitions\n");
+ ERROR("-sort <sort_file>\tsort files according to "
+ "priorities in <sort_file>. One\n");
+ ERROR("\t\t\tfile or dir with priority per line. "
+ "Priority -32768 to\n");
+ ERROR("\t\t\t32767, default priority 0\n");
+ ERROR("-ef <exclude_file>\tlist of exclude dirs/files."
+ " One per line\n");
+ ERROR("-wildcards\t\tAllow extended shell wildcards "
+ "(globbing) to be used in\n\t\t\texclude "
+ "dirs/files\n");
+ ERROR("-regex\t\t\tAllow POSIX regular expressions to "
+ "be used in exclude\n\t\t\tdirs/files\n");
+ ERROR("\nFilesystem append options:\n");
+ ERROR("-noappend\t\tdo not append to existing "
+ "filesystem\n");
+ ERROR("-root-becomes <name>\twhen appending source "
+ "files/directories, make the\n");
+ ERROR("\t\t\toriginal root become a subdirectory in "
+ "the new root\n");
+ ERROR("\t\t\tcalled <name>, rather than adding the new "
+ "source items\n");
+ ERROR("\t\t\tto the original root\n");
+ ERROR("\nMksquashfs runtime options:\n");
+ ERROR("-version\t\tprint version, licence and "
+ "copyright message\n");
+ ERROR("-exit-on-error\t\ttreat normally ignored errors "
+ "as fatal\n");
+ ERROR("-recover <name>\t\trecover filesystem data "
+ "using recovery file <name>\n");
+ ERROR("-no-recovery\t\tdon't generate a recovery "
+ "file\n");
+ ERROR("-info\t\t\tprint files written to filesystem\n");
+ ERROR("-no-progress\t\tdon't display the progress "
+ "bar\n");
+ ERROR("-progress\t\tdisplay progress bar when using "
+ "the -info option\n");
+ ERROR("-processors <number>\tUse <number> processors."
+ " By default will use number of\n");
+ ERROR("\t\t\tprocessors available\n");
+ ERROR("-mem <size>\t\tUse <size> physical memory. "
+ "Currently set to %dM\n", total_mem);
+ ERROR("\t\t\tOptionally a suffix of K, M or G can be"
+ " given to specify\n\t\t\tKbytes, Mbytes or"
+ " Gbytes respectively\n");
+ ERROR("\nMiscellaneous options:\n");
+ ERROR("-root-owned\t\talternative name for -all-root"
+ "\n");
+ ERROR("-noInodeCompression\talternative name for -noI"
+ "\n");
+ ERROR("-noDataCompression\talternative name for -noD"
+ "\n");
+ ERROR("-noFragmentCompression\talternative name for "
+ "-noF\n");
+ ERROR("-noXattrCompression\talternative name for "
+ "-noX\n");
+ ERROR("\n-Xhelp\t\t\tprint compressor options for"
+ " selected compressor\n");
+ ERROR("\nCompressors available and compressor specific "
+ "options:\n");
+ display_compressor_usage(COMP_DEFAULT);
+ exit(1);
+ }
+ }
+
+/* ANDROID CHANGES START*/
+#ifdef ANDROID
+ if (fs_config_file) {
+ if (load_canned_fs_config(fs_config_file) < 0) {
+ fprintf(stderr, "failed to load %s\n", fs_config_file);
+ exit(1);
+ }
+ fs_config_func = canned_fs_config;
+ } else if (mount_point) {
+ fs_config_func = fs_config;
+ }
+#endif
+/* ANDROID CHANGES END */
+
+ /*
+ * Some compressors may need the options to be checked for validity
+ * once all the options have been processed
+ */
+ res = compressor_options_post(comp, block_size);
+ if(res)
+ EXIT_MKSQUASHFS();
+
+ /*
+ * If the -info option has been selected then disable the
+ * progress bar unless it has been explicitly enabled with
+ * the -progress option
+ */
+ if(!silent)
+ progress = force_progress;
+
+#ifdef SQUASHFS_TRACE
+ /*
+ * Disable progress bar if full debug tracing is enabled.
+ * The progress bar in this case just gets in the way of the
+ * debug trace output
+ */
+ progress = FALSE;
+#endif
+
+ for(i = 0; i < source; i++)
+ if(lstat(source_path[i], &source_buf) == -1) {
+ fprintf(stderr, "Cannot stat source directory \"%s\" "
+ "because %s\n", source_path[i],
+ strerror(errno));
+ EXIT_MKSQUASHFS();
+ }
+
+ destination_file = argv[source + 1];
+ if(stat(argv[source + 1], &buf) == -1) {
+ if(errno == ENOENT) { /* Does not exist */
+ fd = open(argv[source + 1], O_CREAT | O_TRUNC | O_RDWR,
+ S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
+ if(fd == -1) {
+ perror("Could not create destination file");
+ exit(1);
+ }
+ delete = TRUE;
+ } else {
+ perror("Could not stat destination file");
+ exit(1);
+ }
+
+ } else {
+ if(S_ISBLK(buf.st_mode)) {
+ if((fd = open(argv[source + 1], O_RDWR)) == -1) {
+ perror("Could not open block device as "
+ "destination");
+ exit(1);
+ }
+ block_device = 1;
+
+ } else if(S_ISREG(buf.st_mode)) {
+ fd = open(argv[source + 1], (delete ? O_TRUNC : 0) |
+ O_RDWR);
+ if(fd == -1) {
+ perror("Could not open regular file for "
+ "writing as destination");
+ exit(1);
+ }
+ }
+ else {
+ ERROR("Destination not block device or regular file\n");
+ exit(1);
+ }
+
+ }
+
+ /*
+ * process the exclude files - must be done afer destination file has
+ * been possibly created
+ */
+ for(i = source + 2; i < argc; i++)
+ if(strcmp(argv[i], "-ef") == 0)
+ /*
+ * Note presence of filename arg has already
+ * been checked
+ */
+ process_exclude_file(argv[++i]);
+ else if(strcmp(argv[i], "-e") == 0)
+ break;
+ else if(strcmp(argv[i], "-root-becomes") == 0 ||
+ strcmp(argv[i], "-sort") == 0 ||
+ strcmp(argv[i], "-pf") == 0 ||
+ strcmp(argv[i], "-af") == 0 ||
+ strcmp(argv[i], "-vaf") == 0 ||
+ strcmp(argv[i], "-comp") == 0)
+ i++;
+
+ if(i != argc) {
+ if(++i == argc) {
+ ERROR("%s: -e missing arguments\n", argv[0]);
+ EXIT_MKSQUASHFS();
+ }
+ while(i < argc)
+ if(old_exclude)
+ old_add_exclude(argv[i++]);
+ else
+ add_exclude(argv[i++]);
+ }
+
+ /* process the sort files - must be done afer the exclude files */
+ for(i = source + 2; i < argc; i++)
+ if(strcmp(argv[i], "-sort") == 0) {
+ int res = read_sort_file(argv[++i], source,
+ source_path);
+ if(res == FALSE)
+ BAD_ERROR("Failed to read sort file\n");
+ sorted ++;
+ } else if(strcmp(argv[i], "-e") == 0)
+ break;
+ else if(strcmp(argv[i], "-root-becomes") == 0 ||
+ strcmp(argv[i], "-ef") == 0 ||
+ strcmp(argv[i], "-pf") == 0 ||
+ strcmp(argv[i], "-af") == 0 ||
+ strcmp(argv[i], "-vaf") == 0 ||
+ strcmp(argv[i], "-comp") == 0)
+ i++;
+
+ if(!delete) {
+ comp = read_super(fd, &sBlk, argv[source + 1]);
+ if(comp == NULL) {
+ ERROR("Failed to read existing filesystem - will not "
+ "overwrite - ABORTING!\n");
+ ERROR("To force Mksquashfs to write to this block "
+ "device or file use -noappend\n");
+ EXIT_MKSQUASHFS();
+ }
+
+ block_log = slog(block_size = sBlk.block_size);
+ noI = SQUASHFS_UNCOMPRESSED_INODES(sBlk.flags);
+ noD = SQUASHFS_UNCOMPRESSED_DATA(sBlk.flags);
+ noF = SQUASHFS_UNCOMPRESSED_FRAGMENTS(sBlk.flags);
+ noX = SQUASHFS_UNCOMPRESSED_XATTRS(sBlk.flags);
+ no_fragments = SQUASHFS_NO_FRAGMENTS(sBlk.flags);
+ always_use_fragments = SQUASHFS_ALWAYS_FRAGMENTS(sBlk.flags);
+ duplicate_checking = SQUASHFS_DUPLICATES(sBlk.flags);
+ exportable = SQUASHFS_EXPORTABLE(sBlk.flags);
+ no_xattrs = SQUASHFS_NO_XATTRS(sBlk.flags);
+ comp_opts = SQUASHFS_COMP_OPTS(sBlk.flags);
+ }
+
+ initialise_threads(readq, fragq, bwriteq, fwriteq, delete,
+ destination_file);
+
+ res = compressor_init(comp, &stream, SQUASHFS_METADATA_SIZE, 0);
+ if(res)
+ BAD_ERROR("compressor_init failed\n");
+
+ if(delete) {
+ int size;
+ void *comp_data = compressor_dump_options(comp, block_size,
+ &size);
+
+ printf("Creating %d.%d filesystem on %s, block size %d.\n",
+ SQUASHFS_MAJOR, SQUASHFS_MINOR, argv[source + 1], block_size);
+
+ /*
+ * store any compressor specific options after the superblock,
+ * and set the COMP_OPT flag to show that the filesystem has
+ * compressor specfic options
+ */
+ if(comp_data) {
+ unsigned short c_byte = size | SQUASHFS_COMPRESSED_BIT;
+
+ SQUASHFS_INSWAP_SHORTS(&c_byte, 1);
+ write_destination(fd, sizeof(struct squashfs_super_block),
+ sizeof(c_byte), &c_byte);
+ write_destination(fd, sizeof(struct squashfs_super_block) +
+ sizeof(c_byte), size, comp_data);
+ bytes = sizeof(struct squashfs_super_block) + sizeof(c_byte)
+ + size;
+ comp_opts = TRUE;
+ } else
+ bytes = sizeof(struct squashfs_super_block);
+ } else {
+ unsigned int last_directory_block, inode_dir_offset,
+ inode_dir_file_size, root_inode_size,
+ inode_dir_start_block, uncompressed_data,
+ compressed_data, inode_dir_inode_number,
+ inode_dir_parent_inode;
+ unsigned int root_inode_start =
+ SQUASHFS_INODE_BLK(sBlk.root_inode),
+ root_inode_offset =
+ SQUASHFS_INODE_OFFSET(sBlk.root_inode);
+
+ if((bytes = read_filesystem(root_name, fd, &sBlk, &inode_table,
+ &data_cache, &directory_table,
+ &directory_data_cache, &last_directory_block,
+ &inode_dir_offset, &inode_dir_file_size,
+ &root_inode_size, &inode_dir_start_block,
+ &file_count, &sym_count, &dev_count, &dir_count,
+ &fifo_count, &sock_count, &total_bytes,
+ &total_inode_bytes, &total_directory_bytes,
+ &inode_dir_inode_number,
+ &inode_dir_parent_inode, add_old_root_entry,
+ &fragment_table, &inode_lookup_table)) == 0) {
+ ERROR("Failed to read existing filesystem - will not "
+ "overwrite - ABORTING!\n");
+ ERROR("To force Mksquashfs to write to this block "
+ "device or file use -noappend\n");
+ EXIT_MKSQUASHFS();
+ }
+ if((append_fragments = fragments = sBlk.fragments)) {
+ fragment_table = realloc((char *) fragment_table,
+ ((fragments + FRAG_SIZE - 1) & ~(FRAG_SIZE - 1))
+ * sizeof(struct squashfs_fragment_entry));
+ if(fragment_table == NULL)
+ BAD_ERROR("Out of memory in save filesystem state\n");
+ }
+
+ printf("Appending to existing %d.%d filesystem on %s, block "
+ "size %d\n", SQUASHFS_MAJOR, SQUASHFS_MINOR, argv[source + 1],
+ block_size);
+ printf("All -b, -noI, -noD, -noF, -noX, no-duplicates, no-fragments, "
+ "-always-use-fragments,\n-exportable and -comp options "
+ "ignored\n");
+ printf("\nIf appending is not wanted, please re-run with "
+ "-noappend specified!\n\n");
+
+ compressed_data = (inode_dir_offset + inode_dir_file_size) &
+ ~(SQUASHFS_METADATA_SIZE - 1);
+ uncompressed_data = (inode_dir_offset + inode_dir_file_size) &
+ (SQUASHFS_METADATA_SIZE - 1);
+
+ /* save original filesystem state for restoring ... */
+ sfragments = fragments;
+ sbytes = bytes;
+ sinode_count = sBlk.inodes;
+ scache_bytes = root_inode_offset + root_inode_size;
+ sdirectory_cache_bytes = uncompressed_data;
+ sdata_cache = malloc(scache_bytes);
+ if(sdata_cache == NULL)
+ BAD_ERROR("Out of memory in save filesystem state\n");
+ sdirectory_data_cache = malloc(sdirectory_cache_bytes);
+ if(sdirectory_data_cache == NULL)
+ BAD_ERROR("Out of memory in save filesystem state\n");
+ memcpy(sdata_cache, data_cache, scache_bytes);
+ memcpy(sdirectory_data_cache, directory_data_cache +
+ compressed_data, sdirectory_cache_bytes);
+ sinode_bytes = root_inode_start;
+ stotal_bytes = total_bytes;
+ stotal_inode_bytes = total_inode_bytes;
+ stotal_directory_bytes = total_directory_bytes +
+ compressed_data;
+ sfile_count = file_count;
+ ssym_count = sym_count;
+ sdev_count = dev_count;
+ sdir_count = dir_count + 1;
+ sfifo_count = fifo_count;
+ ssock_count = sock_count;
+ sdup_files = dup_files;
+ sid_count = id_count;
+ write_recovery_data(&sBlk);
+ save_xattrs();
+ appending = TRUE;
+
+ /*
+ * set the filesystem state up to be able to append to the
+ * original filesystem. The filesystem state differs depending
+ * on whether we're appending to the original root directory, or
+ * if the original root directory becomes a sub-directory
+ * (root-becomes specified on command line, here root_name !=
+ * NULL)
+ */
+ inode_bytes = inode_size = root_inode_start;
+ directory_size = last_directory_block;
+ cache_size = root_inode_offset + root_inode_size;
+ directory_cache_size = inode_dir_offset + inode_dir_file_size;
+ if(root_name) {
+ sdirectory_bytes = last_directory_block;
+ sdirectory_compressed_bytes = 0;
+ root_inode_number = inode_dir_parent_inode;
+ inode_no = sBlk.inodes + 2;
+ directory_bytes = last_directory_block;
+ directory_cache_bytes = uncompressed_data;
+ memmove(directory_data_cache, directory_data_cache +
+ compressed_data, uncompressed_data);
+ cache_bytes = root_inode_offset + root_inode_size;
+ add_old_root_entry(root_name, sBlk.root_inode,
+ inode_dir_inode_number, SQUASHFS_DIR_TYPE);
+ total_directory_bytes += compressed_data;
+ dir_count ++;
+ } else {
+ sdirectory_compressed_bytes = last_directory_block -
+ inode_dir_start_block;
+ sdirectory_compressed =
+ malloc(sdirectory_compressed_bytes);
+ if(sdirectory_compressed == NULL)
+ BAD_ERROR("Out of memory in save filesystem "
+ "state\n");
+ memcpy(sdirectory_compressed, directory_table +
+ inode_dir_start_block,
+ sdirectory_compressed_bytes);
+ sdirectory_bytes = inode_dir_start_block;
+ root_inode_number = inode_dir_inode_number;
+ inode_no = sBlk.inodes + 1;
+ directory_bytes = inode_dir_start_block;
+ directory_cache_bytes = inode_dir_offset;
+ cache_bytes = root_inode_offset;
+ }
+
+ inode_count = file_count + dir_count + sym_count + dev_count +
+ fifo_count + sock_count;
+ }
+
+ if(path)
+ paths = add_subdir(paths, path);
+
+ dump_actions();
+ dump_pseudos();
+
+ if(delete && !keep_as_directory && source == 1 &&
+ S_ISDIR(source_buf.st_mode))
+ dir_scan(&inode, source_path[0], scan1_readdir, progress);
+ else if(!keep_as_directory && source == 1 &&
+ S_ISDIR(source_buf.st_mode))
+ dir_scan(&inode, source_path[0], scan1_single_readdir, progress);
+ else
+ dir_scan(&inode, "", scan1_encomp_readdir, progress);
+ sBlk.root_inode = inode;
+ sBlk.inodes = inode_count;
+ sBlk.s_magic = SQUASHFS_MAGIC;
+ sBlk.s_major = SQUASHFS_MAJOR;
+ sBlk.s_minor = SQUASHFS_MINOR;
+ sBlk.block_size = block_size;
+ sBlk.block_log = block_log;
+ sBlk.flags = SQUASHFS_MKFLAGS(noI, noD, noF, noX, no_fragments,
+ always_use_fragments, duplicate_checking, exportable,
+ no_xattrs, comp_opts);
+ sBlk.mkfs_time = time(NULL);
+
+ disable_info();
+
+ while((fragment = get_frag_action(fragment)))
+ write_fragment(*fragment);
+ unlock_fragments();
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &fragment_mutex);
+ pthread_mutex_lock(&fragment_mutex);
+ while(fragments_outstanding) {
+ pthread_mutex_unlock(&fragment_mutex);
+ sched_yield();
+ pthread_mutex_lock(&fragment_mutex);
+ }
+ pthread_cleanup_pop(1);
+
+ queue_put(to_writer, NULL);
+ if(queue_get(from_writer) != 0)
+ EXIT_MKSQUASHFS();
+
+ set_progressbar_state(FALSE);
+ write_filesystem_tables(&sBlk, nopad);
+
+ return 0;
+}
diff --git a/squashfs-tools/squashfs-tools/mksquashfs.h b/squashfs-tools/squashfs-tools/mksquashfs.h
new file mode 100644
index 0000000..bfbf0bf
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/mksquashfs.h
@@ -0,0 +1,165 @@
+#ifndef MKSQUASHFS_H
+#define MKSQUASHFS_H
+/*
+ * Squashfs
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
+ * 2012, 2013, 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * mksquashfs.h
+ *
+ */
+/* ANDROID CHANGES START*/
+#ifdef ANDROID
+#include <stdint.h>
+#endif
+/* ANDROID CHANGES END */
+#include <pthread.h>
+
+struct dir_info {
+ char *pathname;
+ char *subpath;
+ unsigned int count;
+ unsigned int directory_count;
+ int depth;
+ unsigned int excluded;
+ char dir_is_ldir;
+ struct dir_ent *dir_ent;
+ struct dir_ent *list;
+ DIR *linuxdir;
+};
+
+struct dir_ent {
+ char *name;
+ char *source_name;
+ char *nonstandard_pathname;
+ struct inode_info *inode;
+ struct dir_info *dir;
+ struct dir_info *our_dir;
+ struct dir_ent *next;
+/* ANDROID CHANGES START*/
+#ifdef ANDROID
+ uint64_t capabilities;
+#endif
+/* ANDROID CHANGES END */
+};
+
+struct inode_info {
+ struct stat buf;
+ struct inode_info *next;
+ squashfs_inode inode;
+ unsigned int inode_number;
+ unsigned int nlink;
+ int pseudo_id;
+ char type;
+ char read;
+ char root_entry;
+ char pseudo_file;
+ char no_fragments;
+ char always_use_fragments;
+ char noD;
+ char noF;
+ char symlink[0];
+};
+
+/* in memory file info */
+struct file_info {
+ long long file_size;
+ long long bytes;
+ long long start;
+ unsigned int *block_list;
+ struct file_info *next;
+ struct fragment *fragment;
+ unsigned short checksum;
+ unsigned short fragment_checksum;
+ char have_frag_checksum;
+ char have_checksum;
+};
+
+/* fragment block data structures */
+struct fragment {
+ unsigned int index;
+ int offset;
+ int size;
+};
+
+/* in memory uid tables */
+#define ID_ENTRIES 256
+#define ID_HASH(id) (id & (ID_ENTRIES - 1))
+#define ISA_UID 1
+#define ISA_GID 2
+
+struct id {
+ unsigned int id;
+ int index;
+ char flags;
+ struct id *next;
+};
+
+/* fragment to file mapping used when appending */
+struct append_file {
+ struct file_info *file;
+ struct append_file *next;
+};
+
+#define PSEUDO_FILE_OTHER 1
+#define PSEUDO_FILE_PROCESS 2
+
+#define IS_PSEUDO(a) ((a)->pseudo_file)
+#define IS_PSEUDO_PROCESS(a) ((a)->pseudo_file & PSEUDO_FILE_PROCESS)
+#define IS_PSEUDO_OTHER(a) ((a)->pseudo_file & PSEUDO_FILE_OTHER)
+
+/*
+ * Amount of physical memory to use by default, and the default queue
+ * ratios
+ */
+#define SQUASHFS_TAKE 4
+#define SQUASHFS_READQ_MEM 4
+#define SQUASHFS_BWRITEQ_MEM 4
+#define SQUASHFS_FWRITEQ_MEM 4
+
+/*
+ * Lowest amount of physical memory considered viable for Mksquashfs
+ * to run in Mbytes
+ */
+#define SQUASHFS_LOWMEM 64
+
+/* offset of data in compressed metadata blocks (allowing room for
+ * compressed size */
+#define BLOCK_OFFSET 2
+
+extern struct cache *reader_buffer, *fragment_buffer, *reserve_cache;
+struct cache *bwriter_buffer, *fwriter_buffer;
+extern struct queue *to_reader, *to_deflate, *to_writer, *from_writer,
+ *to_frag, *locked_fragment, *to_process_frag;
+extern struct append_file **file_mapping;
+extern struct seq_queue *to_main;
+extern pthread_mutex_t fragment_mutex, dup_mutex;
+extern struct squashfs_fragment_entry *fragment_table;
+extern struct compressor *comp;
+extern int block_size;
+extern struct file_info *dupl[];
+extern int read_fs_bytes(int, long long, int, void *);
+extern void add_file(long long, long long, long long, unsigned int *, int,
+ unsigned int, int, int);
+extern struct id *create_id(unsigned int);
+extern unsigned int get_uid(unsigned int);
+extern unsigned int get_guid(unsigned int);
+extern int read_bytes(int, void *, int);
+extern unsigned short get_checksum_mem(char *, int);
+#endif
diff --git a/squashfs-tools/squashfs-tools/process_fragments.c b/squashfs-tools/squashfs-tools/process_fragments.c
new file mode 100644
index 0000000..bba6f5a
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/process_fragments.c
@@ -0,0 +1,370 @@
+/*
+ * Create a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * process_fragments.c
+ */
+
+#include <pthread.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <signal.h>
+#include <sys/time.h>
+#include <string.h>
+#include <stdio.h>
+#include <math.h>
+#include <stdarg.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <dirent.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include "caches-queues-lists.h"
+#include "squashfs_fs.h"
+#include "mksquashfs.h"
+#include "error.h"
+#include "progressbar.h"
+#include "info.h"
+#include "compressor.h"
+#include "process_fragments.h"
+
+#define FALSE 0
+#define TRUE 1
+
+extern struct queue *to_process_frag;
+extern struct seq_queue *to_main;
+extern int sparse_files;
+
+/*
+ * Compute 16 bit BSD checksum over the data, and check for sparseness
+ */
+static int checksum_sparse(struct file_buffer *file_buffer)
+{
+ unsigned char *b = (unsigned char *) file_buffer->data;
+ unsigned short chksum = 0;
+ int bytes = file_buffer->size, sparse = TRUE, value;
+
+ while(bytes --) {
+ chksum = (chksum & 1) ? (chksum >> 1) | 0x8000 : chksum >> 1;
+ value = *b++;
+ if(value) {
+ sparse = FALSE;
+ chksum += value;
+ }
+ }
+
+ file_buffer->checksum = chksum;
+ return sparse;
+}
+
+
+static int read_filesystem(int fd, long long byte, int bytes, void *buff)
+{
+ off_t off = byte;
+
+ TRACE("read_filesystem: reading from position 0x%llx, bytes %d\n",
+ byte, bytes);
+
+ if(lseek(fd, off, SEEK_SET) == -1) {
+ ERROR("read_filesystem: Lseek on destination failed because %s, "
+ "offset=0x%llx\n", strerror(errno), off);
+ return 0;
+ } else if(read_bytes(fd, buff, bytes) < bytes) {
+ ERROR("Read on destination failed\n");
+ return 0;
+ }
+
+ return 1;
+}
+
+
+static struct file_buffer *get_fragment(struct fragment *fragment,
+ char *data_buffer, int fd)
+{
+ struct squashfs_fragment_entry *disk_fragment;
+ struct file_buffer *buffer, *compressed_buffer;
+ long long start_block;
+ int res, size, index = fragment->index;
+ char locked;
+
+ /*
+ * Lookup fragment block in cache.
+ * If the fragment block doesn't exist, then get the compressed version
+ * from the writer cache or off disk, and decompress it.
+ *
+ * This routine has two things which complicate the code:
+ *
+ * 1. Multiple threads can simultaneously lookup/create the
+ * same buffer. This means a buffer needs to be "locked"
+ * when it is being filled in, to prevent other threads from
+ * using it when it is not ready. This is because we now do
+ * fragment duplicate checking in parallel.
+ * 2. We have two caches which need to be checked for the
+ * presence of fragment blocks: the normal fragment cache
+ * and a "reserve" cache. The reserve cache is used to
+ * prevent an unnecessary pipeline stall when the fragment cache
+ * is full of fragments waiting to be compressed.
+ */
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &dup_mutex);
+ pthread_mutex_lock(&dup_mutex);
+
+again:
+ buffer = cache_lookup_nowait(fragment_buffer, index, &locked);
+ if(buffer) {
+ pthread_mutex_unlock(&dup_mutex);
+ if(locked)
+ /* got a buffer being filled in. Wait for it */
+ cache_wait_unlock(buffer);
+ goto finished;
+ }
+
+ /* not in fragment cache, is it in the reserve cache? */
+ buffer = cache_lookup_nowait(reserve_cache, index, &locked);
+ if(buffer) {
+ pthread_mutex_unlock(&dup_mutex);
+ if(locked)
+ /* got a buffer being filled in. Wait for it */
+ cache_wait_unlock(buffer);
+ goto finished;
+ }
+
+ /* in neither cache, try to get it from the fragment cache */
+ buffer = cache_get_nowait(fragment_buffer, index);
+ if(!buffer) {
+ /*
+ * no room, get it from the reserve cache, this is
+ * dimensioned so it will always have space (no more than
+ * processors + 1 can have an outstanding reserve buffer)
+ */
+ buffer = cache_get_nowait(reserve_cache, index);
+ if(!buffer) {
+ /* failsafe */
+ ERROR("no space in reserve cache\n");
+ goto again;
+ }
+ }
+
+ pthread_mutex_unlock(&dup_mutex);
+
+ compressed_buffer = cache_lookup(fwriter_buffer, index);
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &fragment_mutex);
+ pthread_mutex_lock(&fragment_mutex);
+ disk_fragment = &fragment_table[index];
+ size = SQUASHFS_COMPRESSED_SIZE_BLOCK(disk_fragment->size);
+ start_block = disk_fragment->start_block;
+ pthread_cleanup_pop(1);
+
+ if(SQUASHFS_COMPRESSED_BLOCK(disk_fragment->size)) {
+ int error;
+ char *data;
+
+ if(compressed_buffer)
+ data = compressed_buffer->data;
+ else {
+ res = read_filesystem(fd, start_block, size, data_buffer);
+ if(res == 0) {
+ ERROR("Failed to read fragment from output"
+ " filesystem\n");
+ BAD_ERROR("Output filesystem corrupted?\n");
+ }
+ data = data_buffer;
+ }
+
+ res = compressor_uncompress(comp, buffer->data, data, size,
+ block_size, &error);
+ if(res == -1)
+ BAD_ERROR("%s uncompress failed with error code %d\n",
+ comp->name, error);
+ } else if(compressed_buffer)
+ memcpy(buffer->data, compressed_buffer->data, size);
+ else {
+ res = read_filesystem(fd, start_block, size, buffer->data);
+ if(res == 0) {
+ ERROR("Failed to read fragment from output "
+ "filesystem\n");
+ BAD_ERROR("Output filesystem corrupted?\n");
+ }
+ }
+
+ cache_unlock(buffer);
+ cache_block_put(compressed_buffer);
+
+finished:
+ pthread_cleanup_pop(0);
+
+ return buffer;
+}
+
+
+struct file_buffer *get_fragment_cksum(struct file_info *file,
+ char *data_buffer, int fd, unsigned short *checksum)
+{
+ struct file_buffer *frag_buffer;
+ struct append_file *append;
+ int index = file->fragment->index;
+
+ frag_buffer = get_fragment(file->fragment, data_buffer, fd);
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &dup_mutex);
+
+ for(append = file_mapping[index]; append; append = append->next) {
+ int offset = append->file->fragment->offset;
+ int size = append->file->fragment->size;
+ char *data = frag_buffer->data + offset;
+ unsigned short cksum = get_checksum_mem(data, size);
+
+ if(file == append->file)
+ *checksum = cksum;
+
+ pthread_mutex_lock(&dup_mutex);
+ append->file->fragment_checksum = cksum;
+ append->file->have_frag_checksum = TRUE;
+ pthread_mutex_unlock(&dup_mutex);
+ }
+
+ pthread_cleanup_pop(0);
+
+ return frag_buffer;
+}
+
+
+void *frag_thrd(void *destination_file)
+{
+ sigset_t sigmask, old_mask;
+ char *data_buffer;
+ int fd;
+
+ sigemptyset(&sigmask);
+ sigaddset(&sigmask, SIGINT);
+ sigaddset(&sigmask, SIGTERM);
+ sigaddset(&sigmask, SIGUSR1);
+ pthread_sigmask(SIG_BLOCK, &sigmask, &old_mask);
+
+ fd = open(destination_file, O_RDONLY);
+ if(fd == -1)
+ BAD_ERROR("frag_thrd: can't open destination for reading\n");
+
+ data_buffer = malloc(SQUASHFS_FILE_MAX_SIZE);
+ if(data_buffer == NULL)
+ MEM_ERROR();
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &dup_mutex);
+
+ while(1) {
+ struct file_buffer *file_buffer = queue_get(to_process_frag);
+ struct file_buffer *buffer;
+ int sparse = checksum_sparse(file_buffer);
+ struct file_info *dupl_ptr;
+ long long file_size;
+ unsigned short checksum;
+ char flag;
+ int res;
+
+ if(sparse_files && sparse) {
+ file_buffer->c_byte = 0;
+ file_buffer->fragment = FALSE;
+ } else
+ file_buffer->c_byte = file_buffer->size;
+
+ /*
+ * Specutively pull into the fragment cache any fragment blocks
+ * which contain fragments which *this* fragment may be
+ * be a duplicate.
+ *
+ * By ensuring the fragment block is in cache ahead of time
+ * should eliminate the parallelisation stall when the
+ * main thread needs to read the fragment block to do a
+ * duplicate check on it.
+ *
+ * If this is a fragment belonging to a larger file
+ * (with additional blocks) then ignore it. Here we're
+ * interested in the "low hanging fruit" of files which
+ * consist of only a fragment
+ */
+ if(file_buffer->file_size != file_buffer->size) {
+ seq_queue_put(to_main, file_buffer);
+ continue;
+ }
+
+ file_size = file_buffer->file_size;
+
+ pthread_mutex_lock(&dup_mutex);
+ dupl_ptr = dupl[DUP_HASH(file_size)];
+ pthread_mutex_unlock(&dup_mutex);
+
+ file_buffer->dupl_start = dupl_ptr;
+ file_buffer->duplicate = FALSE;
+
+ for(; dupl_ptr; dupl_ptr = dupl_ptr->next) {
+ if(file_size != dupl_ptr->file_size ||
+ file_size != dupl_ptr->fragment->size)
+ continue;
+
+ pthread_mutex_lock(&dup_mutex);
+ flag = dupl_ptr->have_frag_checksum;
+ checksum = dupl_ptr->fragment_checksum;
+ pthread_mutex_unlock(&dup_mutex);
+
+ /*
+ * If we have the checksum and it matches then
+ * read in the fragment block.
+ *
+ * If we *don't* have the checksum, then we are
+ * appending, and the fragment block is on the
+ * "old" filesystem. Read it in and checksum
+ * the entire fragment buffer
+ */
+ if(!flag) {
+ buffer = get_fragment_cksum(dupl_ptr,
+ data_buffer, fd, &checksum);
+ if(checksum != file_buffer->checksum) {
+ cache_block_put(buffer);
+ continue;
+ }
+ } else if(checksum == file_buffer->checksum)
+ buffer = get_fragment(dupl_ptr->fragment,
+ data_buffer, fd);
+ else
+ continue;
+
+ res = memcmp(file_buffer->data, buffer->data +
+ dupl_ptr->fragment->offset, file_size);
+ cache_block_put(buffer);
+ if(res == 0) {
+ struct file_buffer *dup = malloc(sizeof(*dup));
+ if(dup == NULL)
+ MEM_ERROR();
+ memcpy(dup, file_buffer, sizeof(*dup));
+ cache_block_put(file_buffer);
+ dup->dupl_start = dupl_ptr;
+ dup->duplicate = TRUE;
+ file_buffer = dup;
+ break;
+ }
+ }
+
+ seq_queue_put(to_main, file_buffer);
+ }
+
+ pthread_cleanup_pop(0);
+}
diff --git a/squashfs-tools/squashfs-tools/process_fragments.h b/squashfs-tools/squashfs-tools/process_fragments.h
new file mode 100644
index 0000000..6f6bdf2
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/process_fragments.h
@@ -0,0 +1,30 @@
+#ifndef PROCESS_FRAGMENTS_H
+#define PROCESS_FRAGMENTS_H
+/*
+ * Create a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * process_fragments.h
+ */
+
+#define DUP_HASH(a) (a & 0xffff)
+
+extern void *frag_thrd(void *);
+#endif
diff --git a/squashfs-tools/squashfs-tools/progressbar.c b/squashfs-tools/squashfs-tools/progressbar.c
new file mode 100644
index 0000000..987a45b
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/progressbar.c
@@ -0,0 +1,259 @@
+/*
+ * Create a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2012, 2013, 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * progressbar.c
+ */
+
+#include <pthread.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <signal.h>
+#include <sys/time.h>
+#include <stdio.h>
+#include <math.h>
+#include <stdarg.h>
+#include <errno.h>
+#include <stdlib.h>
+
+#include "error.h"
+
+#define FALSE 0
+#define TRUE 1
+
+/* flag whether progressbar display is enabled or not */
+int display_progress_bar = FALSE;
+
+/* flag whether the progress bar is temporarily disbled */
+int temp_disabled = FALSE;
+
+int rotate = 0;
+int cur_uncompressed = 0, estimated_uncompressed = 0;
+int columns;
+
+pthread_t progress_thread;
+pthread_mutex_t progress_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+
+static void sigwinch_handler()
+{
+ struct winsize winsize;
+
+ if(ioctl(1, TIOCGWINSZ, &winsize) == -1) {
+ if(isatty(STDOUT_FILENO))
+ ERROR("TIOCGWINSZ ioctl failed, defaulting to 80 "
+ "columns\n");
+ columns = 80;
+ } else
+ columns = winsize.ws_col;
+}
+
+
+static void sigalrm_handler()
+{
+ rotate = (rotate + 1) % 4;
+}
+
+
+void inc_progress_bar()
+{
+ cur_uncompressed ++;
+}
+
+
+void dec_progress_bar(int count)
+{
+ cur_uncompressed -= count;
+}
+
+
+void progress_bar_size(int count)
+{
+ estimated_uncompressed += count;
+}
+
+
+static void progress_bar(long long current, long long max, int columns)
+{
+ char rotate_list[] = { '|', '/', '-', '\\' };
+ int max_digits, used, hashes, spaces;
+ static int tty = -1;
+
+ if(max == 0)
+ return;
+
+ max_digits = floor(log10(max)) + 1;
+ used = max_digits * 2 + 11;
+ hashes = (current * (columns - used)) / max;
+ spaces = columns - used - hashes;
+
+ if((current > max) || (columns - used < 0))
+ return;
+
+ if(tty == -1)
+ tty = isatty(STDOUT_FILENO);
+ if(!tty) {
+ static long long previous = -1;
+
+ /* Updating much more frequently than this results in huge
+ * log files. */
+ if((current % 100) != 0 && current != max)
+ return;
+ /* Don't update just to rotate the spinner. */
+ if(current == previous)
+ return;
+ previous = current;
+ }
+
+ printf("\r[");
+
+ while (hashes --)
+ putchar('=');
+
+ putchar(rotate_list[rotate]);
+
+ while(spaces --)
+ putchar(' ');
+
+ printf("] %*lld/%*lld", max_digits, current, max_digits, max);
+ printf(" %3lld%%", current * 100 / max);
+ fflush(stdout);
+}
+
+
+void enable_progress_bar()
+{
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &progress_mutex);
+ pthread_mutex_lock(&progress_mutex);
+ if(display_progress_bar)
+ progress_bar(cur_uncompressed, estimated_uncompressed, columns);
+ temp_disabled = FALSE;
+ pthread_cleanup_pop(1);
+}
+
+
+void disable_progress_bar()
+{
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &progress_mutex);
+ pthread_mutex_lock(&progress_mutex);
+ if(display_progress_bar)
+ printf("\n");
+ temp_disabled = TRUE;
+ pthread_cleanup_pop(1);
+}
+
+
+void set_progressbar_state(int state)
+{
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &progress_mutex);
+ pthread_mutex_lock(&progress_mutex);
+ if(display_progress_bar != state) {
+ if(display_progress_bar && !temp_disabled) {
+ progress_bar(cur_uncompressed, estimated_uncompressed,
+ columns);
+ printf("\n");
+ }
+ display_progress_bar = state;
+ }
+ pthread_cleanup_pop(1);
+}
+
+
+void *progress_thrd(void *arg)
+{
+ struct timespec requested_time, remaining;
+ struct itimerval itimerval;
+ struct winsize winsize;
+
+ if(ioctl(1, TIOCGWINSZ, &winsize) == -1) {
+ if(isatty(STDOUT_FILENO))
+ ERROR("TIOCGWINSZ ioctl failed, defaulting to 80 "
+ "columns\n");
+ columns = 80;
+ } else
+ columns = winsize.ws_col;
+ signal(SIGWINCH, sigwinch_handler);
+ signal(SIGALRM, sigalrm_handler);
+
+ itimerval.it_value.tv_sec = 0;
+ itimerval.it_value.tv_usec = 250000;
+ itimerval.it_interval.tv_sec = 0;
+ itimerval.it_interval.tv_usec = 250000;
+ setitimer(ITIMER_REAL, &itimerval, NULL);
+
+ requested_time.tv_sec = 0;
+ requested_time.tv_nsec = 250000000;
+
+ while(1) {
+ int res = nanosleep(&requested_time, &remaining);
+
+ if(res == -1 && errno != EINTR)
+ BAD_ERROR("nanosleep failed in progress thread\n");
+
+ pthread_mutex_lock(&progress_mutex);
+ if(display_progress_bar && !temp_disabled)
+ progress_bar(cur_uncompressed, estimated_uncompressed,
+ columns);
+ pthread_mutex_unlock(&progress_mutex);
+ }
+}
+
+
+void init_progress_bar()
+{
+ pthread_create(&progress_thread, NULL, progress_thrd, NULL);
+}
+
+
+void progressbar_error(char *fmt, ...)
+{
+ va_list ap;
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &progress_mutex);
+ pthread_mutex_lock(&progress_mutex);
+
+ if(display_progress_bar && !temp_disabled)
+ fprintf(stderr, "\n");
+
+ va_start(ap, fmt);
+ vfprintf(stderr, fmt, ap);
+ va_end(ap);
+
+ pthread_cleanup_pop(1);
+}
+
+
+void progressbar_info(char *fmt, ...)
+{
+ va_list ap;
+
+ pthread_cleanup_push((void *) pthread_mutex_unlock, &progress_mutex);
+ pthread_mutex_lock(&progress_mutex);
+
+ if(display_progress_bar && !temp_disabled)
+ printf("\n");
+
+ va_start(ap, fmt);
+ vprintf(fmt, ap);
+ va_end(ap);
+
+ pthread_cleanup_pop(1);
+}
+
diff --git a/squashfs-tools/squashfs-tools/progressbar.h b/squashfs-tools/squashfs-tools/progressbar.h
new file mode 100644
index 0000000..b33b367
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/progressbar.h
@@ -0,0 +1,34 @@
+#ifndef PROGRESSBAR_H
+#define PROGRESSBAR_H
+/*
+ * Create a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2012, 2013, 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * progressbar.h
+ */
+
+extern void inc_progress_bar();
+extern void dec_progress_bar(int count);
+extern void progress_bar_size(int count);
+extern void enable_progress_bar();
+extern void disable_progress_bar();
+extern void init_progress_bar();
+extern void set_progressbar_state(int);
+#endif
diff --git a/squashfs-tools/squashfs-tools/pseudo.c b/squashfs-tools/squashfs-tools/pseudo.c
new file mode 100644
index 0000000..e12d399
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/pseudo.c
@@ -0,0 +1,529 @@
+/*
+ * Create a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2009, 2010, 2012, 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * pseudo.c
+ */
+
+#include <pwd.h>
+#include <grp.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <ctype.h>
+
+#include "pseudo.h"
+#include "error.h"
+#include "progressbar.h"
+
+#define TRUE 1
+#define FALSE 0
+
+extern int read_file(char *filename, char *type, int (parse_line)(char *));
+
+struct pseudo_dev **pseudo_file = NULL;
+struct pseudo *pseudo = NULL;
+int pseudo_count = 0;
+
+static char *get_component(char *target, char **targname)
+{
+ char *start;
+
+ while(*target == '/')
+ target ++;
+
+ start = target;
+ while(*target != '/' && *target != '\0')
+ target ++;
+
+ *targname = strndup(start, target - start);
+
+ while(*target == '/')
+ target ++;
+
+ return target;
+}
+
+
+/*
+ * Add pseudo device target to the set of pseudo devices. Pseudo_dev
+ * describes the pseudo device attributes.
+ */
+struct pseudo *add_pseudo(struct pseudo *pseudo, struct pseudo_dev *pseudo_dev,
+ char *target, char *alltarget)
+{
+ char *targname;
+ int i;
+
+ target = get_component(target, &targname);
+
+ if(pseudo == NULL) {
+ pseudo = malloc(sizeof(struct pseudo));
+ if(pseudo == NULL)
+ MEM_ERROR();
+
+ pseudo->names = 0;
+ pseudo->count = 0;
+ pseudo->name = NULL;
+ }
+
+ for(i = 0; i < pseudo->names; i++)
+ if(strcmp(pseudo->name[i].name, targname) == 0)
+ break;
+
+ if(i == pseudo->names) {
+ /* allocate new name entry */
+ pseudo->names ++;
+ pseudo->name = realloc(pseudo->name, (i + 1) *
+ sizeof(struct pseudo_entry));
+ if(pseudo->name == NULL)
+ MEM_ERROR();
+ pseudo->name[i].name = targname;
+
+ if(target[0] == '\0') {
+ /* at leaf pathname component */
+ pseudo->name[i].pseudo = NULL;
+ pseudo->name[i].pathname = strdup(alltarget);
+ pseudo->name[i].dev = pseudo_dev;
+ } else {
+ /* recurse adding child components */
+ pseudo->name[i].dev = NULL;
+ pseudo->name[i].pseudo = add_pseudo(NULL, pseudo_dev,
+ target, alltarget);
+ }
+ } else {
+ /* existing matching entry */
+ free(targname);
+
+ if(pseudo->name[i].pseudo == NULL) {
+ /* No sub-directory which means this is the leaf
+ * component of a pre-existing pseudo file.
+ */
+ if(target[0] != '\0') {
+ /*
+ * entry must exist as either a 'd' type or
+ * 'm' type pseudo file
+ */
+ if(pseudo->name[i].dev->type == 'd' ||
+ pseudo->name[i].dev->type == 'm')
+ /* recurse adding child components */
+ pseudo->name[i].pseudo =
+ add_pseudo(NULL, pseudo_dev,
+ target, alltarget);
+ else {
+ ERROR_START("%s already exists as a "
+ "non directory.",
+ pseudo->name[i].name);
+ ERROR_EXIT(". Ignoring %s!\n",
+ alltarget);
+ }
+ } else if(memcmp(pseudo_dev, pseudo->name[i].dev,
+ sizeof(struct pseudo_dev)) != 0) {
+ ERROR_START("%s already exists as a different "
+ "pseudo definition.", alltarget);
+ ERROR_EXIT(" Ignoring!\n");
+ } else {
+ ERROR_START("%s already exists as an identical "
+ "pseudo definition!", alltarget);
+ ERROR_EXIT(" Ignoring!\n");
+ }
+ } else {
+ if(target[0] == '\0') {
+ /*
+ * sub-directory exists, which means we can only
+ * add a pseudo file of type 'd' or type 'm'
+ */
+ if(pseudo->name[i].dev == NULL &&
+ (pseudo_dev->type == 'd' ||
+ pseudo_dev->type == 'm')) {
+ pseudo->name[i].pathname =
+ strdup(alltarget);
+ pseudo->name[i].dev = pseudo_dev;
+ } else {
+ ERROR_START("%s already exists as a "
+ "different pseudo definition.",
+ pseudo->name[i].name);
+ ERROR_EXIT(" Ignoring %s!\n",
+ alltarget);
+ }
+ } else
+ /* recurse adding child components */
+ add_pseudo(pseudo->name[i].pseudo, pseudo_dev,
+ target, alltarget);
+ }
+ }
+
+ return pseudo;
+}
+
+
+/*
+ * Find subdirectory in pseudo directory referenced by pseudo, matching
+ * filename. If filename doesn't exist or if filename is a leaf file
+ * return NULL
+ */
+struct pseudo *pseudo_subdir(char *filename, struct pseudo *pseudo)
+{
+ int i;
+
+ if(pseudo == NULL)
+ return NULL;
+
+ for(i = 0; i < pseudo->names; i++)
+ if(strcmp(filename, pseudo->name[i].name) == 0)
+ return pseudo->name[i].pseudo;
+
+ return NULL;
+}
+
+
+struct pseudo_entry *pseudo_readdir(struct pseudo *pseudo)
+{
+ if(pseudo == NULL)
+ return NULL;
+
+ while(pseudo->count < pseudo->names) {
+ if(pseudo->name[pseudo->count].dev != NULL)
+ return &pseudo->name[pseudo->count++];
+ else
+ pseudo->count++;
+ }
+
+ return NULL;
+}
+
+
+int pseudo_exec_file(struct pseudo_dev *dev, int *child)
+{
+ int res, pipefd[2];
+
+ res = pipe(pipefd);
+ if(res == -1) {
+ ERROR("Executing dynamic pseudo file, pipe failed\n");
+ return 0;
+ }
+
+ *child = fork();
+ if(*child == -1) {
+ ERROR("Executing dynamic pseudo file, fork failed\n");
+ goto failed;
+ }
+
+ if(*child == 0) {
+ close(pipefd[0]);
+ close(STDOUT_FILENO);
+ res = dup(pipefd[1]);
+ if(res == -1)
+ exit(EXIT_FAILURE);
+
+ execl("/bin/sh", "sh", "-c", dev->command, (char *) NULL);
+ exit(EXIT_FAILURE);
+ }
+
+ close(pipefd[1]);
+ return pipefd[0];
+
+failed:
+ close(pipefd[0]);
+ close(pipefd[1]);
+ return 0;
+}
+
+
+void add_pseudo_file(struct pseudo_dev *dev)
+{
+ pseudo_file = realloc(pseudo_file, (pseudo_count + 1) *
+ sizeof(struct pseudo_dev *));
+ if(pseudo_file == NULL)
+ MEM_ERROR();
+
+ dev->pseudo_id = pseudo_count;
+ pseudo_file[pseudo_count ++] = dev;
+}
+
+
+struct pseudo_dev *get_pseudo_file(int pseudo_id)
+{
+ return pseudo_file[pseudo_id];
+}
+
+
+int read_pseudo_def(char *def)
+{
+ int n, bytes;
+ unsigned int major = 0, minor = 0, mode;
+ char type, *ptr;
+ char suid[100], sgid[100]; /* overflow safe */
+ char *filename, *name;
+ char *orig_def = def;
+ long long uid, gid;
+ struct pseudo_dev *dev;
+
+ /*
+ * Scan for filename, don't use sscanf() and "%s" because
+ * that can't handle filenames with spaces
+ */
+ filename = malloc(strlen(def) + 1);
+ if(filename == NULL)
+ MEM_ERROR();
+
+ for(name = filename; !isspace(*def) && *def != '\0';) {
+ if(*def == '\\') {
+ def ++;
+ if (*def == '\0')
+ break;
+ }
+ *name ++ = *def ++;
+ }
+ *name = '\0';
+
+ if(*filename == '\0') {
+ ERROR("Not enough or invalid arguments in pseudo file "
+ "definition \"%s\"\n", orig_def);
+ goto error;
+ }
+
+ n = sscanf(def, " %c %o %99s %99s %n", &type, &mode, suid, sgid,
+ &bytes);
+ def += bytes;
+
+ if(n < 4) {
+ ERROR("Not enough or invalid arguments in pseudo file "
+ "definition \"%s\"\n", orig_def);
+ switch(n) {
+ case -1:
+ /* FALLTHROUGH */
+ case 0:
+ ERROR("Read filename, but failed to read or match "
+ "type\n");
+ break;
+ case 1:
+ ERROR("Read filename and type, but failed to read or "
+ "match octal mode\n");
+ break;
+ case 2:
+ ERROR("Read filename, type and mode, but failed to "
+ "read or match uid\n");
+ break;
+ default:
+ ERROR("Read filename, type, mode and uid, but failed "
+ "to read or match gid\n");
+ break;
+ }
+ goto error;
+ }
+
+ switch(type) {
+ case 'b':
+ /* FALLTHROUGH */
+ case 'c':
+ n = sscanf(def, "%u %u %n", &major, &minor, &bytes);
+ def += bytes;
+
+ if(n < 2) {
+ ERROR("Not enough or invalid arguments in %s device "
+ "pseudo file definition \"%s\"\n", type == 'b' ?
+ "block" : "character", orig_def);
+ if(n < 1)
+ ERROR("Read filename, type, mode, uid and gid, "
+ "but failed to read or match major\n");
+ else
+ ERROR("Read filename, type, mode, uid, gid "
+ "and major, but failed to read or "
+ "match minor\n");
+ goto error;
+ }
+
+ if(major > 0xfff) {
+ ERROR("Major %d out of range\n", major);
+ goto error;
+ }
+
+ if(minor > 0xfffff) {
+ ERROR("Minor %d out of range\n", minor);
+ goto error;
+ }
+ /* FALLTHROUGH */
+ case 'd':
+ /* FALLTHROUGH */
+ case 'm':
+ /*
+ * Check for trailing junk after expected arguments
+ */
+ if(def[0] != '\0') {
+ ERROR("Unexpected tailing characters in pseudo file "
+ "definition \"%s\"\n", orig_def);
+ goto error;
+ }
+ break;
+ case 'f':
+ if(def[0] == '\0') {
+ ERROR("Not enough arguments in dynamic file pseudo "
+ "definition \"%s\"\n", orig_def);
+ ERROR("Expected command, which can be an executable "
+ "or a piece of shell script\n");
+ goto error;
+ }
+ break;
+ default:
+ ERROR("Unsupported type %c\n", type);
+ goto error;
+ }
+
+
+ if(mode > 07777) {
+ ERROR("Mode %o out of range\n", mode);
+ goto error;
+ }
+
+ uid = strtoll(suid, &ptr, 10);
+ if(*ptr == '\0') {
+ if(uid < 0 || uid > ((1LL << 32) - 1)) {
+ ERROR("Uid %s out of range\n", suid);
+ goto error;
+ }
+ } else {
+ struct passwd *pwuid = getpwnam(suid);
+ if(pwuid)
+ uid = pwuid->pw_uid;
+ else {
+ ERROR("Uid %s invalid uid or unknown user\n", suid);
+ goto error;
+ }
+ }
+
+ gid = strtoll(sgid, &ptr, 10);
+ if(*ptr == '\0') {
+ if(gid < 0 || gid > ((1LL << 32) - 1)) {
+ ERROR("Gid %s out of range\n", sgid);
+ goto error;
+ }
+ } else {
+ struct group *grgid = getgrnam(sgid);
+ if(grgid)
+ gid = grgid->gr_gid;
+ else {
+ ERROR("Gid %s invalid uid or unknown user\n", sgid);
+ goto error;
+ }
+ }
+
+ switch(type) {
+ case 'b':
+ mode |= S_IFBLK;
+ break;
+ case 'c':
+ mode |= S_IFCHR;
+ break;
+ case 'd':
+ mode |= S_IFDIR;
+ break;
+ case 'f':
+ mode |= S_IFREG;
+ break;
+ }
+
+ dev = malloc(sizeof(struct pseudo_dev));
+ if(dev == NULL)
+ MEM_ERROR();
+
+ dev->type = type;
+ dev->mode = mode;
+ dev->uid = uid;
+ dev->gid = gid;
+ dev->major = major;
+ dev->minor = minor;
+ if(type == 'f') {
+ dev->command = strdup(def);
+ add_pseudo_file(dev);
+ }
+
+ pseudo = add_pseudo(pseudo, dev, filename, filename);
+
+ free(filename);
+ return TRUE;
+
+error:
+ ERROR("Pseudo definitions should be of format\n");
+ ERROR("\tfilename d mode uid gid\n");
+ ERROR("\tfilename m mode uid gid\n");
+ ERROR("\tfilename b mode uid gid major minor\n");
+ ERROR("\tfilename c mode uid gid major minor\n");
+ ERROR("\tfilename f mode uid command\n");
+ free(filename);
+ return FALSE;
+}
+
+
+int read_pseudo_file(char *filename)
+{
+ return read_file(filename, "pseudo", read_pseudo_def);
+}
+
+
+struct pseudo *get_pseudo()
+{
+ return pseudo;
+}
+
+
+#ifdef SQUASHFS_TRACE
+static void dump_pseudo(struct pseudo *pseudo, char *string)
+{
+ int i, res;
+ char *path;
+
+ for(i = 0; i < pseudo->names; i++) {
+ struct pseudo_entry *entry = &pseudo->name[i];
+ if(string) {
+ res = asprintf(&path, "%s/%s", string, entry->name);
+ if(res == -1)
+ BAD_ERROR("asprintf failed in dump_pseudo\n");
+ } else
+ path = entry->name;
+ if(entry->dev)
+ ERROR("%s %c 0%o %d %d %d %d\n", path, entry->dev->type,
+ entry->dev->mode & ~S_IFMT, entry->dev->uid,
+ entry->dev->gid, entry->dev->major,
+ entry->dev->minor);
+ if(entry->pseudo)
+ dump_pseudo(entry->pseudo, path);
+ if(string)
+ free(path);
+ }
+}
+
+
+void dump_pseudos()
+{
+ if (pseudo)
+ dump_pseudo(pseudo, NULL);
+}
+#else
+void dump_pseudos()
+{
+}
+#endif
diff --git a/squashfs-tools/squashfs-tools/pseudo.h b/squashfs-tools/squashfs-tools/pseudo.h
new file mode 100644
index 0000000..c0d9f6f
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/pseudo.h
@@ -0,0 +1,58 @@
+#ifndef PSEUDO_H
+#define PSEUDO_H
+/*
+ * Create a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2009, 2010, 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * pseudo.h
+ */
+struct pseudo_dev {
+ char type;
+ unsigned int mode;
+ unsigned int uid;
+ unsigned int gid;
+ unsigned int major;
+ unsigned int minor;
+ int pseudo_id;
+ char *command;
+};
+
+struct pseudo_entry {
+ char *name;
+ char *pathname;
+ struct pseudo *pseudo;
+ struct pseudo_dev *dev;
+};
+
+struct pseudo {
+ int names;
+ int count;
+ struct pseudo_entry *name;
+};
+
+extern int read_pseudo_def(char *);
+extern int read_pseudo_file(char *);
+extern struct pseudo *pseudo_subdir(char *, struct pseudo *);
+extern struct pseudo_entry *pseudo_readdir(struct pseudo *);
+extern struct pseudo_dev *get_pseudo_file(int);
+extern int pseudo_exec_file(struct pseudo_dev *, int *);
+extern struct pseudo *get_pseudo();
+extern void dump_pseudos();
+#endif
diff --git a/squashfs-tools/squashfs-tools/read_file.c b/squashfs-tools/squashfs-tools/read_file.c
new file mode 100644
index 0000000..22705a0
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/read_file.c
@@ -0,0 +1,150 @@
+/*
+ * Create a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2012
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * read_file.c
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+
+#include "error.h"
+
+#define TRUE 1
+#define FALSE 0
+#define MAX_LINE 16384
+
+/*
+ * Read file, passing each line to parse_line() for
+ * parsing.
+ *
+ * Lines can be split across multiple lines using "\".
+ *
+ * Blank lines and comment lines indicated by # are supported.
+ */
+int read_file(char *filename, char *type, int (parse_line)(char *))
+{
+ FILE *fd;
+ char *def, *err, *line = NULL;
+ int res, size = 0;
+
+ fd = fopen(filename, "r");
+ if(fd == NULL) {
+ ERROR("Could not open %s device file \"%s\" because %s\n",
+ type, filename, strerror(errno));
+ return FALSE;
+ }
+
+ while(1) {
+ int total = 0;
+
+ while(1) {
+ int len;
+
+ if(total + (MAX_LINE + 1) > size) {
+ line = realloc(line, size += (MAX_LINE + 1));
+ if(line == NULL)
+ MEM_ERROR();
+ }
+
+ err = fgets(line + total, MAX_LINE + 1, fd);
+ if(err == NULL)
+ break;
+
+ len = strlen(line + total);
+ total += len;
+
+ if(len == MAX_LINE && line[total - 1] != '\n') {
+ /* line too large */
+ ERROR("Line too long when reading "
+ "%s file \"%s\", larger than "
+ "%d bytes\n", type, filename, MAX_LINE);
+ goto failed;
+ }
+
+ /*
+ * Remove '\n' terminator if it exists (the last line
+ * in the file may not be '\n' terminated)
+ */
+ if(len && line[total - 1] == '\n') {
+ line[-- total] = '\0';
+ len --;
+ }
+
+ /*
+ * If no line continuation then jump out to
+ * process line. Note, we have to be careful to
+ * check for "\\" (backslashed backslash) and to
+ * ensure we don't look at the previous line
+ */
+ if(len == 0 || line[total - 1] != '\\' || (len >= 2 &&
+ strcmp(line + total - 2, "\\\\") == 0))
+ break;
+ else
+ total --;
+ }
+
+ if(err == NULL) {
+ if(ferror(fd)) {
+ ERROR("Reading %s file \"%s\" failed "
+ "because %s\n", type, filename,
+ strerror(errno));
+ goto failed;
+ }
+
+ /*
+ * At EOF, normally we'll be finished, but, have to
+ * check for special case where we had "\" line
+ * continuation and then hit EOF immediately afterwards
+ */
+ if(total == 0)
+ break;
+ else
+ line[total] = '\0';
+ }
+
+ /* Skip any leading whitespace */
+ for(def = line; isspace(*def); def ++);
+
+ /* if line is now empty after skipping characters, skip it */
+ if(*def == '\0')
+ continue;
+
+ /* if comment line, skip */
+ if(*def == '#')
+ continue;
+
+ res = parse_line(def);
+ if(res == FALSE)
+ goto failed;
+ }
+
+ fclose(fd);
+ free(line);
+ return TRUE;
+
+failed:
+ fclose(fd);
+ free(line);
+ return FALSE;
+}
diff --git a/squashfs-tools/squashfs-tools/read_fs.c b/squashfs-tools/squashfs-tools/read_fs.c
new file mode 100644
index 0000000..ca84460
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/read_fs.c
@@ -0,0 +1,980 @@
+/*
+ * Read a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+ * 2012, 2013, 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * read_fs.c
+ */
+
+#define TRUE 1
+#define FALSE 0
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <limits.h>
+#include <dirent.h>
+
+#ifndef linux
+#define __BYTE_ORDER BYTE_ORDER
+#define __BIG_ENDIAN BIG_ENDIAN
+#define __LITTLE_ENDIAN LITTLE_ENDIAN
+#else
+#include <endian.h>
+#endif
+
+#include <stdlib.h>
+
+#include "squashfs_fs.h"
+#include "squashfs_swap.h"
+#include "compressor.h"
+#include "xattr.h"
+#include "error.h"
+#include "mksquashfs.h"
+
+int read_block(int fd, long long start, long long *next, int expected,
+ void *block)
+{
+ unsigned short c_byte;
+ int res, compressed;
+ int outlen = expected ? expected : SQUASHFS_METADATA_SIZE;
+
+ /* Read block size */
+ res = read_fs_bytes(fd, start, 2, &c_byte);
+ if(res == 0)
+ return 0;
+
+ SQUASHFS_INSWAP_SHORTS(&c_byte, 1);
+ compressed = SQUASHFS_COMPRESSED(c_byte);
+ c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte);
+
+ /*
+ * The block size should not be larger than
+ * the uncompressed size (or max uncompressed size if
+ * expected is 0)
+ */
+ if (c_byte > outlen)
+ return 0;
+
+ if(compressed) {
+ char buffer[c_byte];
+ int error;
+
+ res = read_fs_bytes(fd, start + 2, c_byte, buffer);
+ if(res == 0)
+ return 0;
+
+ res = compressor_uncompress(comp, block, buffer, c_byte,
+ outlen, &error);
+ if(res == -1) {
+ ERROR("%s uncompress failed with error code %d\n",
+ comp->name, error);
+ return 0;
+ }
+ } else {
+ res = read_fs_bytes(fd, start + 2, c_byte, block);
+ if(res == 0)
+ return 0;
+ res = c_byte;
+ }
+
+ if(next)
+ *next = start + 2 + c_byte;
+
+ /*
+ * if expected, then check the (uncompressed) return data
+ * is of the expected size
+ */
+ if(expected && expected != res)
+ return 0;
+ else
+ return res;
+}
+
+
+#define NO_BYTES(SIZE) \
+ (bytes - (cur_ptr - *inode_table) < (SIZE))
+
+#define NO_INODE_BYTES(INODE) NO_BYTES(sizeof(struct INODE))
+
+int scan_inode_table(int fd, long long start, long long end,
+ long long root_inode_start, int root_inode_offset,
+ struct squashfs_super_block *sBlk, union squashfs_inode_header
+ *dir_inode, unsigned char **inode_table, unsigned int *root_inode_block,
+ unsigned int *root_inode_size, long long *uncompressed_file,
+ unsigned int *uncompressed_directory, int *file_count, int *sym_count,
+ int *dev_count, int *dir_count, int *fifo_count, int *sock_count,
+ unsigned int *id_table)
+{
+ unsigned char *cur_ptr;
+ int byte, files = 0;
+ unsigned int directory_start_block, bytes = 0, size = 0;
+ struct squashfs_base_inode_header base;
+
+ TRACE("scan_inode_table: start 0x%llx, end 0x%llx, root_inode_start "
+ "0x%llx\n", start, end, root_inode_start);
+
+ *root_inode_block = UINT_MAX;
+ while(start < end) {
+ if(start == root_inode_start) {
+ TRACE("scan_inode_table: read compressed block 0x%llx "
+ "containing root inode\n", start);
+ *root_inode_block = bytes;
+ }
+ if(size - bytes < SQUASHFS_METADATA_SIZE) {
+ *inode_table = realloc(*inode_table, size
+ += SQUASHFS_METADATA_SIZE);
+ if(*inode_table == NULL)
+ MEM_ERROR();
+ }
+ TRACE("scan_inode_table: reading block 0x%llx\n", start);
+ byte = read_block(fd, start, &start, 0, *inode_table + bytes);
+ if(byte == 0)
+ goto corrupted;
+
+ bytes += byte;
+
+ /* If this is not the last metadata block in the inode table
+ * then it should be SQUASHFS_METADATA_SIZE in size.
+ * Note, we can't use expected in read_block() above for this
+ * because we don't know if this is the last block until
+ * after reading.
+ */
+ if(start != end && byte != SQUASHFS_METADATA_SIZE)
+ goto corrupted;
+ }
+
+ /*
+ * We expect to have found the metadata block containing the
+ * root inode in the above inode_table metadata block scan. If it
+ * hasn't been found then the filesystem is corrupted
+ */
+ if(*root_inode_block == UINT_MAX)
+ goto corrupted;
+
+ /*
+ * The number of bytes available after the root inode medata block
+ * should be at least the root inode offset + the size of a
+ * regular directory inode, if not the filesystem is corrupted
+ *
+ * +-----------------------+-----------------------+
+ * | | directory |
+ * | | inode |
+ * +-----------------------+-----------------------+
+ * ^ ^ ^
+ * *root_inode_block root_inode_offset bytes
+ */
+ if((bytes - *root_inode_block) < (root_inode_offset +
+ sizeof(struct squashfs_dir_inode_header)))
+ goto corrupted;
+
+ /*
+ * Read last inode entry which is the root directory inode, and obtain
+ * the last directory start block index. This is used when calculating
+ * the total uncompressed directory size. The directory bytes in the
+ * last * block will be counted as normal.
+ *
+ * Note, the previous check ensures the following calculation won't
+ * underflow, and we won't access beyond the buffer
+ */
+ *root_inode_size = bytes - (*root_inode_block + root_inode_offset);
+ bytes = *root_inode_block + root_inode_offset;
+ SQUASHFS_SWAP_DIR_INODE_HEADER(*inode_table + bytes, &dir_inode->dir);
+
+ if(dir_inode->base.inode_type == SQUASHFS_DIR_TYPE)
+ directory_start_block = dir_inode->dir.start_block;
+ else if(dir_inode->base.inode_type == SQUASHFS_LDIR_TYPE) {
+ if(*root_inode_size < sizeof(struct squashfs_ldir_inode_header))
+ /* corrupted filesystem */
+ goto corrupted;
+ SQUASHFS_SWAP_LDIR_INODE_HEADER(*inode_table + bytes,
+ &dir_inode->ldir);
+ directory_start_block = dir_inode->ldir.start_block;
+ } else
+ /* bad type, corrupted filesystem */
+ goto corrupted;
+
+ get_uid(id_table[dir_inode->base.uid]);
+ get_guid(id_table[dir_inode->base.guid]);
+
+ /* allocate fragment to file mapping table */
+ file_mapping = calloc(sBlk->fragments, sizeof(struct append_file *));
+ if(file_mapping == NULL)
+ MEM_ERROR();
+
+ for(cur_ptr = *inode_table; cur_ptr < *inode_table + bytes; files ++) {
+ if(NO_INODE_BYTES(squashfs_base_inode_header))
+ /* corrupted filesystem */
+ goto corrupted;
+
+ SQUASHFS_SWAP_BASE_INODE_HEADER(cur_ptr, &base);
+
+ TRACE("scan_inode_table: processing inode @ byte position "
+ "0x%x, type 0x%x\n",
+ (unsigned int) (cur_ptr - *inode_table),
+ base.inode_type);
+
+ get_uid(id_table[base.uid]);
+ get_guid(id_table[base.guid]);
+
+ switch(base.inode_type) {
+ case SQUASHFS_FILE_TYPE: {
+ struct squashfs_reg_inode_header inode;
+ int frag_bytes, blocks, i;
+ long long start, file_bytes = 0;
+ unsigned int *block_list;
+
+ if(NO_INODE_BYTES(squashfs_reg_inode_header))
+ /* corrupted filesystem */
+ goto corrupted;
+
+ SQUASHFS_SWAP_REG_INODE_HEADER(cur_ptr, &inode);
+
+ frag_bytes = inode.fragment == SQUASHFS_INVALID_FRAG ?
+ 0 : inode.file_size % sBlk->block_size;
+ blocks = inode.fragment == SQUASHFS_INVALID_FRAG ?
+ (inode.file_size + sBlk->block_size - 1) >>
+ sBlk->block_log : inode.file_size >>
+ sBlk->block_log;
+ start = inode.start_block;
+
+ TRACE("scan_inode_table: regular file, file_size %d, "
+ "blocks %d\n", inode.file_size, blocks);
+
+ if(NO_BYTES(blocks * sizeof(unsigned int)))
+ /* corrupted filesystem */
+ goto corrupted;
+
+ block_list = malloc(blocks * sizeof(unsigned int));
+ if(block_list == NULL)
+ MEM_ERROR();
+
+ cur_ptr += sizeof(inode);
+ SQUASHFS_SWAP_INTS(cur_ptr, block_list, blocks);
+
+ *uncompressed_file += inode.file_size;
+ (*file_count) ++;
+
+ for(i = 0; i < blocks; i++)
+ file_bytes +=
+ SQUASHFS_COMPRESSED_SIZE_BLOCK
+ (block_list[i]);
+
+ if(inode.fragment != SQUASHFS_INVALID_FRAG &&
+ inode.fragment >= sBlk->fragments) {
+ free(block_list);
+ goto corrupted;
+ }
+
+ add_file(start, inode.file_size, file_bytes,
+ block_list, blocks, inode.fragment,
+ inode.offset, frag_bytes);
+
+ cur_ptr += blocks * sizeof(unsigned int);
+ break;
+ }
+ case SQUASHFS_LREG_TYPE: {
+ struct squashfs_lreg_inode_header inode;
+ int frag_bytes, blocks, i;
+ long long start, file_bytes = 0;
+ unsigned int *block_list;
+
+ if(NO_INODE_BYTES(squashfs_lreg_inode_header))
+ /* corrupted filesystem */
+ goto corrupted;
+
+ SQUASHFS_SWAP_LREG_INODE_HEADER(cur_ptr, &inode);
+
+ frag_bytes = inode.fragment == SQUASHFS_INVALID_FRAG ?
+ 0 : inode.file_size % sBlk->block_size;
+ blocks = inode.fragment == SQUASHFS_INVALID_FRAG ?
+ (inode.file_size + sBlk->block_size - 1) >>
+ sBlk->block_log : inode.file_size >>
+ sBlk->block_log;
+ start = inode.start_block;
+
+ TRACE("scan_inode_table: extended regular "
+ "file, file_size %lld, blocks %d\n",
+ inode.file_size, blocks);
+
+ if(NO_BYTES(blocks * sizeof(unsigned int)))
+ /* corrupted filesystem */
+ goto corrupted;
+
+ block_list = malloc(blocks * sizeof(unsigned int));
+ if(block_list == NULL)
+ MEM_ERROR();
+
+ cur_ptr += sizeof(inode);
+ SQUASHFS_SWAP_INTS(cur_ptr, block_list, blocks);
+
+ *uncompressed_file += inode.file_size;
+ (*file_count) ++;
+
+ for(i = 0; i < blocks; i++)
+ file_bytes +=
+ SQUASHFS_COMPRESSED_SIZE_BLOCK
+ (block_list[i]);
+
+ if(inode.fragment != SQUASHFS_INVALID_FRAG &&
+ inode.fragment >= sBlk->fragments) {
+ free(block_list);
+ goto corrupted;
+ }
+
+ add_file(start, inode.file_size, file_bytes,
+ block_list, blocks, inode.fragment,
+ inode.offset, frag_bytes);
+
+ cur_ptr += blocks * sizeof(unsigned int);
+ break;
+ }
+ case SQUASHFS_SYMLINK_TYPE:
+ case SQUASHFS_LSYMLINK_TYPE: {
+ struct squashfs_symlink_inode_header inode;
+
+ if(NO_INODE_BYTES(squashfs_symlink_inode_header))
+ /* corrupted filesystem */
+ goto corrupted;
+
+ SQUASHFS_SWAP_SYMLINK_INODE_HEADER(cur_ptr, &inode);
+
+ (*sym_count) ++;
+
+ if (inode.inode_type == SQUASHFS_LSYMLINK_TYPE) {
+ if(NO_BYTES(inode.symlink_size +
+ sizeof(unsigned int)))
+ /* corrupted filesystem */
+ goto corrupted;
+ cur_ptr += sizeof(inode) + inode.symlink_size +
+ sizeof(unsigned int);
+ } else {
+ if(NO_BYTES(inode.symlink_size))
+ /* corrupted filesystem */
+ goto corrupted;
+ cur_ptr += sizeof(inode) + inode.symlink_size;
+ }
+ break;
+ }
+ case SQUASHFS_DIR_TYPE: {
+ struct squashfs_dir_inode_header dir_inode;
+
+ if(NO_INODE_BYTES(squashfs_dir_inode_header))
+ /* corrupted filesystem */
+ goto corrupted;
+
+ SQUASHFS_SWAP_DIR_INODE_HEADER(cur_ptr, &dir_inode);
+
+ if(dir_inode.start_block < directory_start_block)
+ *uncompressed_directory += dir_inode.file_size;
+
+ (*dir_count) ++;
+ cur_ptr += sizeof(struct squashfs_dir_inode_header);
+ break;
+ }
+ case SQUASHFS_LDIR_TYPE: {
+ struct squashfs_ldir_inode_header dir_inode;
+ int i;
+
+ if(NO_INODE_BYTES(squashfs_ldir_inode_header))
+ /* corrupted filesystem */
+ goto corrupted;
+
+ SQUASHFS_SWAP_LDIR_INODE_HEADER(cur_ptr, &dir_inode);
+
+ if(dir_inode.start_block < directory_start_block)
+ *uncompressed_directory += dir_inode.file_size;
+
+ (*dir_count) ++;
+ cur_ptr += sizeof(struct squashfs_ldir_inode_header);
+
+ for(i = 0; i < dir_inode.i_count; i++) {
+ struct squashfs_dir_index index;
+
+ if(NO_BYTES(sizeof(index)))
+ /* corrupted filesystem */
+ goto corrupted;
+
+ SQUASHFS_SWAP_DIR_INDEX(cur_ptr, &index);
+
+ if(NO_BYTES(index.size + 1))
+ /* corrupted filesystem */
+ goto corrupted;
+
+ cur_ptr += sizeof(index) + index.size + 1;
+ }
+ break;
+ }
+ case SQUASHFS_BLKDEV_TYPE:
+ case SQUASHFS_CHRDEV_TYPE:
+ if(NO_INODE_BYTES(squashfs_dev_inode_header))
+ /* corrupted filesystem */
+ goto corrupted;
+
+ (*dev_count) ++;
+ cur_ptr += sizeof(struct squashfs_dev_inode_header);
+ break;
+ case SQUASHFS_LBLKDEV_TYPE:
+ case SQUASHFS_LCHRDEV_TYPE:
+ if(NO_INODE_BYTES(squashfs_ldev_inode_header))
+ /* corrupted filesystem */
+ goto corrupted;
+
+ (*dev_count) ++;
+ cur_ptr += sizeof(struct squashfs_ldev_inode_header);
+ break;
+ case SQUASHFS_FIFO_TYPE:
+ if(NO_INODE_BYTES(squashfs_ipc_inode_header))
+ /* corrupted filesystem */
+ goto corrupted;
+
+ (*fifo_count) ++;
+ cur_ptr += sizeof(struct squashfs_ipc_inode_header);
+ break;
+ case SQUASHFS_LFIFO_TYPE:
+ if(NO_INODE_BYTES(squashfs_lipc_inode_header))
+ /* corrupted filesystem */
+ goto corrupted;
+
+ (*fifo_count) ++;
+ cur_ptr += sizeof(struct squashfs_lipc_inode_header);
+ break;
+ case SQUASHFS_SOCKET_TYPE:
+ if(NO_INODE_BYTES(squashfs_ipc_inode_header))
+ /* corrupted filesystem */
+ goto corrupted;
+
+ (*sock_count) ++;
+ cur_ptr += sizeof(struct squashfs_ipc_inode_header);
+ break;
+ case SQUASHFS_LSOCKET_TYPE:
+ if(NO_INODE_BYTES(squashfs_lipc_inode_header))
+ /* corrupted filesystem */
+ goto corrupted;
+
+ (*sock_count) ++;
+ cur_ptr += sizeof(struct squashfs_lipc_inode_header);
+ break;
+ default:
+ ERROR("Unknown inode type %d in scan_inode_table!\n",
+ base.inode_type);
+ goto corrupted;
+ }
+ }
+
+ printf("Read existing filesystem, %d inodes scanned\n", files);
+ return TRUE;
+
+corrupted:
+ ERROR("scan_inode_table: filesystem corruption detected in "
+ "scanning metadata\n");
+ free(*inode_table);
+ return FALSE;
+}
+
+
+struct compressor *read_super(int fd, struct squashfs_super_block *sBlk, char *source)
+{
+ int res, bytes = 0;
+ char buffer[SQUASHFS_METADATA_SIZE] __attribute__ ((aligned));
+
+ res = read_fs_bytes(fd, SQUASHFS_START, sizeof(struct squashfs_super_block),
+ sBlk);
+ if(res == 0) {
+ ERROR("Can't find a SQUASHFS superblock on %s\n",
+ source);
+ ERROR("Wrong filesystem or filesystem is corrupted!\n");
+ goto failed_mount;
+ }
+
+ SQUASHFS_INSWAP_SUPER_BLOCK(sBlk);
+
+ if(sBlk->s_magic != SQUASHFS_MAGIC) {
+ if(sBlk->s_magic == SQUASHFS_MAGIC_SWAP)
+ ERROR("Pre 4.0 big-endian filesystem on %s, appending"
+ " to this is unsupported\n", source);
+ else {
+ ERROR("Can't find a SQUASHFS superblock on %s\n",
+ source);
+ ERROR("Wrong filesystem or filesystem is corrupted!\n");
+ }
+ goto failed_mount;
+ }
+
+ /* Check the MAJOR & MINOR versions */
+ if(sBlk->s_major != SQUASHFS_MAJOR || sBlk->s_minor > SQUASHFS_MINOR) {
+ if(sBlk->s_major < 4)
+ ERROR("Filesystem on %s is a SQUASHFS %d.%d filesystem."
+ " Appending\nto SQUASHFS %d.%d filesystems is "
+ "not supported. Please convert it to a "
+ "SQUASHFS 4 filesystem\n", source,
+ sBlk->s_major,
+ sBlk->s_minor, sBlk->s_major, sBlk->s_minor);
+ else
+ ERROR("Filesystem on %s is %d.%d, which is a later "
+ "filesystem version than I support\n",
+ source, sBlk->s_major, sBlk->s_minor);
+ goto failed_mount;
+ }
+
+ /* Check the compression type */
+ comp = lookup_compressor_id(sBlk->compression);
+ if(!comp->supported) {
+ ERROR("Filesystem on %s uses %s compression, this is "
+ "unsupported by this version\n", source, comp->name);
+ ERROR("Compressors available:\n");
+ display_compressors("", "");
+ goto failed_mount;
+ }
+
+ /*
+ * Read extended superblock information from disk.
+ *
+ * Read compressor specific options from disk if present, and pass
+ * to compressor to set compressor options.
+ *
+ * Note, if there's no compressor options present, the compressor
+ * is still called to set the default options (the defaults may have
+ * been changed by the user specifying options on the command
+ * line which need to be over-ridden).
+ *
+ * Compressor_extract_options is also used to ensure that
+ * we know how decompress a filesystem compressed with these
+ * compression options.
+ */
+ if(SQUASHFS_COMP_OPTS(sBlk->flags)) {
+ bytes = read_block(fd, sizeof(*sBlk), NULL, 0, buffer);
+
+ if(bytes == 0) {
+ ERROR("Failed to read compressor options from append "
+ "filesystem\n");
+ ERROR("Filesystem corrupted?\n");
+ goto failed_mount;
+ }
+ }
+
+ res = compressor_extract_options(comp, sBlk->block_size, buffer, bytes);
+ if(res == -1) {
+ ERROR("Compressor failed to set compressor options\n");
+ goto failed_mount;
+ }
+
+ printf("Found a valid %sSQUASHFS superblock on %s.\n",
+ SQUASHFS_EXPORTABLE(sBlk->flags) ? "exportable " : "", source);
+ printf("\tCompression used %s\n", comp->name);
+ printf("\tInodes are %scompressed\n",
+ SQUASHFS_UNCOMPRESSED_INODES(sBlk->flags) ? "un" : "");
+ printf("\tData is %scompressed\n",
+ SQUASHFS_UNCOMPRESSED_DATA(sBlk->flags) ? "un" : "");
+ printf("\tFragments are %scompressed\n",
+ SQUASHFS_UNCOMPRESSED_FRAGMENTS(sBlk->flags) ? "un" : "");
+ printf("\tXattrs are %scompressed\n",
+ SQUASHFS_UNCOMPRESSED_XATTRS(sBlk->flags) ? "un" : "");
+ printf("\tFragments are %spresent in the filesystem\n",
+ SQUASHFS_NO_FRAGMENTS(sBlk->flags) ? "not " : "");
+ printf("\tAlways-use-fragments option is %sspecified\n",
+ SQUASHFS_ALWAYS_FRAGMENTS(sBlk->flags) ? "" : "not ");
+ printf("\tDuplicates are %sremoved\n",
+ SQUASHFS_DUPLICATES(sBlk->flags) ? "" : "not ");
+ printf("\tXattrs are %sstored\n",
+ SQUASHFS_NO_XATTRS(sBlk->flags) ? "not " : "");
+ printf("\tFilesystem size %.2f Kbytes (%.2f Mbytes)\n",
+ sBlk->bytes_used / 1024.0, sBlk->bytes_used
+ / (1024.0 * 1024.0));
+ printf("\tBlock size %d\n", sBlk->block_size);
+ printf("\tNumber of fragments %d\n", sBlk->fragments);
+ printf("\tNumber of inodes %d\n", sBlk->inodes);
+ printf("\tNumber of ids %d\n", sBlk->no_ids);
+ TRACE("sBlk->inode_table_start %llx\n", sBlk->inode_table_start);
+ TRACE("sBlk->directory_table_start %llx\n",
+ sBlk->directory_table_start);
+ TRACE("sBlk->id_table_start %llx\n", sBlk->id_table_start);
+ TRACE("sBlk->fragment_table_start %llx\n", sBlk->fragment_table_start);
+ TRACE("sBlk->lookup_table_start %llx\n", sBlk->lookup_table_start);
+ TRACE("sBlk->xattr_id_table_start %llx\n", sBlk->xattr_id_table_start);
+ printf("\n");
+
+ return comp;
+
+failed_mount:
+ return NULL;
+}
+
+
+unsigned char *squashfs_readdir(int fd, int root_entries,
+ unsigned int directory_start_block, int offset, int size,
+ unsigned int *last_directory_block, struct squashfs_super_block *sBlk,
+ void (push_directory_entry)(char *, squashfs_inode, int, int))
+{
+ struct squashfs_dir_header dirh;
+ char buffer[sizeof(struct squashfs_dir_entry) + SQUASHFS_NAME_LEN + 1]
+ __attribute__ ((aligned));
+ struct squashfs_dir_entry *dire = (struct squashfs_dir_entry *) buffer;
+ unsigned char *directory_table = NULL;
+ int byte, bytes = 0, dir_count;
+ long long start = sBlk->directory_table_start + directory_start_block,
+ last_start_block = start;
+
+ size += offset;
+ directory_table = malloc((size + SQUASHFS_METADATA_SIZE * 2 - 1) &
+ ~(SQUASHFS_METADATA_SIZE - 1));
+ if(directory_table == NULL)
+ MEM_ERROR();
+
+ while(bytes < size) {
+ int expected = (size - bytes) >= SQUASHFS_METADATA_SIZE ?
+ SQUASHFS_METADATA_SIZE : 0;
+
+ TRACE("squashfs_readdir: reading block 0x%llx, bytes read so "
+ "far %d\n", start, bytes);
+
+ last_start_block = start;
+ byte = read_block(fd, start, &start, expected, directory_table + bytes);
+ if(byte == 0) {
+ ERROR("Failed to read directory\n");
+ ERROR("Filesystem corrupted?\n");
+ free(directory_table);
+ return NULL;
+ }
+ bytes += byte;
+ }
+
+ if(!root_entries)
+ goto all_done;
+
+ bytes = offset;
+ while(bytes < size) {
+ SQUASHFS_SWAP_DIR_HEADER(directory_table + bytes, &dirh);
+
+ dir_count = dirh.count + 1;
+ TRACE("squashfs_readdir: Read directory header @ byte position "
+ "0x%x, 0x%x directory entries\n", bytes, dir_count);
+ bytes += sizeof(dirh);
+
+ while(dir_count--) {
+ SQUASHFS_SWAP_DIR_ENTRY(directory_table + bytes, dire);
+ bytes += sizeof(*dire);
+
+ memcpy(dire->name, directory_table + bytes,
+ dire->size + 1);
+ dire->name[dire->size + 1] = '\0';
+ TRACE("squashfs_readdir: pushing directory entry %s, "
+ "inode %x:%x, type 0x%x\n", dire->name,
+ dirh.start_block, dire->offset, dire->type);
+ push_directory_entry(dire->name,
+ SQUASHFS_MKINODE(dirh.start_block,
+ dire->offset), dirh.inode_number +
+ dire->inode_number, dire->type);
+ bytes += dire->size + 1;
+ }
+ }
+
+all_done:
+ *last_directory_block = (unsigned int) last_start_block -
+ sBlk->directory_table_start;
+ return directory_table;
+}
+
+
+unsigned int *read_id_table(int fd, struct squashfs_super_block *sBlk)
+{
+ int indexes = SQUASHFS_ID_BLOCKS(sBlk->no_ids);
+ long long index[indexes];
+ int bytes = SQUASHFS_ID_BYTES(sBlk->no_ids);
+ unsigned int *id_table;
+ int res, i;
+
+ id_table = malloc(bytes);
+ if(id_table == NULL)
+ MEM_ERROR();
+
+ res = read_fs_bytes(fd, sBlk->id_table_start,
+ SQUASHFS_ID_BLOCK_BYTES(sBlk->no_ids), index);
+ if(res == 0) {
+ ERROR("Failed to read id table index\n");
+ ERROR("Filesystem corrupted?\n");
+ free(id_table);
+ return NULL;
+ }
+
+ SQUASHFS_INSWAP_ID_BLOCKS(index, indexes);
+
+ for(i = 0; i < indexes; i++) {
+ int expected = (i + 1) != indexes ? SQUASHFS_METADATA_SIZE :
+ bytes & (SQUASHFS_METADATA_SIZE - 1);
+ int length = read_block(fd, index[i], NULL, expected,
+ ((unsigned char *) id_table) +
+ (i * SQUASHFS_METADATA_SIZE));
+ TRACE("Read id table block %d, from 0x%llx, length %d\n", i,
+ index[i], length);
+ if(length == 0) {
+ ERROR("Failed to read id table block %d, from 0x%llx, "
+ "length %d\n", i, index[i], length);
+ ERROR("Filesystem corrupted?\n");
+ free(id_table);
+ return NULL;
+ }
+ }
+
+ SQUASHFS_INSWAP_INTS(id_table, sBlk->no_ids);
+
+ for(i = 0; i < sBlk->no_ids; i++) {
+ TRACE("Adding id %d to id tables\n", id_table[i]);
+ create_id(id_table[i]);
+ }
+
+ return id_table;
+}
+
+
+int read_fragment_table(int fd, struct squashfs_super_block *sBlk,
+ struct squashfs_fragment_entry **fragment_table)
+{
+ int res, i;
+ int bytes = SQUASHFS_FRAGMENT_BYTES(sBlk->fragments);
+ int indexes = SQUASHFS_FRAGMENT_INDEXES(sBlk->fragments);
+ long long fragment_table_index[indexes];
+
+ TRACE("read_fragment_table: %d fragments, reading %d fragment indexes "
+ "from 0x%llx\n", sBlk->fragments, indexes,
+ sBlk->fragment_table_start);
+
+ if(sBlk->fragments == 0)
+ return 1;
+
+ *fragment_table = malloc(bytes);
+ if(*fragment_table == NULL)
+ MEM_ERROR();
+
+ res = read_fs_bytes(fd, sBlk->fragment_table_start,
+ SQUASHFS_FRAGMENT_INDEX_BYTES(sBlk->fragments),
+ fragment_table_index);
+ if(res == 0) {
+ ERROR("Failed to read fragment table index\n");
+ ERROR("Filesystem corrupted?\n");
+ free(*fragment_table);
+ return 0;
+ }
+
+ SQUASHFS_INSWAP_FRAGMENT_INDEXES(fragment_table_index, indexes);
+
+ for(i = 0; i < indexes; i++) {
+ int expected = (i + 1) != indexes ? SQUASHFS_METADATA_SIZE :
+ bytes & (SQUASHFS_METADATA_SIZE - 1);
+ int length = read_block(fd, fragment_table_index[i], NULL,
+ expected, ((unsigned char *) *fragment_table) +
+ (i * SQUASHFS_METADATA_SIZE));
+ TRACE("Read fragment table block %d, from 0x%llx, length %d\n",
+ i, fragment_table_index[i], length);
+ if(length == 0) {
+ ERROR("Failed to read fragment table block %d, from "
+ "0x%llx, length %d\n", i,
+ fragment_table_index[i], length);
+ ERROR("Filesystem corrupted?\n");
+ free(*fragment_table);
+ return 0;
+ }
+ }
+
+ for(i = 0; i < sBlk->fragments; i++)
+ SQUASHFS_INSWAP_FRAGMENT_ENTRY(&(*fragment_table)[i]);
+
+ return 1;
+}
+
+
+int read_inode_lookup_table(int fd, struct squashfs_super_block *sBlk,
+ squashfs_inode **inode_lookup_table)
+{
+ int lookup_bytes = SQUASHFS_LOOKUP_BYTES(sBlk->inodes);
+ int indexes = SQUASHFS_LOOKUP_BLOCKS(sBlk->inodes);
+ long long index[indexes];
+ int res, i;
+
+ if(sBlk->lookup_table_start == SQUASHFS_INVALID_BLK)
+ return 1;
+
+ *inode_lookup_table = malloc(lookup_bytes);
+ if(*inode_lookup_table == NULL)
+ MEM_ERROR();
+
+ res = read_fs_bytes(fd, sBlk->lookup_table_start,
+ SQUASHFS_LOOKUP_BLOCK_BYTES(sBlk->inodes), index);
+ if(res == 0) {
+ ERROR("Failed to read inode lookup table index\n");
+ ERROR("Filesystem corrupted?\n");
+ free(*inode_lookup_table);
+ return 0;
+ }
+
+ SQUASHFS_INSWAP_LONG_LONGS(index, indexes);
+
+ for(i = 0; i < indexes; i++) {
+ int expected = (i + 1) != indexes ? SQUASHFS_METADATA_SIZE :
+ lookup_bytes & (SQUASHFS_METADATA_SIZE - 1);
+ int length = read_block(fd, index[i], NULL, expected,
+ ((unsigned char *) *inode_lookup_table) +
+ (i * SQUASHFS_METADATA_SIZE));
+ TRACE("Read inode lookup table block %d, from 0x%llx, length "
+ "%d\n", i, index[i], length);
+ if(length == 0) {
+ ERROR("Failed to read inode lookup table block %d, "
+ "from 0x%llx, length %d\n", i, index[i],
+ length);
+ ERROR("Filesystem corrupted?\n");
+ free(*inode_lookup_table);
+ return 0;
+ }
+ }
+
+ SQUASHFS_INSWAP_LONG_LONGS(*inode_lookup_table, sBlk->inodes);
+
+ return 1;
+}
+
+
+long long read_filesystem(char *root_name, int fd, struct squashfs_super_block *sBlk,
+ char **cinode_table, char **data_cache, char **cdirectory_table,
+ char **directory_data_cache, unsigned int *last_directory_block,
+ unsigned int *inode_dir_offset, unsigned int *inode_dir_file_size,
+ unsigned int *root_inode_size, unsigned int *inode_dir_start_block,
+ int *file_count, int *sym_count, int *dev_count, int *dir_count,
+ int *fifo_count, int *sock_count, long long *uncompressed_file,
+ unsigned int *uncompressed_inode, unsigned int *uncompressed_directory,
+ unsigned int *inode_dir_inode_number,
+ unsigned int *inode_dir_parent_inode,
+ void (push_directory_entry)(char *, squashfs_inode, int, int),
+ struct squashfs_fragment_entry **fragment_table,
+ squashfs_inode **inode_lookup_table)
+{
+ unsigned char *inode_table = NULL, *directory_table = NULL;
+ long long start = sBlk->inode_table_start;
+ long long end = sBlk->directory_table_start;
+ long long root_inode_start = start +
+ SQUASHFS_INODE_BLK(sBlk->root_inode);
+ unsigned int root_inode_offset =
+ SQUASHFS_INODE_OFFSET(sBlk->root_inode);
+ unsigned int root_inode_block;
+ union squashfs_inode_header inode;
+ unsigned int *id_table = NULL;
+ int res;
+
+ printf("Scanning existing filesystem...\n");
+
+ if(get_xattrs(fd, sBlk) == 0)
+ goto error;
+
+ if(read_fragment_table(fd, sBlk, fragment_table) == 0)
+ goto error;
+
+ if(read_inode_lookup_table(fd, sBlk, inode_lookup_table) == 0)
+ goto error;
+
+ id_table = read_id_table(fd, sBlk);
+ if(id_table == NULL)
+ goto error;
+
+ res = scan_inode_table(fd, start, end, root_inode_start,
+ root_inode_offset, sBlk, &inode, &inode_table,
+ &root_inode_block, root_inode_size, uncompressed_file,
+ uncompressed_directory, file_count, sym_count, dev_count,
+ dir_count, fifo_count, sock_count, id_table);
+ if(res == 0)
+ goto error;
+
+ *uncompressed_inode = root_inode_block;
+
+ if(inode.base.inode_type == SQUASHFS_DIR_TYPE ||
+ inode.base.inode_type == SQUASHFS_LDIR_TYPE) {
+ if(inode.base.inode_type == SQUASHFS_DIR_TYPE) {
+ *inode_dir_start_block = inode.dir.start_block;
+ *inode_dir_offset = inode.dir.offset;
+ *inode_dir_file_size = inode.dir.file_size - 3;
+ *inode_dir_inode_number = inode.dir.inode_number;
+ *inode_dir_parent_inode = inode.dir.parent_inode;
+ } else {
+ *inode_dir_start_block = inode.ldir.start_block;
+ *inode_dir_offset = inode.ldir.offset;
+ *inode_dir_file_size = inode.ldir.file_size - 3;
+ *inode_dir_inode_number = inode.ldir.inode_number;
+ *inode_dir_parent_inode = inode.ldir.parent_inode;
+ }
+
+ directory_table = squashfs_readdir(fd, !root_name,
+ *inode_dir_start_block, *inode_dir_offset,
+ *inode_dir_file_size, last_directory_block, sBlk,
+ push_directory_entry);
+ if(directory_table == NULL)
+ goto error;
+
+ root_inode_start -= start;
+ *cinode_table = malloc(root_inode_start);
+ if(*cinode_table == NULL)
+ MEM_ERROR();
+
+ res = read_fs_bytes(fd, start, root_inode_start, *cinode_table);
+ if(res == 0) {
+ ERROR("Failed to read inode table\n");
+ ERROR("Filesystem corrupted?\n");
+ goto error;
+ }
+
+ *cdirectory_table = malloc(*last_directory_block);
+ if(*cdirectory_table == NULL)
+ MEM_ERROR();
+
+ res = read_fs_bytes(fd, sBlk->directory_table_start,
+ *last_directory_block, *cdirectory_table);
+ if(res == 0) {
+ ERROR("Failed to read directory table\n");
+ ERROR("Filesystem corrupted?\n");
+ goto error;
+ }
+
+ *data_cache = malloc(root_inode_offset + *root_inode_size);
+ if(*data_cache == NULL)
+ MEM_ERROR();
+
+ memcpy(*data_cache, inode_table + root_inode_block,
+ root_inode_offset + *root_inode_size);
+
+ *directory_data_cache = malloc(*inode_dir_offset +
+ *inode_dir_file_size);
+ if(*directory_data_cache == NULL)
+ MEM_ERROR();
+
+ memcpy(*directory_data_cache, directory_table,
+ *inode_dir_offset + *inode_dir_file_size);
+
+ free(id_table);
+ free(inode_table);
+ free(directory_table);
+ return sBlk->inode_table_start;
+ }
+
+error:
+ free(id_table);
+ free(inode_table);
+ free(directory_table);
+ return 0;
+}
diff --git a/squashfs-tools/squashfs-tools/read_fs.h b/squashfs-tools/squashfs-tools/read_fs.h
new file mode 100644
index 0000000..9ad32c0
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/read_fs.h
@@ -0,0 +1,34 @@
+#ifndef READ_FS_H
+#define READ_FS_H
+/*
+ * Squashfs
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2013
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * read_fs.h
+ *
+ */
+extern struct compressor *read_super(int, struct squashfs_super_block *,
+ char *);
+extern long long read_filesystem(char *, int, struct squashfs_super_block *,
+char **, char **, char **, char **, unsigned int *, unsigned int *,
+unsigned int *, unsigned int *, unsigned int *, int *, int *, int *, int *,
+int *, int *, long long *, unsigned int *, unsigned int *, unsigned int *,
+unsigned int *, void (push_directory_entry)(char *, squashfs_inode, int, int),
+struct squashfs_fragment_entry **, squashfs_inode **);
+#endif
diff --git a/squashfs-tools/squashfs-tools/read_xattrs.c b/squashfs-tools/squashfs-tools/read_xattrs.c
new file mode 100644
index 0000000..837d3fb
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/read_xattrs.c
@@ -0,0 +1,390 @@
+/*
+ * Read a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2010, 2012, 2013
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * read_xattrs.c
+ */
+
+/*
+ * Common xattr read code shared between mksquashfs and unsquashfs
+ */
+
+#define TRUE 1
+#define FALSE 0
+#include <stdio.h>
+#include <string.h>
+
+#ifndef linux
+#define __BYTE_ORDER BYTE_ORDER
+#define __BIG_ENDIAN BIG_ENDIAN
+#define __LITTLE_ENDIAN LITTLE_ENDIAN
+#else
+#include <endian.h>
+#endif
+
+#include <stdlib.h>
+
+#include "squashfs_fs.h"
+#include "squashfs_swap.h"
+#include "xattr.h"
+#include "error.h"
+
+extern int read_fs_bytes(int, long long, int, void *);
+extern int read_block(int, long long, long long *, int, void *);
+
+static struct hash_entry {
+ long long start;
+ unsigned int offset;
+ struct hash_entry *next;
+} *hash_table[65536];
+
+static struct squashfs_xattr_id *xattr_ids;
+static void *xattrs = NULL;
+static long long xattr_table_start;
+
+/*
+ * Prefix lookup table, storing mapping to/from prefix string and prefix id
+ */
+struct prefix prefix_table[] = {
+ { "user.", SQUASHFS_XATTR_USER },
+ { "trusted.", SQUASHFS_XATTR_TRUSTED },
+ { "security.", SQUASHFS_XATTR_SECURITY },
+ { "", -1 }
+};
+
+/*
+ * store mapping from location of compressed block in fs ->
+ * location of uncompressed block in memory
+ */
+static void save_xattr_block(long long start, int offset)
+{
+ struct hash_entry *hash_entry = malloc(sizeof(*hash_entry));
+ int hash = start & 0xffff;
+
+ TRACE("save_xattr_block: start %lld, offset %d\n", start, offset);
+
+ if(hash_entry == NULL)
+ MEM_ERROR();
+
+ hash_entry->start = start;
+ hash_entry->offset = offset;
+ hash_entry->next = hash_table[hash];
+ hash_table[hash] = hash_entry;
+}
+
+
+/*
+ * map from location of compressed block in fs ->
+ * location of uncompressed block in memory
+ */
+static int get_xattr_block(long long start)
+{
+ int hash = start & 0xffff;
+ struct hash_entry *hash_entry = hash_table[hash];
+
+ for(; hash_entry; hash_entry = hash_entry->next)
+ if(hash_entry->start == start)
+ break;
+
+ TRACE("get_xattr_block: start %lld, offset %d\n", start,
+ hash_entry ? hash_entry->offset : -1);
+
+ return hash_entry ? hash_entry->offset : -1;
+}
+
+
+/*
+ * construct the xattr_list entry from the fs xattr, including
+ * mapping name and prefix into a full name
+ */
+static int read_xattr_entry(struct xattr_list *xattr,
+ struct squashfs_xattr_entry *entry, void *name)
+{
+ int i, len, type = entry->type & XATTR_PREFIX_MASK;
+
+ for(i = 0; prefix_table[i].type != -1; i++)
+ if(prefix_table[i].type == type)
+ break;
+
+ if(prefix_table[i].type == -1) {
+ ERROR("Unrecognised type in read_xattr_entry\n");
+ return 0;
+ }
+
+ len = strlen(prefix_table[i].prefix);
+ xattr->full_name = malloc(len + entry->size + 1);
+ if(xattr->full_name == NULL)
+ MEM_ERROR();
+
+ memcpy(xattr->full_name, prefix_table[i].prefix, len);
+ memcpy(xattr->full_name + len, name, entry->size);
+ xattr->full_name[len + entry->size] = '\0';
+ xattr->name = xattr->full_name + len;
+ xattr->size = entry->size;
+ xattr->type = type;
+
+ return 1;
+}
+
+
+/*
+ * Read and decompress the xattr id table and the xattr metadata.
+ * This is cached in memory for later use by get_xattr()
+ */
+int read_xattrs_from_disk(int fd, struct squashfs_super_block *sBlk)
+{
+ int res, bytes, i, indexes, index_bytes, ids;
+ long long *index, start, end;
+ struct squashfs_xattr_table id_table;
+
+ TRACE("read_xattrs_from_disk\n");
+
+ if(sBlk->xattr_id_table_start == SQUASHFS_INVALID_BLK)
+ return SQUASHFS_INVALID_BLK;
+
+ /*
+ * Read xattr id table, containing start of xattr metadata and the
+ * number of xattrs in the file system
+ */
+ res = read_fs_bytes(fd, sBlk->xattr_id_table_start, sizeof(id_table),
+ &id_table);
+ if(res == 0)
+ return 0;
+
+ SQUASHFS_INSWAP_XATTR_TABLE(&id_table);
+
+ /*
+ * Allocate and read the index to the xattr id table metadata
+ * blocks
+ */
+ ids = id_table.xattr_ids;
+ xattr_table_start = id_table.xattr_table_start;
+ index_bytes = SQUASHFS_XATTR_BLOCK_BYTES(ids);
+ indexes = SQUASHFS_XATTR_BLOCKS(ids);
+ index = malloc(index_bytes);
+ if(index == NULL)
+ MEM_ERROR();
+
+ res = read_fs_bytes(fd, sBlk->xattr_id_table_start + sizeof(id_table),
+ index_bytes, index);
+ if(res ==0)
+ goto failed1;
+
+ SQUASHFS_INSWAP_LONG_LONGS(index, indexes);
+
+ /*
+ * Allocate enough space for the uncompressed xattr id table, and
+ * read and decompress it
+ */
+ bytes = SQUASHFS_XATTR_BYTES(ids);
+ xattr_ids = malloc(bytes);
+ if(xattr_ids == NULL)
+ MEM_ERROR();
+
+ for(i = 0; i < indexes; i++) {
+ int expected = (i + 1) != indexes ? SQUASHFS_METADATA_SIZE :
+ bytes & (SQUASHFS_METADATA_SIZE - 1);
+ int length = read_block(fd, index[i], NULL, expected,
+ ((unsigned char *) xattr_ids) +
+ (i * SQUASHFS_METADATA_SIZE));
+ TRACE("Read xattr id table block %d, from 0x%llx, length "
+ "%d\n", i, index[i], length);
+ if(length == 0) {
+ ERROR("Failed to read xattr id table block %d, "
+ "from 0x%llx, length %d\n", i, index[i],
+ length);
+ goto failed2;
+ }
+ }
+
+ /*
+ * Read and decompress the xattr metadata
+ *
+ * Note the first xattr id table metadata block is immediately after
+ * the last xattr metadata block, so we can use index[0] to work out
+ * the end of the xattr metadata
+ */
+ start = xattr_table_start;
+ end = index[0];
+ for(i = 0; start < end; i++) {
+ int length;
+ xattrs = realloc(xattrs, (i + 1) * SQUASHFS_METADATA_SIZE);
+ if(xattrs == NULL)
+ MEM_ERROR();
+
+ /* store mapping from location of compressed block in fs ->
+ * location of uncompressed block in memory */
+ save_xattr_block(start, i * SQUASHFS_METADATA_SIZE);
+
+ length = read_block(fd, start, &start, 0,
+ ((unsigned char *) xattrs) +
+ (i * SQUASHFS_METADATA_SIZE));
+ TRACE("Read xattr block %d, length %d\n", i, length);
+ if(length == 0) {
+ ERROR("Failed to read xattr block %d\n", i);
+ goto failed3;
+ }
+
+ /*
+ * If this is not the last metadata block in the xattr metadata
+ * then it should be SQUASHFS_METADATA_SIZE in size.
+ * Note, we can't use expected in read_block() above for this
+ * because we don't know if this is the last block until
+ * after reading.
+ */
+ if(start != end && length != SQUASHFS_METADATA_SIZE) {
+ ERROR("Xattr block %d should be %d bytes in length, "
+ "it is %d bytes\n", i, SQUASHFS_METADATA_SIZE,
+ length);
+ goto failed3;
+ }
+ }
+
+ /* swap if necessary the xattr id entries */
+ for(i = 0; i < ids; i++)
+ SQUASHFS_INSWAP_XATTR_ID(&xattr_ids[i]);
+
+ free(index);
+
+ return ids;
+
+failed3:
+ free(xattrs);
+failed2:
+ free(xattr_ids);
+failed1:
+ free(index);
+
+ return 0;
+}
+
+
+void free_xattr(struct xattr_list *xattr_list, int count)
+{
+ int i;
+
+ for(i = 0; i < count; i++)
+ free(xattr_list[i].full_name);
+
+ free(xattr_list);
+}
+
+
+/*
+ * Construct and return the list of xattr name:value pairs for the passed xattr
+ * id
+ *
+ * There are two users for get_xattr(), Mksquashfs uses it to read the
+ * xattrs from the filesystem on appending, and Unsquashfs uses it
+ * to retrieve the xattrs for writing to disk.
+ *
+ * Unfortunately, the two users disagree on what to do with unknown
+ * xattr prefixes, Mksquashfs wants to treat this as fatal otherwise
+ * this will cause xattrs to be be lost on appending. Unsquashfs
+ * on the otherhand wants to retrieve the xattrs which are known and
+ * to ignore the rest, this allows Unsquashfs to cope more gracefully
+ * with future versions which may have unknown xattrs, as long as the
+ * general xattr structure is adhered to, Unsquashfs should be able
+ * to safely ignore unknown xattrs, and to write the ones it knows about,
+ * this is better than completely refusing to retrieve all the xattrs.
+ *
+ * If ignore is TRUE then don't treat unknown xattr prefixes as
+ * a failure to read the xattr.
+ */
+struct xattr_list *get_xattr(int i, unsigned int *count, int ignore)
+{
+ long long start;
+ struct xattr_list *xattr_list = NULL;
+ unsigned int offset;
+ void *xptr;
+ int j = 0, res = 1;
+
+ TRACE("get_xattr\n");
+
+ *count = xattr_ids[i].count;
+ start = SQUASHFS_XATTR_BLK(xattr_ids[i].xattr) + xattr_table_start;
+ offset = SQUASHFS_XATTR_OFFSET(xattr_ids[i].xattr);
+ xptr = xattrs + get_xattr_block(start) + offset;
+
+ TRACE("get_xattr: xattr_id %d, count %d, start %lld, offset %d\n", i,
+ *count, start, offset);
+
+ while(j < *count) {
+ struct squashfs_xattr_entry entry;
+ struct squashfs_xattr_val val;
+
+ if(res != 0) {
+ xattr_list = realloc(xattr_list, (j + 1) *
+ sizeof(struct xattr_list));
+ if(xattr_list == NULL)
+ MEM_ERROR();
+ }
+
+ SQUASHFS_SWAP_XATTR_ENTRY(xptr, &entry);
+ xptr += sizeof(entry);
+
+ res = read_xattr_entry(&xattr_list[j], &entry, xptr);
+ if(ignore && res == 0) {
+ /* unknown prefix, but ignore flag is set */
+ (*count) --;
+ continue;
+ }
+
+ if(res != 1)
+ goto failed;
+
+ xptr += entry.size;
+
+ TRACE("get_xattr: xattr %d, type %d, size %d, name %s\n", j,
+ entry.type, entry.size, xattr_list[j].full_name);
+
+ if(entry.type & SQUASHFS_XATTR_VALUE_OOL) {
+ long long xattr;
+ void *ool_xptr;
+
+ xptr += sizeof(val);
+ SQUASHFS_SWAP_LONG_LONGS(xptr, &xattr, 1);
+ xptr += sizeof(xattr);
+ start = SQUASHFS_XATTR_BLK(xattr) + xattr_table_start;
+ offset = SQUASHFS_XATTR_OFFSET(xattr);
+ ool_xptr = xattrs + get_xattr_block(start) + offset;
+ SQUASHFS_SWAP_XATTR_VAL(ool_xptr, &val);
+ xattr_list[j].value = ool_xptr + sizeof(val);
+ } else {
+ SQUASHFS_SWAP_XATTR_VAL(xptr, &val);
+ xattr_list[j].value = xptr + sizeof(val);
+ xptr += sizeof(val) + val.vsize;
+ }
+
+ TRACE("get_xattr: xattr %d, vsize %d\n", j, val.vsize);
+
+ xattr_list[j ++].vsize = val.vsize;
+ }
+
+ if(*count == 0)
+ goto failed;
+
+ return xattr_list;
+
+failed:
+ free_xattr(xattr_list, j);
+
+ return NULL;
+}
diff --git a/squashfs-tools/squashfs-tools/restore.c b/squashfs-tools/squashfs-tools/restore.c
new file mode 100644
index 0000000..5e336b3
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/restore.c
@@ -0,0 +1,155 @@
+/*
+ * Create a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2013, 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * restore.c
+ */
+
+#include <pthread.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <signal.h>
+#include <sys/time.h>
+#include <stdio.h>
+#include <math.h>
+#include <stdarg.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <dirent.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "caches-queues-lists.h"
+#include "squashfs_fs.h"
+#include "mksquashfs.h"
+#include "error.h"
+#include "progressbar.h"
+#include "info.h"
+
+#define FALSE 0
+#define TRUE 1
+
+extern pthread_t reader_thread, writer_thread, main_thread;
+extern pthread_t *deflator_thread, *frag_deflator_thread, *frag_thread;
+extern struct queue *to_deflate, *to_writer, *to_frag, *to_process_frag;
+extern struct seq_queue *to_main;
+extern void restorefs();
+extern int processors;
+
+static int interrupted = 0;
+static pthread_t restore_thread;
+
+void *restore_thrd(void *arg)
+{
+ sigset_t sigmask, old_mask;
+ int i, sig;
+
+ sigemptyset(&sigmask);
+ sigaddset(&sigmask, SIGINT);
+ sigaddset(&sigmask, SIGTERM);
+ sigaddset(&sigmask, SIGUSR1);
+ pthread_sigmask(SIG_BLOCK, &sigmask, &old_mask);
+
+ while(1) {
+ sigwait(&sigmask, &sig);
+
+ if((sig == SIGINT || sig == SIGTERM) && !interrupted) {
+ ERROR("Interrupting will restore original "
+ "filesystem!\n");
+ ERROR("Interrupt again to quit\n");
+ interrupted = TRUE;
+ continue;
+ }
+
+ /* kill main thread/worker threads and restore */
+ set_progressbar_state(FALSE);
+ disable_info();
+
+ /* first kill the reader thread */
+ pthread_cancel(reader_thread);
+ pthread_join(reader_thread, NULL);
+
+ /*
+ * then flush the reader to deflator thread(s) output queue.
+ * The deflator thread(s) will idle
+ */
+ queue_flush(to_deflate);
+
+ /* now kill the deflator thread(s) */
+ for(i = 0; i < processors; i++)
+ pthread_cancel(deflator_thread[i]);
+ for(i = 0; i < processors; i++)
+ pthread_join(deflator_thread[i], NULL);
+
+ /*
+ * then flush the reader to process fragment thread(s) output
+ * queue. The process fragment thread(s) will idle
+ */
+ queue_flush(to_process_frag);
+
+ /* now kill the process fragment thread(s) */
+ for(i = 0; i < processors; i++)
+ pthread_cancel(frag_thread[i]);
+ for(i = 0; i < processors; i++)
+ pthread_join(frag_thread[i], NULL);
+
+ /*
+ * then flush the reader/deflator/process fragment to main
+ * thread output queue. The main thread will idle
+ */
+ seq_queue_flush(to_main);
+
+ /* now kill the main thread */
+ pthread_cancel(main_thread);
+ pthread_join(main_thread, NULL);
+
+ /* then flush the main thread to fragment deflator thread(s)
+ * queue. The fragment deflator thread(s) will idle
+ */
+ queue_flush(to_frag);
+
+ /* now kill the fragment deflator thread(s) */
+ for(i = 0; i < processors; i++)
+ pthread_cancel(frag_deflator_thread[i]);
+ for(i = 0; i < processors; i++)
+ pthread_join(frag_deflator_thread[i], NULL);
+
+ /*
+ * then flush the main thread/fragment deflator thread(s)
+ * to writer thread queue. The writer thread will idle
+ */
+ queue_flush(to_writer);
+
+ /* now kill the writer thread */
+ pthread_cancel(writer_thread);
+ pthread_join(writer_thread, NULL);
+
+ TRACE("All threads cancelled\n");
+
+ restorefs();
+ }
+}
+
+
+pthread_t *init_restore_thread()
+{
+ pthread_create(&restore_thread, NULL, restore_thrd, NULL);
+ return &restore_thread;
+}
diff --git a/squashfs-tools/squashfs-tools/restore.h b/squashfs-tools/squashfs-tools/restore.h
new file mode 100644
index 0000000..35129f0
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/restore.h
@@ -0,0 +1,28 @@
+#ifndef RESTORE_H
+#define RESTORE_H
+/*
+ * Create a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2013, 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * restore.h
+ */
+
+extern pthread_t *init_restore_thread();
+#endif
diff --git a/squashfs-tools/squashfs-tools/sort.c b/squashfs-tools/squashfs-tools/sort.c
new file mode 100644
index 0000000..89df9e4
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/sort.c
@@ -0,0 +1,363 @@
+/*
+ * Create a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012,
+ * 2013, 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * sort.c
+ */
+
+#define TRUE 1
+#define FALSE 0
+#define MAX_LINE 16384
+
+#include <unistd.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <dirent.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+#include "squashfs_fs.h"
+#include "mksquashfs.h"
+#include "sort.h"
+#include "error.h"
+#include "progressbar.h"
+
+int mkisofs_style = -1;
+
+struct sort_info {
+ dev_t st_dev;
+ ino_t st_ino;
+ int priority;
+ struct sort_info *next;
+};
+
+struct sort_info *sort_info_list[65536];
+
+struct priority_entry *priority_list[65536];
+
+extern int silent;
+extern void write_file(squashfs_inode *inode, struct dir_ent *dir_ent,
+ int *c_size);
+extern char *pathname(struct dir_ent *dir_ent);
+
+
+void add_priority_list(struct dir_ent *dir, int priority)
+{
+ struct priority_entry *new_priority_entry;
+
+ priority += 32768;
+ new_priority_entry = malloc(sizeof(struct priority_entry));
+ if(new_priority_entry == NULL)
+ MEM_ERROR();
+
+ new_priority_entry->dir = dir;;
+ new_priority_entry->next = priority_list[priority];
+ priority_list[priority] = new_priority_entry;
+}
+
+
+int get_priority(char *filename, struct stat *buf, int priority)
+{
+ int hash = buf->st_ino & 0xffff;
+ struct sort_info *s;
+
+ for(s = sort_info_list[hash]; s; s = s->next)
+ if((s->st_dev == buf->st_dev) && (s->st_ino == buf->st_ino)) {
+ TRACE("returning priority %d (%s)\n", s->priority,
+ filename);
+ return s->priority;
+ }
+ TRACE("returning priority %d (%s)\n", priority, filename);
+ return priority;
+}
+
+
+#define ADD_ENTRY(buf, priority) {\
+ int hash = buf.st_ino & 0xffff;\
+ struct sort_info *s;\
+ if((s = malloc(sizeof(struct sort_info))) == NULL) \
+ MEM_ERROR(); \
+ s->st_dev = buf.st_dev;\
+ s->st_ino = buf.st_ino;\
+ s->priority = priority;\
+ s->next = sort_info_list[hash];\
+ sort_info_list[hash] = s;\
+ }
+int add_sort_list(char *path, int priority, int source, char *source_path[])
+{
+ int i, n;
+ struct stat buf;
+
+ TRACE("add_sort_list: filename %s, priority %d\n", path, priority);
+ if(strlen(path) > 1 && strcmp(path + strlen(path) - 2, "/*") == 0)
+ path[strlen(path) - 2] = '\0';
+
+ TRACE("add_sort_list: filename %s, priority %d\n", path, priority);
+re_read:
+ if(path[0] == '/' || strncmp(path, "./", 2) == 0 ||
+ strncmp(path, "../", 3) == 0 || mkisofs_style == 1) {
+ if(lstat(path, &buf) == -1)
+ goto error;
+ TRACE("adding filename %s, priority %d, st_dev %d, st_ino "
+ "%lld\n", path, priority, (int) buf.st_dev,
+ (long long) buf.st_ino);
+ ADD_ENTRY(buf, priority);
+ return TRUE;
+ }
+
+ for(i = 0, n = 0; i < source; i++) {
+ char *filename;
+ int res = asprintf(&filename, "%s/%s", source_path[i], path);
+ if(res == -1)
+ BAD_ERROR("asprintf failed in add_sort_list\n");
+ res = lstat(filename, &buf);
+ free(filename);
+ if(res == -1) {
+ if(!(errno == ENOENT || errno == ENOTDIR))
+ goto error;
+ continue;
+ }
+ ADD_ENTRY(buf, priority);
+ n ++;
+ }
+
+ if(n == 0 && mkisofs_style == -1 && lstat(path, &buf) != -1) {
+ ERROR("WARNING: Mkisofs style sortlist detected! This is "
+ "supported but please\n");
+ ERROR("convert to mksquashfs style sortlist! A sortlist entry");
+ ERROR(" should be\neither absolute (starting with ");
+ ERROR("'/') start with './' or '../' (taken to be\nrelative to "
+ "$PWD), otherwise it ");
+ ERROR("is assumed the entry is relative to one\nof the source "
+ "directories, i.e. with ");
+ ERROR("\"mksquashfs test test.sqsh\",\nthe sortlist ");
+ ERROR("entry \"file\" is assumed to be inside the directory "
+ "test.\n\n");
+ mkisofs_style = 1;
+ goto re_read;
+ }
+
+ mkisofs_style = 0;
+
+ if(n == 1)
+ return TRUE;
+ if(n > 1) {
+ ERROR(" Ambiguous sortlist entry \"%s\"\n\nIt maps to more "
+ "than one source entry! Please use an absolute path."
+ "\n", path);
+ return FALSE;
+ }
+
+error:
+ ERROR_START("Cannot stat sortlist entry \"%s\"\n", path);
+ ERROR("This is probably because you're using the wrong file\n");
+ ERROR("path relative to the source directories.");
+ ERROR_EXIT(" Ignoring");
+ /*
+ * Historical note
+ * Failure to stat a sortlist entry is deliberately ignored, even
+ * though it is an error. Squashfs release 2.2 changed the behaviour
+ * to treat it as a fatal error, but it was changed back to
+ * the original behaviour to ignore it in release 2.2-r2 following
+ * feedback from users at the time.
+ */
+ return TRUE;
+}
+
+
+void generate_file_priorities(struct dir_info *dir, int priority,
+ struct stat *buf)
+{
+ struct dir_ent *dir_ent = dir->list;
+
+ priority = get_priority(dir->pathname, buf, priority);
+
+ for(; dir_ent; dir_ent = dir_ent->next) {
+ struct stat *buf = &dir_ent->inode->buf;
+ if(dir_ent->inode->root_entry)
+ continue;
+
+ switch(buf->st_mode & S_IFMT) {
+ case S_IFREG:
+ add_priority_list(dir_ent,
+ get_priority(pathname(dir_ent), buf,
+ priority));
+ break;
+ case S_IFDIR:
+ generate_file_priorities(dir_ent->dir,
+ priority, buf);
+ break;
+ }
+ }
+}
+
+
+int read_sort_file(char *filename, int source, char *source_path[])
+{
+ FILE *fd;
+ char line_buffer[MAX_LINE + 1]; /* overflow safe */
+ char sort_filename[MAX_LINE + 1]; /* overflow safe */
+ char *line, *name;
+ int n, priority, res;
+
+ if((fd = fopen(filename, "r")) == NULL) {
+ ERROR("Failed to open sort file \"%s\" because %s\n",
+ filename, strerror(errno));
+ return FALSE;
+ }
+
+ while(fgets(line = line_buffer, MAX_LINE + 1, fd) != NULL) {
+ int len = strlen(line);
+
+ if(len == MAX_LINE && line[len - 1] != '\n') {
+ /* line too large */
+ ERROR("Line too long when reading "
+ "sort file \"%s\", larger than %d "
+ "bytes\n", filename, MAX_LINE);
+ goto failed;
+ }
+
+ /*
+ * Remove '\n' terminator if it exists (the last line
+ * in the file may not be '\n' terminated)
+ */
+ if(len && line[len - 1] == '\n')
+ line[len - 1] = '\0';
+
+ /* Skip any leading whitespace */
+ while(isspace(*line))
+ line ++;
+
+ /* if comment line, skip */
+ if(*line == '#')
+ continue;
+
+ /*
+ * Scan for filename, don't use sscanf() and "%s" because
+ * that can't handle filenames with spaces
+ */
+ for(name = sort_filename; !isspace(*line) && *line != '\0';) {
+ if(*line == '\\') {
+ line ++;
+ if (*line == '\0')
+ break;
+ }
+ *name ++ = *line ++;
+ }
+ *name = '\0';
+
+ /*
+ * if filename empty, then line was empty of anything but
+ * whitespace or a backslash character. Skip empy lines
+ */
+ if(sort_filename[0] == '\0')
+ continue;
+
+ /*
+ * Scan the rest of the line, we expect a decimal number
+ * which is the filename priority
+ */
+ errno = 0;
+ res = sscanf(line, "%d%n", &priority, &n);
+
+ if((res < 1 || errno) && errno != ERANGE) {
+ if(errno == 0)
+ /* No error, assume EOL or match failure */
+ ERROR("Sort file \"%s\", can't find priority "
+ "in entry \"%s\", EOL or match "
+ "failure\n", filename, line_buffer);
+ else
+ /* Some other failure not ERANGE */
+ ERROR("Sscanf failed reading sort file \"%s\" "
+ "because %s\n", filename,
+ strerror(errno));
+ goto failed;
+ } else if((errno == ERANGE) ||
+ (priority < -32768 || priority > 32767)) {
+ ERROR("Sort file \"%s\", entry \"%s\" has priority "
+ "outside range of -32767:32768.\n", filename,
+ line_buffer);
+ goto failed;
+ }
+
+ /* Skip any trailing whitespace */
+ line += n;
+ while(isspace(*line))
+ line ++;
+
+ if(*line != '\0') {
+ ERROR("Sort file \"%s\", trailing characters after "
+ "priority in entry \"%s\"\n", filename,
+ line_buffer);
+ goto failed;
+ }
+
+ res = add_sort_list(sort_filename, priority, source,
+ source_path);
+ if(res == FALSE)
+ goto failed;
+ }
+
+ if(ferror(fd)) {
+ ERROR("Reading sort file \"%s\" failed because %s\n", filename,
+ strerror(errno));
+ goto failed;
+ }
+
+ fclose(fd);
+ return TRUE;
+
+failed:
+ fclose(fd);
+ return FALSE;
+}
+
+
+void sort_files_and_write(struct dir_info *dir)
+{
+ int i;
+ struct priority_entry *entry;
+ squashfs_inode inode;
+ int duplicate_file;
+
+ for(i = 65535; i >= 0; i--)
+ for(entry = priority_list[i]; entry; entry = entry->next) {
+ TRACE("%d: %s\n", i - 32768, pathname(entry->dir));
+ if(entry->dir->inode->inode == SQUASHFS_INVALID_BLK) {
+ write_file(&inode, entry->dir, &duplicate_file);
+ INFO("file %s, uncompressed size %lld bytes %s"
+ "\n", pathname(entry->dir),
+ (long long)
+ entry->dir->inode->buf.st_size,
+ duplicate_file ? "DUPLICATE" : "");
+ entry->dir->inode->inode = inode;
+ entry->dir->inode->type = SQUASHFS_FILE_TYPE;
+ } else
+ INFO("file %s, uncompressed size %lld bytes "
+ "LINK\n", pathname(entry->dir),
+ (long long)
+ entry->dir->inode->buf.st_size);
+ }
+}
diff --git a/squashfs-tools/squashfs-tools/sort.h b/squashfs-tools/squashfs-tools/sort.h
new file mode 100644
index 0000000..98db62c
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/sort.h
@@ -0,0 +1,37 @@
+#ifndef SORT_H
+#define SORT_H
+
+/*
+ * Squashfs
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2013
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * sort.h
+ */
+
+struct priority_entry {
+ struct dir_ent *dir;
+ struct priority_entry *next;
+};
+
+extern int read_sort_file(char *, int, char *[]);
+extern void sort_files_and_write(struct dir_info *);
+extern void generate_file_priorities(struct dir_info *, int priority,
+ struct stat *);
+extern struct priority_entry *priority_list[65536];
+#endif
diff --git a/squashfs-tools/squashfs-tools/squashfs_compat.h b/squashfs-tools/squashfs-tools/squashfs_compat.h
new file mode 100644
index 0000000..83b0278
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/squashfs_compat.h
@@ -0,0 +1,818 @@
+#ifndef SQUASHFS_COMPAT
+#define SQUASHFS_COMPAT
+/*
+ * Squashfs
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * squashfs_compat.h
+ */
+
+/*
+ * definitions for structures on disk - layout 3.x
+ */
+
+#define SQUASHFS_CHECK 2
+#define SQUASHFS_CHECK_DATA(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_CHECK)
+
+/* Max number of uids and gids */
+#define SQUASHFS_UIDS 256
+#define SQUASHFS_GUIDS 255
+
+struct squashfs_super_block_3 {
+ unsigned int s_magic;
+ unsigned int inodes;
+ unsigned int bytes_used_2;
+ unsigned int uid_start_2;
+ unsigned int guid_start_2;
+ unsigned int inode_table_start_2;
+ unsigned int directory_table_start_2;
+ unsigned int s_major:16;
+ unsigned int s_minor:16;
+ unsigned int block_size_1:16;
+ unsigned int block_log:16;
+ unsigned int flags:8;
+ unsigned int no_uids:8;
+ unsigned int no_guids:8;
+ int mkfs_time /* time of filesystem creation */;
+ squashfs_inode root_inode;
+ unsigned int block_size;
+ unsigned int fragments;
+ unsigned int fragment_table_start_2;
+ long long bytes_used;
+ long long uid_start;
+ long long guid_start;
+ long long inode_table_start;
+ long long directory_table_start;
+ long long fragment_table_start;
+ long long lookup_table_start;
+} __attribute__ ((packed));
+
+struct squashfs_dir_index_3 {
+ unsigned int index;
+ unsigned int start_block;
+ unsigned char size;
+ unsigned char name[0];
+} __attribute__ ((packed));
+
+struct squashfs_base_inode_header_3 {
+ unsigned int inode_type:4;
+ unsigned int mode:12;
+ unsigned int uid:8;
+ unsigned int guid:8;
+ int mtime;
+ unsigned int inode_number;
+} __attribute__ ((packed));
+
+struct squashfs_ipc_inode_header_3 {
+ unsigned int inode_type:4;
+ unsigned int mode:12;
+ unsigned int uid:8;
+ unsigned int guid:8;
+ int mtime;
+ unsigned int inode_number;
+ unsigned int nlink;
+} __attribute__ ((packed));
+
+struct squashfs_dev_inode_header_3 {
+ unsigned int inode_type:4;
+ unsigned int mode:12;
+ unsigned int uid:8;
+ unsigned int guid:8;
+ int mtime;
+ unsigned int inode_number;
+ unsigned int nlink;
+ unsigned short rdev;
+} __attribute__ ((packed));
+
+struct squashfs_symlink_inode_header_3 {
+ unsigned int inode_type:4;
+ unsigned int mode:12;
+ unsigned int uid:8;
+ unsigned int guid:8;
+ int mtime;
+ unsigned int inode_number;
+ unsigned int nlink;
+ unsigned short symlink_size;
+ char symlink[0];
+} __attribute__ ((packed));
+
+struct squashfs_reg_inode_header_3 {
+ unsigned int inode_type:4;
+ unsigned int mode:12;
+ unsigned int uid:8;
+ unsigned int guid:8;
+ int mtime;
+ unsigned int inode_number;
+ squashfs_block start_block;
+ unsigned int fragment;
+ unsigned int offset;
+ unsigned int file_size;
+ unsigned short block_list[0];
+} __attribute__ ((packed));
+
+struct squashfs_lreg_inode_header_3 {
+ unsigned int inode_type:4;
+ unsigned int mode:12;
+ unsigned int uid:8;
+ unsigned int guid:8;
+ int mtime;
+ unsigned int inode_number;
+ unsigned int nlink;
+ squashfs_block start_block;
+ unsigned int fragment;
+ unsigned int offset;
+ long long file_size;
+ unsigned short block_list[0];
+} __attribute__ ((packed));
+
+struct squashfs_dir_inode_header_3 {
+ unsigned int inode_type:4;
+ unsigned int mode:12;
+ unsigned int uid:8;
+ unsigned int guid:8;
+ int mtime;
+ unsigned int inode_number;
+ unsigned int nlink;
+ unsigned int file_size:19;
+ unsigned int offset:13;
+ unsigned int start_block;
+ unsigned int parent_inode;
+} __attribute__ ((packed));
+
+struct squashfs_ldir_inode_header_3 {
+ unsigned int inode_type:4;
+ unsigned int mode:12;
+ unsigned int uid:8;
+ unsigned int guid:8;
+ int mtime;
+ unsigned int inode_number;
+ unsigned int nlink;
+ unsigned int file_size:27;
+ unsigned int offset:13;
+ unsigned int start_block;
+ unsigned int i_count:16;
+ unsigned int parent_inode;
+ struct squashfs_dir_index_3 index[0];
+} __attribute__ ((packed));
+
+union squashfs_inode_header_3 {
+ struct squashfs_base_inode_header_3 base;
+ struct squashfs_dev_inode_header_3 dev;
+ struct squashfs_symlink_inode_header_3 symlink;
+ struct squashfs_reg_inode_header_3 reg;
+ struct squashfs_lreg_inode_header_3 lreg;
+ struct squashfs_dir_inode_header_3 dir;
+ struct squashfs_ldir_inode_header_3 ldir;
+ struct squashfs_ipc_inode_header_3 ipc;
+};
+
+struct squashfs_dir_entry_3 {
+ unsigned int offset:13;
+ unsigned int type:3;
+ unsigned int size:8;
+ int inode_number:16;
+ char name[0];
+} __attribute__ ((packed));
+
+struct squashfs_dir_header_3 {
+ unsigned int count:8;
+ unsigned int start_block;
+ unsigned int inode_number;
+} __attribute__ ((packed));
+
+struct squashfs_fragment_entry_3 {
+ long long start_block;
+ unsigned int size;
+ unsigned int pending;
+} __attribute__ ((packed));
+
+
+typedef struct squashfs_super_block_3 squashfs_super_block_3;
+typedef struct squashfs_dir_index_3 squashfs_dir_index_3;
+typedef struct squashfs_base_inode_header_3 squashfs_base_inode_header_3;
+typedef struct squashfs_ipc_inode_header_3 squashfs_ipc_inode_header_3;
+typedef struct squashfs_dev_inode_header_3 squashfs_dev_inode_header_3;
+typedef struct squashfs_symlink_inode_header_3 squashfs_symlink_inode_header_3;
+typedef struct squashfs_reg_inode_header_3 squashfs_reg_inode_header_3;
+typedef struct squashfs_lreg_inode_header_3 squashfs_lreg_inode_header_3;
+typedef struct squashfs_dir_inode_header_3 squashfs_dir_inode_header_3;
+typedef struct squashfs_ldir_inode_header_3 squashfs_ldir_inode_header_3;
+typedef struct squashfs_dir_entry_3 squashfs_dir_entry_3;
+typedef struct squashfs_dir_header_3 squashfs_dir_header_3;
+typedef struct squashfs_fragment_entry_3 squashfs_fragment_entry_3;
+
+/*
+ * macros to convert each packed bitfield structure from little endian to big
+ * endian and vice versa. These are needed when creating or using a filesystem
+ * on a machine with different byte ordering to the target architecture.
+ *
+ */
+
+#define SQUASHFS_SWAP_START \
+ int bits;\
+ int b_pos;\
+ unsigned long long val;\
+ unsigned char *s;\
+ unsigned char *d;
+
+#define SQUASHFS_SWAP_SUPER_BLOCK_3(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_super_block_3));\
+ SQUASHFS_SWAP((s)->s_magic, d, 0, 32);\
+ SQUASHFS_SWAP((s)->inodes, d, 32, 32);\
+ SQUASHFS_SWAP((s)->bytes_used_2, d, 64, 32);\
+ SQUASHFS_SWAP((s)->uid_start_2, d, 96, 32);\
+ SQUASHFS_SWAP((s)->guid_start_2, d, 128, 32);\
+ SQUASHFS_SWAP((s)->inode_table_start_2, d, 160, 32);\
+ SQUASHFS_SWAP((s)->directory_table_start_2, d, 192, 32);\
+ SQUASHFS_SWAP((s)->s_major, d, 224, 16);\
+ SQUASHFS_SWAP((s)->s_minor, d, 240, 16);\
+ SQUASHFS_SWAP((s)->block_size_1, d, 256, 16);\
+ SQUASHFS_SWAP((s)->block_log, d, 272, 16);\
+ SQUASHFS_SWAP((s)->flags, d, 288, 8);\
+ SQUASHFS_SWAP((s)->no_uids, d, 296, 8);\
+ SQUASHFS_SWAP((s)->no_guids, d, 304, 8);\
+ SQUASHFS_SWAP((s)->mkfs_time, d, 312, 32);\
+ SQUASHFS_SWAP((s)->root_inode, d, 344, 64);\
+ SQUASHFS_SWAP((s)->block_size, d, 408, 32);\
+ SQUASHFS_SWAP((s)->fragments, d, 440, 32);\
+ SQUASHFS_SWAP((s)->fragment_table_start_2, d, 472, 32);\
+ SQUASHFS_SWAP((s)->bytes_used, d, 504, 64);\
+ SQUASHFS_SWAP((s)->uid_start, d, 568, 64);\
+ SQUASHFS_SWAP((s)->guid_start, d, 632, 64);\
+ SQUASHFS_SWAP((s)->inode_table_start, d, 696, 64);\
+ SQUASHFS_SWAP((s)->directory_table_start, d, 760, 64);\
+ SQUASHFS_SWAP((s)->fragment_table_start, d, 824, 64);\
+ SQUASHFS_SWAP((s)->lookup_table_start, d, 888, 64);\
+}
+
+#define SQUASHFS_SWAP_BASE_INODE_CORE_3(s, d, n)\
+ SQUASHFS_MEMSET(s, d, n);\
+ SQUASHFS_SWAP((s)->inode_type, d, 0, 4);\
+ SQUASHFS_SWAP((s)->mode, d, 4, 12);\
+ SQUASHFS_SWAP((s)->uid, d, 16, 8);\
+ SQUASHFS_SWAP((s)->guid, d, 24, 8);\
+ SQUASHFS_SWAP((s)->mtime, d, 32, 32);\
+ SQUASHFS_SWAP((s)->inode_number, d, 64, 32);
+
+#define SQUASHFS_SWAP_BASE_INODE_HEADER_3(s, d, n) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_3(s, d, n)\
+}
+
+#define SQUASHFS_SWAP_IPC_INODE_HEADER_3(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_3(s, d, \
+ sizeof(struct squashfs_ipc_inode_header_3))\
+ SQUASHFS_SWAP((s)->nlink, d, 96, 32);\
+}
+
+#define SQUASHFS_SWAP_DEV_INODE_HEADER_3(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_3(s, d, \
+ sizeof(struct squashfs_dev_inode_header_3)); \
+ SQUASHFS_SWAP((s)->nlink, d, 96, 32);\
+ SQUASHFS_SWAP((s)->rdev, d, 128, 16);\
+}
+
+#define SQUASHFS_SWAP_SYMLINK_INODE_HEADER_3(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_3(s, d, \
+ sizeof(struct squashfs_symlink_inode_header_3));\
+ SQUASHFS_SWAP((s)->nlink, d, 96, 32);\
+ SQUASHFS_SWAP((s)->symlink_size, d, 128, 16);\
+}
+
+#define SQUASHFS_SWAP_REG_INODE_HEADER_3(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_3(s, d, \
+ sizeof(struct squashfs_reg_inode_header_3));\
+ SQUASHFS_SWAP((s)->start_block, d, 96, 64);\
+ SQUASHFS_SWAP((s)->fragment, d, 160, 32);\
+ SQUASHFS_SWAP((s)->offset, d, 192, 32);\
+ SQUASHFS_SWAP((s)->file_size, d, 224, 32);\
+}
+
+#define SQUASHFS_SWAP_LREG_INODE_HEADER_3(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_3(s, d, \
+ sizeof(struct squashfs_lreg_inode_header_3));\
+ SQUASHFS_SWAP((s)->nlink, d, 96, 32);\
+ SQUASHFS_SWAP((s)->start_block, d, 128, 64);\
+ SQUASHFS_SWAP((s)->fragment, d, 192, 32);\
+ SQUASHFS_SWAP((s)->offset, d, 224, 32);\
+ SQUASHFS_SWAP((s)->file_size, d, 256, 64);\
+}
+
+#define SQUASHFS_SWAP_DIR_INODE_HEADER_3(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_3(s, d, \
+ sizeof(struct squashfs_dir_inode_header_3));\
+ SQUASHFS_SWAP((s)->nlink, d, 96, 32);\
+ SQUASHFS_SWAP((s)->file_size, d, 128, 19);\
+ SQUASHFS_SWAP((s)->offset, d, 147, 13);\
+ SQUASHFS_SWAP((s)->start_block, d, 160, 32);\
+ SQUASHFS_SWAP((s)->parent_inode, d, 192, 32);\
+}
+
+#define SQUASHFS_SWAP_LDIR_INODE_HEADER_3(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_3(s, d, \
+ sizeof(struct squashfs_ldir_inode_header_3));\
+ SQUASHFS_SWAP((s)->nlink, d, 96, 32);\
+ SQUASHFS_SWAP((s)->file_size, d, 128, 27);\
+ SQUASHFS_SWAP((s)->offset, d, 155, 13);\
+ SQUASHFS_SWAP((s)->start_block, d, 168, 32);\
+ SQUASHFS_SWAP((s)->i_count, d, 200, 16);\
+ SQUASHFS_SWAP((s)->parent_inode, d, 216, 32);\
+}
+
+#define SQUASHFS_SWAP_DIR_INDEX_3(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_index_3));\
+ SQUASHFS_SWAP((s)->index, d, 0, 32);\
+ SQUASHFS_SWAP((s)->start_block, d, 32, 32);\
+ SQUASHFS_SWAP((s)->size, d, 64, 8);\
+}
+
+#define SQUASHFS_SWAP_DIR_HEADER_3(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_header_3));\
+ SQUASHFS_SWAP((s)->count, d, 0, 8);\
+ SQUASHFS_SWAP((s)->start_block, d, 8, 32);\
+ SQUASHFS_SWAP((s)->inode_number, d, 40, 32);\
+}
+
+#define SQUASHFS_SWAP_DIR_ENTRY_3(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_entry_3));\
+ SQUASHFS_SWAP((s)->offset, d, 0, 13);\
+ SQUASHFS_SWAP((s)->type, d, 13, 3);\
+ SQUASHFS_SWAP((s)->size, d, 16, 8);\
+ SQUASHFS_SWAP((s)->inode_number, d, 24, 16);\
+}
+
+#define SQUASHFS_SWAP_INODE_T_3(s, d) SQUASHFS_SWAP_LONG_LONGS_3(s, d, 1)
+
+#define SQUASHFS_SWAP_SHORTS_3(s, d, n) {\
+ int entry;\
+ int bit_position;\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_MEMSET(s, d, n * 2);\
+ for(entry = 0, bit_position = 0; entry < n; entry++, bit_position += \
+ 16)\
+ SQUASHFS_SWAP(s[entry], d, bit_position, 16);\
+}
+
+#define SQUASHFS_SWAP_INTS_3(s, d, n) {\
+ int entry;\
+ int bit_position;\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_MEMSET(s, d, n * 4);\
+ for(entry = 0, bit_position = 0; entry < n; entry++, bit_position += \
+ 32)\
+ SQUASHFS_SWAP(s[entry], d, bit_position, 32);\
+}
+
+#define SQUASHFS_SWAP_LONG_LONGS_3(s, d, n) {\
+ int entry;\
+ int bit_position;\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_MEMSET(s, d, n * 8);\
+ for(entry = 0, bit_position = 0; entry < n; entry++, bit_position += \
+ 64)\
+ SQUASHFS_SWAP(s[entry], d, bit_position, 64);\
+}
+
+#define SQUASHFS_SWAP_DATA(s, d, n, bits) {\
+ int entry;\
+ int bit_position;\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_MEMSET(s, d, n * bits / 8);\
+ for(entry = 0, bit_position = 0; entry < n; entry++, bit_position += \
+ bits)\
+ SQUASHFS_SWAP(s[entry], d, bit_position, bits);\
+}
+
+#define SQUASHFS_SWAP_FRAGMENT_INDEXES_3(s, d, n) SQUASHFS_SWAP_LONG_LONGS_3(s, d, n)
+#define SQUASHFS_SWAP_LOOKUP_BLOCKS_3(s, d, n) SQUASHFS_SWAP_LONG_LONGS_3(s, d, n)
+
+#define SQUASHFS_SWAP_FRAGMENT_ENTRY_3(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_fragment_entry_3));\
+ SQUASHFS_SWAP((s)->start_block, d, 0, 64);\
+ SQUASHFS_SWAP((s)->size, d, 64, 32);\
+}
+
+/* fragment and fragment table defines */
+#define SQUASHFS_FRAGMENT_BYTES_3(A) ((A) * sizeof(struct squashfs_fragment_entry_3))
+
+#define SQUASHFS_FRAGMENT_INDEX_3(A) (SQUASHFS_FRAGMENT_BYTES_3(A) / \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_FRAGMENT_INDEX_OFFSET_3(A) (SQUASHFS_FRAGMENT_BYTES_3(A) % \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_FRAGMENT_INDEXES_3(A) ((SQUASHFS_FRAGMENT_BYTES_3(A) + \
+ SQUASHFS_METADATA_SIZE - 1) / \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_FRAGMENT_INDEX_BYTES_3(A) (SQUASHFS_FRAGMENT_INDEXES_3(A) *\
+ sizeof(long long))
+
+/*
+ * definitions for structures on disk - layout 1.x
+ */
+#define SQUASHFS_TYPES 5
+#define SQUASHFS_IPC_TYPE 0
+
+struct squashfs_base_inode_header_1 {
+ unsigned int inode_type:4;
+ unsigned int mode:12; /* protection */
+ unsigned int uid:4; /* index into uid table */
+ unsigned int guid:4; /* index into guid table */
+} __attribute__ ((packed));
+
+struct squashfs_ipc_inode_header_1 {
+ unsigned int inode_type:4;
+ unsigned int mode:12; /* protection */
+ unsigned int uid:4; /* index into uid table */
+ unsigned int guid:4; /* index into guid table */
+ unsigned int type:4;
+ unsigned int offset:4;
+} __attribute__ ((packed));
+
+struct squashfs_dev_inode_header_1 {
+ unsigned int inode_type:4;
+ unsigned int mode:12; /* protection */
+ unsigned int uid:4; /* index into uid table */
+ unsigned int guid:4; /* index into guid table */
+ unsigned short rdev;
+} __attribute__ ((packed));
+
+struct squashfs_symlink_inode_header_1 {
+ unsigned int inode_type:4;
+ unsigned int mode:12; /* protection */
+ unsigned int uid:4; /* index into uid table */
+ unsigned int guid:4; /* index into guid table */
+ unsigned short symlink_size;
+ char symlink[0];
+} __attribute__ ((packed));
+
+struct squashfs_reg_inode_header_1 {
+ unsigned int inode_type:4;
+ unsigned int mode:12; /* protection */
+ unsigned int uid:4; /* index into uid table */
+ unsigned int guid:4; /* index into guid table */
+ int mtime;
+ unsigned int start_block;
+ unsigned int file_size:32;
+ unsigned short block_list[0];
+} __attribute__ ((packed));
+
+struct squashfs_dir_inode_header_1 {
+ unsigned int inode_type:4;
+ unsigned int mode:12; /* protection */
+ unsigned int uid:4; /* index into uid table */
+ unsigned int guid:4; /* index into guid table */
+ unsigned int file_size:19;
+ unsigned int offset:13;
+ int mtime;
+ unsigned int start_block:24;
+} __attribute__ ((packed));
+
+union squashfs_inode_header_1 {
+ struct squashfs_base_inode_header_1 base;
+ struct squashfs_dev_inode_header_1 dev;
+ struct squashfs_symlink_inode_header_1 symlink;
+ struct squashfs_reg_inode_header_1 reg;
+ struct squashfs_dir_inode_header_1 dir;
+ struct squashfs_ipc_inode_header_1 ipc;
+};
+
+typedef struct squashfs_dir_index_1 squashfs_dir_index_1;
+typedef struct squashfs_base_inode_header_1 squashfs_base_inode_header_1;
+typedef struct squashfs_ipc_inode_header_1 squashfs_ipc_inode_header_1;
+typedef struct squashfs_dev_inode_header_1 squashfs_dev_inode_header_1;
+typedef struct squashfs_symlink_inode_header_1 squashfs_symlink_inode_header_1;
+typedef struct squashfs_reg_inode_header_1 squashfs_reg_inode_header_1;
+typedef struct squashfs_dir_inode_header_1 squashfs_dir_inode_header_1;
+
+#define SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, n) \
+ SQUASHFS_MEMSET(s, d, n);\
+ SQUASHFS_SWAP((s)->inode_type, d, 0, 4);\
+ SQUASHFS_SWAP((s)->mode, d, 4, 12);\
+ SQUASHFS_SWAP((s)->uid, d, 16, 4);\
+ SQUASHFS_SWAP((s)->guid, d, 20, 4);
+
+#define SQUASHFS_SWAP_BASE_INODE_HEADER_1(s, d, n) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, n)\
+}
+
+#define SQUASHFS_SWAP_IPC_INODE_HEADER_1(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \
+ sizeof(struct squashfs_ipc_inode_header_1));\
+ SQUASHFS_SWAP((s)->type, d, 24, 4);\
+ SQUASHFS_SWAP((s)->offset, d, 28, 4);\
+}
+
+#define SQUASHFS_SWAP_DEV_INODE_HEADER_1(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \
+ sizeof(struct squashfs_dev_inode_header_1));\
+ SQUASHFS_SWAP((s)->rdev, d, 24, 16);\
+}
+
+#define SQUASHFS_SWAP_SYMLINK_INODE_HEADER_1(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \
+ sizeof(struct squashfs_symlink_inode_header_1));\
+ SQUASHFS_SWAP((s)->symlink_size, d, 24, 16);\
+}
+
+#define SQUASHFS_SWAP_REG_INODE_HEADER_1(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \
+ sizeof(struct squashfs_reg_inode_header_1));\
+ SQUASHFS_SWAP((s)->mtime, d, 24, 32);\
+ SQUASHFS_SWAP((s)->start_block, d, 56, 32);\
+ SQUASHFS_SWAP((s)->file_size, d, 88, 32);\
+}
+
+#define SQUASHFS_SWAP_DIR_INODE_HEADER_1(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \
+ sizeof(struct squashfs_dir_inode_header_1));\
+ SQUASHFS_SWAP((s)->file_size, d, 24, 19);\
+ SQUASHFS_SWAP((s)->offset, d, 43, 13);\
+ SQUASHFS_SWAP((s)->mtime, d, 56, 32);\
+ SQUASHFS_SWAP((s)->start_block, d, 88, 24);\
+}
+
+/*
+ * definitions for structures on disk - layout 2.x
+ */
+struct squashfs_dir_index_2 {
+ unsigned int index:27;
+ unsigned int start_block:29;
+ unsigned char size;
+ unsigned char name[0];
+} __attribute__ ((packed));
+
+struct squashfs_base_inode_header_2 {
+ unsigned int inode_type:4;
+ unsigned int mode:12; /* protection */
+ unsigned int uid:8; /* index into uid table */
+ unsigned int guid:8; /* index into guid table */
+} __attribute__ ((packed));
+
+struct squashfs_ipc_inode_header_2 {
+ unsigned int inode_type:4;
+ unsigned int mode:12; /* protection */
+ unsigned int uid:8; /* index into uid table */
+ unsigned int guid:8; /* index into guid table */
+} __attribute__ ((packed));
+
+struct squashfs_dev_inode_header_2 {
+ unsigned int inode_type:4;
+ unsigned int mode:12; /* protection */
+ unsigned int uid:8; /* index into uid table */
+ unsigned int guid:8; /* index into guid table */
+ unsigned short rdev;
+} __attribute__ ((packed));
+
+struct squashfs_symlink_inode_header_2 {
+ unsigned int inode_type:4;
+ unsigned int mode:12; /* protection */
+ unsigned int uid:8; /* index into uid table */
+ unsigned int guid:8; /* index into guid table */
+ unsigned short symlink_size;
+ char symlink[0];
+} __attribute__ ((packed));
+
+struct squashfs_reg_inode_header_2 {
+ unsigned int inode_type:4;
+ unsigned int mode:12; /* protection */
+ unsigned int uid:8; /* index into uid table */
+ unsigned int guid:8; /* index into guid table */
+ int mtime;
+ unsigned int start_block;
+ unsigned int fragment;
+ unsigned int offset;
+ unsigned int file_size:32;
+ unsigned short block_list[0];
+} __attribute__ ((packed));
+
+struct squashfs_dir_inode_header_2 {
+ unsigned int inode_type:4;
+ unsigned int mode:12; /* protection */
+ unsigned int uid:8; /* index into uid table */
+ unsigned int guid:8; /* index into guid table */
+ unsigned int file_size:19;
+ unsigned int offset:13;
+ int mtime;
+ unsigned int start_block:24;
+} __attribute__ ((packed));
+
+struct squashfs_ldir_inode_header_2 {
+ unsigned int inode_type:4;
+ unsigned int mode:12; /* protection */
+ unsigned int uid:8; /* index into uid table */
+ unsigned int guid:8; /* index into guid table */
+ unsigned int file_size:27;
+ unsigned int offset:13;
+ int mtime;
+ unsigned int start_block:24;
+ unsigned int i_count:16;
+ struct squashfs_dir_index_2 index[0];
+} __attribute__ ((packed));
+
+union squashfs_inode_header_2 {
+ struct squashfs_base_inode_header_2 base;
+ struct squashfs_dev_inode_header_2 dev;
+ struct squashfs_symlink_inode_header_2 symlink;
+ struct squashfs_reg_inode_header_2 reg;
+ struct squashfs_dir_inode_header_2 dir;
+ struct squashfs_ldir_inode_header_2 ldir;
+ struct squashfs_ipc_inode_header_2 ipc;
+};
+
+struct squashfs_dir_header_2 {
+ unsigned int count:8;
+ unsigned int start_block:24;
+} __attribute__ ((packed));
+
+struct squashfs_dir_entry_2 {
+ unsigned int offset:13;
+ unsigned int type:3;
+ unsigned int size:8;
+ char name[0];
+} __attribute__ ((packed));
+
+struct squashfs_fragment_entry_2 {
+ unsigned int start_block;
+ unsigned int size;
+} __attribute__ ((packed));
+
+typedef struct squashfs_dir_index_2 squashfs_dir_index_2;
+typedef struct squashfs_base_inode_header_2 squashfs_base_inode_header_2;
+typedef struct squashfs_ipc_inode_header_2 squashfs_ipc_inode_header_2;
+typedef struct squashfs_dev_inode_header_2 squashfs_dev_inode_header_2;
+typedef struct squashfs_symlink_inode_header_2 squashfs_symlink_inode_header_2;
+typedef struct squashfs_reg_inode_header_2 squashfs_reg_inode_header_2;
+typedef struct squashfs_lreg_inode_header_2 squashfs_lreg_inode_header_2;
+typedef struct squashfs_dir_inode_header_2 squashfs_dir_inode_header_2;
+typedef struct squashfs_ldir_inode_header_2 squashfs_ldir_inode_header_2;
+typedef struct squashfs_dir_entry_2 squashfs_dir_entry_2;
+typedef struct squashfs_dir_header_2 squashfs_dir_header_2;
+typedef struct squashfs_fragment_entry_2 squashfs_fragment_entry_2;
+
+#define SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, n)\
+ SQUASHFS_MEMSET(s, d, n);\
+ SQUASHFS_SWAP((s)->inode_type, d, 0, 4);\
+ SQUASHFS_SWAP((s)->mode, d, 4, 12);\
+ SQUASHFS_SWAP((s)->uid, d, 16, 8);\
+ SQUASHFS_SWAP((s)->guid, d, 24, 8);\
+
+#define SQUASHFS_SWAP_BASE_INODE_HEADER_2(s, d, n) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, n)\
+}
+
+#define SQUASHFS_SWAP_IPC_INODE_HEADER_2(s, d) \
+ SQUASHFS_SWAP_BASE_INODE_HEADER_2(s, d, sizeof(struct squashfs_ipc_inode_header_2))
+
+#define SQUASHFS_SWAP_DEV_INODE_HEADER_2(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \
+ sizeof(struct squashfs_dev_inode_header_2)); \
+ SQUASHFS_SWAP((s)->rdev, d, 32, 16);\
+}
+
+#define SQUASHFS_SWAP_SYMLINK_INODE_HEADER_2(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \
+ sizeof(struct squashfs_symlink_inode_header_2));\
+ SQUASHFS_SWAP((s)->symlink_size, d, 32, 16);\
+}
+
+#define SQUASHFS_SWAP_REG_INODE_HEADER_2(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \
+ sizeof(struct squashfs_reg_inode_header_2));\
+ SQUASHFS_SWAP((s)->mtime, d, 32, 32);\
+ SQUASHFS_SWAP((s)->start_block, d, 64, 32);\
+ SQUASHFS_SWAP((s)->fragment, d, 96, 32);\
+ SQUASHFS_SWAP((s)->offset, d, 128, 32);\
+ SQUASHFS_SWAP((s)->file_size, d, 160, 32);\
+}
+
+#define SQUASHFS_SWAP_DIR_INODE_HEADER_2(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \
+ sizeof(struct squashfs_dir_inode_header_2));\
+ SQUASHFS_SWAP((s)->file_size, d, 32, 19);\
+ SQUASHFS_SWAP((s)->offset, d, 51, 13);\
+ SQUASHFS_SWAP((s)->mtime, d, 64, 32);\
+ SQUASHFS_SWAP((s)->start_block, d, 96, 24);\
+}
+
+#define SQUASHFS_SWAP_LDIR_INODE_HEADER_2(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \
+ sizeof(struct squashfs_ldir_inode_header_2));\
+ SQUASHFS_SWAP((s)->file_size, d, 32, 27);\
+ SQUASHFS_SWAP((s)->offset, d, 59, 13);\
+ SQUASHFS_SWAP((s)->mtime, d, 72, 32);\
+ SQUASHFS_SWAP((s)->start_block, d, 104, 24);\
+ SQUASHFS_SWAP((s)->i_count, d, 128, 16);\
+}
+
+#define SQUASHFS_SWAP_DIR_INDEX_2(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_index_2));\
+ SQUASHFS_SWAP((s)->index, d, 0, 27);\
+ SQUASHFS_SWAP((s)->start_block, d, 27, 29);\
+ SQUASHFS_SWAP((s)->size, d, 56, 8);\
+}
+#define SQUASHFS_SWAP_DIR_HEADER_2(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_header_2));\
+ SQUASHFS_SWAP((s)->count, d, 0, 8);\
+ SQUASHFS_SWAP((s)->start_block, d, 8, 24);\
+}
+
+#define SQUASHFS_SWAP_DIR_ENTRY_2(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_entry_2));\
+ SQUASHFS_SWAP((s)->offset, d, 0, 13);\
+ SQUASHFS_SWAP((s)->type, d, 13, 3);\
+ SQUASHFS_SWAP((s)->size, d, 16, 8);\
+}
+
+#define SQUASHFS_SWAP_FRAGMENT_ENTRY_2(s, d) {\
+ SQUASHFS_SWAP_START\
+ SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_fragment_entry_2));\
+ SQUASHFS_SWAP((s)->start_block, d, 0, 32);\
+ SQUASHFS_SWAP((s)->size, d, 32, 32);\
+}
+
+#define SQUASHFS_SWAP_FRAGMENT_INDEXES_2(s, d, n) SQUASHFS_SWAP_INTS_3(s, d, n)
+
+/* fragment and fragment table defines */
+#define SQUASHFS_FRAGMENT_BYTES_2(A) ((A) * sizeof(struct squashfs_fragment_entry_2))
+
+#define SQUASHFS_FRAGMENT_INDEX_2(A) (SQUASHFS_FRAGMENT_BYTES_2(A) / \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_FRAGMENT_INDEX_OFFSET_2(A) (SQUASHFS_FRAGMENT_BYTES_2(A) % \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_FRAGMENT_INDEXES_2(A) ((SQUASHFS_FRAGMENT_BYTES_2(A) + \
+ SQUASHFS_METADATA_SIZE - 1) / \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_FRAGMENT_INDEX_BYTES_2(A) (SQUASHFS_FRAGMENT_INDEXES_2(A) *\
+ sizeof(int))
+/*
+ * macros used to swap each structure entry, taking into account
+ * bitfields and different bitfield placing conventions on differing architectures
+ */
+#if __BYTE_ORDER == __BIG_ENDIAN
+ /* convert from big endian to little endian */
+#define SQUASHFS_SWAP(value, p, pos, tbits) _SQUASHFS_SWAP(value, p, pos, tbits, b_pos)
+#else
+ /* convert from little endian to big endian */
+#define SQUASHFS_SWAP(value, p, pos, tbits) _SQUASHFS_SWAP(value, p, pos, tbits, 64 - tbits - b_pos)
+#endif
+
+#define _SQUASHFS_SWAP(value, p, pos, tbits, SHIFT) {\
+ b_pos = pos % 8;\
+ val = 0;\
+ s = (unsigned char *)p + (pos / 8);\
+ d = ((unsigned char *) &val) + 7;\
+ for(bits = 0; bits < (tbits + b_pos); bits += 8) \
+ *d-- = *s++;\
+ value = (val >> (SHIFT))/* & ((1 << tbits) - 1)*/;\
+}
+#define SQUASHFS_MEMSET(s, d, n) memset(s, 0, n);
+#endif
diff --git a/squashfs-tools/squashfs-tools/squashfs_fs.h b/squashfs-tools/squashfs-tools/squashfs_fs.h
new file mode 100644
index 0000000..791fe12
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/squashfs_fs.h
@@ -0,0 +1,491 @@
+#ifndef SQUASHFS_FS
+#define SQUASHFS_FS
+/*
+ * Squashfs
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012,
+ * 2013, 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * squashfs_fs.h
+ */
+
+#define SQUASHFS_CACHED_FRAGMENTS CONFIG_SQUASHFS_FRAGMENT_CACHE_SIZE
+#define SQUASHFS_MAJOR 4
+#define SQUASHFS_MINOR 0
+#define SQUASHFS_MAGIC 0x73717368
+#define SQUASHFS_MAGIC_SWAP 0x68737173
+#define SQUASHFS_START 0
+
+/* size of metadata (inode and directory) blocks */
+#define SQUASHFS_METADATA_SIZE 8192
+#define SQUASHFS_METADATA_LOG 13
+
+/* default size of data blocks */
+#define SQUASHFS_FILE_SIZE 131072
+
+#define SQUASHFS_FILE_MAX_SIZE 1048576
+#define SQUASHFS_FILE_MAX_LOG 20
+
+/* Max number of uids and gids */
+#define SQUASHFS_IDS 65536
+
+/* Max length of filename (not 255) */
+#define SQUASHFS_NAME_LEN 256
+
+#define SQUASHFS_INVALID ((long long) 0xffffffffffff)
+#define SQUASHFS_INVALID_FRAG ((unsigned int) 0xffffffff)
+#define SQUASHFS_INVALID_XATTR ((unsigned int) 0xffffffff)
+#define SQUASHFS_INVALID_BLK ((long long) -1)
+#define SQUASHFS_USED_BLK ((long long) -2)
+
+/* Filesystem flags */
+#define SQUASHFS_NOI 0
+#define SQUASHFS_NOD 1
+#define SQUASHFS_CHECK 2
+#define SQUASHFS_NOF 3
+#define SQUASHFS_NO_FRAG 4
+#define SQUASHFS_ALWAYS_FRAG 5
+#define SQUASHFS_DUPLICATE 6
+#define SQUASHFS_EXPORT 7
+#define SQUASHFS_NOX 8
+#define SQUASHFS_NO_XATTR 9
+#define SQUASHFS_COMP_OPT 10
+
+#define SQUASHFS_BIT(flag, bit) ((flag >> bit) & 1)
+
+#define SQUASHFS_UNCOMPRESSED_INODES(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_NOI)
+
+#define SQUASHFS_UNCOMPRESSED_DATA(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_NOD)
+
+#define SQUASHFS_UNCOMPRESSED_FRAGMENTS(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_NOF)
+
+#define SQUASHFS_NO_FRAGMENTS(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_NO_FRAG)
+
+#define SQUASHFS_ALWAYS_FRAGMENTS(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_ALWAYS_FRAG)
+
+#define SQUASHFS_DUPLICATES(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_DUPLICATE)
+
+#define SQUASHFS_EXPORTABLE(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_EXPORT)
+
+#define SQUASHFS_UNCOMPRESSED_XATTRS(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_NOX)
+
+#define SQUASHFS_NO_XATTRS(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_NO_XATTR)
+
+#define SQUASHFS_COMP_OPTS(flags) SQUASHFS_BIT(flags, \
+ SQUASHFS_COMP_OPT)
+
+#define SQUASHFS_MKFLAGS(noi, nod, nof, nox, no_frag, always_frag, \
+ duplicate_checking, exportable, no_xattr, comp_opt) (noi | \
+ (nod << 1) | (nof << 3) | (no_frag << 4) | \
+ (always_frag << 5) | (duplicate_checking << 6) | \
+ (exportable << 7) | (nox << 8) | (no_xattr << 9) | \
+ (comp_opt << 10))
+
+/* Max number of types and file types */
+#define SQUASHFS_DIR_TYPE 1
+#define SQUASHFS_FILE_TYPE 2
+#define SQUASHFS_SYMLINK_TYPE 3
+#define SQUASHFS_BLKDEV_TYPE 4
+#define SQUASHFS_CHRDEV_TYPE 5
+#define SQUASHFS_FIFO_TYPE 6
+#define SQUASHFS_SOCKET_TYPE 7
+#define SQUASHFS_LDIR_TYPE 8
+#define SQUASHFS_LREG_TYPE 9
+#define SQUASHFS_LSYMLINK_TYPE 10
+#define SQUASHFS_LBLKDEV_TYPE 11
+#define SQUASHFS_LCHRDEV_TYPE 12
+#define SQUASHFS_LFIFO_TYPE 13
+#define SQUASHFS_LSOCKET_TYPE 14
+
+/* Xattr types */
+#define SQUASHFS_XATTR_USER 0
+#define SQUASHFS_XATTR_TRUSTED 1
+#define SQUASHFS_XATTR_SECURITY 2
+#define SQUASHFS_XATTR_VALUE_OOL 256
+#define SQUASHFS_XATTR_PREFIX_MASK 0xff
+
+/* Flag whether block is compressed or uncompressed, bit is set if block is
+ * uncompressed */
+#define SQUASHFS_COMPRESSED_BIT (1 << 15)
+
+#define SQUASHFS_COMPRESSED_SIZE(B) (((B) & ~SQUASHFS_COMPRESSED_BIT) ? \
+ (B) & ~SQUASHFS_COMPRESSED_BIT : SQUASHFS_COMPRESSED_BIT)
+
+#define SQUASHFS_COMPRESSED(B) (!((B) & SQUASHFS_COMPRESSED_BIT))
+
+#define SQUASHFS_COMPRESSED_BIT_BLOCK (1 << 24)
+
+#define SQUASHFS_COMPRESSED_SIZE_BLOCK(B) ((B) & \
+ ~SQUASHFS_COMPRESSED_BIT_BLOCK)
+
+#define SQUASHFS_COMPRESSED_BLOCK(B) (!((B) & SQUASHFS_COMPRESSED_BIT_BLOCK))
+
+/*
+ * Inode number ops. Inodes consist of a compressed block number, and an
+ * uncompressed offset within that block
+ */
+#define SQUASHFS_INODE_BLK(a) ((unsigned int) ((a) >> 16))
+
+#define SQUASHFS_INODE_OFFSET(a) ((unsigned int) ((a) & 0xffff))
+
+#define SQUASHFS_MKINODE(A, B) ((squashfs_inode)(((squashfs_inode) (A)\
+ << 16) + (B)))
+
+/* Compute 32 bit VFS inode number from squashfs inode number */
+#define SQUASHFS_MK_VFS_INODE(a, b) ((unsigned int) (((a) << 8) + \
+ ((b) >> 2) + 1))
+
+/* Translate between VFS mode and squashfs mode */
+#define SQUASHFS_MODE(a) ((a) & 0xfff)
+
+/* fragment and fragment table defines */
+#define SQUASHFS_FRAGMENT_BYTES(A) ((A) * \
+ sizeof(struct squashfs_fragment_entry))
+
+#define SQUASHFS_FRAGMENT_INDEX(A) (SQUASHFS_FRAGMENT_BYTES(A) / \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_FRAGMENT_INDEX_OFFSET(A) (SQUASHFS_FRAGMENT_BYTES(A) % \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_FRAGMENT_INDEXES(A) ((SQUASHFS_FRAGMENT_BYTES(A) + \
+ SQUASHFS_METADATA_SIZE - 1) / \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_FRAGMENT_INDEX_BYTES(A) (SQUASHFS_FRAGMENT_INDEXES(A) *\
+ sizeof(long long))
+
+/* inode lookup table defines */
+#define SQUASHFS_LOOKUP_BYTES(A) ((A) * sizeof(squashfs_inode))
+
+#define SQUASHFS_LOOKUP_BLOCK(A) (SQUASHFS_LOOKUP_BYTES(A) / \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_LOOKUP_BLOCK_OFFSET(A) (SQUASHFS_LOOKUP_BYTES(A) % \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_LOOKUP_BLOCKS(A) ((SQUASHFS_LOOKUP_BYTES(A) + \
+ SQUASHFS_METADATA_SIZE - 1) / \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_LOOKUP_BLOCK_BYTES(A) (SQUASHFS_LOOKUP_BLOCKS(A) *\
+ sizeof(long long))
+
+/* uid lookup table defines */
+#define SQUASHFS_ID_BYTES(A) ((A) * sizeof(unsigned int))
+
+#define SQUASHFS_ID_BLOCK(A) (SQUASHFS_ID_BYTES(A) / \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_ID_BLOCK_OFFSET(A) (SQUASHFS_ID_BYTES(A) % \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_ID_BLOCKS(A) ((SQUASHFS_ID_BYTES(A) + \
+ SQUASHFS_METADATA_SIZE - 1) / \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_ID_BLOCK_BYTES(A) (SQUASHFS_ID_BLOCKS(A) *\
+ sizeof(long long))
+
+/* xattr id lookup table defines */
+#define SQUASHFS_XATTR_BYTES(A) ((A) * sizeof(struct squashfs_xattr_id))
+
+#define SQUASHFS_XATTR_BLOCK(A) (SQUASHFS_XATTR_BYTES(A) / \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_XATTR_BLOCK_OFFSET(A) (SQUASHFS_XATTR_BYTES(A) % \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_XATTR_BLOCKS(A) ((SQUASHFS_XATTR_BYTES(A) + \
+ SQUASHFS_METADATA_SIZE - 1) / \
+ SQUASHFS_METADATA_SIZE)
+
+#define SQUASHFS_XATTR_BLOCK_BYTES(A) (SQUASHFS_XATTR_BLOCKS(A) *\
+ sizeof(long long))
+
+#define SQUASHFS_XATTR_BLK(A) ((unsigned int) ((A) >> 16))
+
+#define SQUASHFS_XATTR_OFFSET(A) ((unsigned int) ((A) & 0xffff))
+
+/* cached data constants for filesystem */
+#define SQUASHFS_CACHED_BLKS 8
+
+#define SQUASHFS_MAX_FILE_SIZE_LOG 64
+
+#define SQUASHFS_MAX_FILE_SIZE ((long long) 1 << \
+ (SQUASHFS_MAX_FILE_SIZE_LOG - 2))
+
+#define SQUASHFS_MARKER_BYTE 0xff
+
+/* meta index cache */
+#define SQUASHFS_META_INDEXES (SQUASHFS_METADATA_SIZE / sizeof(unsigned int))
+#define SQUASHFS_META_ENTRIES 31
+#define SQUASHFS_META_NUMBER 8
+#define SQUASHFS_SLOTS 4
+
+struct meta_entry {
+ long long data_block;
+ unsigned int index_block;
+ unsigned short offset;
+ unsigned short pad;
+};
+
+struct meta_index {
+ unsigned int inode_number;
+ unsigned int offset;
+ unsigned short entries;
+ unsigned short skip;
+ unsigned short locked;
+ unsigned short pad;
+ struct meta_entry meta_entry[SQUASHFS_META_ENTRIES];
+};
+
+
+/*
+ * definitions for structures on disk
+ */
+
+typedef long long squashfs_block;
+typedef long long squashfs_inode;
+
+#define ZLIB_COMPRESSION 1
+#define LZMA_COMPRESSION 2
+#define LZO_COMPRESSION 3
+#define XZ_COMPRESSION 4
+#define LZ4_COMPRESSION 5
+
+struct squashfs_super_block {
+ unsigned int s_magic;
+ unsigned int inodes;
+ int mkfs_time /* time of filesystem creation */;
+ unsigned int block_size;
+ unsigned int fragments;
+ unsigned short compression;
+ unsigned short block_log;
+ unsigned short flags;
+ unsigned short no_ids;
+ unsigned short s_major;
+ unsigned short s_minor;
+ squashfs_inode root_inode;
+ long long bytes_used;
+ long long id_table_start;
+ long long xattr_id_table_start;
+ long long inode_table_start;
+ long long directory_table_start;
+ long long fragment_table_start;
+ long long lookup_table_start;
+};
+
+struct squashfs_dir_index {
+ unsigned int index;
+ unsigned int start_block;
+ unsigned int size;
+ unsigned char name[0];
+};
+
+struct squashfs_base_inode_header {
+ unsigned short inode_type;
+ unsigned short mode;
+ unsigned short uid;
+ unsigned short guid;
+ int mtime;
+ unsigned int inode_number;
+};
+
+struct squashfs_ipc_inode_header {
+ unsigned short inode_type;
+ unsigned short mode;
+ unsigned short uid;
+ unsigned short guid;
+ int mtime;
+ unsigned int inode_number;
+ unsigned int nlink;
+};
+
+struct squashfs_lipc_inode_header {
+ unsigned short inode_type;
+ unsigned short mode;
+ unsigned short uid;
+ unsigned short guid;
+ int mtime;
+ unsigned int inode_number;
+ unsigned int nlink;
+ unsigned int xattr;
+};
+
+struct squashfs_dev_inode_header {
+ unsigned short inode_type;
+ unsigned short mode;
+ unsigned short uid;
+ unsigned short guid;
+ int mtime;
+ unsigned int inode_number;
+ unsigned int nlink;
+ unsigned int rdev;
+};
+
+struct squashfs_ldev_inode_header {
+ unsigned short inode_type;
+ unsigned short mode;
+ unsigned short uid;
+ unsigned short guid;
+ int mtime;
+ unsigned int inode_number;
+ unsigned int nlink;
+ unsigned int rdev;
+ unsigned int xattr;
+};
+
+struct squashfs_symlink_inode_header {
+ unsigned short inode_type;
+ unsigned short mode;
+ unsigned short uid;
+ unsigned short guid;
+ int mtime;
+ unsigned int inode_number;
+ unsigned int nlink;
+ unsigned int symlink_size;
+ char symlink[0];
+};
+
+struct squashfs_reg_inode_header {
+ unsigned short inode_type;
+ unsigned short mode;
+ unsigned short uid;
+ unsigned short guid;
+ int mtime;
+ unsigned int inode_number;
+ unsigned int start_block;
+ unsigned int fragment;
+ unsigned int offset;
+ unsigned int file_size;
+ unsigned int block_list[0];
+};
+
+struct squashfs_lreg_inode_header {
+ unsigned short inode_type;
+ unsigned short mode;
+ unsigned short uid;
+ unsigned short guid;
+ int mtime;
+ unsigned int inode_number;
+ squashfs_block start_block;
+ long long file_size;
+ long long sparse;
+ unsigned int nlink;
+ unsigned int fragment;
+ unsigned int offset;
+ unsigned int xattr;
+ unsigned int block_list[0];
+};
+
+struct squashfs_dir_inode_header {
+ unsigned short inode_type;
+ unsigned short mode;
+ unsigned short uid;
+ unsigned short guid;
+ int mtime;
+ unsigned int inode_number;
+ unsigned int start_block;
+ unsigned int nlink;
+ unsigned short file_size;
+ unsigned short offset;
+ unsigned int parent_inode;
+};
+
+struct squashfs_ldir_inode_header {
+ unsigned short inode_type;
+ unsigned short mode;
+ unsigned short uid;
+ unsigned short guid;
+ int mtime;
+ unsigned int inode_number;
+ unsigned int nlink;
+ unsigned int file_size;
+ unsigned int start_block;
+ unsigned int parent_inode;
+ unsigned short i_count;
+ unsigned short offset;
+ unsigned int xattr;
+ struct squashfs_dir_index index[0];
+};
+
+union squashfs_inode_header {
+ struct squashfs_base_inode_header base;
+ struct squashfs_dev_inode_header dev;
+ struct squashfs_ldev_inode_header ldev;
+ struct squashfs_symlink_inode_header symlink;
+ struct squashfs_reg_inode_header reg;
+ struct squashfs_lreg_inode_header lreg;
+ struct squashfs_dir_inode_header dir;
+ struct squashfs_ldir_inode_header ldir;
+ struct squashfs_ipc_inode_header ipc;
+ struct squashfs_lipc_inode_header lipc;
+};
+
+struct squashfs_dir_entry {
+ unsigned short offset;
+ short inode_number;
+ unsigned short type;
+ unsigned short size;
+ char name[0];
+};
+
+struct squashfs_dir_header {
+ unsigned int count;
+ unsigned int start_block;
+ unsigned int inode_number;
+};
+
+struct squashfs_fragment_entry {
+ long long start_block;
+ unsigned int size;
+ unsigned int unused;
+};
+
+struct squashfs_xattr_entry {
+ unsigned short type;
+ unsigned short size;
+};
+
+struct squashfs_xattr_val {
+ unsigned int vsize;
+};
+
+struct squashfs_xattr_id {
+ long long xattr;
+ unsigned int count;
+ unsigned int size;
+};
+
+struct squashfs_xattr_table {
+ long long xattr_table_start;
+ unsigned int xattr_ids;
+ unsigned int unused;
+};
+
+#endif
diff --git a/squashfs-tools/squashfs-tools/squashfs_swap.h b/squashfs-tools/squashfs-tools/squashfs_swap.h
new file mode 100644
index 0000000..f1becfc
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/squashfs_swap.h
@@ -0,0 +1,424 @@
+#ifndef SQUASHFS_SWAP_H
+#define SQUASHFS_SWAP_H
+/*
+ * Squashfs
+ *
+ * Copyright (c) 2008, 2009, 2010, 2013, 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * squashfs_swap.h
+ */
+
+/*
+ * macros to convert each stucture from big endian to little endian
+ */
+
+#if __BYTE_ORDER == __BIG_ENDIAN
+#include <stddef.h>
+extern void swap_le16(void *, void *);
+extern void swap_le32(void *, void *);
+extern void swap_le64(void *, void *);
+extern void swap_le16_num(void *, void *, int);
+extern void swap_le32_num(void *, void *, int);
+extern void swap_le64_num(void *, void *, int);
+extern unsigned short inswap_le16(unsigned short);
+extern unsigned int inswap_le32(unsigned int);
+extern long long inswap_le64(long long);
+extern void inswap_le16_num(unsigned short *, int);
+extern void inswap_le32_num(unsigned int *, int);
+extern void inswap_le64_num(long long *, int);
+
+#define _SQUASHFS_SWAP_SUPER_BLOCK(s, d, SWAP_FUNC) {\
+ SWAP_FUNC(32, s, d, s_magic, struct squashfs_super_block);\
+ SWAP_FUNC(32, s, d, inodes, struct squashfs_super_block);\
+ SWAP_FUNC##S(32, s, d, mkfs_time, struct squashfs_super_block);\
+ SWAP_FUNC(32, s, d, block_size, struct squashfs_super_block);\
+ SWAP_FUNC(32, s, d, fragments, struct squashfs_super_block);\
+ SWAP_FUNC(16, s, d, compression, struct squashfs_super_block);\
+ SWAP_FUNC(16, s, d, block_log, struct squashfs_super_block);\
+ SWAP_FUNC(16, s, d, flags, struct squashfs_super_block);\
+ SWAP_FUNC(16, s, d, no_ids, struct squashfs_super_block);\
+ SWAP_FUNC(16, s, d, s_major, struct squashfs_super_block);\
+ SWAP_FUNC(16, s, d, s_minor, struct squashfs_super_block);\
+ SWAP_FUNC(64, s, d, root_inode, struct squashfs_super_block);\
+ SWAP_FUNC(64, s, d, bytes_used, struct squashfs_super_block);\
+ SWAP_FUNC(64, s, d, id_table_start, struct squashfs_super_block);\
+ SWAP_FUNC(64, s, d, xattr_id_table_start, struct squashfs_super_block);\
+ SWAP_FUNC(64, s, d, inode_table_start, struct squashfs_super_block);\
+ SWAP_FUNC(64, s, d, directory_table_start, struct squashfs_super_block);\
+ SWAP_FUNC(64, s, d, fragment_table_start, struct squashfs_super_block);\
+ SWAP_FUNC(64, s, d, lookup_table_start, struct squashfs_super_block);\
+}
+
+#define _SQUASHFS_SWAP_DIR_INDEX(s, d, SWAP_FUNC) {\
+ SWAP_FUNC(32, s, d, index, struct squashfs_dir_index);\
+ SWAP_FUNC(32, s, d, start_block, struct squashfs_dir_index);\
+ SWAP_FUNC(32, s, d, size, struct squashfs_dir_index);\
+}
+
+#define _SQUASHFS_SWAP_BASE_INODE_HEADER(s, d, SWAP_FUNC) {\
+ SWAP_FUNC(16, s, d, inode_type, struct squashfs_base_inode_header);\
+ SWAP_FUNC(16, s, d, mode, struct squashfs_base_inode_header);\
+ SWAP_FUNC(16, s, d, uid, struct squashfs_base_inode_header);\
+ SWAP_FUNC(16, s, d, guid, struct squashfs_base_inode_header);\
+ SWAP_FUNC##S(32, s, d, mtime, struct squashfs_base_inode_header);\
+ SWAP_FUNC(32, s, d, inode_number, struct squashfs_base_inode_header);\
+}
+
+#define _SQUASHFS_SWAP_IPC_INODE_HEADER(s, d, SWAP_FUNC) {\
+ SWAP_FUNC(16, s, d, inode_type, struct squashfs_ipc_inode_header);\
+ SWAP_FUNC(16, s, d, mode, struct squashfs_ipc_inode_header);\
+ SWAP_FUNC(16, s, d, uid, struct squashfs_ipc_inode_header);\
+ SWAP_FUNC(16, s, d, guid, struct squashfs_ipc_inode_header);\
+ SWAP_FUNC##S(32, s, d, mtime, struct squashfs_ipc_inode_header);\
+ SWAP_FUNC(32, s, d, inode_number, struct squashfs_ipc_inode_header);\
+ SWAP_FUNC(32, s, d, nlink, struct squashfs_ipc_inode_header);\
+}
+
+#define _SQUASHFS_SWAP_LIPC_INODE_HEADER(s, d, SWAP_FUNC) {\
+ SWAP_FUNC(16, s, d, inode_type, struct squashfs_lipc_inode_header);\
+ SWAP_FUNC(16, s, d, mode, struct squashfs_lipc_inode_header);\
+ SWAP_FUNC(16, s, d, uid, struct squashfs_lipc_inode_header);\
+ SWAP_FUNC(16, s, d, guid, struct squashfs_lipc_inode_header);\
+ SWAP_FUNC##S(32, s, d, mtime, struct squashfs_lipc_inode_header);\
+ SWAP_FUNC(32, s, d, inode_number, struct squashfs_lipc_inode_header);\
+ SWAP_FUNC(32, s, d, nlink, struct squashfs_lipc_inode_header);\
+ SWAP_FUNC(32, s, d, xattr, struct squashfs_lipc_inode_header);\
+}
+
+#define _SQUASHFS_SWAP_DEV_INODE_HEADER(s, d, SWAP_FUNC) {\
+ SWAP_FUNC(16, s, d, inode_type, struct squashfs_dev_inode_header);\
+ SWAP_FUNC(16, s, d, mode, struct squashfs_dev_inode_header);\
+ SWAP_FUNC(16, s, d, uid, struct squashfs_dev_inode_header);\
+ SWAP_FUNC(16, s, d, guid, struct squashfs_dev_inode_header);\
+ SWAP_FUNC##S(32, s, d, mtime, struct squashfs_dev_inode_header);\
+ SWAP_FUNC(32, s, d, inode_number, struct squashfs_dev_inode_header);\
+ SWAP_FUNC(32, s, d, nlink, struct squashfs_dev_inode_header);\
+ SWAP_FUNC(32, s, d, rdev, struct squashfs_dev_inode_header);\
+}
+
+#define _SQUASHFS_SWAP_LDEV_INODE_HEADER(s, d, SWAP_FUNC) {\
+ SWAP_FUNC(16, s, d, inode_type, struct squashfs_ldev_inode_header);\
+ SWAP_FUNC(16, s, d, mode, struct squashfs_ldev_inode_header);\
+ SWAP_FUNC(16, s, d, uid, struct squashfs_ldev_inode_header);\
+ SWAP_FUNC(16, s, d, guid, struct squashfs_ldev_inode_header);\
+ SWAP_FUNC##S(32, s, d, mtime, struct squashfs_ldev_inode_header);\
+ SWAP_FUNC(32, s, d, inode_number, struct squashfs_ldev_inode_header);\
+ SWAP_FUNC(32, s, d, nlink, struct squashfs_ldev_inode_header);\
+ SWAP_FUNC(32, s, d, rdev, struct squashfs_ldev_inode_header);\
+ SWAP_FUNC(32, s, d, xattr, struct squashfs_ldev_inode_header);\
+}
+
+#define _SQUASHFS_SWAP_SYMLINK_INODE_HEADER(s, d, SWAP_FUNC) {\
+ SWAP_FUNC(16, s, d, inode_type, struct squashfs_symlink_inode_header);\
+ SWAP_FUNC(16, s, d, mode, struct squashfs_symlink_inode_header);\
+ SWAP_FUNC(16, s, d, uid, struct squashfs_symlink_inode_header);\
+ SWAP_FUNC(16, s, d, guid, struct squashfs_symlink_inode_header);\
+ SWAP_FUNC##S(32, s, d, mtime, struct squashfs_symlink_inode_header);\
+ SWAP_FUNC(32, s, d, inode_number, struct squashfs_symlink_inode_header);\
+ SWAP_FUNC(32, s, d, nlink, struct squashfs_symlink_inode_header);\
+ SWAP_FUNC(32, s, d, symlink_size, struct squashfs_symlink_inode_header);\
+}
+
+#define _SQUASHFS_SWAP_REG_INODE_HEADER(s, d, SWAP_FUNC) {\
+ SWAP_FUNC(16, s, d, inode_type, struct squashfs_reg_inode_header);\
+ SWAP_FUNC(16, s, d, mode, struct squashfs_reg_inode_header);\
+ SWAP_FUNC(16, s, d, uid, struct squashfs_reg_inode_header);\
+ SWAP_FUNC(16, s, d, guid, struct squashfs_reg_inode_header);\
+ SWAP_FUNC##S(32, s, d, mtime, struct squashfs_reg_inode_header);\
+ SWAP_FUNC(32, s, d, inode_number, struct squashfs_reg_inode_header);\
+ SWAP_FUNC(32, s, d, start_block, struct squashfs_reg_inode_header);\
+ SWAP_FUNC(32, s, d, fragment, struct squashfs_reg_inode_header);\
+ SWAP_FUNC(32, s, d, offset, struct squashfs_reg_inode_header);\
+ SWAP_FUNC(32, s, d, file_size, struct squashfs_reg_inode_header);\
+}
+
+#define _SQUASHFS_SWAP_LREG_INODE_HEADER(s, d, SWAP_FUNC) {\
+ SWAP_FUNC(16, s, d, inode_type, struct squashfs_lreg_inode_header);\
+ SWAP_FUNC(16, s, d, mode, struct squashfs_lreg_inode_header);\
+ SWAP_FUNC(16, s, d, uid, struct squashfs_lreg_inode_header);\
+ SWAP_FUNC(16, s, d, guid, struct squashfs_lreg_inode_header);\
+ SWAP_FUNC##S(32, s, d, mtime, struct squashfs_lreg_inode_header);\
+ SWAP_FUNC(32, s, d, inode_number, struct squashfs_lreg_inode_header);\
+ SWAP_FUNC(64, s, d, start_block, struct squashfs_lreg_inode_header);\
+ SWAP_FUNC(64, s, d, file_size, struct squashfs_lreg_inode_header);\
+ SWAP_FUNC(64, s, d, sparse, struct squashfs_lreg_inode_header);\
+ SWAP_FUNC(32, s, d, nlink, struct squashfs_lreg_inode_header);\
+ SWAP_FUNC(32, s, d, fragment, struct squashfs_lreg_inode_header);\
+ SWAP_FUNC(32, s, d, offset, struct squashfs_lreg_inode_header);\
+ SWAP_FUNC(32, s, d, xattr, struct squashfs_lreg_inode_header);\
+}
+
+#define _SQUASHFS_SWAP_DIR_INODE_HEADER(s, d, SWAP_FUNC) {\
+ SWAP_FUNC(16, s, d, inode_type, struct squashfs_dir_inode_header);\
+ SWAP_FUNC(16, s, d, mode, struct squashfs_dir_inode_header);\
+ SWAP_FUNC(16, s, d, uid, struct squashfs_dir_inode_header);\
+ SWAP_FUNC(16, s, d, guid, struct squashfs_dir_inode_header);\
+ SWAP_FUNC##S(32, s, d, mtime, struct squashfs_dir_inode_header);\
+ SWAP_FUNC(32, s, d, inode_number, struct squashfs_dir_inode_header);\
+ SWAP_FUNC(32, s, d, start_block, struct squashfs_dir_inode_header);\
+ SWAP_FUNC(32, s, d, nlink, struct squashfs_dir_inode_header);\
+ SWAP_FUNC(16, s, d, file_size, struct squashfs_dir_inode_header);\
+ SWAP_FUNC(16, s, d, offset, struct squashfs_dir_inode_header);\
+ SWAP_FUNC(32, s, d, parent_inode, struct squashfs_dir_inode_header);\
+}
+
+#define _SQUASHFS_SWAP_LDIR_INODE_HEADER(s, d, SWAP_FUNC) {\
+ SWAP_FUNC(16, s, d, inode_type, struct squashfs_ldir_inode_header);\
+ SWAP_FUNC(16, s, d, mode, struct squashfs_ldir_inode_header);\
+ SWAP_FUNC(16, s, d, uid, struct squashfs_ldir_inode_header);\
+ SWAP_FUNC(16, s, d, guid, struct squashfs_ldir_inode_header);\
+ SWAP_FUNC##S(32, s, d, mtime, struct squashfs_ldir_inode_header);\
+ SWAP_FUNC(32, s, d, inode_number, struct squashfs_ldir_inode_header);\
+ SWAP_FUNC(32, s, d, nlink, struct squashfs_ldir_inode_header);\
+ SWAP_FUNC(32, s, d, file_size, struct squashfs_ldir_inode_header);\
+ SWAP_FUNC(32, s, d, start_block, struct squashfs_ldir_inode_header);\
+ SWAP_FUNC(32, s, d, parent_inode, struct squashfs_ldir_inode_header);\
+ SWAP_FUNC(16, s, d, i_count, struct squashfs_ldir_inode_header);\
+ SWAP_FUNC(16, s, d, offset, struct squashfs_ldir_inode_header);\
+ SWAP_FUNC(32, s, d, xattr, struct squashfs_ldir_inode_header);\
+}
+
+#define _SQUASHFS_SWAP_DIR_ENTRY(s, d, SWAP_FUNC) {\
+ SWAP_FUNC(16, s, d, offset, struct squashfs_dir_entry);\
+ SWAP_FUNC##S(16, s, d, inode_number, struct squashfs_dir_entry);\
+ SWAP_FUNC(16, s, d, type, struct squashfs_dir_entry);\
+ SWAP_FUNC(16, s, d, size, struct squashfs_dir_entry);\
+}
+
+#define _SQUASHFS_SWAP_DIR_HEADER(s, d, SWAP_FUNC) {\
+ SWAP_FUNC(32, s, d, count, struct squashfs_dir_header);\
+ SWAP_FUNC(32, s, d, start_block, struct squashfs_dir_header);\
+ SWAP_FUNC(32, s, d, inode_number, struct squashfs_dir_header);\
+}
+
+#define _SQUASHFS_SWAP_FRAGMENT_ENTRY(s, d, SWAP_FUNC) {\
+ SWAP_FUNC(64, s, d, start_block, struct squashfs_fragment_entry);\
+ SWAP_FUNC(32, s, d, size, struct squashfs_fragment_entry);\
+}
+
+#define _SQUASHFS_SWAP_XATTR_ENTRY(s, d, SWAP_FUNC) {\
+ SWAP_FUNC(16, s, d, type, struct squashfs_xattr_entry);\
+ SWAP_FUNC(16, s, d, size, struct squashfs_xattr_entry);\
+}
+
+#define _SQUASHFS_SWAP_XATTR_VAL(s, d, SWAP_FUNC) {\
+ SWAP_FUNC(32, s, d, vsize, struct squashfs_xattr_val);\
+}
+
+#define _SQUASHFS_SWAP_XATTR_ID(s, d, SWAP_FUNC) {\
+ SWAP_FUNC(64, s, d, xattr, struct squashfs_xattr_id);\
+ SWAP_FUNC(32, s, d, count, struct squashfs_xattr_id);\
+ SWAP_FUNC(32, s, d, size, struct squashfs_xattr_id);\
+}
+
+#define _SQUASHFS_SWAP_XATTR_TABLE(s, d, SWAP_FUNC) {\
+ SWAP_FUNC(64, s, d, xattr_table_start, struct squashfs_xattr_table);\
+ SWAP_FUNC(32, s, d, xattr_ids, struct squashfs_xattr_table);\
+}
+
+/* big endian architecture copy and swap macros */
+#define SQUASHFS_SWAP_SUPER_BLOCK(s, d) \
+ _SQUASHFS_SWAP_SUPER_BLOCK(s, d, SWAP_LE)
+#define SQUASHFS_SWAP_DIR_INDEX(s, d) \
+ _SQUASHFS_SWAP_DIR_INDEX(s, d, SWAP_LE)
+#define SQUASHFS_SWAP_BASE_INODE_HEADER(s, d) \
+ _SQUASHFS_SWAP_BASE_INODE_HEADER(s, d, SWAP_LE)
+#define SQUASHFS_SWAP_IPC_INODE_HEADER(s, d) \
+ _SQUASHFS_SWAP_IPC_INODE_HEADER(s, d, SWAP_LE)
+#define SQUASHFS_SWAP_LIPC_INODE_HEADER(s, d) \
+ _SQUASHFS_SWAP_LIPC_INODE_HEADER(s, d, SWAP_LE)
+#define SQUASHFS_SWAP_DEV_INODE_HEADER(s, d) \
+ _SQUASHFS_SWAP_DEV_INODE_HEADER(s, d, SWAP_LE)
+#define SQUASHFS_SWAP_LDEV_INODE_HEADER(s, d) \
+ _SQUASHFS_SWAP_LDEV_INODE_HEADER(s, d, SWAP_LE)
+#define SQUASHFS_SWAP_SYMLINK_INODE_HEADER(s, d) \
+ _SQUASHFS_SWAP_SYMLINK_INODE_HEADER(s, d, SWAP_LE)
+#define SQUASHFS_SWAP_REG_INODE_HEADER(s, d) \
+ _SQUASHFS_SWAP_REG_INODE_HEADER(s, d, SWAP_LE)
+#define SQUASHFS_SWAP_LREG_INODE_HEADER(s, d) \
+ _SQUASHFS_SWAP_LREG_INODE_HEADER(s, d, SWAP_LE)
+#define SQUASHFS_SWAP_DIR_INODE_HEADER(s, d) \
+ _SQUASHFS_SWAP_DIR_INODE_HEADER(s, d, SWAP_LE)
+#define SQUASHFS_SWAP_LDIR_INODE_HEADER(s, d) \
+ _SQUASHFS_SWAP_LDIR_INODE_HEADER(s, d, SWAP_LE)
+#define SQUASHFS_SWAP_DIR_ENTRY(s, d) \
+ _SQUASHFS_SWAP_DIR_ENTRY(s, d, SWAP_LE)
+#define SQUASHFS_SWAP_DIR_HEADER(s, d) \
+ _SQUASHFS_SWAP_DIR_HEADER(s, d, SWAP_LE)
+#define SQUASHFS_SWAP_FRAGMENT_ENTRY(s, d) \
+ _SQUASHFS_SWAP_FRAGMENT_ENTRY(s, d, SWAP_LE)
+#define SQUASHFS_SWAP_XATTR_ENTRY(s, d) \
+ _SQUASHFS_SWAP_XATTR_ENTRY(s, d, SWAP_LE)
+#define SQUASHFS_SWAP_XATTR_VAL(s, d) \
+ _SQUASHFS_SWAP_XATTR_VAL(s, d, SWAP_LE)
+#define SQUASHFS_SWAP_XATTR_ID(s, d) \
+ _SQUASHFS_SWAP_XATTR_ID(s, d, SWAP_LE)
+#define SQUASHFS_SWAP_XATTR_TABLE(s, d) \
+ _SQUASHFS_SWAP_XATTR_TABLE(s, d, SWAP_LE)
+#define SWAP_LE(bits, s, d, field, type) \
+ SWAP_LE##bits(((void *)(s)) + offsetof(type, field), \
+ ((void *)(d)) + offsetof(type, field))
+#define SWAP_LES(bits, s, d, field, type) \
+ SWAP_LE(bits, s, d, field, type)
+#define SQUASHFS_SWAP_INODE_T(s, d) SQUASHFS_SWAP_LONG_LONGS(s, d, 1)
+#define SQUASHFS_SWAP_FRAGMENT_INDEXES(s, d, n) \
+ SQUASHFS_SWAP_LONG_LONGS(s, d, n)
+#define SQUASHFS_SWAP_LOOKUP_BLOCKS(s, d, n) SQUASHFS_SWAP_LONG_LONGS(s, d, n)
+#define SQUASHFS_SWAP_ID_BLOCKS(s, d, n) SQUASHFS_SWAP_LONG_LONGS(s, d, n)
+
+#define SQUASHFS_SWAP_SHORTS(s, d, n) swap_le16_num(s, d, n)
+#define SQUASHFS_SWAP_INTS(s, d, n) swap_le32_num(s, d, n)
+#define SQUASHFS_SWAP_LONG_LONGS(s, d, n) swap_le64_num(s, d, n)
+
+#define SWAP_LE16(s, d) swap_le16(s, d)
+#define SWAP_LE32(s, d) swap_le32(s, d)
+#define SWAP_LE64(s, d) swap_le64(s, d)
+
+/* big endian architecture swap in-place macros */
+#define SQUASHFS_INSWAP_SUPER_BLOCK(s) \
+ _SQUASHFS_SWAP_SUPER_BLOCK(s, s, INSWAP_LE)
+#define SQUASHFS_INSWAP_DIR_INDEX(s) \
+ _SQUASHFS_SWAP_DIR_INDEX(s, s, INSWAP_LE)
+#define SQUASHFS_INSWAP_BASE_INODE_HEADER(s) \
+ _SQUASHFS_SWAP_BASE_INODE_HEADER(s, s, INSWAP_LE)
+#define SQUASHFS_INSWAP_IPC_INODE_HEADER(s) \
+ _SQUASHFS_SWAP_IPC_INODE_HEADER(s, s, INSWAP_LE)
+#define SQUASHFS_INSWAP_LIPC_INODE_HEADER(s) \
+ _SQUASHFS_SWAP_LIPC_INODE_HEADER(s, s, INSWAP_LE)
+#define SQUASHFS_INSWAP_DEV_INODE_HEADER(s) \
+ _SQUASHFS_SWAP_DEV_INODE_HEADER(s, s, INSWAP_LE)
+#define SQUASHFS_INSWAP_LDEV_INODE_HEADER(s) \
+ _SQUASHFS_SWAP_LDEV_INODE_HEADER(s, s, INSWAP_LE)
+#define SQUASHFS_INSWAP_SYMLINK_INODE_HEADER(s) \
+ _SQUASHFS_SWAP_SYMLINK_INODE_HEADER(s, s, INSWAP_LE)
+#define SQUASHFS_INSWAP_REG_INODE_HEADER(s) \
+ _SQUASHFS_SWAP_REG_INODE_HEADER(s, s, INSWAP_LE)
+#define SQUASHFS_INSWAP_LREG_INODE_HEADER(s) \
+ _SQUASHFS_SWAP_LREG_INODE_HEADER(s, s, INSWAP_LE)
+#define SQUASHFS_INSWAP_DIR_INODE_HEADER(s) \
+ _SQUASHFS_SWAP_DIR_INODE_HEADER(s, s, INSWAP_LE)
+#define SQUASHFS_INSWAP_LDIR_INODE_HEADER(s) \
+ _SQUASHFS_SWAP_LDIR_INODE_HEADER(s, s, INSWAP_LE)
+#define SQUASHFS_INSWAP_DIR_ENTRY(s) \
+ _SQUASHFS_SWAP_DIR_ENTRY(s, s, INSWAP_LE)
+#define SQUASHFS_INSWAP_DIR_HEADER(s) \
+ _SQUASHFS_SWAP_DIR_HEADER(s, s, INSWAP_LE)
+#define SQUASHFS_INSWAP_FRAGMENT_ENTRY(s) \
+ _SQUASHFS_SWAP_FRAGMENT_ENTRY(s, s, INSWAP_LE)
+#define SQUASHFS_INSWAP_XATTR_ENTRY(s) \
+ _SQUASHFS_SWAP_XATTR_ENTRY(s, s, INSWAP_LE)
+#define SQUASHFS_INSWAP_XATTR_VAL(s) \
+ _SQUASHFS_SWAP_XATTR_VAL(s, s, INSWAP_LE)
+#define SQUASHFS_INSWAP_XATTR_ID(s) \
+ _SQUASHFS_SWAP_XATTR_ID(s, s, INSWAP_LE)
+#define SQUASHFS_INSWAP_XATTR_TABLE(s) \
+ _SQUASHFS_SWAP_XATTR_TABLE(s, s, INSWAP_LE)
+#define INSWAP_LE(bits, s, d, field, type) \
+ (s)->field = inswap_le##bits((s)->field)
+#define INSWAP_LES(bits, s, d, field, type) \
+ (s)->field = INSWAP_LES##bits((s)->field)
+#define INSWAP_LES16(num) (short) inswap_le16((unsigned short) (num))
+#define INSWAP_LES32(num) (int) inswap_le32((unsigned int) (num))
+#define SQUASHFS_INSWAP_INODE_T(s) s = inswap_le64(s)
+#define SQUASHFS_INSWAP_FRAGMENT_INDEXES(s, n) inswap_le64_num(s, n)
+#define SQUASHFS_INSWAP_LOOKUP_BLOCKS(s, n) inswap_le64_num(s, n)
+#define SQUASHFS_INSWAP_ID_BLOCKS(s, n) inswap_le64_num(s, n)
+#define SQUASHFS_INSWAP_SHORTS(s, n) inswap_le16_num(s, n)
+#define SQUASHFS_INSWAP_INTS(s, n) inswap_le32_num(s, n)
+#define SQUASHFS_INSWAP_LONG_LONGS(s, n) inswap_le64_num(s, n)
+#else
+/* little endian architecture, just copy */
+#define SQUASHFS_SWAP_SUPER_BLOCK(s, d) \
+ SQUASHFS_MEMCPY(s, d, sizeof(struct squashfs_super_block))
+#define SQUASHFS_SWAP_DIR_INDEX(s, d) \
+ SQUASHFS_MEMCPY(s, d, sizeof(struct squashfs_dir_index))
+#define SQUASHFS_SWAP_BASE_INODE_HEADER(s, d) \
+ SQUASHFS_MEMCPY(s, d, sizeof(struct squashfs_base_inode_header))
+#define SQUASHFS_SWAP_IPC_INODE_HEADER(s, d) \
+ SQUASHFS_MEMCPY(s, d, sizeof(struct squashfs_ipc_inode_header))
+#define SQUASHFS_SWAP_LIPC_INODE_HEADER(s, d) \
+ SQUASHFS_MEMCPY(s, d, sizeof(struct squashfs_lipc_inode_header))
+#define SQUASHFS_SWAP_DEV_INODE_HEADER(s, d) \
+ SQUASHFS_MEMCPY(s, d, sizeof(struct squashfs_dev_inode_header))
+#define SQUASHFS_SWAP_LDEV_INODE_HEADER(s, d) \
+ SQUASHFS_MEMCPY(s, d, sizeof(struct squashfs_ldev_inode_header))
+#define SQUASHFS_SWAP_SYMLINK_INODE_HEADER(s, d) \
+ SQUASHFS_MEMCPY(s, d, sizeof(struct squashfs_symlink_inode_header))
+#define SQUASHFS_SWAP_REG_INODE_HEADER(s, d) \
+ SQUASHFS_MEMCPY(s, d, sizeof(struct squashfs_reg_inode_header))
+#define SQUASHFS_SWAP_LREG_INODE_HEADER(s, d) \
+ SQUASHFS_MEMCPY(s, d, sizeof(struct squashfs_lreg_inode_header))
+#define SQUASHFS_SWAP_DIR_INODE_HEADER(s, d) \
+ SQUASHFS_MEMCPY(s, d, sizeof(struct squashfs_dir_inode_header))
+#define SQUASHFS_SWAP_LDIR_INODE_HEADER(s, d) \
+ SQUASHFS_MEMCPY(s, d, sizeof(struct squashfs_ldir_inode_header))
+#define SQUASHFS_SWAP_DIR_ENTRY(s, d) \
+ SQUASHFS_MEMCPY(s, d, sizeof(struct squashfs_dir_entry))
+#define SQUASHFS_SWAP_DIR_HEADER(s, d) \
+ SQUASHFS_MEMCPY(s, d, sizeof(struct squashfs_dir_header))
+#define SQUASHFS_SWAP_FRAGMENT_ENTRY(s, d) \
+ SQUASHFS_MEMCPY(s, d, sizeof(struct squashfs_fragment_entry))
+#define SQUASHFS_SWAP_XATTR_ENTRY(s, d) \
+ SQUASHFS_MEMCPY(s, d, sizeof(struct squashfs_xattr_entry))
+#define SQUASHFS_SWAP_XATTR_VAL(s, d) \
+ SQUASHFS_MEMCPY(s, d, sizeof(struct squashfs_xattr_val))
+#define SQUASHFS_SWAP_XATTR_ID(s, d) \
+ SQUASHFS_MEMCPY(s, d, sizeof(struct squashfs_xattr_id))
+#define SQUASHFS_SWAP_XATTR_TABLE(s, d) \
+ SQUASHFS_MEMCPY(s, d, sizeof(struct squashfs_xattr_table))
+#define SQUASHFS_SWAP_INODE_T(s, d) SQUASHFS_SWAP_LONG_LONGS(s, d, 1)
+#define SQUASHFS_SWAP_FRAGMENT_INDEXES(s, d, n) \
+ SQUASHFS_SWAP_LONG_LONGS(s, d, n)
+#define SQUASHFS_SWAP_LOOKUP_BLOCKS(s, d, n) SQUASHFS_SWAP_LONG_LONGS(s, d, n)
+#define SQUASHFS_SWAP_ID_BLOCKS(s, d, n) SQUASHFS_SWAP_LONG_LONGS(s, d, n)
+
+#define SQUASHFS_MEMCPY(s, d, n) memcpy(d, s, n)
+#define SQUASHFS_SWAP_SHORTS(s, d, n) memcpy(d, s, n * sizeof(short))
+#define SQUASHFS_SWAP_INTS(s, d, n) memcpy(d, s, n * sizeof(int))
+#define SQUASHFS_SWAP_LONG_LONGS(s, d, n) \
+ memcpy(d, s, n * sizeof(long long))
+
+/* little endian architecture, data already in place so do nothing */
+#define SQUASHFS_INSWAP_SUPER_BLOCK(s)
+#define SQUASHFS_INSWAP_DIR_INDEX(s)
+#define SQUASHFS_INSWAP_BASE_INODE_HEADER(s)
+#define SQUASHFS_INSWAP_IPC_INODE_HEADER(s)
+#define SQUASHFS_INSWAP_LIPC_INODE_HEADER(s)
+#define SQUASHFS_INSWAP_DEV_INODE_HEADER(s)
+#define SQUASHFS_INSWAP_LDEV_INODE_HEADER(s)
+#define SQUASHFS_INSWAP_SYMLINK_INODE_HEADER(s)
+#define SQUASHFS_INSWAP_REG_INODE_HEADER(s)
+#define SQUASHFS_INSWAP_LREG_INODE_HEADER(s)
+#define SQUASHFS_INSWAP_DIR_INODE_HEADER(s)
+#define SQUASHFS_INSWAP_LDIR_INODE_HEADER(s)
+#define SQUASHFS_INSWAP_DIR_ENTRY(s)
+#define SQUASHFS_INSWAP_DIR_HEADER(s)
+#define SQUASHFS_INSWAP_FRAGMENT_ENTRY(s)
+#define SQUASHFS_INSWAP_XATTR_ENTRY(s)
+#define SQUASHFS_INSWAP_XATTR_VAL(s)
+#define SQUASHFS_INSWAP_XATTR_ID(s)
+#define SQUASHFS_INSWAP_XATTR_TABLE(s)
+#define SQUASHFS_INSWAP_INODE_T(s)
+#define SQUASHFS_INSWAP_FRAGMENT_INDEXES(s, n)
+#define SQUASHFS_INSWAP_LOOKUP_BLOCKS(s, n)
+#define SQUASHFS_INSWAP_ID_BLOCKS(s, n)
+#define SQUASHFS_INSWAP_SHORTS(s, n)
+#define SQUASHFS_INSWAP_INTS(s, n)
+#define SQUASHFS_INSWAP_LONG_LONGS(s, n)
+#endif
+#endif
diff --git a/squashfs-tools/squashfs-tools/swap.c b/squashfs-tools/squashfs-tools/swap.c
new file mode 100644
index 0000000..45c8cbc
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/swap.c
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2009, 2010
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * swap.c
+ */
+
+#ifndef linux
+#define __BYTE_ORDER BYTE_ORDER
+#define __BIG_ENDIAN BIG_ENDIAN
+#define __LITTLE_ENDIAN LITTLE_ENDIAN
+#else
+#include <endian.h>
+#endif
+
+#if __BYTE_ORDER == __BIG_ENDIAN
+void swap_le16(void *src, void *dest)
+{
+ unsigned char *s = src;
+ unsigned char *d = dest;
+
+ d[0] = s[1];
+ d[1] = s[0];
+}
+
+
+void swap_le32(void *src, void *dest)
+{
+ unsigned char *s = src;
+ unsigned char *d = dest;
+
+ d[0] = s[3];
+ d[1] = s[2];
+ d[2] = s[1];
+ d[3] = s[0];
+}
+
+
+void swap_le64(void *src, void *dest)
+{
+ unsigned char *s = src;
+ unsigned char *d = dest;
+
+ d[0] = s[7];
+ d[1] = s[6];
+ d[2] = s[5];
+ d[3] = s[4];
+ d[4] = s[3];
+ d[5] = s[2];
+ d[6] = s[1];
+ d[7] = s[0];
+}
+
+
+unsigned short inswap_le16(unsigned short num)
+{
+ return (num >> 8) |
+ ((num & 0xff) << 8);
+}
+
+
+unsigned int inswap_le32(unsigned int num)
+{
+ return (num >> 24) |
+ ((num & 0xff0000) >> 8) |
+ ((num & 0xff00) << 8) |
+ ((num & 0xff) << 24);
+}
+
+
+long long inswap_le64(long long n)
+{
+ unsigned long long num = n;
+
+ return (num >> 56) |
+ ((num & 0xff000000000000LL) >> 40) |
+ ((num & 0xff0000000000LL) >> 24) |
+ ((num & 0xff00000000LL) >> 8) |
+ ((num & 0xff000000) << 8) |
+ ((num & 0xff0000) << 24) |
+ ((num & 0xff00) << 40) |
+ ((num & 0xff) << 56);
+}
+
+
+#define SWAP_LE_NUM(BITS) \
+void swap_le##BITS##_num(void *s, void *d, int n) \
+{\
+ int i;\
+ for(i = 0; i < n; i++, s += BITS / 8, d += BITS / 8)\
+ swap_le##BITS(s, d);\
+}
+
+SWAP_LE_NUM(16)
+SWAP_LE_NUM(32)
+SWAP_LE_NUM(64)
+
+#define INSWAP_LE_NUM(BITS, TYPE) \
+void inswap_le##BITS##_num(TYPE *s, int n) \
+{\
+ int i;\
+ for(i = 0; i < n; i++)\
+ s[i] = inswap_le##BITS(s[i]);\
+}
+
+INSWAP_LE_NUM(16, unsigned short)
+INSWAP_LE_NUM(32, unsigned int)
+INSWAP_LE_NUM(64, long long)
+#endif
diff --git a/squashfs-tools/squashfs-tools/unsquash-1.c b/squashfs-tools/squashfs-tools/unsquash-1.c
new file mode 100644
index 0000000..c2e7d38
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/unsquash-1.c
@@ -0,0 +1,357 @@
+/*
+ * Unsquash a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2009, 2010, 2011, 2012
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * unsquash-1.c
+ */
+
+#include "unsquashfs.h"
+#include "squashfs_compat.h"
+
+void read_block_list_1(unsigned int *block_list, char *block_ptr, int blocks)
+{
+ unsigned short block_size;
+ int i;
+
+ TRACE("read_block_list: blocks %d\n", blocks);
+
+ for(i = 0; i < blocks; i++, block_ptr += 2) {
+ if(swap) {
+ unsigned short sblock_size;
+ memcpy(&sblock_size, block_ptr, sizeof(unsigned short));
+ SQUASHFS_SWAP_SHORTS_3((&block_size), &sblock_size, 1);
+ } else
+ memcpy(&block_size, block_ptr, sizeof(unsigned short));
+ block_list[i] = SQUASHFS_COMPRESSED_SIZE(block_size) |
+ (SQUASHFS_COMPRESSED(block_size) ? 0 :
+ SQUASHFS_COMPRESSED_BIT_BLOCK);
+ }
+}
+
+
+int read_fragment_table_1(long long *directory_table_end)
+{
+ TRACE("read_fragment_table\n");
+ *directory_table_end = sBlk.s.fragment_table_start;
+ return TRUE;
+}
+
+
+struct inode *read_inode_1(unsigned int start_block, unsigned int offset)
+{
+ static union squashfs_inode_header_1 header;
+ long long start = sBlk.s.inode_table_start + start_block;
+ int bytes = lookup_entry(inode_table_hash, start);
+ char *block_ptr = inode_table + bytes + offset;
+ static struct inode i;
+
+ TRACE("read_inode: reading inode [%d:%d]\n", start_block, offset);
+
+ if(bytes == -1)
+ EXIT_UNSQUASH("read_inode: inode table block %lld not found\n",
+ start);
+
+ if(swap) {
+ squashfs_base_inode_header_1 sinode;
+ memcpy(&sinode, block_ptr, sizeof(header.base));
+ SQUASHFS_SWAP_BASE_INODE_HEADER_1(&header.base, &sinode,
+ sizeof(squashfs_base_inode_header_1));
+ } else
+ memcpy(&header.base, block_ptr, sizeof(header.base));
+
+ i.uid = (uid_t) uid_table[(header.base.inode_type - 1) /
+ SQUASHFS_TYPES * 16 + header.base.uid];
+ if(header.base.inode_type == SQUASHFS_IPC_TYPE) {
+ squashfs_ipc_inode_header_1 *inodep = &header.ipc;
+
+ if(swap) {
+ squashfs_ipc_inode_header_1 sinodep;
+ memcpy(&sinodep, block_ptr, sizeof(sinodep));
+ SQUASHFS_SWAP_IPC_INODE_HEADER_1(inodep, &sinodep);
+ } else
+ memcpy(inodep, block_ptr, sizeof(*inodep));
+
+ if(inodep->type == SQUASHFS_SOCKET_TYPE) {
+ i.mode = S_IFSOCK | header.base.mode;
+ i.type = SQUASHFS_SOCKET_TYPE;
+ } else {
+ i.mode = S_IFIFO | header.base.mode;
+ i.type = SQUASHFS_FIFO_TYPE;
+ }
+ i.uid = (uid_t) uid_table[inodep->offset * 16 + inodep->uid];
+ } else {
+ i.mode = lookup_type[(header.base.inode_type - 1) %
+ SQUASHFS_TYPES + 1] | header.base.mode;
+ i.type = (header.base.inode_type - 1) % SQUASHFS_TYPES + 1;
+ }
+
+ i.xattr = SQUASHFS_INVALID_XATTR;
+ i.gid = header.base.guid == 15 ? i.uid :
+ (uid_t) guid_table[header.base.guid];
+ i.time = sBlk.s.mkfs_time;
+ i.inode_number = inode_number ++;
+
+ switch(i.type) {
+ case SQUASHFS_DIR_TYPE: {
+ squashfs_dir_inode_header_1 *inode = &header.dir;
+
+ if(swap) {
+ squashfs_dir_inode_header_1 sinode;
+ memcpy(&sinode, block_ptr, sizeof(header.dir));
+ SQUASHFS_SWAP_DIR_INODE_HEADER_1(inode,
+ &sinode);
+ } else
+ memcpy(inode, block_ptr, sizeof(header.dir));
+
+ i.data = inode->file_size;
+ i.offset = inode->offset;
+ i.start = inode->start_block;
+ i.time = inode->mtime;
+ break;
+ }
+ case SQUASHFS_FILE_TYPE: {
+ squashfs_reg_inode_header_1 *inode = &header.reg;
+
+ if(swap) {
+ squashfs_reg_inode_header_1 sinode;
+ memcpy(&sinode, block_ptr, sizeof(sinode));
+ SQUASHFS_SWAP_REG_INODE_HEADER_1(inode,
+ &sinode);
+ } else
+ memcpy(inode, block_ptr, sizeof(*inode));
+
+ i.data = inode->file_size;
+ i.time = inode->mtime;
+ i.blocks = (i.data + sBlk.s.block_size - 1) >>
+ sBlk.s.block_log;
+ i.start = inode->start_block;
+ i.block_ptr = block_ptr + sizeof(*inode);
+ i.fragment = 0;
+ i.frag_bytes = 0;
+ i.offset = 0;
+ i.sparse = 0;
+ break;
+ }
+ case SQUASHFS_SYMLINK_TYPE: {
+ squashfs_symlink_inode_header_1 *inodep =
+ &header.symlink;
+
+ if(swap) {
+ squashfs_symlink_inode_header_1 sinodep;
+ memcpy(&sinodep, block_ptr, sizeof(sinodep));
+ SQUASHFS_SWAP_SYMLINK_INODE_HEADER_1(inodep,
+ &sinodep);
+ } else
+ memcpy(inodep, block_ptr, sizeof(*inodep));
+
+ i.symlink = malloc(inodep->symlink_size + 1);
+ if(i.symlink == NULL)
+ EXIT_UNSQUASH("read_inode: failed to malloc "
+ "symlink data\n");
+ strncpy(i.symlink, block_ptr +
+ sizeof(squashfs_symlink_inode_header_1),
+ inodep->symlink_size);
+ i.symlink[inodep->symlink_size] = '\0';
+ i.data = inodep->symlink_size;
+ break;
+ }
+ case SQUASHFS_BLKDEV_TYPE:
+ case SQUASHFS_CHRDEV_TYPE: {
+ squashfs_dev_inode_header_1 *inodep = &header.dev;
+
+ if(swap) {
+ squashfs_dev_inode_header_1 sinodep;
+ memcpy(&sinodep, block_ptr, sizeof(sinodep));
+ SQUASHFS_SWAP_DEV_INODE_HEADER_1(inodep,
+ &sinodep);
+ } else
+ memcpy(inodep, block_ptr, sizeof(*inodep));
+
+ i.data = inodep->rdev;
+ break;
+ }
+ case SQUASHFS_FIFO_TYPE:
+ case SQUASHFS_SOCKET_TYPE: {
+ i.data = 0;
+ break;
+ }
+ default:
+ EXIT_UNSQUASH("Unknown inode type %d in "
+ " read_inode_header_1!\n",
+ header.base.inode_type);
+ }
+ return &i;
+}
+
+
+struct dir *squashfs_opendir_1(unsigned int block_start, unsigned int offset,
+ struct inode **i)
+{
+ squashfs_dir_header_2 dirh;
+ char buffer[sizeof(squashfs_dir_entry_2) + SQUASHFS_NAME_LEN + 1]
+ __attribute__((aligned));
+ squashfs_dir_entry_2 *dire = (squashfs_dir_entry_2 *) buffer;
+ long long start;
+ int bytes;
+ int dir_count, size;
+ struct dir_ent *new_dir;
+ struct dir *dir;
+
+ TRACE("squashfs_opendir: inode start block %d, offset %d\n",
+ block_start, offset);
+
+ *i = s_ops.read_inode(block_start, offset);
+
+ dir = malloc(sizeof(struct dir));
+ if(dir == NULL)
+ EXIT_UNSQUASH("squashfs_opendir: malloc failed!\n");
+
+ dir->dir_count = 0;
+ dir->cur_entry = 0;
+ dir->mode = (*i)->mode;
+ dir->uid = (*i)->uid;
+ dir->guid = (*i)->gid;
+ dir->mtime = (*i)->time;
+ dir->xattr = (*i)->xattr;
+ dir->dirs = NULL;
+
+ if ((*i)->data == 0)
+ /*
+ * if the directory is empty, skip the unnecessary
+ * lookup_entry, this fixes the corner case with
+ * completely empty filesystems where lookup_entry correctly
+ * returning -1 is incorrectly treated as an error
+ */
+ return dir;
+
+ start = sBlk.s.directory_table_start + (*i)->start;
+ bytes = lookup_entry(directory_table_hash, start);
+ if(bytes == -1)
+ EXIT_UNSQUASH("squashfs_opendir: directory block %d not "
+ "found!\n", block_start);
+
+ bytes += (*i)->offset;
+ size = (*i)->data + bytes;
+
+ while(bytes < size) {
+ if(swap) {
+ squashfs_dir_header_2 sdirh;
+ memcpy(&sdirh, directory_table + bytes, sizeof(sdirh));
+ SQUASHFS_SWAP_DIR_HEADER_2(&dirh, &sdirh);
+ } else
+ memcpy(&dirh, directory_table + bytes, sizeof(dirh));
+
+ dir_count = dirh.count + 1;
+ TRACE("squashfs_opendir: Read directory header @ byte position "
+ "%d, %d directory entries\n", bytes, dir_count);
+ bytes += sizeof(dirh);
+
+ /* dir_count should never be larger than 256 */
+ if(dir_count > 256)
+ goto corrupted;
+
+ while(dir_count--) {
+ if(swap) {
+ squashfs_dir_entry_2 sdire;
+ memcpy(&sdire, directory_table + bytes,
+ sizeof(sdire));
+ SQUASHFS_SWAP_DIR_ENTRY_2(dire, &sdire);
+ } else
+ memcpy(dire, directory_table + bytes,
+ sizeof(*dire));
+ bytes += sizeof(*dire);
+
+ /* size should never be larger than SQUASHFS_NAME_LEN */
+ if(dire->size > SQUASHFS_NAME_LEN)
+ goto corrupted;
+
+ memcpy(dire->name, directory_table + bytes,
+ dire->size + 1);
+ dire->name[dire->size + 1] = '\0';
+ TRACE("squashfs_opendir: directory entry %s, inode "
+ "%d:%d, type %d\n", dire->name,
+ dirh.start_block, dire->offset, dire->type);
+ if((dir->dir_count % DIR_ENT_SIZE) == 0) {
+ new_dir = realloc(dir->dirs, (dir->dir_count +
+ DIR_ENT_SIZE) * sizeof(struct dir_ent));
+ if(new_dir == NULL)
+ EXIT_UNSQUASH("squashfs_opendir: "
+ "realloc failed!\n");
+ dir->dirs = new_dir;
+ }
+ strcpy(dir->dirs[dir->dir_count].name, dire->name);
+ dir->dirs[dir->dir_count].start_block =
+ dirh.start_block;
+ dir->dirs[dir->dir_count].offset = dire->offset;
+ dir->dirs[dir->dir_count].type = dire->type;
+ dir->dir_count ++;
+ bytes += dire->size + 1;
+ }
+ }
+
+ return dir;
+
+corrupted:
+ free(dir->dirs);
+ free(dir);
+ return NULL;
+}
+
+
+int read_uids_guids_1()
+{
+ int res;
+
+ TRACE("read_uids_guids: no_uids %d, no_guids %d\n", sBlk.no_uids,
+ sBlk.no_guids);
+
+ uid_table = malloc((sBlk.no_uids + sBlk.no_guids) *
+ sizeof(unsigned int));
+ if(uid_table == NULL) {
+ ERROR("read_uids_guids: failed to allocate uid/gid table\n");
+ return FALSE;
+ }
+
+ guid_table = uid_table + sBlk.no_uids;
+
+ if(swap) {
+ unsigned int suid_table[sBlk.no_uids + sBlk.no_guids];
+
+ res = read_fs_bytes(fd, sBlk.uid_start, (sBlk.no_uids +
+ sBlk.no_guids) * sizeof(unsigned int), suid_table);
+ if(res == FALSE) {
+ ERROR("read_uids_guids: failed to read uid/gid table"
+ "\n");
+ return FALSE;
+ }
+ SQUASHFS_SWAP_INTS_3(uid_table, suid_table,
+ sBlk.no_uids + sBlk.no_guids);
+ } else {
+ res = read_fs_bytes(fd, sBlk.uid_start, (sBlk.no_uids +
+ sBlk.no_guids) * sizeof(unsigned int), uid_table);
+ if(res == FALSE) {
+ ERROR("read_uids_guids: failed to read uid/gid table"
+ "\n");
+ return FALSE;
+ }
+ }
+
+ return TRUE;
+}
diff --git a/squashfs-tools/squashfs-tools/unsquash-2.c b/squashfs-tools/squashfs-tools/unsquash-2.c
new file mode 100644
index 0000000..0f2bfe8
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/unsquash-2.c
@@ -0,0 +1,270 @@
+/*
+ * Unsquash a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2009, 2010, 2013
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * unsquash-2.c
+ */
+
+#include "unsquashfs.h"
+#include "squashfs_compat.h"
+
+static squashfs_fragment_entry_2 *fragment_table;
+
+void read_block_list_2(unsigned int *block_list, char *block_ptr, int blocks)
+{
+ TRACE("read_block_list: blocks %d\n", blocks);
+
+ if(swap) {
+ unsigned int sblock_list[blocks];
+ memcpy(sblock_list, block_ptr, blocks * sizeof(unsigned int));
+ SQUASHFS_SWAP_INTS_3(block_list, sblock_list, blocks);
+ } else
+ memcpy(block_list, block_ptr, blocks * sizeof(unsigned int));
+}
+
+
+int read_fragment_table_2(long long *directory_table_end)
+{
+ int res, i;
+ int bytes = SQUASHFS_FRAGMENT_BYTES_2(sBlk.s.fragments);
+ int indexes = SQUASHFS_FRAGMENT_INDEXES_2(sBlk.s.fragments);
+ unsigned int fragment_table_index[indexes];
+
+ TRACE("read_fragment_table: %d fragments, reading %d fragment indexes "
+ "from 0x%llx\n", sBlk.s.fragments, indexes,
+ sBlk.s.fragment_table_start);
+
+ if(sBlk.s.fragments == 0) {
+ *directory_table_end = sBlk.s.fragment_table_start;
+ return TRUE;
+ }
+
+ fragment_table = malloc(bytes);
+ if(fragment_table == NULL)
+ EXIT_UNSQUASH("read_fragment_table: failed to allocate "
+ "fragment table\n");
+
+ if(swap) {
+ unsigned int sfragment_table_index[indexes];
+
+ res = read_fs_bytes(fd, sBlk.s.fragment_table_start,
+ SQUASHFS_FRAGMENT_INDEX_BYTES_2(sBlk.s.fragments),
+ sfragment_table_index);
+ if(res == FALSE) {
+ ERROR("read_fragment_table: failed to read fragment "
+ "table index\n");
+ return FALSE;
+ }
+ SQUASHFS_SWAP_FRAGMENT_INDEXES_2(fragment_table_index,
+ sfragment_table_index, indexes);
+ } else {
+ res = read_fs_bytes(fd, sBlk.s.fragment_table_start,
+ SQUASHFS_FRAGMENT_INDEX_BYTES_2(sBlk.s.fragments),
+ fragment_table_index);
+ if(res == FALSE) {
+ ERROR("read_fragment_table: failed to read fragment "
+ "table index\n");
+ return FALSE;
+ }
+ }
+
+ for(i = 0; i < indexes; i++) {
+ int expected = (i + 1) != indexes ? SQUASHFS_METADATA_SIZE :
+ bytes & (SQUASHFS_METADATA_SIZE - 1);
+ int length = read_block(fd, fragment_table_index[i], NULL,
+ expected, ((char *) fragment_table) + (i *
+ SQUASHFS_METADATA_SIZE));
+ TRACE("Read fragment table block %d, from 0x%x, length %d\n", i,
+ fragment_table_index[i], length);
+ if(length == FALSE) {
+ ERROR("read_fragment_table: failed to read fragment "
+ "table block\n");
+ return FALSE;
+ }
+ }
+
+ if(swap) {
+ squashfs_fragment_entry_2 sfragment;
+ for(i = 0; i < sBlk.s.fragments; i++) {
+ SQUASHFS_SWAP_FRAGMENT_ENTRY_2((&sfragment),
+ (&fragment_table[i]));
+ memcpy((char *) &fragment_table[i], (char *) &sfragment,
+ sizeof(squashfs_fragment_entry_2));
+ }
+ }
+
+ *directory_table_end = fragment_table_index[0];
+ return TRUE;
+}
+
+
+void read_fragment_2(unsigned int fragment, long long *start_block, int *size)
+{
+ TRACE("read_fragment: reading fragment %d\n", fragment);
+
+ squashfs_fragment_entry_2 *fragment_entry = &fragment_table[fragment];
+ *start_block = fragment_entry->start_block;
+ *size = fragment_entry->size;
+}
+
+
+struct inode *read_inode_2(unsigned int start_block, unsigned int offset)
+{
+ static union squashfs_inode_header_2 header;
+ long long start = sBlk.s.inode_table_start + start_block;
+ int bytes = lookup_entry(inode_table_hash, start);
+ char *block_ptr = inode_table + bytes + offset;
+ static struct inode i;
+
+ TRACE("read_inode: reading inode [%d:%d]\n", start_block, offset);
+
+ if(bytes == -1)
+ EXIT_UNSQUASH("read_inode: inode table block %lld not found\n",
+ start);
+
+ if(swap) {
+ squashfs_base_inode_header_2 sinode;
+ memcpy(&sinode, block_ptr, sizeof(header.base));
+ SQUASHFS_SWAP_BASE_INODE_HEADER_2(&header.base, &sinode,
+ sizeof(squashfs_base_inode_header_2));
+ } else
+ memcpy(&header.base, block_ptr, sizeof(header.base));
+
+ i.xattr = SQUASHFS_INVALID_XATTR;
+ i.uid = (uid_t) uid_table[header.base.uid];
+ i.gid = header.base.guid == SQUASHFS_GUIDS ? i.uid :
+ (uid_t) guid_table[header.base.guid];
+ i.mode = lookup_type[header.base.inode_type] | header.base.mode;
+ i.type = header.base.inode_type;
+ i.time = sBlk.s.mkfs_time;
+ i.inode_number = inode_number++;
+
+ switch(header.base.inode_type) {
+ case SQUASHFS_DIR_TYPE: {
+ squashfs_dir_inode_header_2 *inode = &header.dir;
+
+ if(swap) {
+ squashfs_dir_inode_header_2 sinode;
+ memcpy(&sinode, block_ptr, sizeof(header.dir));
+ SQUASHFS_SWAP_DIR_INODE_HEADER_2(&header.dir,
+ &sinode);
+ } else
+ memcpy(&header.dir, block_ptr,
+ sizeof(header.dir));
+
+ i.data = inode->file_size;
+ i.offset = inode->offset;
+ i.start = inode->start_block;
+ i.time = inode->mtime;
+ break;
+ }
+ case SQUASHFS_LDIR_TYPE: {
+ squashfs_ldir_inode_header_2 *inode = &header.ldir;
+
+ if(swap) {
+ squashfs_ldir_inode_header_2 sinode;
+ memcpy(&sinode, block_ptr, sizeof(header.ldir));
+ SQUASHFS_SWAP_LDIR_INODE_HEADER_2(&header.ldir,
+ &sinode);
+ } else
+ memcpy(&header.ldir, block_ptr,
+ sizeof(header.ldir));
+
+ i.data = inode->file_size;
+ i.offset = inode->offset;
+ i.start = inode->start_block;
+ i.time = inode->mtime;
+ break;
+ }
+ case SQUASHFS_FILE_TYPE: {
+ squashfs_reg_inode_header_2 *inode = &header.reg;
+
+ if(swap) {
+ squashfs_reg_inode_header_2 sinode;
+ memcpy(&sinode, block_ptr, sizeof(sinode));
+ SQUASHFS_SWAP_REG_INODE_HEADER_2(inode,
+ &sinode);
+ } else
+ memcpy(inode, block_ptr, sizeof(*inode));
+
+ i.data = inode->file_size;
+ i.time = inode->mtime;
+ i.frag_bytes = inode->fragment == SQUASHFS_INVALID_FRAG
+ ? 0 : inode->file_size % sBlk.s.block_size;
+ i.fragment = inode->fragment;
+ i.offset = inode->offset;
+ i.blocks = inode->fragment == SQUASHFS_INVALID_FRAG ?
+ (i.data + sBlk.s.block_size - 1) >>
+ sBlk.s.block_log : i.data >>
+ sBlk.s.block_log;
+ i.start = inode->start_block;
+ i.sparse = 0;
+ i.block_ptr = block_ptr + sizeof(*inode);
+ break;
+ }
+ case SQUASHFS_SYMLINK_TYPE: {
+ squashfs_symlink_inode_header_2 *inodep =
+ &header.symlink;
+
+ if(swap) {
+ squashfs_symlink_inode_header_2 sinodep;
+ memcpy(&sinodep, block_ptr, sizeof(sinodep));
+ SQUASHFS_SWAP_SYMLINK_INODE_HEADER_2(inodep,
+ &sinodep);
+ } else
+ memcpy(inodep, block_ptr, sizeof(*inodep));
+
+ i.symlink = malloc(inodep->symlink_size + 1);
+ if(i.symlink == NULL)
+ EXIT_UNSQUASH("read_inode: failed to malloc "
+ "symlink data\n");
+ strncpy(i.symlink, block_ptr +
+ sizeof(squashfs_symlink_inode_header_2),
+ inodep->symlink_size);
+ i.symlink[inodep->symlink_size] = '\0';
+ i.data = inodep->symlink_size;
+ break;
+ }
+ case SQUASHFS_BLKDEV_TYPE:
+ case SQUASHFS_CHRDEV_TYPE: {
+ squashfs_dev_inode_header_2 *inodep = &header.dev;
+
+ if(swap) {
+ squashfs_dev_inode_header_2 sinodep;
+ memcpy(&sinodep, block_ptr, sizeof(sinodep));
+ SQUASHFS_SWAP_DEV_INODE_HEADER_2(inodep,
+ &sinodep);
+ } else
+ memcpy(inodep, block_ptr, sizeof(*inodep));
+
+ i.data = inodep->rdev;
+ break;
+ }
+ case SQUASHFS_FIFO_TYPE:
+ case SQUASHFS_SOCKET_TYPE:
+ i.data = 0;
+ break;
+ default:
+ EXIT_UNSQUASH("Unknown inode type %d in "
+ "read_inode_header_2!\n",
+ header.base.inode_type);
+ }
+ return &i;
+}
diff --git a/squashfs-tools/squashfs-tools/unsquash-3.c b/squashfs-tools/squashfs-tools/unsquash-3.c
new file mode 100644
index 0000000..d5af57a
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/unsquash-3.c
@@ -0,0 +1,393 @@
+/*
+ * Unsquash a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2009, 2010, 2011, 2012, 2013
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * unsquash-3.c
+ */
+
+#include "unsquashfs.h"
+#include "squashfs_compat.h"
+
+static squashfs_fragment_entry_3 *fragment_table;
+
+int read_fragment_table_3(long long *directory_table_end)
+{
+ int res, i;
+ int bytes = SQUASHFS_FRAGMENT_BYTES_3(sBlk.s.fragments);
+ int indexes = SQUASHFS_FRAGMENT_INDEXES_3(sBlk.s.fragments);
+ long long fragment_table_index[indexes];
+
+ TRACE("read_fragment_table: %d fragments, reading %d fragment indexes "
+ "from 0x%llx\n", sBlk.s.fragments, indexes,
+ sBlk.s.fragment_table_start);
+
+ if(sBlk.s.fragments == 0) {
+ *directory_table_end = sBlk.s.fragment_table_start;
+ return TRUE;
+ }
+
+ fragment_table = malloc(bytes);
+ if(fragment_table == NULL)
+ EXIT_UNSQUASH("read_fragment_table: failed to allocate "
+ "fragment table\n");
+
+ if(swap) {
+ long long sfragment_table_index[indexes];
+
+ res = read_fs_bytes(fd, sBlk.s.fragment_table_start,
+ SQUASHFS_FRAGMENT_INDEX_BYTES_3(sBlk.s.fragments),
+ sfragment_table_index);
+ if(res == FALSE) {
+ ERROR("read_fragment_table: failed to read fragment "
+ "table index\n");
+ return FALSE;
+ }
+ SQUASHFS_SWAP_FRAGMENT_INDEXES_3(fragment_table_index,
+ sfragment_table_index, indexes);
+ } else {
+ res = read_fs_bytes(fd, sBlk.s.fragment_table_start,
+ SQUASHFS_FRAGMENT_INDEX_BYTES_3(sBlk.s.fragments),
+ fragment_table_index);
+ if(res == FALSE) {
+ ERROR("read_fragment_table: failed to read fragment "
+ "table index\n");
+ return FALSE;
+ }
+ }
+
+ for(i = 0; i < indexes; i++) {
+ int expected = (i + 1) != indexes ? SQUASHFS_METADATA_SIZE :
+ bytes & (SQUASHFS_METADATA_SIZE - 1);
+ int length = read_block(fd, fragment_table_index[i], NULL,
+ expected, ((char *) fragment_table) + (i *
+ SQUASHFS_METADATA_SIZE));
+ TRACE("Read fragment table block %d, from 0x%llx, length %d\n",
+ i, fragment_table_index[i], length);
+ if(length == FALSE) {
+ ERROR("read_fragment_table: failed to read fragment "
+ "table block\n");
+ return FALSE;
+ }
+ }
+
+ if(swap) {
+ squashfs_fragment_entry_3 sfragment;
+ for(i = 0; i < sBlk.s.fragments; i++) {
+ SQUASHFS_SWAP_FRAGMENT_ENTRY_3((&sfragment),
+ (&fragment_table[i]));
+ memcpy((char *) &fragment_table[i], (char *) &sfragment,
+ sizeof(squashfs_fragment_entry_3));
+ }
+ }
+
+ *directory_table_end = fragment_table_index[0];
+ return TRUE;
+}
+
+
+void read_fragment_3(unsigned int fragment, long long *start_block, int *size)
+{
+ TRACE("read_fragment: reading fragment %d\n", fragment);
+
+ squashfs_fragment_entry_3 *fragment_entry = &fragment_table[fragment];
+ *start_block = fragment_entry->start_block;
+ *size = fragment_entry->size;
+}
+
+
+struct inode *read_inode_3(unsigned int start_block, unsigned int offset)
+{
+ static union squashfs_inode_header_3 header;
+ long long start = sBlk.s.inode_table_start + start_block;
+ int bytes = lookup_entry(inode_table_hash, start);
+ char *block_ptr = inode_table + bytes + offset;
+ static struct inode i;
+
+ TRACE("read_inode: reading inode [%d:%d]\n", start_block, offset);
+
+ if(bytes == -1)
+ EXIT_UNSQUASH("read_inode: inode table block %lld not found\n",
+ start);
+
+ if(swap) {
+ squashfs_base_inode_header_3 sinode;
+ memcpy(&sinode, block_ptr, sizeof(header.base));
+ SQUASHFS_SWAP_BASE_INODE_HEADER_3(&header.base, &sinode,
+ sizeof(squashfs_base_inode_header_3));
+ } else
+ memcpy(&header.base, block_ptr, sizeof(header.base));
+
+ i.xattr = SQUASHFS_INVALID_XATTR;
+ i.uid = (uid_t) uid_table[header.base.uid];
+ i.gid = header.base.guid == SQUASHFS_GUIDS ? i.uid :
+ (uid_t) guid_table[header.base.guid];
+ i.mode = lookup_type[header.base.inode_type] | header.base.mode;
+ i.type = header.base.inode_type;
+ i.time = header.base.mtime;
+ i.inode_number = header.base.inode_number;
+
+ switch(header.base.inode_type) {
+ case SQUASHFS_DIR_TYPE: {
+ squashfs_dir_inode_header_3 *inode = &header.dir;
+
+ if(swap) {
+ squashfs_dir_inode_header_3 sinode;
+ memcpy(&sinode, block_ptr, sizeof(header.dir));
+ SQUASHFS_SWAP_DIR_INODE_HEADER_3(&header.dir,
+ &sinode);
+ } else
+ memcpy(&header.dir, block_ptr,
+ sizeof(header.dir));
+
+ i.data = inode->file_size;
+ i.offset = inode->offset;
+ i.start = inode->start_block;
+ break;
+ }
+ case SQUASHFS_LDIR_TYPE: {
+ squashfs_ldir_inode_header_3 *inode = &header.ldir;
+
+ if(swap) {
+ squashfs_ldir_inode_header_3 sinode;
+ memcpy(&sinode, block_ptr, sizeof(header.ldir));
+ SQUASHFS_SWAP_LDIR_INODE_HEADER_3(&header.ldir,
+ &sinode);
+ } else
+ memcpy(&header.ldir, block_ptr,
+ sizeof(header.ldir));
+
+ i.data = inode->file_size;
+ i.offset = inode->offset;
+ i.start = inode->start_block;
+ break;
+ }
+ case SQUASHFS_FILE_TYPE: {
+ squashfs_reg_inode_header_3 *inode = &header.reg;
+
+ if(swap) {
+ squashfs_reg_inode_header_3 sinode;
+ memcpy(&sinode, block_ptr, sizeof(sinode));
+ SQUASHFS_SWAP_REG_INODE_HEADER_3(inode,
+ &sinode);
+ } else
+ memcpy(inode, block_ptr, sizeof(*inode));
+
+ i.data = inode->file_size;
+ i.frag_bytes = inode->fragment == SQUASHFS_INVALID_FRAG
+ ? 0 : inode->file_size % sBlk.s.block_size;
+ i.fragment = inode->fragment;
+ i.offset = inode->offset;
+ i.blocks = inode->fragment == SQUASHFS_INVALID_FRAG ?
+ (i.data + sBlk.s.block_size - 1) >>
+ sBlk.s.block_log :
+ i.data >> sBlk.s.block_log;
+ i.start = inode->start_block;
+ i.sparse = 1;
+ i.block_ptr = block_ptr + sizeof(*inode);
+ break;
+ }
+ case SQUASHFS_LREG_TYPE: {
+ squashfs_lreg_inode_header_3 *inode = &header.lreg;
+
+ if(swap) {
+ squashfs_lreg_inode_header_3 sinode;
+ memcpy(&sinode, block_ptr, sizeof(sinode));
+ SQUASHFS_SWAP_LREG_INODE_HEADER_3(inode,
+ &sinode);
+ } else
+ memcpy(inode, block_ptr, sizeof(*inode));
+
+ i.data = inode->file_size;
+ i.frag_bytes = inode->fragment == SQUASHFS_INVALID_FRAG
+ ? 0 : inode->file_size % sBlk.s.block_size;
+ i.fragment = inode->fragment;
+ i.offset = inode->offset;
+ i.blocks = inode->fragment == SQUASHFS_INVALID_FRAG ?
+ (inode->file_size + sBlk.s.block_size - 1) >>
+ sBlk.s.block_log :
+ inode->file_size >> sBlk.s.block_log;
+ i.start = inode->start_block;
+ i.sparse = 1;
+ i.block_ptr = block_ptr + sizeof(*inode);
+ break;
+ }
+ case SQUASHFS_SYMLINK_TYPE: {
+ squashfs_symlink_inode_header_3 *inodep =
+ &header.symlink;
+
+ if(swap) {
+ squashfs_symlink_inode_header_3 sinodep;
+ memcpy(&sinodep, block_ptr, sizeof(sinodep));
+ SQUASHFS_SWAP_SYMLINK_INODE_HEADER_3(inodep,
+ &sinodep);
+ } else
+ memcpy(inodep, block_ptr, sizeof(*inodep));
+
+ i.symlink = malloc(inodep->symlink_size + 1);
+ if(i.symlink == NULL)
+ EXIT_UNSQUASH("read_inode: failed to malloc "
+ "symlink data\n");
+ strncpy(i.symlink, block_ptr +
+ sizeof(squashfs_symlink_inode_header_3),
+ inodep->symlink_size);
+ i.symlink[inodep->symlink_size] = '\0';
+ i.data = inodep->symlink_size;
+ break;
+ }
+ case SQUASHFS_BLKDEV_TYPE:
+ case SQUASHFS_CHRDEV_TYPE: {
+ squashfs_dev_inode_header_3 *inodep = &header.dev;
+
+ if(swap) {
+ squashfs_dev_inode_header_3 sinodep;
+ memcpy(&sinodep, block_ptr, sizeof(sinodep));
+ SQUASHFS_SWAP_DEV_INODE_HEADER_3(inodep,
+ &sinodep);
+ } else
+ memcpy(inodep, block_ptr, sizeof(*inodep));
+
+ i.data = inodep->rdev;
+ break;
+ }
+ case SQUASHFS_FIFO_TYPE:
+ case SQUASHFS_SOCKET_TYPE:
+ i.data = 0;
+ break;
+ default:
+ EXIT_UNSQUASH("Unknown inode type %d in read_inode!\n",
+ header.base.inode_type);
+ }
+ return &i;
+}
+
+
+struct dir *squashfs_opendir_3(unsigned int block_start, unsigned int offset,
+ struct inode **i)
+{
+ squashfs_dir_header_3 dirh;
+ char buffer[sizeof(squashfs_dir_entry_3) + SQUASHFS_NAME_LEN + 1]
+ __attribute__((aligned));
+ squashfs_dir_entry_3 *dire = (squashfs_dir_entry_3 *) buffer;
+ long long start;
+ int bytes;
+ int dir_count, size;
+ struct dir_ent *new_dir;
+ struct dir *dir;
+
+ TRACE("squashfs_opendir: inode start block %d, offset %d\n",
+ block_start, offset);
+
+ *i = s_ops.read_inode(block_start, offset);
+
+ dir = malloc(sizeof(struct dir));
+ if(dir == NULL)
+ EXIT_UNSQUASH("squashfs_opendir: malloc failed!\n");
+
+ dir->dir_count = 0;
+ dir->cur_entry = 0;
+ dir->mode = (*i)->mode;
+ dir->uid = (*i)->uid;
+ dir->guid = (*i)->gid;
+ dir->mtime = (*i)->time;
+ dir->xattr = (*i)->xattr;
+ dir->dirs = NULL;
+
+ if ((*i)->data == 3)
+ /*
+ * if the directory is empty, skip the unnecessary
+ * lookup_entry, this fixes the corner case with
+ * completely empty filesystems where lookup_entry correctly
+ * returning -1 is incorrectly treated as an error
+ */
+ return dir;
+
+ start = sBlk.s.directory_table_start + (*i)->start;
+ bytes = lookup_entry(directory_table_hash, start);
+
+ if(bytes == -1)
+ EXIT_UNSQUASH("squashfs_opendir: directory block %d not "
+ "found!\n", block_start);
+
+ bytes += (*i)->offset;
+ size = (*i)->data + bytes - 3;
+
+ while(bytes < size) {
+ if(swap) {
+ squashfs_dir_header_3 sdirh;
+ memcpy(&sdirh, directory_table + bytes, sizeof(sdirh));
+ SQUASHFS_SWAP_DIR_HEADER_3(&dirh, &sdirh);
+ } else
+ memcpy(&dirh, directory_table + bytes, sizeof(dirh));
+
+ dir_count = dirh.count + 1;
+ TRACE("squashfs_opendir: Read directory header @ byte position "
+ "%d, %d directory entries\n", bytes, dir_count);
+ bytes += sizeof(dirh);
+
+ /* dir_count should never be larger than 256 */
+ if(dir_count > 256)
+ goto corrupted;
+
+ while(dir_count--) {
+ if(swap) {
+ squashfs_dir_entry_3 sdire;
+ memcpy(&sdire, directory_table + bytes,
+ sizeof(sdire));
+ SQUASHFS_SWAP_DIR_ENTRY_3(dire, &sdire);
+ } else
+ memcpy(dire, directory_table + bytes,
+ sizeof(*dire));
+ bytes += sizeof(*dire);
+
+ /* size should never be larger than SQUASHFS_NAME_LEN */
+ if(dire->size > SQUASHFS_NAME_LEN)
+ goto corrupted;
+
+ memcpy(dire->name, directory_table + bytes,
+ dire->size + 1);
+ dire->name[dire->size + 1] = '\0';
+ TRACE("squashfs_opendir: directory entry %s, inode "
+ "%d:%d, type %d\n", dire->name,
+ dirh.start_block, dire->offset, dire->type);
+ if((dir->dir_count % DIR_ENT_SIZE) == 0) {
+ new_dir = realloc(dir->dirs, (dir->dir_count +
+ DIR_ENT_SIZE) * sizeof(struct dir_ent));
+ if(new_dir == NULL)
+ EXIT_UNSQUASH("squashfs_opendir: "
+ "realloc failed!\n");
+ dir->dirs = new_dir;
+ }
+ strcpy(dir->dirs[dir->dir_count].name, dire->name);
+ dir->dirs[dir->dir_count].start_block =
+ dirh.start_block;
+ dir->dirs[dir->dir_count].offset = dire->offset;
+ dir->dirs[dir->dir_count].type = dire->type;
+ dir->dir_count ++;
+ bytes += dire->size + 1;
+ }
+ }
+
+ return dir;
+
+corrupted:
+ free(dir->dirs);
+ free(dir);
+ return NULL;
+}
diff --git a/squashfs-tools/squashfs-tools/unsquash-4.c b/squashfs-tools/squashfs-tools/unsquash-4.c
new file mode 100644
index 0000000..ecdaac7
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/unsquash-4.c
@@ -0,0 +1,392 @@
+/*
+ * Unsquash a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2009, 2010, 2011, 2012, 2013
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * unsquash-4.c
+ */
+
+#include "unsquashfs.h"
+#include "squashfs_swap.h"
+
+static struct squashfs_fragment_entry *fragment_table;
+static unsigned int *id_table;
+
+int read_fragment_table_4(long long *directory_table_end)
+{
+ int res, i;
+ int bytes = SQUASHFS_FRAGMENT_BYTES(sBlk.s.fragments);
+ int indexes = SQUASHFS_FRAGMENT_INDEXES(sBlk.s.fragments);
+ long long fragment_table_index[indexes];
+
+ TRACE("read_fragment_table: %d fragments, reading %d fragment indexes "
+ "from 0x%llx\n", sBlk.s.fragments, indexes,
+ sBlk.s.fragment_table_start);
+
+ if(sBlk.s.fragments == 0) {
+ *directory_table_end = sBlk.s.fragment_table_start;
+ return TRUE;
+ }
+
+ fragment_table = malloc(bytes);
+ if(fragment_table == NULL)
+ EXIT_UNSQUASH("read_fragment_table: failed to allocate "
+ "fragment table\n");
+
+ res = read_fs_bytes(fd, sBlk.s.fragment_table_start,
+ SQUASHFS_FRAGMENT_INDEX_BYTES(sBlk.s.fragments),
+ fragment_table_index);
+ if(res == FALSE) {
+ ERROR("read_fragment_table: failed to read fragment table "
+ "index\n");
+ return FALSE;
+ }
+ SQUASHFS_INSWAP_FRAGMENT_INDEXES(fragment_table_index, indexes);
+
+ for(i = 0; i < indexes; i++) {
+ int expected = (i + 1) != indexes ? SQUASHFS_METADATA_SIZE :
+ bytes & (SQUASHFS_METADATA_SIZE - 1);
+ int length = read_block(fd, fragment_table_index[i], NULL,
+ expected, ((char *) fragment_table) + (i *
+ SQUASHFS_METADATA_SIZE));
+ TRACE("Read fragment table block %d, from 0x%llx, length %d\n",
+ i, fragment_table_index[i], length);
+ if(length == FALSE) {
+ ERROR("read_fragment_table: failed to read fragment "
+ "table index\n");
+ return FALSE;
+ }
+ }
+
+ for(i = 0; i < sBlk.s.fragments; i++)
+ SQUASHFS_INSWAP_FRAGMENT_ENTRY(&fragment_table[i]);
+
+ *directory_table_end = fragment_table_index[0];
+ return TRUE;
+}
+
+
+void read_fragment_4(unsigned int fragment, long long *start_block, int *size)
+{
+ TRACE("read_fragment: reading fragment %d\n", fragment);
+
+ struct squashfs_fragment_entry *fragment_entry;
+
+ fragment_entry = &fragment_table[fragment];
+ *start_block = fragment_entry->start_block;
+ *size = fragment_entry->size;
+}
+
+
+struct inode *read_inode_4(unsigned int start_block, unsigned int offset)
+{
+ static union squashfs_inode_header header;
+ long long start = sBlk.s.inode_table_start + start_block;
+ int bytes = lookup_entry(inode_table_hash, start);
+ char *block_ptr = inode_table + bytes + offset;
+ static struct inode i;
+
+ TRACE("read_inode: reading inode [%d:%d]\n", start_block, offset);
+
+ if(bytes == -1)
+ EXIT_UNSQUASH("read_inode: inode table block %lld not found\n",
+ start);
+
+ SQUASHFS_SWAP_BASE_INODE_HEADER(block_ptr, &header.base);
+
+ i.uid = (uid_t) id_table[header.base.uid];
+ i.gid = (uid_t) id_table[header.base.guid];
+ i.mode = lookup_type[header.base.inode_type] | header.base.mode;
+ i.type = header.base.inode_type;
+ i.time = header.base.mtime;
+ i.inode_number = header.base.inode_number;
+
+ switch(header.base.inode_type) {
+ case SQUASHFS_DIR_TYPE: {
+ struct squashfs_dir_inode_header *inode = &header.dir;
+
+ SQUASHFS_SWAP_DIR_INODE_HEADER(block_ptr, inode);
+
+ i.data = inode->file_size;
+ i.offset = inode->offset;
+ i.start = inode->start_block;
+ i.xattr = SQUASHFS_INVALID_XATTR;
+ break;
+ }
+ case SQUASHFS_LDIR_TYPE: {
+ struct squashfs_ldir_inode_header *inode = &header.ldir;
+
+ SQUASHFS_SWAP_LDIR_INODE_HEADER(block_ptr, inode);
+
+ i.data = inode->file_size;
+ i.offset = inode->offset;
+ i.start = inode->start_block;
+ i.xattr = inode->xattr;
+ break;
+ }
+ case SQUASHFS_FILE_TYPE: {
+ struct squashfs_reg_inode_header *inode = &header.reg;
+
+ SQUASHFS_SWAP_REG_INODE_HEADER(block_ptr, inode);
+
+ i.data = inode->file_size;
+ i.frag_bytes = inode->fragment == SQUASHFS_INVALID_FRAG
+ ? 0 : inode->file_size % sBlk.s.block_size;
+ i.fragment = inode->fragment;
+ i.offset = inode->offset;
+ i.blocks = inode->fragment == SQUASHFS_INVALID_FRAG ?
+ (i.data + sBlk.s.block_size - 1) >>
+ sBlk.s.block_log :
+ i.data >> sBlk.s.block_log;
+ i.start = inode->start_block;
+ i.sparse = 0;
+ i.block_ptr = block_ptr + sizeof(*inode);
+ i.xattr = SQUASHFS_INVALID_XATTR;
+ break;
+ }
+ case SQUASHFS_LREG_TYPE: {
+ struct squashfs_lreg_inode_header *inode = &header.lreg;
+
+ SQUASHFS_SWAP_LREG_INODE_HEADER(block_ptr, inode);
+
+ i.data = inode->file_size;
+ i.frag_bytes = inode->fragment == SQUASHFS_INVALID_FRAG
+ ? 0 : inode->file_size % sBlk.s.block_size;
+ i.fragment = inode->fragment;
+ i.offset = inode->offset;
+ i.blocks = inode->fragment == SQUASHFS_INVALID_FRAG ?
+ (inode->file_size + sBlk.s.block_size - 1) >>
+ sBlk.s.block_log :
+ inode->file_size >> sBlk.s.block_log;
+ i.start = inode->start_block;
+ i.sparse = inode->sparse != 0;
+ i.block_ptr = block_ptr + sizeof(*inode);
+ i.xattr = inode->xattr;
+ break;
+ }
+ case SQUASHFS_SYMLINK_TYPE:
+ case SQUASHFS_LSYMLINK_TYPE: {
+ struct squashfs_symlink_inode_header *inode = &header.symlink;
+
+ SQUASHFS_SWAP_SYMLINK_INODE_HEADER(block_ptr, inode);
+
+ i.symlink = malloc(inode->symlink_size + 1);
+ if(i.symlink == NULL)
+ EXIT_UNSQUASH("read_inode: failed to malloc "
+ "symlink data\n");
+ strncpy(i.symlink, block_ptr +
+ sizeof(struct squashfs_symlink_inode_header),
+ inode->symlink_size);
+ i.symlink[inode->symlink_size] = '\0';
+ i.data = inode->symlink_size;
+
+ if(header.base.inode_type == SQUASHFS_LSYMLINK_TYPE)
+ SQUASHFS_SWAP_INTS(block_ptr +
+ sizeof(struct squashfs_symlink_inode_header) +
+ inode->symlink_size, &i.xattr, 1);
+ else
+ i.xattr = SQUASHFS_INVALID_XATTR;
+ break;
+ }
+ case SQUASHFS_BLKDEV_TYPE:
+ case SQUASHFS_CHRDEV_TYPE: {
+ struct squashfs_dev_inode_header *inode = &header.dev;
+
+ SQUASHFS_SWAP_DEV_INODE_HEADER(block_ptr, inode);
+
+ i.data = inode->rdev;
+ i.xattr = SQUASHFS_INVALID_XATTR;
+ break;
+ }
+ case SQUASHFS_LBLKDEV_TYPE:
+ case SQUASHFS_LCHRDEV_TYPE: {
+ struct squashfs_ldev_inode_header *inode = &header.ldev;
+
+ SQUASHFS_SWAP_LDEV_INODE_HEADER(block_ptr, inode);
+
+ i.data = inode->rdev;
+ i.xattr = inode->xattr;
+ break;
+ }
+ case SQUASHFS_FIFO_TYPE:
+ case SQUASHFS_SOCKET_TYPE:
+ i.data = 0;
+ i.xattr = SQUASHFS_INVALID_XATTR;
+ break;
+ case SQUASHFS_LFIFO_TYPE:
+ case SQUASHFS_LSOCKET_TYPE: {
+ struct squashfs_lipc_inode_header *inode = &header.lipc;
+
+ SQUASHFS_SWAP_LIPC_INODE_HEADER(block_ptr, inode);
+
+ i.data = 0;
+ i.xattr = inode->xattr;
+ break;
+ }
+ default:
+ EXIT_UNSQUASH("Unknown inode type %d in read_inode!\n",
+ header.base.inode_type);
+ }
+ return &i;
+}
+
+
+struct dir *squashfs_opendir_4(unsigned int block_start, unsigned int offset,
+ struct inode **i)
+{
+ struct squashfs_dir_header dirh;
+ char buffer[sizeof(struct squashfs_dir_entry) + SQUASHFS_NAME_LEN + 1]
+ __attribute__((aligned));
+ struct squashfs_dir_entry *dire = (struct squashfs_dir_entry *) buffer;
+ long long start;
+ int bytes;
+ int dir_count, size;
+ struct dir_ent *new_dir;
+ struct dir *dir;
+
+ TRACE("squashfs_opendir: inode start block %d, offset %d\n",
+ block_start, offset);
+
+ *i = s_ops.read_inode(block_start, offset);
+
+ dir = malloc(sizeof(struct dir));
+ if(dir == NULL)
+ EXIT_UNSQUASH("squashfs_opendir: malloc failed!\n");
+
+ dir->dir_count = 0;
+ dir->cur_entry = 0;
+ dir->mode = (*i)->mode;
+ dir->uid = (*i)->uid;
+ dir->guid = (*i)->gid;
+ dir->mtime = (*i)->time;
+ dir->xattr = (*i)->xattr;
+ dir->dirs = NULL;
+
+ if ((*i)->data == 3)
+ /*
+ * if the directory is empty, skip the unnecessary
+ * lookup_entry, this fixes the corner case with
+ * completely empty filesystems where lookup_entry correctly
+ * returning -1 is incorrectly treated as an error
+ */
+ return dir;
+
+ start = sBlk.s.directory_table_start + (*i)->start;
+ bytes = lookup_entry(directory_table_hash, start);
+
+ if(bytes == -1)
+ EXIT_UNSQUASH("squashfs_opendir: directory block %d not "
+ "found!\n", block_start);
+
+ bytes += (*i)->offset;
+ size = (*i)->data + bytes - 3;
+
+ while(bytes < size) {
+ SQUASHFS_SWAP_DIR_HEADER(directory_table + bytes, &dirh);
+
+ dir_count = dirh.count + 1;
+ TRACE("squashfs_opendir: Read directory header @ byte position "
+ "%d, %d directory entries\n", bytes, dir_count);
+ bytes += sizeof(dirh);
+
+ /* dir_count should never be larger than 256 */
+ if(dir_count > 256)
+ goto corrupted;
+
+ while(dir_count--) {
+ SQUASHFS_SWAP_DIR_ENTRY(directory_table + bytes, dire);
+
+ bytes += sizeof(*dire);
+
+ /* size should never be larger than SQUASHFS_NAME_LEN */
+ if(dire->size > SQUASHFS_NAME_LEN)
+ goto corrupted;
+
+ memcpy(dire->name, directory_table + bytes,
+ dire->size + 1);
+ dire->name[dire->size + 1] = '\0';
+ TRACE("squashfs_opendir: directory entry %s, inode "
+ "%d:%d, type %d\n", dire->name,
+ dirh.start_block, dire->offset, dire->type);
+ if((dir->dir_count % DIR_ENT_SIZE) == 0) {
+ new_dir = realloc(dir->dirs, (dir->dir_count +
+ DIR_ENT_SIZE) * sizeof(struct dir_ent));
+ if(new_dir == NULL)
+ EXIT_UNSQUASH("squashfs_opendir: "
+ "realloc failed!\n");
+ dir->dirs = new_dir;
+ }
+ strcpy(dir->dirs[dir->dir_count].name, dire->name);
+ dir->dirs[dir->dir_count].start_block =
+ dirh.start_block;
+ dir->dirs[dir->dir_count].offset = dire->offset;
+ dir->dirs[dir->dir_count].type = dire->type;
+ dir->dir_count ++;
+ bytes += dire->size + 1;
+ }
+ }
+
+ return dir;
+
+corrupted:
+ free(dir->dirs);
+ free(dir);
+ return NULL;
+}
+
+
+int read_uids_guids_4()
+{
+ int res, i;
+ int bytes = SQUASHFS_ID_BYTES(sBlk.s.no_ids);
+ int indexes = SQUASHFS_ID_BLOCKS(sBlk.s.no_ids);
+ long long id_index_table[indexes];
+
+ TRACE("read_uids_guids: no_ids %d\n", sBlk.s.no_ids);
+
+ id_table = malloc(bytes);
+ if(id_table == NULL) {
+ ERROR("read_uids_guids: failed to allocate id table\n");
+ return FALSE;
+ }
+
+ res = read_fs_bytes(fd, sBlk.s.id_table_start,
+ SQUASHFS_ID_BLOCK_BYTES(sBlk.s.no_ids), id_index_table);
+ if(res == FALSE) {
+ ERROR("read_uids_guids: failed to read id index table\n");
+ return FALSE;
+ }
+ SQUASHFS_INSWAP_ID_BLOCKS(id_index_table, indexes);
+
+ for(i = 0; i < indexes; i++) {
+ int expected = (i + 1) != indexes ? SQUASHFS_METADATA_SIZE :
+ bytes & (SQUASHFS_METADATA_SIZE - 1);
+ res = read_block(fd, id_index_table[i], NULL, expected,
+ ((char *) id_table) + i * SQUASHFS_METADATA_SIZE);
+ if(res == FALSE) {
+ ERROR("read_uids_guids: failed to read id table block"
+ "\n");
+ return FALSE;
+ }
+ }
+
+ SQUASHFS_INSWAP_INTS(id_table, sBlk.s.no_ids);
+
+ return TRUE;
+}
diff --git a/squashfs-tools/squashfs-tools/unsquashfs.c b/squashfs-tools/squashfs-tools/unsquashfs.c
new file mode 100644
index 0000000..7f46968
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/unsquashfs.c
@@ -0,0 +1,2820 @@
+/*
+ * Unsquash a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
+ * 2012, 2013, 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * unsquashfs.c
+ */
+
+#include "unsquashfs.h"
+#include "squashfs_swap.h"
+#include "squashfs_compat.h"
+#include "compressor.h"
+#include "xattr.h"
+#include "unsquashfs_info.h"
+#include "stdarg.h"
+
+#ifndef linux
+#include <sys/sysctl.h>
+#else
+#include <sys/sysinfo.h>
+#endif
+
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <limits.h>
+#include <ctype.h>
+
+struct cache *fragment_cache, *data_cache;
+struct queue *to_reader, *to_inflate, *to_writer, *from_writer;
+pthread_t *thread, *inflator_thread;
+pthread_mutex_t fragment_mutex;
+
+/* user options that control parallelisation */
+int processors = -1;
+
+struct super_block sBlk;
+squashfs_operations s_ops;
+struct compressor *comp;
+
+int bytes = 0, swap, file_count = 0, dir_count = 0, sym_count = 0,
+ dev_count = 0, fifo_count = 0;
+char *inode_table = NULL, *directory_table = NULL;
+struct hash_table_entry *inode_table_hash[65536], *directory_table_hash[65536];
+int fd;
+unsigned int *uid_table, *guid_table;
+unsigned int cached_frag = SQUASHFS_INVALID_FRAG;
+char *fragment_data;
+char *file_data;
+char *data;
+unsigned int block_size;
+unsigned int block_log;
+int lsonly = FALSE, info = FALSE, force = FALSE, short_ls = TRUE;
+int use_regex = FALSE;
+char **created_inode;
+int root_process;
+int columns;
+int rotate = 0;
+pthread_mutex_t screen_mutex;
+int progress = TRUE, progress_enabled = FALSE;
+unsigned int total_blocks = 0, total_files = 0, total_inodes = 0;
+unsigned int cur_blocks = 0;
+int inode_number = 1;
+int no_xattrs = XATTR_DEF;
+int user_xattrs = FALSE;
+
+int lookup_type[] = {
+ 0,
+ S_IFDIR,
+ S_IFREG,
+ S_IFLNK,
+ S_IFBLK,
+ S_IFCHR,
+ S_IFIFO,
+ S_IFSOCK,
+ S_IFDIR,
+ S_IFREG,
+ S_IFLNK,
+ S_IFBLK,
+ S_IFCHR,
+ S_IFIFO,
+ S_IFSOCK
+};
+
+struct test table[] = {
+ { S_IFMT, S_IFSOCK, 0, 's' },
+ { S_IFMT, S_IFLNK, 0, 'l' },
+ { S_IFMT, S_IFBLK, 0, 'b' },
+ { S_IFMT, S_IFDIR, 0, 'd' },
+ { S_IFMT, S_IFCHR, 0, 'c' },
+ { S_IFMT, S_IFIFO, 0, 'p' },
+ { S_IRUSR, S_IRUSR, 1, 'r' },
+ { S_IWUSR, S_IWUSR, 2, 'w' },
+ { S_IRGRP, S_IRGRP, 4, 'r' },
+ { S_IWGRP, S_IWGRP, 5, 'w' },
+ { S_IROTH, S_IROTH, 7, 'r' },
+ { S_IWOTH, S_IWOTH, 8, 'w' },
+ { S_IXUSR | S_ISUID, S_IXUSR | S_ISUID, 3, 's' },
+ { S_IXUSR | S_ISUID, S_ISUID, 3, 'S' },
+ { S_IXUSR | S_ISUID, S_IXUSR, 3, 'x' },
+ { S_IXGRP | S_ISGID, S_IXGRP | S_ISGID, 6, 's' },
+ { S_IXGRP | S_ISGID, S_ISGID, 6, 'S' },
+ { S_IXGRP | S_ISGID, S_IXGRP, 6, 'x' },
+ { S_IXOTH | S_ISVTX, S_IXOTH | S_ISVTX, 9, 't' },
+ { S_IXOTH | S_ISVTX, S_ISVTX, 9, 'T' },
+ { S_IXOTH | S_ISVTX, S_IXOTH, 9, 'x' },
+ { 0, 0, 0, 0}
+};
+
+void progress_bar(long long current, long long max, int columns);
+
+#define MAX_LINE 16384
+
+void prep_exit()
+{
+}
+
+
+void sigwinch_handler()
+{
+ struct winsize winsize;
+
+ if(ioctl(1, TIOCGWINSZ, &winsize) == -1) {
+ if(isatty(STDOUT_FILENO))
+ ERROR("TIOCGWINSZ ioctl failed, defaulting to 80 "
+ "columns\n");
+ columns = 80;
+ } else
+ columns = winsize.ws_col;
+}
+
+
+void sigalrm_handler()
+{
+ rotate = (rotate + 1) % 4;
+}
+
+
+int add_overflow(int a, int b)
+{
+ return (INT_MAX - a) < b;
+}
+
+
+int shift_overflow(int a, int shift)
+{
+ return (INT_MAX >> shift) < a;
+}
+
+
+int multiply_overflow(int a, int multiplier)
+{
+ return (INT_MAX / multiplier) < a;
+}
+
+
+struct queue *queue_init(int size)
+{
+ struct queue *queue = malloc(sizeof(struct queue));
+
+ if(queue == NULL)
+ EXIT_UNSQUASH("Out of memory in queue_init\n");
+
+ if(add_overflow(size, 1) ||
+ multiply_overflow(size + 1, sizeof(void *)))
+ EXIT_UNSQUASH("Size too large in queue_init\n");
+
+ queue->data = malloc(sizeof(void *) * (size + 1));
+ if(queue->data == NULL)
+ EXIT_UNSQUASH("Out of memory in queue_init\n");
+
+ queue->size = size + 1;
+ queue->readp = queue->writep = 0;
+ pthread_mutex_init(&queue->mutex, NULL);
+ pthread_cond_init(&queue->empty, NULL);
+ pthread_cond_init(&queue->full, NULL);
+
+ return queue;
+}
+
+
+void queue_put(struct queue *queue, void *data)
+{
+ int nextp;
+
+ pthread_mutex_lock(&queue->mutex);
+
+ while((nextp = (queue->writep + 1) % queue->size) == queue->readp)
+ pthread_cond_wait(&queue->full, &queue->mutex);
+
+ queue->data[queue->writep] = data;
+ queue->writep = nextp;
+ pthread_cond_signal(&queue->empty);
+ pthread_mutex_unlock(&queue->mutex);
+}
+
+
+void *queue_get(struct queue *queue)
+{
+ void *data;
+ pthread_mutex_lock(&queue->mutex);
+
+ while(queue->readp == queue->writep)
+ pthread_cond_wait(&queue->empty, &queue->mutex);
+
+ data = queue->data[queue->readp];
+ queue->readp = (queue->readp + 1) % queue->size;
+ pthread_cond_signal(&queue->full);
+ pthread_mutex_unlock(&queue->mutex);
+
+ return data;
+}
+
+
+void dump_queue(struct queue *queue)
+{
+ pthread_mutex_lock(&queue->mutex);
+
+ printf("Max size %d, size %d%s\n", queue->size - 1,
+ queue->readp <= queue->writep ? queue->writep - queue->readp :
+ queue->size - queue->readp + queue->writep,
+ queue->readp == queue->writep ? " (EMPTY)" :
+ ((queue->writep + 1) % queue->size) == queue->readp ?
+ " (FULL)" : "");
+
+ pthread_mutex_unlock(&queue->mutex);
+}
+
+
+/* Called with the cache mutex held */
+void insert_hash_table(struct cache *cache, struct cache_entry *entry)
+{
+ int hash = CALCULATE_HASH(entry->block);
+
+ entry->hash_next = cache->hash_table[hash];
+ cache->hash_table[hash] = entry;
+ entry->hash_prev = NULL;
+ if(entry->hash_next)
+ entry->hash_next->hash_prev = entry;
+}
+
+
+/* Called with the cache mutex held */
+void remove_hash_table(struct cache *cache, struct cache_entry *entry)
+{
+ if(entry->hash_prev)
+ entry->hash_prev->hash_next = entry->hash_next;
+ else
+ cache->hash_table[CALCULATE_HASH(entry->block)] =
+ entry->hash_next;
+ if(entry->hash_next)
+ entry->hash_next->hash_prev = entry->hash_prev;
+
+ entry->hash_prev = entry->hash_next = NULL;
+}
+
+
+/* Called with the cache mutex held */
+void insert_free_list(struct cache *cache, struct cache_entry *entry)
+{
+ if(cache->free_list) {
+ entry->free_next = cache->free_list;
+ entry->free_prev = cache->free_list->free_prev;
+ cache->free_list->free_prev->free_next = entry;
+ cache->free_list->free_prev = entry;
+ } else {
+ cache->free_list = entry;
+ entry->free_prev = entry->free_next = entry;
+ }
+}
+
+
+/* Called with the cache mutex held */
+void remove_free_list(struct cache *cache, struct cache_entry *entry)
+{
+ if(entry->free_prev == NULL || entry->free_next == NULL)
+ /* not in free list */
+ return;
+ else if(entry->free_prev == entry && entry->free_next == entry) {
+ /* only this entry in the free list */
+ cache->free_list = NULL;
+ } else {
+ /* more than one entry in the free list */
+ entry->free_next->free_prev = entry->free_prev;
+ entry->free_prev->free_next = entry->free_next;
+ if(cache->free_list == entry)
+ cache->free_list = entry->free_next;
+ }
+
+ entry->free_prev = entry->free_next = NULL;
+}
+
+
+struct cache *cache_init(int buffer_size, int max_buffers)
+{
+ struct cache *cache = malloc(sizeof(struct cache));
+
+ if(cache == NULL)
+ EXIT_UNSQUASH("Out of memory in cache_init\n");
+
+ cache->max_buffers = max_buffers;
+ cache->buffer_size = buffer_size;
+ cache->count = 0;
+ cache->used = 0;
+ cache->free_list = NULL;
+ memset(cache->hash_table, 0, sizeof(struct cache_entry *) * 65536);
+ cache->wait_free = FALSE;
+ cache->wait_pending = FALSE;
+ pthread_mutex_init(&cache->mutex, NULL);
+ pthread_cond_init(&cache->wait_for_free, NULL);
+ pthread_cond_init(&cache->wait_for_pending, NULL);
+
+ return cache;
+}
+
+
+struct cache_entry *cache_get(struct cache *cache, long long block, int size)
+{
+ /*
+ * Get a block out of the cache. If the block isn't in the cache
+ * it is added and queued to the reader() and inflate() threads for
+ * reading off disk and decompression. The cache grows until max_blocks
+ * is reached, once this occurs existing discarded blocks on the free
+ * list are reused
+ */
+ int hash = CALCULATE_HASH(block);
+ struct cache_entry *entry;
+
+ pthread_mutex_lock(&cache->mutex);
+
+ for(entry = cache->hash_table[hash]; entry; entry = entry->hash_next)
+ if(entry->block == block)
+ break;
+
+ if(entry) {
+ /*
+ * found the block in the cache. If the block is currently unused
+ * remove it from the free list and increment cache used count.
+ */
+ if(entry->used == 0) {
+ cache->used ++;
+ remove_free_list(cache, entry);
+ }
+ entry->used ++;
+ pthread_mutex_unlock(&cache->mutex);
+ } else {
+ /*
+ * not in the cache
+ *
+ * first try to allocate new block
+ */
+ if(cache->count < cache->max_buffers) {
+ entry = malloc(sizeof(struct cache_entry));
+ if(entry == NULL)
+ EXIT_UNSQUASH("Out of memory in cache_get\n");
+ entry->data = malloc(cache->buffer_size);
+ if(entry->data == NULL)
+ EXIT_UNSQUASH("Out of memory in cache_get\n");
+ entry->cache = cache;
+ entry->free_prev = entry->free_next = NULL;
+ cache->count ++;
+ } else {
+ /*
+ * try to get from free list
+ */
+ while(cache->free_list == NULL) {
+ cache->wait_free = TRUE;
+ pthread_cond_wait(&cache->wait_for_free,
+ &cache->mutex);
+ }
+ entry = cache->free_list;
+ remove_free_list(cache, entry);
+ remove_hash_table(cache, entry);
+ }
+
+ /*
+ * Initialise block and insert into the hash table.
+ * Increment used which tracks how many buffers in the
+ * cache are actively in use (the other blocks, count - used,
+ * are in the cache and available for lookup, but can also be
+ * re-used).
+ */
+ entry->block = block;
+ entry->size = size;
+ entry->used = 1;
+ entry->error = FALSE;
+ entry->pending = TRUE;
+ insert_hash_table(cache, entry);
+ cache->used ++;
+
+ /*
+ * queue to read thread to read and ultimately (via the
+ * decompress threads) decompress the buffer
+ */
+ pthread_mutex_unlock(&cache->mutex);
+ queue_put(to_reader, entry);
+ }
+
+ return entry;
+}
+
+
+void cache_block_ready(struct cache_entry *entry, int error)
+{
+ /*
+ * mark cache entry as being complete, reading and (if necessary)
+ * decompression has taken place, and the buffer is valid for use.
+ * If an error occurs reading or decompressing, the buffer also
+ * becomes ready but with an error...
+ */
+ pthread_mutex_lock(&entry->cache->mutex);
+ entry->pending = FALSE;
+ entry->error = error;
+
+ /*
+ * if the wait_pending flag is set, one or more threads may be waiting
+ * on this buffer
+ */
+ if(entry->cache->wait_pending) {
+ entry->cache->wait_pending = FALSE;
+ pthread_cond_broadcast(&entry->cache->wait_for_pending);
+ }
+
+ pthread_mutex_unlock(&entry->cache->mutex);
+}
+
+
+void cache_block_wait(struct cache_entry *entry)
+{
+ /*
+ * wait for this cache entry to become ready, when reading and (if
+ * necessary) decompression has taken place
+ */
+ pthread_mutex_lock(&entry->cache->mutex);
+
+ while(entry->pending) {
+ entry->cache->wait_pending = TRUE;
+ pthread_cond_wait(&entry->cache->wait_for_pending,
+ &entry->cache->mutex);
+ }
+
+ pthread_mutex_unlock(&entry->cache->mutex);
+}
+
+
+void cache_block_put(struct cache_entry *entry)
+{
+ /*
+ * finished with this cache entry, once the usage count reaches zero it
+ * can be reused and is put onto the free list. As it remains
+ * accessible via the hash table it can be found getting a new lease of
+ * life before it is reused.
+ */
+ pthread_mutex_lock(&entry->cache->mutex);
+
+ entry->used --;
+ if(entry->used == 0) {
+ insert_free_list(entry->cache, entry);
+ entry->cache->used --;
+
+ /*
+ * if the wait_free flag is set, one or more threads may be
+ * waiting on this buffer
+ */
+ if(entry->cache->wait_free) {
+ entry->cache->wait_free = FALSE;
+ pthread_cond_broadcast(&entry->cache->wait_for_free);
+ }
+ }
+
+ pthread_mutex_unlock(&entry->cache->mutex);
+}
+
+
+void dump_cache(struct cache *cache)
+{
+ pthread_mutex_lock(&cache->mutex);
+
+ printf("Max buffers %d, Current size %d, Used %d, %s\n",
+ cache->max_buffers, cache->count, cache->used,
+ cache->free_list ? "Free buffers" : "No free buffers");
+
+ pthread_mutex_unlock(&cache->mutex);
+}
+
+
+char *modestr(char *str, int mode)
+{
+ int i;
+
+ strcpy(str, "----------");
+
+ for(i = 0; table[i].mask != 0; i++) {
+ if((mode & table[i].mask) == table[i].value)
+ str[table[i].position] = table[i].mode;
+ }
+
+ return str;
+}
+
+
+#define TOTALCHARS 25
+int print_filename(char *pathname, struct inode *inode)
+{
+ char str[11], dummy[12], dummy2[12]; /* overflow safe */
+ char *userstr, *groupstr;
+ int padchars;
+ struct passwd *user;
+ struct group *group;
+ struct tm *t;
+
+ if(short_ls) {
+ printf("%s\n", pathname);
+ return 1;
+ }
+
+ user = getpwuid(inode->uid);
+ if(user == NULL) {
+ int res = snprintf(dummy, 12, "%d", inode->uid);
+ if(res < 0)
+ EXIT_UNSQUASH("snprintf failed in print_filename()\n");
+ else if(res >= 12)
+ /* unsigned int shouldn't ever need more than 11 bytes
+ * (including terminating '\0') to print in base 10 */
+ userstr = "*";
+ else
+ userstr = dummy;
+ } else
+ userstr = user->pw_name;
+
+ group = getgrgid(inode->gid);
+ if(group == NULL) {
+ int res = snprintf(dummy2, 12, "%d", inode->gid);
+ if(res < 0)
+ EXIT_UNSQUASH("snprintf failed in print_filename()\n");
+ else if(res >= 12)
+ /* unsigned int shouldn't ever need more than 11 bytes
+ * (including terminating '\0') to print in base 10 */
+ groupstr = "*";
+ else
+ groupstr = dummy2;
+ } else
+ groupstr = group->gr_name;
+
+ printf("%s %s/%s ", modestr(str, inode->mode), userstr, groupstr);
+
+ switch(inode->mode & S_IFMT) {
+ case S_IFREG:
+ case S_IFDIR:
+ case S_IFSOCK:
+ case S_IFIFO:
+ case S_IFLNK:
+ padchars = TOTALCHARS - strlen(userstr) -
+ strlen(groupstr);
+
+ printf("%*lld ", padchars > 0 ? padchars : 0,
+ inode->data);
+ break;
+ case S_IFCHR:
+ case S_IFBLK:
+ padchars = TOTALCHARS - strlen(userstr) -
+ strlen(groupstr) - 7;
+
+ printf("%*s%3d,%3d ", padchars > 0 ? padchars : 0, " ",
+ (int) inode->data >> 8, (int) inode->data &
+ 0xff);
+ break;
+ }
+
+ t = localtime(&inode->time);
+
+ printf("%d-%02d-%02d %02d:%02d %s", t->tm_year + 1900, t->tm_mon + 1,
+ t->tm_mday, t->tm_hour, t->tm_min, pathname);
+ if((inode->mode & S_IFMT) == S_IFLNK)
+ printf(" -> %s", inode->symlink);
+ printf("\n");
+
+ return 1;
+}
+
+
+void add_entry(struct hash_table_entry *hash_table[], long long start,
+ int bytes)
+{
+ int hash = CALCULATE_HASH(start);
+ struct hash_table_entry *hash_table_entry;
+
+ hash_table_entry = malloc(sizeof(struct hash_table_entry));
+ if(hash_table_entry == NULL)
+ EXIT_UNSQUASH("Out of memory in add_entry\n");
+
+ hash_table_entry->start = start;
+ hash_table_entry->bytes = bytes;
+ hash_table_entry->next = hash_table[hash];
+ hash_table[hash] = hash_table_entry;
+}
+
+
+int lookup_entry(struct hash_table_entry *hash_table[], long long start)
+{
+ int hash = CALCULATE_HASH(start);
+ struct hash_table_entry *hash_table_entry;
+
+ for(hash_table_entry = hash_table[hash]; hash_table_entry;
+ hash_table_entry = hash_table_entry->next)
+
+ if(hash_table_entry->start == start)
+ return hash_table_entry->bytes;
+
+ return -1;
+}
+
+
+int read_fs_bytes(int fd, long long byte, int bytes, void *buff)
+{
+ off_t off = byte;
+ int res, count;
+
+ TRACE("read_bytes: reading from position 0x%llx, bytes %d\n", byte,
+ bytes);
+
+ if(lseek(fd, off, SEEK_SET) == -1) {
+ ERROR("Lseek failed because %s\n", strerror(errno));
+ return FALSE;
+ }
+
+ for(count = 0; count < bytes; count += res) {
+ res = read(fd, buff + count, bytes - count);
+ if(res < 1) {
+ if(res == 0) {
+ ERROR("Read on filesystem failed because "
+ "EOF\n");
+ return FALSE;
+ } else if(errno != EINTR) {
+ ERROR("Read on filesystem failed because %s\n",
+ strerror(errno));
+ return FALSE;
+ } else
+ res = 0;
+ }
+ }
+
+ return TRUE;
+}
+
+
+int read_block(int fd, long long start, long long *next, int expected,
+ void *block)
+{
+ unsigned short c_byte;
+ int offset = 2, res, compressed;
+ int outlen = expected ? expected : SQUASHFS_METADATA_SIZE;
+
+ if(swap) {
+ if(read_fs_bytes(fd, start, 2, &c_byte) == FALSE)
+ goto failed;
+ c_byte = (c_byte >> 8) | ((c_byte & 0xff) << 8);
+ } else
+ if(read_fs_bytes(fd, start, 2, &c_byte) == FALSE)
+ goto failed;
+
+ TRACE("read_block: block @0x%llx, %d %s bytes\n", start,
+ SQUASHFS_COMPRESSED_SIZE(c_byte), SQUASHFS_COMPRESSED(c_byte) ?
+ "compressed" : "uncompressed");
+
+ if(SQUASHFS_CHECK_DATA(sBlk.s.flags))
+ offset = 3;
+
+ compressed = SQUASHFS_COMPRESSED(c_byte);
+ c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte);
+
+ /*
+ * The block size should not be larger than
+ * the uncompressed size (or max uncompressed size if
+ * expected is 0)
+ */
+ if(c_byte > outlen)
+ return 0;
+
+ if(compressed) {
+ char buffer[c_byte];
+ int error;
+
+ res = read_fs_bytes(fd, start + offset, c_byte, buffer);
+ if(res == FALSE)
+ goto failed;
+
+ res = compressor_uncompress(comp, block, buffer, c_byte,
+ outlen, &error);
+
+ if(res == -1) {
+ ERROR("%s uncompress failed with error code %d\n",
+ comp->name, error);
+ goto failed;
+ }
+ } else {
+ res = read_fs_bytes(fd, start + offset, c_byte, block);
+ if(res == FALSE)
+ goto failed;
+ res = c_byte;
+ }
+
+ if(next)
+ *next = start + offset + c_byte;
+
+ /*
+ * if expected, then check the (uncompressed) return data
+ * is of the expected size
+ */
+ if(expected && expected != res)
+ return 0;
+ else
+ return res;
+
+failed:
+ ERROR("read_block: failed to read block @0x%llx\n", start);
+ return FALSE;
+}
+
+
+int read_data_block(long long start, unsigned int size, char *block)
+{
+ int error, res;
+ int c_byte = SQUASHFS_COMPRESSED_SIZE_BLOCK(size);
+
+ TRACE("read_data_block: block @0x%llx, %d %s bytes\n", start,
+ c_byte, SQUASHFS_COMPRESSED_BLOCK(size) ? "compressed" :
+ "uncompressed");
+
+ if(SQUASHFS_COMPRESSED_BLOCK(size)) {
+ if(read_fs_bytes(fd, start, c_byte, data) == FALSE)
+ goto failed;
+
+ res = compressor_uncompress(comp, block, data, c_byte,
+ block_size, &error);
+
+ if(res == -1) {
+ ERROR("%s uncompress failed with error code %d\n",
+ comp->name, error);
+ goto failed;
+ }
+
+ return res;
+ } else {
+ if(read_fs_bytes(fd, start, c_byte, block) == FALSE)
+ goto failed;
+
+ return c_byte;
+ }
+
+failed:
+ ERROR("read_data_block: failed to read block @0x%llx, size %d\n", start,
+ c_byte);
+ return FALSE;
+}
+
+
+int read_inode_table(long long start, long long end)
+{
+ int size = 0, bytes = 0, res;
+
+ TRACE("read_inode_table: start %lld, end %lld\n", start, end);
+
+ while(start < end) {
+ if(size - bytes < SQUASHFS_METADATA_SIZE) {
+ inode_table = realloc(inode_table, size +=
+ SQUASHFS_METADATA_SIZE);
+ if(inode_table == NULL) {
+ ERROR("Out of memory in read_inode_table");
+ goto failed;
+ }
+ }
+
+ add_entry(inode_table_hash, start, bytes);
+
+ res = read_block(fd, start, &start, 0, inode_table + bytes);
+ if(res == 0) {
+ ERROR("read_inode_table: failed to read block\n");
+ goto failed;
+ }
+ bytes += res;
+
+ /*
+ * If this is not the last metadata block in the inode table
+ * then it should be SQUASHFS_METADATA_SIZE in size.
+ * Note, we can't use expected in read_block() above for this
+ * because we don't know if this is the last block until
+ * after reading.
+ */
+ if(start != end && res != SQUASHFS_METADATA_SIZE) {
+ ERROR("read_inode_table: metadata block should be %d "
+ "bytes in length, it is %d bytes\n",
+ SQUASHFS_METADATA_SIZE, res);
+
+ goto failed;
+ }
+ }
+
+ return TRUE;
+
+failed:
+ free(inode_table);
+ return FALSE;
+}
+
+
+int set_attributes(char *pathname, int mode, uid_t uid, gid_t guid, time_t time,
+ unsigned int xattr, unsigned int set_mode)
+{
+ struct utimbuf times = { time, time };
+
+ write_xattr(pathname, xattr);
+
+ if(utime(pathname, ×) == -1) {
+ ERROR("set_attributes: failed to set time on %s, because %s\n",
+ pathname, strerror(errno));
+ return FALSE;
+ }
+
+ if(root_process) {
+ if(chown(pathname, uid, guid) == -1) {
+ ERROR("set_attributes: failed to change uid and gids "
+ "on %s, because %s\n", pathname,
+ strerror(errno));
+ return FALSE;
+ }
+ } else
+ mode &= ~07000;
+
+ if((set_mode || (mode & 07000)) && chmod(pathname, (mode_t) mode) == -1) {
+ ERROR("set_attributes: failed to change mode %s, because %s\n",
+ pathname, strerror(errno));
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+
+int write_bytes(int fd, char *buff, int bytes)
+{
+ int res, count;
+
+ for(count = 0; count < bytes; count += res) {
+ res = write(fd, buff + count, bytes - count);
+ if(res == -1) {
+ if(errno != EINTR) {
+ ERROR("Write on output file failed because "
+ "%s\n", strerror(errno));
+ return -1;
+ }
+ res = 0;
+ }
+ }
+
+ return 0;
+}
+
+
+int lseek_broken = FALSE;
+char *zero_data = NULL;
+
+int write_block(int file_fd, char *buffer, int size, long long hole, int sparse)
+{
+ off_t off = hole;
+
+ if(hole) {
+ if(sparse && lseek_broken == FALSE) {
+ int error = lseek(file_fd, off, SEEK_CUR);
+ if(error == -1)
+ /* failed to seek beyond end of file */
+ lseek_broken = TRUE;
+ }
+
+ if((sparse == FALSE || lseek_broken) && zero_data == NULL) {
+ if((zero_data = malloc(block_size)) == NULL)
+ EXIT_UNSQUASH("write_block: failed to alloc "
+ "zero data block\n");
+ memset(zero_data, 0, block_size);
+ }
+
+ if(sparse == FALSE || lseek_broken) {
+ int blocks = (hole + block_size -1) / block_size;
+ int avail_bytes, i;
+ for(i = 0; i < blocks; i++, hole -= avail_bytes) {
+ avail_bytes = hole > block_size ? block_size :
+ hole;
+ if(write_bytes(file_fd, zero_data, avail_bytes)
+ == -1)
+ goto failure;
+ }
+ }
+ }
+
+ if(write_bytes(file_fd, buffer, size) == -1)
+ goto failure;
+
+ return TRUE;
+
+failure:
+ return FALSE;
+}
+
+
+pthread_mutex_t open_mutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t open_empty = PTHREAD_COND_INITIALIZER;
+int open_unlimited, open_count;
+#define OPEN_FILE_MARGIN 10
+
+
+void open_init(int count)
+{
+ open_count = count;
+ open_unlimited = count == -1;
+}
+
+
+int open_wait(char *pathname, int flags, mode_t mode)
+{
+ if (!open_unlimited) {
+ pthread_mutex_lock(&open_mutex);
+ while (open_count == 0)
+ pthread_cond_wait(&open_empty, &open_mutex);
+ open_count --;
+ pthread_mutex_unlock(&open_mutex);
+ }
+
+ return open(pathname, flags, mode);
+}
+
+
+void close_wake(int fd)
+{
+ close(fd);
+
+ if (!open_unlimited) {
+ pthread_mutex_lock(&open_mutex);
+ open_count ++;
+ pthread_cond_signal(&open_empty);
+ pthread_mutex_unlock(&open_mutex);
+ }
+}
+
+
+void queue_file(char *pathname, int file_fd, struct inode *inode)
+{
+ struct squashfs_file *file = malloc(sizeof(struct squashfs_file));
+ if(file == NULL)
+ EXIT_UNSQUASH("queue_file: unable to malloc file\n");
+
+ file->fd = file_fd;
+ file->file_size = inode->data;
+ file->mode = inode->mode;
+ file->gid = inode->gid;
+ file->uid = inode->uid;
+ file->time = inode->time;
+ file->pathname = strdup(pathname);
+ file->blocks = inode->blocks + (inode->frag_bytes > 0);
+ file->sparse = inode->sparse;
+ file->xattr = inode->xattr;
+ queue_put(to_writer, file);
+}
+
+
+void queue_dir(char *pathname, struct dir *dir)
+{
+ struct squashfs_file *file = malloc(sizeof(struct squashfs_file));
+ if(file == NULL)
+ EXIT_UNSQUASH("queue_dir: unable to malloc file\n");
+
+ file->fd = -1;
+ file->mode = dir->mode;
+ file->gid = dir->guid;
+ file->uid = dir->uid;
+ file->time = dir->mtime;
+ file->pathname = strdup(pathname);
+ file->xattr = dir->xattr;
+ queue_put(to_writer, file);
+}
+
+
+int write_file(struct inode *inode, char *pathname)
+{
+ unsigned int file_fd, i;
+ unsigned int *block_list;
+ int file_end = inode->data / block_size;
+ long long start = inode->start;
+
+ TRACE("write_file: regular file, blocks %d\n", inode->blocks);
+
+ file_fd = open_wait(pathname, O_CREAT | O_WRONLY |
+ (force ? O_TRUNC : 0), (mode_t) inode->mode & 0777);
+ if(file_fd == -1) {
+ ERROR("write_file: failed to create file %s, because %s\n",
+ pathname, strerror(errno));
+ return FALSE;
+ }
+
+ block_list = malloc(inode->blocks * sizeof(unsigned int));
+ if(block_list == NULL)
+ EXIT_UNSQUASH("write_file: unable to malloc block list\n");
+
+ s_ops.read_block_list(block_list, inode->block_ptr, inode->blocks);
+
+ /*
+ * the writer thread is queued a squashfs_file structure describing the
+ * file. If the file has one or more blocks or a fragment they are
+ * queued separately (references to blocks in the cache).
+ */
+ queue_file(pathname, file_fd, inode);
+
+ for(i = 0; i < inode->blocks; i++) {
+ int c_byte = SQUASHFS_COMPRESSED_SIZE_BLOCK(block_list[i]);
+ struct file_entry *block = malloc(sizeof(struct file_entry));
+
+ if(block == NULL)
+ EXIT_UNSQUASH("write_file: unable to malloc file\n");
+ block->offset = 0;
+ block->size = i == file_end ? inode->data & (block_size - 1) :
+ block_size;
+ if(block_list[i] == 0) /* sparse block */
+ block->buffer = NULL;
+ else {
+ block->buffer = cache_get(data_cache, start,
+ block_list[i]);
+ start += c_byte;
+ }
+ queue_put(to_writer, block);
+ }
+
+ if(inode->frag_bytes) {
+ int size;
+ long long start;
+ struct file_entry *block = malloc(sizeof(struct file_entry));
+
+ if(block == NULL)
+ EXIT_UNSQUASH("write_file: unable to malloc file\n");
+ s_ops.read_fragment(inode->fragment, &start, &size);
+ block->buffer = cache_get(fragment_cache, start, size);
+ block->offset = inode->offset;
+ block->size = inode->frag_bytes;
+ queue_put(to_writer, block);
+ }
+
+ free(block_list);
+ return TRUE;
+}
+
+
+int create_inode(char *pathname, struct inode *i)
+{
+ TRACE("create_inode: pathname %s\n", pathname);
+
+ if(created_inode[i->inode_number - 1]) {
+ TRACE("create_inode: hard link\n");
+ if(force)
+ unlink(pathname);
+
+ if(link(created_inode[i->inode_number - 1], pathname) == -1) {
+ ERROR("create_inode: failed to create hardlink, "
+ "because %s\n", strerror(errno));
+ return FALSE;
+ }
+
+ return TRUE;
+ }
+
+ switch(i->type) {
+ case SQUASHFS_FILE_TYPE:
+ case SQUASHFS_LREG_TYPE:
+ TRACE("create_inode: regular file, file_size %lld, "
+ "blocks %d\n", i->data, i->blocks);
+
+ if(write_file(i, pathname))
+ file_count ++;
+ break;
+ case SQUASHFS_SYMLINK_TYPE:
+ case SQUASHFS_LSYMLINK_TYPE:
+ TRACE("create_inode: symlink, symlink_size %lld\n",
+ i->data);
+
+ if(force)
+ unlink(pathname);
+
+ if(symlink(i->symlink, pathname) == -1) {
+ ERROR("create_inode: failed to create symlink "
+ "%s, because %s\n", pathname,
+ strerror(errno));
+ break;
+ }
+
+ write_xattr(pathname, i->xattr);
+
+ if(root_process) {
+ if(lchown(pathname, i->uid, i->gid) == -1)
+ ERROR("create_inode: failed to change "
+ "uid and gids on %s, because "
+ "%s\n", pathname,
+ strerror(errno));
+ }
+
+ sym_count ++;
+ break;
+ case SQUASHFS_BLKDEV_TYPE:
+ case SQUASHFS_CHRDEV_TYPE:
+ case SQUASHFS_LBLKDEV_TYPE:
+ case SQUASHFS_LCHRDEV_TYPE: {
+ int chrdev = i->type == SQUASHFS_CHRDEV_TYPE;
+ TRACE("create_inode: dev, rdev 0x%llx\n", i->data);
+
+ if(root_process) {
+ if(force)
+ unlink(pathname);
+
+ if(mknod(pathname, chrdev ? S_IFCHR : S_IFBLK,
+ makedev((i->data >> 8) & 0xff,
+ i->data & 0xff)) == -1) {
+ ERROR("create_inode: failed to create "
+ "%s device %s, because %s\n",
+ chrdev ? "character" : "block",
+ pathname, strerror(errno));
+ break;
+ }
+ set_attributes(pathname, i->mode, i->uid,
+ i->gid, i->time, i->xattr, TRUE);
+ dev_count ++;
+ } else
+ ERROR("create_inode: could not create %s "
+ "device %s, because you're not "
+ "superuser!\n", chrdev ? "character" :
+ "block", pathname);
+ break;
+ }
+ case SQUASHFS_FIFO_TYPE:
+ case SQUASHFS_LFIFO_TYPE:
+ TRACE("create_inode: fifo\n");
+
+ if(force)
+ unlink(pathname);
+
+ if(mknod(pathname, S_IFIFO, 0) == -1) {
+ ERROR("create_inode: failed to create fifo %s, "
+ "because %s\n", pathname,
+ strerror(errno));
+ break;
+ }
+ set_attributes(pathname, i->mode, i->uid, i->gid,
+ i->time, i->xattr, TRUE);
+ fifo_count ++;
+ break;
+ case SQUASHFS_SOCKET_TYPE:
+ case SQUASHFS_LSOCKET_TYPE:
+ TRACE("create_inode: socket\n");
+ ERROR("create_inode: socket %s ignored\n", pathname);
+ break;
+ default:
+ ERROR("Unknown inode type %d in create_inode_table!\n",
+ i->type);
+ return FALSE;
+ }
+
+ created_inode[i->inode_number - 1] = strdup(pathname);
+
+ return TRUE;
+}
+
+
+int read_directory_table(long long start, long long end)
+{
+ int bytes = 0, size = 0, res;
+
+ TRACE("read_directory_table: start %lld, end %lld\n", start, end);
+
+ while(start < end) {
+ if(size - bytes < SQUASHFS_METADATA_SIZE) {
+ directory_table = realloc(directory_table, size +=
+ SQUASHFS_METADATA_SIZE);
+ if(directory_table == NULL) {
+ ERROR("Out of memory in "
+ "read_directory_table\n");
+ goto failed;
+ }
+ }
+
+ add_entry(directory_table_hash, start, bytes);
+
+ res = read_block(fd, start, &start, 0, directory_table + bytes);
+ if(res == 0) {
+ ERROR("read_directory_table: failed to read block\n");
+ goto failed;
+ }
+
+ bytes += res;
+
+ /*
+ * If this is not the last metadata block in the directory table
+ * then it should be SQUASHFS_METADATA_SIZE in size.
+ * Note, we can't use expected in read_block() above for this
+ * because we don't know if this is the last block until
+ * after reading.
+ */
+ if(start != end && res != SQUASHFS_METADATA_SIZE) {
+ ERROR("read_directory_table: metadata block "
+ "should be %d bytes in length, it is %d "
+ "bytes\n", SQUASHFS_METADATA_SIZE, res);
+ goto failed;
+ }
+ }
+
+ return TRUE;
+
+failed:
+ free(directory_table);
+ return FALSE;
+}
+
+
+int squashfs_readdir(struct dir *dir, char **name, unsigned int *start_block,
+unsigned int *offset, unsigned int *type)
+{
+ if(dir->cur_entry == dir->dir_count)
+ return FALSE;
+
+ *name = dir->dirs[dir->cur_entry].name;
+ *start_block = dir->dirs[dir->cur_entry].start_block;
+ *offset = dir->dirs[dir->cur_entry].offset;
+ *type = dir->dirs[dir->cur_entry].type;
+ dir->cur_entry ++;
+
+ return TRUE;
+}
+
+
+void squashfs_closedir(struct dir *dir)
+{
+ free(dir->dirs);
+ free(dir);
+}
+
+
+char *get_component(char *target, char **targname)
+{
+ char *start;
+
+ while(*target == '/')
+ target ++;
+
+ start = target;
+ while(*target != '/' && *target != '\0')
+ target ++;
+
+ *targname = strndup(start, target - start);
+
+ while(*target == '/')
+ target ++;
+
+ return target;
+}
+
+
+void free_path(struct pathname *paths)
+{
+ int i;
+
+ for(i = 0; i < paths->names; i++) {
+ if(paths->name[i].paths)
+ free_path(paths->name[i].paths);
+ free(paths->name[i].name);
+ if(paths->name[i].preg) {
+ regfree(paths->name[i].preg);
+ free(paths->name[i].preg);
+ }
+ }
+
+ free(paths);
+}
+
+
+struct pathname *add_path(struct pathname *paths, char *target, char *alltarget)
+{
+ char *targname;
+ int i, error;
+
+ TRACE("add_path: adding \"%s\" extract file\n", target);
+
+ target = get_component(target, &targname);
+
+ if(paths == NULL) {
+ paths = malloc(sizeof(struct pathname));
+ if(paths == NULL)
+ EXIT_UNSQUASH("failed to allocate paths\n");
+
+ paths->names = 0;
+ paths->name = NULL;
+ }
+
+ for(i = 0; i < paths->names; i++)
+ if(strcmp(paths->name[i].name, targname) == 0)
+ break;
+
+ if(i == paths->names) {
+ /*
+ * allocate new name entry
+ */
+ paths->names ++;
+ paths->name = realloc(paths->name, (i + 1) *
+ sizeof(struct path_entry));
+ if(paths->name == NULL)
+ EXIT_UNSQUASH("Out of memory in add_path\n");
+ paths->name[i].name = targname;
+ paths->name[i].paths = NULL;
+ if(use_regex) {
+ paths->name[i].preg = malloc(sizeof(regex_t));
+ if(paths->name[i].preg == NULL)
+ EXIT_UNSQUASH("Out of memory in add_path\n");
+ error = regcomp(paths->name[i].preg, targname,
+ REG_EXTENDED|REG_NOSUB);
+ if(error) {
+ char str[1024]; /* overflow safe */
+
+ regerror(error, paths->name[i].preg, str, 1024);
+ EXIT_UNSQUASH("invalid regex %s in export %s, "
+ "because %s\n", targname, alltarget,
+ str);
+ }
+ } else
+ paths->name[i].preg = NULL;
+
+ if(target[0] == '\0')
+ /*
+ * at leaf pathname component
+ */
+ paths->name[i].paths = NULL;
+ else
+ /*
+ * recurse adding child components
+ */
+ paths->name[i].paths = add_path(NULL, target, alltarget);
+ } else {
+ /*
+ * existing matching entry
+ */
+ free(targname);
+
+ if(paths->name[i].paths == NULL) {
+ /*
+ * No sub-directory which means this is the leaf
+ * component of a pre-existing extract which subsumes
+ * the extract currently being added, in which case stop
+ * adding components
+ */
+ } else if(target[0] == '\0') {
+ /*
+ * at leaf pathname component and child components exist
+ * from more specific extracts, delete as they're
+ * subsumed by this extract
+ */
+ free_path(paths->name[i].paths);
+ paths->name[i].paths = NULL;
+ } else
+ /*
+ * recurse adding child components
+ */
+ add_path(paths->name[i].paths, target, alltarget);
+ }
+
+ return paths;
+}
+
+
+struct pathnames *init_subdir()
+{
+ struct pathnames *new = malloc(sizeof(struct pathnames));
+ if(new == NULL)
+ EXIT_UNSQUASH("Out of memory in init_subdir\n");
+ new->count = 0;
+ return new;
+}
+
+
+struct pathnames *add_subdir(struct pathnames *paths, struct pathname *path)
+{
+ if(paths->count % PATHS_ALLOC_SIZE == 0) {
+ paths = realloc(paths, sizeof(struct pathnames *) +
+ (paths->count + PATHS_ALLOC_SIZE) *
+ sizeof(struct pathname *));
+ if(paths == NULL)
+ EXIT_UNSQUASH("Out of memory in add_subdir\n");
+ }
+
+ paths->path[paths->count++] = path;
+ return paths;
+}
+
+
+void free_subdir(struct pathnames *paths)
+{
+ free(paths);
+}
+
+
+int matches(struct pathnames *paths, char *name, struct pathnames **new)
+{
+ int i, n;
+
+ if(paths == NULL) {
+ *new = NULL;
+ return TRUE;
+ }
+
+ *new = init_subdir();
+
+ for(n = 0; n < paths->count; n++) {
+ struct pathname *path = paths->path[n];
+ for(i = 0; i < path->names; i++) {
+ int match = use_regex ?
+ regexec(path->name[i].preg, name, (size_t) 0,
+ NULL, 0) == 0 : fnmatch(path->name[i].name,
+ name, FNM_PATHNAME|FNM_PERIOD|FNM_EXTMATCH) ==
+ 0;
+ if(match && path->name[i].paths == NULL)
+ /*
+ * match on a leaf component, any subdirectories
+ * will implicitly match, therefore return an
+ * empty new search set
+ */
+ goto empty_set;
+
+ if(match)
+ /*
+ * match on a non-leaf component, add any
+ * subdirectories to the new set of
+ * subdirectories to scan for this name
+ */
+ *new = add_subdir(*new, path->name[i].paths);
+ }
+ }
+
+ if((*new)->count == 0) {
+ /*
+ * no matching names found, delete empty search set, and return
+ * FALSE
+ */
+ free_subdir(*new);
+ *new = NULL;
+ return FALSE;
+ }
+
+ /*
+ * one or more matches with sub-directories found (no leaf matches),
+ * return new search set and return TRUE
+ */
+ return TRUE;
+
+empty_set:
+ /*
+ * found matching leaf exclude, return empty search set and return TRUE
+ */
+ free_subdir(*new);
+ *new = NULL;
+ return TRUE;
+}
+
+
+void pre_scan(char *parent_name, unsigned int start_block, unsigned int offset,
+ struct pathnames *paths)
+{
+ unsigned int type;
+ char *name;
+ struct pathnames *new;
+ struct inode *i;
+ struct dir *dir = s_ops.squashfs_opendir(start_block, offset, &i);
+
+ if(dir == NULL)
+ return;
+
+ while(squashfs_readdir(dir, &name, &start_block, &offset, &type)) {
+ struct inode *i;
+ char *pathname;
+ int res;
+
+ TRACE("pre_scan: name %s, start_block %d, offset %d, type %d\n",
+ name, start_block, offset, type);
+
+ if(!matches(paths, name, &new))
+ continue;
+
+ res = asprintf(&pathname, "%s/%s", parent_name, name);
+ if(res == -1)
+ EXIT_UNSQUASH("asprintf failed in dir_scan\n");
+
+ if(type == SQUASHFS_DIR_TYPE)
+ pre_scan(parent_name, start_block, offset, new);
+ else if(new == NULL) {
+ if(type == SQUASHFS_FILE_TYPE ||
+ type == SQUASHFS_LREG_TYPE) {
+ i = s_ops.read_inode(start_block, offset);
+ if(created_inode[i->inode_number - 1] == NULL) {
+ created_inode[i->inode_number - 1] =
+ (char *) i;
+ total_blocks += (i->data +
+ (block_size - 1)) >> block_log;
+ }
+ total_files ++;
+ }
+ total_inodes ++;
+ }
+
+ free_subdir(new);
+ free(pathname);
+ }
+
+ squashfs_closedir(dir);
+}
+
+
+void dir_scan(char *parent_name, unsigned int start_block, unsigned int offset,
+ struct pathnames *paths)
+{
+ unsigned int type;
+ char *name;
+ struct pathnames *new;
+ struct inode *i;
+ struct dir *dir = s_ops.squashfs_opendir(start_block, offset, &i);
+
+ if(dir == NULL) {
+ ERROR("dir_scan: failed to read directory %s, skipping\n",
+ parent_name);
+ return;
+ }
+
+ if(lsonly || info)
+ print_filename(parent_name, i);
+
+ if(!lsonly) {
+ /*
+ * Make directory with default User rwx permissions rather than
+ * the permissions from the filesystem, as these may not have
+ * write/execute permission. These are fixed up later in
+ * set_attributes().
+ */
+ int res = mkdir(parent_name, S_IRUSR|S_IWUSR|S_IXUSR);
+ if(res == -1) {
+ /*
+ * Skip directory if mkdir fails, unless we're
+ * forcing and the error is -EEXIST
+ */
+ if(!force || errno != EEXIST) {
+ ERROR("dir_scan: failed to make directory %s, "
+ "because %s\n", parent_name,
+ strerror(errno));
+ squashfs_closedir(dir);
+ return;
+ }
+
+ /*
+ * Try to change permissions of existing directory so
+ * that we can write to it
+ */
+ res = chmod(parent_name, S_IRUSR|S_IWUSR|S_IXUSR);
+ if (res == -1)
+ ERROR("dir_scan: failed to change permissions "
+ "for directory %s, because %s\n",
+ parent_name, strerror(errno));
+ }
+ }
+
+ while(squashfs_readdir(dir, &name, &start_block, &offset, &type)) {
+ char *pathname;
+ int res;
+
+ TRACE("dir_scan: name %s, start_block %d, offset %d, type %d\n",
+ name, start_block, offset, type);
+
+
+ if(!matches(paths, name, &new))
+ continue;
+
+ res = asprintf(&pathname, "%s/%s", parent_name, name);
+ if(res == -1)
+ EXIT_UNSQUASH("asprintf failed in dir_scan\n");
+
+ if(type == SQUASHFS_DIR_TYPE) {
+ dir_scan(pathname, start_block, offset, new);
+ free(pathname);
+ } else if(new == NULL) {
+ update_info(pathname);
+
+ i = s_ops.read_inode(start_block, offset);
+
+ if(lsonly || info)
+ print_filename(pathname, i);
+
+ if(!lsonly)
+ create_inode(pathname, i);
+
+ if(i->type == SQUASHFS_SYMLINK_TYPE ||
+ i->type == SQUASHFS_LSYMLINK_TYPE)
+ free(i->symlink);
+ } else
+ free(pathname);
+
+ free_subdir(new);
+ }
+
+ if(!lsonly)
+ queue_dir(parent_name, dir);
+
+ squashfs_closedir(dir);
+ dir_count ++;
+}
+
+
+void squashfs_stat(char *source)
+{
+ time_t mkfs_time = (time_t) sBlk.s.mkfs_time;
+ char *mkfs_str = ctime(&mkfs_time);
+
+#if __BYTE_ORDER == __BIG_ENDIAN
+ printf("Found a valid %sSQUASHFS %d:%d superblock on %s.\n",
+ sBlk.s.s_major == 4 ? "" : swap ? "little endian " :
+ "big endian ", sBlk.s.s_major, sBlk.s.s_minor, source);
+#else
+ printf("Found a valid %sSQUASHFS %d:%d superblock on %s.\n",
+ sBlk.s.s_major == 4 ? "" : swap ? "big endian " :
+ "little endian ", sBlk.s.s_major, sBlk.s.s_minor, source);
+#endif
+
+ printf("Creation or last append time %s", mkfs_str ? mkfs_str :
+ "failed to get time\n");
+ printf("Filesystem size %.2f Kbytes (%.2f Mbytes)\n",
+ sBlk.s.bytes_used / 1024.0, sBlk.s.bytes_used /
+ (1024.0 * 1024.0));
+
+ if(sBlk.s.s_major == 4) {
+ printf("Compression %s\n", comp->name);
+
+ if(SQUASHFS_COMP_OPTS(sBlk.s.flags)) {
+ char buffer[SQUASHFS_METADATA_SIZE] __attribute__ ((aligned));
+ int bytes;
+
+ bytes = read_block(fd, sizeof(sBlk.s), NULL, 0, buffer);
+ if(bytes == 0) {
+ ERROR("Failed to read compressor options\n");
+ return;
+ }
+
+ compressor_display_options(comp, buffer, bytes);
+ }
+ }
+
+ printf("Block size %d\n", sBlk.s.block_size);
+ printf("Filesystem is %sexportable via NFS\n",
+ SQUASHFS_EXPORTABLE(sBlk.s.flags) ? "" : "not ");
+ printf("Inodes are %scompressed\n",
+ SQUASHFS_UNCOMPRESSED_INODES(sBlk.s.flags) ? "un" : "");
+ printf("Data is %scompressed\n",
+ SQUASHFS_UNCOMPRESSED_DATA(sBlk.s.flags) ? "un" : "");
+
+ if(sBlk.s.s_major > 1) {
+ if(SQUASHFS_NO_FRAGMENTS(sBlk.s.flags))
+ printf("Fragments are not stored\n");
+ else {
+ printf("Fragments are %scompressed\n",
+ SQUASHFS_UNCOMPRESSED_FRAGMENTS(sBlk.s.flags) ?
+ "un" : "");
+ printf("Always-use-fragments option is %sspecified\n",
+ SQUASHFS_ALWAYS_FRAGMENTS(sBlk.s.flags) ? "" :
+ "not ");
+ }
+ }
+
+ if(sBlk.s.s_major == 4) {
+ if(SQUASHFS_NO_XATTRS(sBlk.s.flags))
+ printf("Xattrs are not stored\n");
+ else
+ printf("Xattrs are %scompressed\n",
+ SQUASHFS_UNCOMPRESSED_XATTRS(sBlk.s.flags) ?
+ "un" : "");
+ }
+
+ if(sBlk.s.s_major < 4)
+ printf("Check data is %spresent in the filesystem\n",
+ SQUASHFS_CHECK_DATA(sBlk.s.flags) ? "" :
+ "not ");
+
+ if(sBlk.s.s_major > 1)
+ printf("Duplicates are %sremoved\n",
+ SQUASHFS_DUPLICATES(sBlk.s.flags) ? "" : "not ");
+ else
+ printf("Duplicates are removed\n");
+
+ if(sBlk.s.s_major > 1)
+ printf("Number of fragments %d\n", sBlk.s.fragments);
+
+ printf("Number of inodes %d\n", sBlk.s.inodes);
+
+ if(sBlk.s.s_major == 4)
+ printf("Number of ids %d\n", sBlk.s.no_ids);
+ else {
+ printf("Number of uids %d\n", sBlk.no_uids);
+ printf("Number of gids %d\n", sBlk.no_guids);
+ }
+
+ TRACE("sBlk.s.inode_table_start 0x%llx\n", sBlk.s.inode_table_start);
+ TRACE("sBlk.s.directory_table_start 0x%llx\n",
+ sBlk.s.directory_table_start);
+
+ if(sBlk.s.s_major > 1)
+ TRACE("sBlk.s.fragment_table_start 0x%llx\n\n",
+ sBlk.s.fragment_table_start);
+
+ if(sBlk.s.s_major > 2)
+ TRACE("sBlk.s.lookup_table_start 0x%llx\n\n",
+ sBlk.s.lookup_table_start);
+
+ if(sBlk.s.s_major == 4) {
+ TRACE("sBlk.s.id_table_start 0x%llx\n", sBlk.s.id_table_start);
+ TRACE("sBlk.s.xattr_id_table_start 0x%llx\n",
+ sBlk.s.xattr_id_table_start);
+ } else {
+ TRACE("sBlk.uid_start 0x%llx\n", sBlk.uid_start);
+ TRACE("sBlk.guid_start 0x%llx\n", sBlk.guid_start);
+ }
+}
+
+
+int check_compression(struct compressor *comp)
+{
+ int res, bytes = 0;
+ char buffer[SQUASHFS_METADATA_SIZE] __attribute__ ((aligned));
+
+ if(!comp->supported) {
+ ERROR("Filesystem uses %s compression, this is "
+ "unsupported by this version\n", comp->name);
+ ERROR("Decompressors available:\n");
+ display_compressors("", "");
+ return 0;
+ }
+
+ /*
+ * Read compression options from disk if present, and pass to
+ * the compressor to ensure we know how to decompress a filesystem
+ * compressed with these compression options.
+ *
+ * Note, even if there is no compression options we still call the
+ * compressor because some compression options may be mandatory
+ * for some compressors.
+ */
+ if(SQUASHFS_COMP_OPTS(sBlk.s.flags)) {
+ bytes = read_block(fd, sizeof(sBlk.s), NULL, 0, buffer);
+ if(bytes == 0) {
+ ERROR("Failed to read compressor options\n");
+ return 0;
+ }
+ }
+
+ res = compressor_check_options(comp, sBlk.s.block_size, buffer, bytes);
+
+ return res != -1;
+}
+
+
+int read_super(char *source)
+{
+ squashfs_super_block_3 sBlk_3;
+ struct squashfs_super_block sBlk_4;
+
+ /*
+ * Try to read a Squashfs 4 superblock
+ */
+ read_fs_bytes(fd, SQUASHFS_START, sizeof(struct squashfs_super_block),
+ &sBlk_4);
+ swap = sBlk_4.s_magic != SQUASHFS_MAGIC;
+ SQUASHFS_INSWAP_SUPER_BLOCK(&sBlk_4);
+
+ if(sBlk_4.s_magic == SQUASHFS_MAGIC && sBlk_4.s_major == 4 &&
+ sBlk_4.s_minor == 0) {
+ s_ops.squashfs_opendir = squashfs_opendir_4;
+ s_ops.read_fragment = read_fragment_4;
+ s_ops.read_fragment_table = read_fragment_table_4;
+ s_ops.read_block_list = read_block_list_2;
+ s_ops.read_inode = read_inode_4;
+ s_ops.read_uids_guids = read_uids_guids_4;
+ memcpy(&sBlk, &sBlk_4, sizeof(sBlk_4));
+
+ /*
+ * Check the compression type
+ */
+ comp = lookup_compressor_id(sBlk.s.compression);
+ return TRUE;
+ }
+
+ /*
+ * Not a Squashfs 4 superblock, try to read a squashfs 3 superblock
+ * (compatible with 1 and 2 filesystems)
+ */
+ read_fs_bytes(fd, SQUASHFS_START, sizeof(squashfs_super_block_3),
+ &sBlk_3);
+
+ /*
+ * Check it is a SQUASHFS superblock
+ */
+ swap = 0;
+ if(sBlk_3.s_magic != SQUASHFS_MAGIC) {
+ if(sBlk_3.s_magic == SQUASHFS_MAGIC_SWAP) {
+ squashfs_super_block_3 sblk;
+ ERROR("Reading a different endian SQUASHFS filesystem "
+ "on %s\n", source);
+ SQUASHFS_SWAP_SUPER_BLOCK_3(&sblk, &sBlk_3);
+ memcpy(&sBlk_3, &sblk, sizeof(squashfs_super_block_3));
+ swap = 1;
+ } else {
+ ERROR("Can't find a SQUASHFS superblock on %s\n",
+ source);
+ goto failed_mount;
+ }
+ }
+
+ sBlk.s.s_magic = sBlk_3.s_magic;
+ sBlk.s.inodes = sBlk_3.inodes;
+ sBlk.s.mkfs_time = sBlk_3.mkfs_time;
+ sBlk.s.block_size = sBlk_3.block_size;
+ sBlk.s.fragments = sBlk_3.fragments;
+ sBlk.s.block_log = sBlk_3.block_log;
+ sBlk.s.flags = sBlk_3.flags;
+ sBlk.s.s_major = sBlk_3.s_major;
+ sBlk.s.s_minor = sBlk_3.s_minor;
+ sBlk.s.root_inode = sBlk_3.root_inode;
+ sBlk.s.bytes_used = sBlk_3.bytes_used;
+ sBlk.s.inode_table_start = sBlk_3.inode_table_start;
+ sBlk.s.directory_table_start = sBlk_3.directory_table_start;
+ sBlk.s.fragment_table_start = sBlk_3.fragment_table_start;
+ sBlk.s.lookup_table_start = sBlk_3.lookup_table_start;
+ sBlk.no_uids = sBlk_3.no_uids;
+ sBlk.no_guids = sBlk_3.no_guids;
+ sBlk.uid_start = sBlk_3.uid_start;
+ sBlk.guid_start = sBlk_3.guid_start;
+ sBlk.s.xattr_id_table_start = SQUASHFS_INVALID_BLK;
+
+ /* Check the MAJOR & MINOR versions */
+ if(sBlk.s.s_major == 1 || sBlk.s.s_major == 2) {
+ sBlk.s.bytes_used = sBlk_3.bytes_used_2;
+ sBlk.uid_start = sBlk_3.uid_start_2;
+ sBlk.guid_start = sBlk_3.guid_start_2;
+ sBlk.s.inode_table_start = sBlk_3.inode_table_start_2;
+ sBlk.s.directory_table_start = sBlk_3.directory_table_start_2;
+
+ if(sBlk.s.s_major == 1) {
+ sBlk.s.block_size = sBlk_3.block_size_1;
+ sBlk.s.fragment_table_start = sBlk.uid_start;
+ s_ops.squashfs_opendir = squashfs_opendir_1;
+ s_ops.read_fragment_table = read_fragment_table_1;
+ s_ops.read_block_list = read_block_list_1;
+ s_ops.read_inode = read_inode_1;
+ s_ops.read_uids_guids = read_uids_guids_1;
+ } else {
+ sBlk.s.fragment_table_start =
+ sBlk_3.fragment_table_start_2;
+ s_ops.squashfs_opendir = squashfs_opendir_1;
+ s_ops.read_fragment = read_fragment_2;
+ s_ops.read_fragment_table = read_fragment_table_2;
+ s_ops.read_block_list = read_block_list_2;
+ s_ops.read_inode = read_inode_2;
+ s_ops.read_uids_guids = read_uids_guids_1;
+ }
+ } else if(sBlk.s.s_major == 3) {
+ s_ops.squashfs_opendir = squashfs_opendir_3;
+ s_ops.read_fragment = read_fragment_3;
+ s_ops.read_fragment_table = read_fragment_table_3;
+ s_ops.read_block_list = read_block_list_2;
+ s_ops.read_inode = read_inode_3;
+ s_ops.read_uids_guids = read_uids_guids_1;
+ } else {
+ ERROR("Filesystem on %s is (%d:%d), ", source, sBlk.s.s_major,
+ sBlk.s.s_minor);
+ ERROR("which is a later filesystem version than I support!\n");
+ goto failed_mount;
+ }
+
+ /*
+ * 1.x, 2.x and 3.x filesystems use gzip compression.
+ */
+ comp = lookup_compressor("gzip");
+ return TRUE;
+
+failed_mount:
+ return FALSE;
+}
+
+
+struct pathname *process_extract_files(struct pathname *path, char *filename)
+{
+ FILE *fd;
+ char buffer[MAX_LINE + 1]; /* overflow safe */
+ char *name;
+
+ fd = fopen(filename, "r");
+ if(fd == NULL)
+ EXIT_UNSQUASH("Failed to open extract file \"%s\" because %s\n",
+ filename, strerror(errno));
+
+ while(fgets(name = buffer, MAX_LINE + 1, fd) != NULL) {
+ int len = strlen(name);
+
+ if(len == MAX_LINE && name[len - 1] != '\n')
+ /* line too large */
+ EXIT_UNSQUASH("Line too long when reading "
+ "extract file \"%s\", larger than %d "
+ "bytes\n", filename, MAX_LINE);
+
+ /*
+ * Remove '\n' terminator if it exists (the last line
+ * in the file may not be '\n' terminated)
+ */
+ if(len && name[len - 1] == '\n')
+ name[len - 1] = '\0';
+
+ /* Skip any leading whitespace */
+ while(isspace(*name))
+ name ++;
+
+ /* if comment line, skip */
+ if(*name == '#')
+ continue;
+
+ /* check for initial backslash, to accommodate
+ * filenames with leading space or leading # character
+ */
+ if(*name == '\\')
+ name ++;
+
+ /* if line is now empty after skipping characters, skip it */
+ if(*name == '\0')
+ continue;
+
+ path = add_path(path, name, name);
+ }
+
+ if(ferror(fd))
+ EXIT_UNSQUASH("Reading extract file \"%s\" failed because %s\n",
+ filename, strerror(errno));
+
+ fclose(fd);
+ return path;
+}
+
+
+/*
+ * reader thread. This thread processes read requests queued by the
+ * cache_get() routine.
+ */
+void *reader(void *arg)
+{
+ while(1) {
+ struct cache_entry *entry = queue_get(to_reader);
+ int res = read_fs_bytes(fd, entry->block,
+ SQUASHFS_COMPRESSED_SIZE_BLOCK(entry->size),
+ entry->data);
+
+ if(res && SQUASHFS_COMPRESSED_BLOCK(entry->size))
+ /*
+ * queue successfully read block to the inflate
+ * thread(s) for further processing
+ */
+ queue_put(to_inflate, entry);
+ else
+ /*
+ * block has either been successfully read and is
+ * uncompressed, or an error has occurred, clear pending
+ * flag, set error appropriately, and wake up any
+ * threads waiting on this buffer
+ */
+ cache_block_ready(entry, !res);
+ }
+}
+
+
+/*
+ * writer thread. This processes file write requests queued by the
+ * write_file() routine.
+ */
+void *writer(void *arg)
+{
+ int i;
+
+ while(1) {
+ struct squashfs_file *file = queue_get(to_writer);
+ int file_fd;
+ long long hole = 0;
+ int failed = FALSE;
+ int error;
+
+ if(file == NULL) {
+ queue_put(from_writer, NULL);
+ continue;
+ } else if(file->fd == -1) {
+ /* write attributes for directory file->pathname */
+ set_attributes(file->pathname, file->mode, file->uid,
+ file->gid, file->time, file->xattr, TRUE);
+ free(file->pathname);
+ free(file);
+ continue;
+ }
+
+ TRACE("writer: regular file, blocks %d\n", file->blocks);
+
+ file_fd = file->fd;
+
+ for(i = 0; i < file->blocks; i++, cur_blocks ++) {
+ struct file_entry *block = queue_get(to_writer);
+
+ if(block->buffer == 0) { /* sparse file */
+ hole += block->size;
+ free(block);
+ continue;
+ }
+
+ cache_block_wait(block->buffer);
+
+ if(block->buffer->error)
+ failed = TRUE;
+
+ if(failed)
+ continue;
+
+ error = write_block(file_fd, block->buffer->data +
+ block->offset, block->size, hole, file->sparse);
+
+ if(error == FALSE) {
+ ERROR("writer: failed to write data block %d\n",
+ i);
+ failed = TRUE;
+ }
+
+ hole = 0;
+ cache_block_put(block->buffer);
+ free(block);
+ }
+
+ if(hole && failed == FALSE) {
+ /*
+ * corner case for hole extending to end of file
+ */
+ if(file->sparse == FALSE ||
+ lseek(file_fd, hole, SEEK_CUR) == -1) {
+ /*
+ * for files which we don't want to write
+ * sparsely, or for broken lseeks which cannot
+ * seek beyond end of file, write_block will do
+ * the right thing
+ */
+ hole --;
+ if(write_block(file_fd, "\0", 1, hole,
+ file->sparse) == FALSE) {
+ ERROR("writer: failed to write sparse "
+ "data block\n");
+ failed = TRUE;
+ }
+ } else if(ftruncate(file_fd, file->file_size) == -1) {
+ ERROR("writer: failed to write sparse data "
+ "block\n");
+ failed = TRUE;
+ }
+ }
+
+ close_wake(file_fd);
+ if(failed == FALSE)
+ set_attributes(file->pathname, file->mode, file->uid,
+ file->gid, file->time, file->xattr, force);
+ else {
+ ERROR("Failed to write %s, skipping\n", file->pathname);
+ unlink(file->pathname);
+ }
+ free(file->pathname);
+ free(file);
+
+ }
+}
+
+
+/*
+ * decompress thread. This decompresses buffers queued by the read thread
+ */
+void *inflator(void *arg)
+{
+ char tmp[block_size];
+
+ while(1) {
+ struct cache_entry *entry = queue_get(to_inflate);
+ int error, res;
+
+ res = compressor_uncompress(comp, tmp, entry->data,
+ SQUASHFS_COMPRESSED_SIZE_BLOCK(entry->size), block_size,
+ &error);
+
+ if(res == -1)
+ ERROR("%s uncompress failed with error code %d\n",
+ comp->name, error);
+ else
+ memcpy(entry->data, tmp, res);
+
+ /*
+ * block has been either successfully decompressed, or an error
+ * occurred, clear pending flag, set error appropriately and
+ * wake up any threads waiting on this block
+ */
+ cache_block_ready(entry, res == -1);
+ }
+}
+
+
+void *progress_thread(void *arg)
+{
+ struct timespec requested_time, remaining;
+ struct itimerval itimerval;
+ struct winsize winsize;
+
+ if(ioctl(1, TIOCGWINSZ, &winsize) == -1) {
+ if(isatty(STDOUT_FILENO))
+ ERROR("TIOCGWINSZ ioctl failed, defaulting to 80 "
+ "columns\n");
+ columns = 80;
+ } else
+ columns = winsize.ws_col;
+ signal(SIGWINCH, sigwinch_handler);
+ signal(SIGALRM, sigalrm_handler);
+
+ itimerval.it_value.tv_sec = 0;
+ itimerval.it_value.tv_usec = 250000;
+ itimerval.it_interval.tv_sec = 0;
+ itimerval.it_interval.tv_usec = 250000;
+ setitimer(ITIMER_REAL, &itimerval, NULL);
+
+ requested_time.tv_sec = 0;
+ requested_time.tv_nsec = 250000000;
+
+ while(1) {
+ int res = nanosleep(&requested_time, &remaining);
+
+ if(res == -1 && errno != EINTR)
+ EXIT_UNSQUASH("nanosleep failed in progress thread\n");
+
+ if(progress_enabled) {
+ pthread_mutex_lock(&screen_mutex);
+ progress_bar(sym_count + dev_count +
+ fifo_count + cur_blocks, total_inodes -
+ total_files + total_blocks, columns);
+ pthread_mutex_unlock(&screen_mutex);
+ }
+ }
+}
+
+
+void initialise_threads(int fragment_buffer_size, int data_buffer_size)
+{
+ struct rlimit rlim;
+ int i, max_files, res;
+ sigset_t sigmask, old_mask;
+
+ /* block SIGQUIT and SIGHUP, these are handled by the info thread */
+ sigemptyset(&sigmask);
+ sigaddset(&sigmask, SIGQUIT);
+ sigaddset(&sigmask, SIGHUP);
+ sigaddset(&sigmask, SIGALRM);
+ if(pthread_sigmask(SIG_BLOCK, &sigmask, NULL) == -1)
+ EXIT_UNSQUASH("Failed to set signal mask in initialise_threads"
+ "\n");
+
+ /*
+ * temporarily block these signals so the created sub-threads will
+ * ignore them, ensuring the main thread handles them
+ */
+ sigemptyset(&sigmask);
+ sigaddset(&sigmask, SIGINT);
+ sigaddset(&sigmask, SIGTERM);
+ if(pthread_sigmask(SIG_BLOCK, &sigmask, &old_mask) == -1)
+ EXIT_UNSQUASH("Failed to set signal mask in initialise_threads"
+ "\n");
+
+ if(processors == -1) {
+#ifndef linux
+ int mib[2];
+ size_t len = sizeof(processors);
+
+ mib[0] = CTL_HW;
+#ifdef HW_AVAILCPU
+ mib[1] = HW_AVAILCPU;
+#else
+ mib[1] = HW_NCPU;
+#endif
+
+ if(sysctl(mib, 2, &processors, &len, NULL, 0) == -1) {
+ ERROR("Failed to get number of available processors. "
+ "Defaulting to 1\n");
+ processors = 1;
+ }
+#else
+ processors = sysconf(_SC_NPROCESSORS_ONLN);
+#endif
+ }
+
+ if(add_overflow(processors, 3) ||
+ multiply_overflow(processors + 3, sizeof(pthread_t)))
+ EXIT_UNSQUASH("Processors too large\n");
+
+ thread = malloc((3 + processors) * sizeof(pthread_t));
+ if(thread == NULL)
+ EXIT_UNSQUASH("Out of memory allocating thread descriptors\n");
+ inflator_thread = &thread[3];
+
+ /*
+ * dimensioning the to_reader and to_inflate queues. The size of
+ * these queues is directly related to the amount of block
+ * read-ahead possible. To_reader queues block read requests to
+ * the reader thread and to_inflate queues block decompression
+ * requests to the inflate thread(s) (once the block has been read by
+ * the reader thread). The amount of read-ahead is determined by
+ * the combined size of the data_block and fragment caches which
+ * determine the total number of blocks which can be "in flight"
+ * at any one time (either being read or being decompressed)
+ *
+ * The maximum file open limit, however, affects the read-ahead
+ * possible, in that for normal sizes of the fragment and data block
+ * caches, where the incoming files have few data blocks or one fragment
+ * only, the file open limit is likely to be reached before the
+ * caches are full. This means the worst case sizing of the combined
+ * sizes of the caches is unlikely to ever be necessary. However, is is
+ * obvious read-ahead up to the data block cache size is always possible
+ * irrespective of the file open limit, because a single file could
+ * contain that number of blocks.
+ *
+ * Choosing the size as "file open limit + data block cache size" seems
+ * to be a reasonable estimate. We can reasonably assume the maximum
+ * likely read-ahead possible is data block cache size + one fragment
+ * per open file.
+ *
+ * dimensioning the to_writer queue. The size of this queue is
+ * directly related to the amount of block read-ahead possible.
+ * However, unlike the to_reader and to_inflate queues, this is
+ * complicated by the fact the to_writer queue not only contains
+ * entries for fragments and data_blocks but it also contains
+ * file entries, one per open file in the read-ahead.
+ *
+ * Choosing the size as "2 * (file open limit) +
+ * data block cache size" seems to be a reasonable estimate.
+ * We can reasonably assume the maximum likely read-ahead possible
+ * is data block cache size + one fragment per open file, and then
+ * we will have a file_entry for each open file.
+ */
+ res = getrlimit(RLIMIT_NOFILE, &rlim);
+ if (res == -1) {
+ ERROR("failed to get open file limit! Defaulting to 1\n");
+ rlim.rlim_cur = 1;
+ }
+
+ if (rlim.rlim_cur != RLIM_INFINITY) {
+ /*
+ * leave OPEN_FILE_MARGIN free (rlim_cur includes fds used by
+ * stdin, stdout, stderr and filesystem fd
+ */
+ if (rlim.rlim_cur <= OPEN_FILE_MARGIN)
+ /* no margin, use minimum possible */
+ max_files = 1;
+ else
+ max_files = rlim.rlim_cur - OPEN_FILE_MARGIN;
+ } else
+ max_files = -1;
+
+ /* set amount of available files for use by open_wait and close_wake */
+ open_init(max_files);
+
+ /*
+ * allocate to_reader, to_inflate and to_writer queues. Set based on
+ * open file limit and cache size, unless open file limit is unlimited,
+ * in which case set purely based on cache limits
+ *
+ * In doing so, check that the user supplied values do not overflow
+ * a signed int
+ */
+ if (max_files != -1) {
+ if(add_overflow(data_buffer_size, max_files) ||
+ add_overflow(data_buffer_size, max_files * 2))
+ EXIT_UNSQUASH("Data queue size is too large\n");
+
+ to_reader = queue_init(max_files + data_buffer_size);
+ to_inflate = queue_init(max_files + data_buffer_size);
+ to_writer = queue_init(max_files * 2 + data_buffer_size);
+ } else {
+ int all_buffers_size;
+
+ if(add_overflow(fragment_buffer_size, data_buffer_size))
+ EXIT_UNSQUASH("Data and fragment queues combined are"
+ " too large\n");
+
+ all_buffers_size = fragment_buffer_size + data_buffer_size;
+
+ if(add_overflow(all_buffers_size, all_buffers_size))
+ EXIT_UNSQUASH("Data and fragment queues combined are"
+ " too large\n");
+
+ to_reader = queue_init(all_buffers_size);
+ to_inflate = queue_init(all_buffers_size);
+ to_writer = queue_init(all_buffers_size * 2);
+ }
+
+ from_writer = queue_init(1);
+
+ fragment_cache = cache_init(block_size, fragment_buffer_size);
+ data_cache = cache_init(block_size, data_buffer_size);
+ pthread_create(&thread[0], NULL, reader, NULL);
+ pthread_create(&thread[1], NULL, writer, NULL);
+ pthread_create(&thread[2], NULL, progress_thread, NULL);
+ init_info();
+ pthread_mutex_init(&fragment_mutex, NULL);
+
+ for(i = 0; i < processors; i++) {
+ if(pthread_create(&inflator_thread[i], NULL, inflator, NULL) !=
+ 0)
+ EXIT_UNSQUASH("Failed to create thread\n");
+ }
+
+ printf("Parallel unsquashfs: Using %d processor%s\n", processors,
+ processors == 1 ? "" : "s");
+
+ if(pthread_sigmask(SIG_SETMASK, &old_mask, NULL) == -1)
+ EXIT_UNSQUASH("Failed to set signal mask in initialise_threads"
+ "\n");
+}
+
+
+void enable_progress_bar()
+{
+ pthread_mutex_lock(&screen_mutex);
+ progress_enabled = progress;
+ pthread_mutex_unlock(&screen_mutex);
+}
+
+
+void disable_progress_bar()
+{
+ pthread_mutex_lock(&screen_mutex);
+ if(progress_enabled) {
+ progress_bar(sym_count + dev_count + fifo_count + cur_blocks,
+ total_inodes - total_files + total_blocks, columns);
+ printf("\n");
+ }
+ progress_enabled = FALSE;
+ pthread_mutex_unlock(&screen_mutex);
+}
+
+
+void progressbar_error(char *fmt, ...)
+{
+ va_list ap;
+
+ pthread_mutex_lock(&screen_mutex);
+
+ if(progress_enabled)
+ fprintf(stderr, "\n");
+
+ va_start(ap, fmt);
+ vfprintf(stderr, fmt, ap);
+ va_end(ap);
+
+ pthread_mutex_unlock(&screen_mutex);
+}
+
+
+void progressbar_info(char *fmt, ...)
+{
+ va_list ap;
+
+ pthread_mutex_lock(&screen_mutex);
+
+ if(progress_enabled)
+ printf("\n");
+
+ va_start(ap, fmt);
+ vprintf(fmt, ap);
+ va_end(ap);
+
+ pthread_mutex_unlock(&screen_mutex);
+}
+
+void progress_bar(long long current, long long max, int columns)
+{
+ char rotate_list[] = { '|', '/', '-', '\\' };
+ int max_digits, used, hashes, spaces;
+ static int tty = -1;
+
+ if(max == 0)
+ return;
+
+ max_digits = floor(log10(max)) + 1;
+ used = max_digits * 2 + 11;
+ hashes = (current * (columns - used)) / max;
+ spaces = columns - used - hashes;
+
+ if((current > max) || (columns - used < 0))
+ return;
+
+ if(tty == -1)
+ tty = isatty(STDOUT_FILENO);
+ if(!tty) {
+ static long long previous = -1;
+
+ /*
+ * Updating much more frequently than this results in huge
+ * log files.
+ */
+ if((current % 100) != 0 && current != max)
+ return;
+ /* Don't update just to rotate the spinner. */
+ if(current == previous)
+ return;
+ previous = current;
+ }
+
+ printf("\r[");
+
+ while (hashes --)
+ putchar('=');
+
+ putchar(rotate_list[rotate]);
+
+ while(spaces --)
+ putchar(' ');
+
+ printf("] %*lld/%*lld", max_digits, current, max_digits, max);
+ printf(" %3lld%%", current * 100 / max);
+ fflush(stdout);
+}
+
+
+int parse_number(char *arg, int *res)
+{
+ char *b;
+ long number = strtol(arg, &b, 10);
+
+ /* check for trailing junk after number */
+ if(*b != '\0')
+ return 0;
+
+ /*
+ * check for strtol underflow or overflow in conversion.
+ * Note: strtol can validly return LONG_MIN and LONG_MAX
+ * if the user entered these values, but, additional code
+ * to distinguish this scenario is unnecessary, because for
+ * our purposes LONG_MIN and LONG_MAX are too large anyway
+ */
+ if(number == LONG_MIN || number == LONG_MAX)
+ return 0;
+
+ /* reject negative numbers as invalid */
+ if(number < 0)
+ return 0;
+
+ /* check if long result will overflow signed int */
+ if(number > INT_MAX)
+ return 0;
+
+ *res = number;
+ return 1;
+}
+
+
+#define VERSION() \
+ printf("unsquashfs version 4.3 (2014/05/12)\n");\
+ printf("copyright (C) 2014 Phillip Lougher "\
+ "<phillip@squashfs.org.uk>\n\n");\
+ printf("This program is free software; you can redistribute it and/or"\
+ "\n");\
+ printf("modify it under the terms of the GNU General Public License"\
+ "\n");\
+ printf("as published by the Free Software Foundation; either version "\
+ "2,\n");\
+ printf("or (at your option) any later version.\n\n");\
+ printf("This program is distributed in the hope that it will be "\
+ "useful,\n");\
+ printf("but WITHOUT ANY WARRANTY; without even the implied warranty of"\
+ "\n");\
+ printf("MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the"\
+ "\n");\
+ printf("GNU General Public License for more details.\n");
+int main(int argc, char *argv[])
+{
+ char *dest = "squashfs-root";
+ int i, stat_sys = FALSE, version = FALSE;
+ int n;
+ struct pathnames *paths = NULL;
+ struct pathname *path = NULL;
+ long long directory_table_end;
+ int fragment_buffer_size = FRAGMENT_BUFFER_DEFAULT;
+ int data_buffer_size = DATA_BUFFER_DEFAULT;
+
+ pthread_mutex_init(&screen_mutex, NULL);
+ root_process = geteuid() == 0;
+ if(root_process)
+ umask(0);
+
+ for(i = 1; i < argc; i++) {
+ if(*argv[i] != '-')
+ break;
+ if(strcmp(argv[i], "-version") == 0 ||
+ strcmp(argv[i], "-v") == 0) {
+ VERSION();
+ version = TRUE;
+ } else if(strcmp(argv[i], "-info") == 0 ||
+ strcmp(argv[i], "-i") == 0)
+ info = TRUE;
+ else if(strcmp(argv[i], "-ls") == 0 ||
+ strcmp(argv[i], "-l") == 0)
+ lsonly = TRUE;
+ else if(strcmp(argv[i], "-no-progress") == 0 ||
+ strcmp(argv[i], "-n") == 0)
+ progress = FALSE;
+ else if(strcmp(argv[i], "-no-xattrs") == 0 ||
+ strcmp(argv[i], "-no") == 0)
+ no_xattrs = TRUE;
+ else if(strcmp(argv[i], "-xattrs") == 0 ||
+ strcmp(argv[i], "-x") == 0)
+ no_xattrs = FALSE;
+ else if(strcmp(argv[i], "-user-xattrs") == 0 ||
+ strcmp(argv[i], "-u") == 0) {
+ user_xattrs = TRUE;
+ no_xattrs = FALSE;
+ } else if(strcmp(argv[i], "-dest") == 0 ||
+ strcmp(argv[i], "-d") == 0) {
+ if(++i == argc) {
+ fprintf(stderr, "%s: -dest missing filename\n",
+ argv[0]);
+ exit(1);
+ }
+ dest = argv[i];
+ } else if(strcmp(argv[i], "-processors") == 0 ||
+ strcmp(argv[i], "-p") == 0) {
+ if((++i == argc) ||
+ !parse_number(argv[i],
+ &processors)) {
+ ERROR("%s: -processors missing or invalid "
+ "processor number\n", argv[0]);
+ exit(1);
+ }
+ if(processors < 1) {
+ ERROR("%s: -processors should be 1 or larger\n",
+ argv[0]);
+ exit(1);
+ }
+ } else if(strcmp(argv[i], "-data-queue") == 0 ||
+ strcmp(argv[i], "-da") == 0) {
+ if((++i == argc) ||
+ !parse_number(argv[i],
+ &data_buffer_size)) {
+ ERROR("%s: -data-queue missing or invalid "
+ "queue size\n", argv[0]);
+ exit(1);
+ }
+ if(data_buffer_size < 1) {
+ ERROR("%s: -data-queue should be 1 Mbyte or "
+ "larger\n", argv[0]);
+ exit(1);
+ }
+ } else if(strcmp(argv[i], "-frag-queue") == 0 ||
+ strcmp(argv[i], "-fr") == 0) {
+ if((++i == argc) ||
+ !parse_number(argv[i],
+ &fragment_buffer_size)) {
+ ERROR("%s: -frag-queue missing or invalid "
+ "queue size\n", argv[0]);
+ exit(1);
+ }
+ if(fragment_buffer_size < 1) {
+ ERROR("%s: -frag-queue should be 1 Mbyte or "
+ "larger\n", argv[0]);
+ exit(1);
+ }
+ } else if(strcmp(argv[i], "-force") == 0 ||
+ strcmp(argv[i], "-f") == 0)
+ force = TRUE;
+ else if(strcmp(argv[i], "-stat") == 0 ||
+ strcmp(argv[i], "-s") == 0)
+ stat_sys = TRUE;
+ else if(strcmp(argv[i], "-lls") == 0 ||
+ strcmp(argv[i], "-ll") == 0) {
+ lsonly = TRUE;
+ short_ls = FALSE;
+ } else if(strcmp(argv[i], "-linfo") == 0 ||
+ strcmp(argv[i], "-li") == 0) {
+ info = TRUE;
+ short_ls = FALSE;
+ } else if(strcmp(argv[i], "-ef") == 0 ||
+ strcmp(argv[i], "-e") == 0) {
+ if(++i == argc) {
+ fprintf(stderr, "%s: -ef missing filename\n",
+ argv[0]);
+ exit(1);
+ }
+ path = process_extract_files(path, argv[i]);
+ } else if(strcmp(argv[i], "-regex") == 0 ||
+ strcmp(argv[i], "-r") == 0)
+ use_regex = TRUE;
+ else
+ goto options;
+ }
+
+ if(lsonly || info)
+ progress = FALSE;
+
+#ifdef SQUASHFS_TRACE
+ /*
+ * Disable progress bar if full debug tracing is enabled.
+ * The progress bar in this case just gets in the way of the
+ * debug trace output
+ */
+ progress = FALSE;
+#endif
+
+ if(i == argc) {
+ if(!version) {
+options:
+ ERROR("SYNTAX: %s [options] filesystem [directories or "
+ "files to extract]\n", argv[0]);
+ ERROR("\t-v[ersion]\t\tprint version, licence and "
+ "copyright information\n");
+ ERROR("\t-d[est] <pathname>\tunsquash to <pathname>, "
+ "default \"squashfs-root\"\n");
+ ERROR("\t-n[o-progress]\t\tdon't display the progress "
+ "bar\n");
+ ERROR("\t-no[-xattrs]\t\tdon't extract xattrs in file system"
+ NOXOPT_STR"\n");
+ ERROR("\t-x[attrs]\t\textract xattrs in file system"
+ XOPT_STR "\n");
+ ERROR("\t-u[ser-xattrs]\t\tonly extract user xattrs in "
+ "file system.\n\t\t\t\tEnables extracting "
+ "xattrs\n");
+ ERROR("\t-p[rocessors] <number>\tuse <number> "
+ "processors. By default will use\n");
+ ERROR("\t\t\t\tnumber of processors available\n");
+ ERROR("\t-i[nfo]\t\t\tprint files as they are "
+ "unsquashed\n");
+ ERROR("\t-li[nfo]\t\tprint files as they are "
+ "unsquashed with file\n");
+ ERROR("\t\t\t\tattributes (like ls -l output)\n");
+ ERROR("\t-l[s]\t\t\tlist filesystem, but don't unsquash"
+ "\n");
+ ERROR("\t-ll[s]\t\t\tlist filesystem with file "
+ "attributes (like\n");
+ ERROR("\t\t\t\tls -l output), but don't unsquash\n");
+ ERROR("\t-f[orce]\t\tif file already exists then "
+ "overwrite\n");
+ ERROR("\t-s[tat]\t\t\tdisplay filesystem superblock "
+ "information\n");
+ ERROR("\t-e[f] <extract file>\tlist of directories or "
+ "files to extract.\n\t\t\t\tOne per line\n");
+ ERROR("\t-da[ta-queue] <size>\tSet data queue to "
+ "<size> Mbytes. Default %d\n\t\t\t\tMbytes\n",
+ DATA_BUFFER_DEFAULT);
+ ERROR("\t-fr[ag-queue] <size>\tSet fragment queue to "
+ "<size> Mbytes. Default\n\t\t\t\t%d Mbytes\n",
+ FRAGMENT_BUFFER_DEFAULT);
+ ERROR("\t-r[egex]\t\ttreat extract names as POSIX "
+ "regular expressions\n");
+ ERROR("\t\t\t\trather than use the default shell "
+ "wildcard\n\t\t\t\texpansion (globbing)\n");
+ ERROR("\nDecompressors available:\n");
+ display_compressors("", "");
+ }
+ exit(1);
+ }
+
+ for(n = i + 1; n < argc; n++)
+ path = add_path(path, argv[n], argv[n]);
+
+ if((fd = open(argv[i], O_RDONLY)) == -1) {
+ ERROR("Could not open %s, because %s\n", argv[i],
+ strerror(errno));
+ exit(1);
+ }
+
+ if(read_super(argv[i]) == FALSE)
+ exit(1);
+
+ if(stat_sys) {
+ squashfs_stat(argv[i]);
+ exit(0);
+ }
+
+ if(!check_compression(comp))
+ exit(1);
+
+ block_size = sBlk.s.block_size;
+ block_log = sBlk.s.block_log;
+
+ /*
+ * Sanity check block size and block log.
+ *
+ * Check they're within correct limits
+ */
+ if(block_size > SQUASHFS_FILE_MAX_SIZE ||
+ block_log > SQUASHFS_FILE_MAX_LOG)
+ EXIT_UNSQUASH("Block size or block_log too large."
+ " File system is corrupt.\n");
+
+ /*
+ * Check block_size and block_log match
+ */
+ if(block_size != (1 << block_log))
+ EXIT_UNSQUASH("Block size and block_log do not match."
+ " File system is corrupt.\n");
+
+ /*
+ * convert from queue size in Mbytes to queue size in
+ * blocks.
+ *
+ * In doing so, check that the user supplied values do not
+ * overflow a signed int
+ */
+ if(shift_overflow(fragment_buffer_size, 20 - block_log))
+ EXIT_UNSQUASH("Fragment queue size is too large\n");
+ else
+ fragment_buffer_size <<= 20 - block_log;
+
+ if(shift_overflow(data_buffer_size, 20 - block_log))
+ EXIT_UNSQUASH("Data queue size is too large\n");
+ else
+ data_buffer_size <<= 20 - block_log;
+
+ initialise_threads(fragment_buffer_size, data_buffer_size);
+
+ fragment_data = malloc(block_size);
+ if(fragment_data == NULL)
+ EXIT_UNSQUASH("failed to allocate fragment_data\n");
+
+ file_data = malloc(block_size);
+ if(file_data == NULL)
+ EXIT_UNSQUASH("failed to allocate file_data");
+
+ data = malloc(block_size);
+ if(data == NULL)
+ EXIT_UNSQUASH("failed to allocate data\n");
+
+ created_inode = malloc(sBlk.s.inodes * sizeof(char *));
+ if(created_inode == NULL)
+ EXIT_UNSQUASH("failed to allocate created_inode\n");
+
+ memset(created_inode, 0, sBlk.s.inodes * sizeof(char *));
+
+ if(s_ops.read_uids_guids() == FALSE)
+ EXIT_UNSQUASH("failed to uid/gid table\n");
+
+ if(s_ops.read_fragment_table(&directory_table_end) == FALSE)
+ EXIT_UNSQUASH("failed to read fragment table\n");
+
+ if(read_inode_table(sBlk.s.inode_table_start,
+ sBlk.s.directory_table_start) == FALSE)
+ EXIT_UNSQUASH("failed to read inode table\n");
+
+ if(read_directory_table(sBlk.s.directory_table_start,
+ directory_table_end) == FALSE)
+ EXIT_UNSQUASH("failed to read directory table\n");
+
+ if(no_xattrs)
+ sBlk.s.xattr_id_table_start = SQUASHFS_INVALID_BLK;
+
+ if(read_xattrs_from_disk(fd, &sBlk.s) == 0)
+ EXIT_UNSQUASH("failed to read the xattr table\n");
+
+ if(path) {
+ paths = init_subdir();
+ paths = add_subdir(paths, path);
+ }
+
+ pre_scan(dest, SQUASHFS_INODE_BLK(sBlk.s.root_inode),
+ SQUASHFS_INODE_OFFSET(sBlk.s.root_inode), paths);
+
+ memset(created_inode, 0, sBlk.s.inodes * sizeof(char *));
+ inode_number = 1;
+
+ printf("%d inodes (%d blocks) to write\n\n", total_inodes,
+ total_inodes - total_files + total_blocks);
+
+ enable_progress_bar();
+
+ dir_scan(dest, SQUASHFS_INODE_BLK(sBlk.s.root_inode),
+ SQUASHFS_INODE_OFFSET(sBlk.s.root_inode), paths);
+
+ queue_put(to_writer, NULL);
+ queue_get(from_writer);
+
+ disable_progress_bar();
+
+ if(!lsonly) {
+ printf("\n");
+ printf("created %d files\n", file_count);
+ printf("created %d directories\n", dir_count);
+ printf("created %d symlinks\n", sym_count);
+ printf("created %d devices\n", dev_count);
+ printf("created %d fifos\n", fifo_count);
+ }
+
+ return 0;
+}
diff --git a/squashfs-tools/squashfs-tools/unsquashfs.h b/squashfs-tools/squashfs-tools/unsquashfs.h
new file mode 100644
index 0000000..4836b8d
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/unsquashfs.h
@@ -0,0 +1,282 @@
+#ifndef UNSQUASHFS_H
+#define UNSQUASHFS_H
+/*
+ * Unsquash a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2009, 2010, 2013, 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * unsquashfs.h
+ */
+
+#define TRUE 1
+#define FALSE 0
+#include <stdio.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <utime.h>
+#include <pwd.h>
+#include <grp.h>
+#include <time.h>
+#include <regex.h>
+#include <fnmatch.h>
+#include <signal.h>
+#include <pthread.h>
+#include <math.h>
+#include <sys/ioctl.h>
+#include <sys/time.h>
+
+#ifndef FNM_EXTMATCH /* glibc extension */
+ #define FNM_EXTMATCH 0
+#endif
+
+#ifndef linux
+#define __BYTE_ORDER BYTE_ORDER
+#define __BIG_ENDIAN BIG_ENDIAN
+#define __LITTLE_ENDIAN LITTLE_ENDIAN
+#else
+#include <endian.h>
+#endif
+
+#include "squashfs_fs.h"
+#include "error.h"
+
+#define CALCULATE_HASH(start) (start & 0xffff)
+
+/*
+ * Unified superblock containing fields for all superblocks
+ */
+struct super_block {
+ struct squashfs_super_block s;
+ /* fields only used by squashfs 3 and earlier layouts */
+ unsigned int no_uids;
+ unsigned int no_guids;
+ long long uid_start;
+ long long guid_start;
+};
+
+struct hash_table_entry {
+ long long start;
+ int bytes;
+ struct hash_table_entry *next;
+};
+
+struct inode {
+ int blocks;
+ char *block_ptr;
+ long long data;
+ int fragment;
+ int frag_bytes;
+ gid_t gid;
+ int inode_number;
+ int mode;
+ int offset;
+ long long start;
+ char *symlink;
+ time_t time;
+ int type;
+ uid_t uid;
+ char sparse;
+ unsigned int xattr;
+};
+
+typedef struct squashfs_operations {
+ struct dir *(*squashfs_opendir)(unsigned int block_start,
+ unsigned int offset, struct inode **i);
+ void (*read_fragment)(unsigned int fragment, long long *start_block,
+ int *size);
+ int (*read_fragment_table)(long long *);
+ void (*read_block_list)(unsigned int *block_list, char *block_ptr,
+ int blocks);
+ struct inode *(*read_inode)(unsigned int start_block,
+ unsigned int offset);
+ int (*read_uids_guids)();
+} squashfs_operations;
+
+struct test {
+ int mask;
+ int value;
+ int position;
+ char mode;
+};
+
+
+/* Cache status struct. Caches are used to keep
+ track of memory buffers passed between different threads */
+struct cache {
+ int max_buffers;
+ int count;
+ int used;
+ int buffer_size;
+ int wait_free;
+ int wait_pending;
+ pthread_mutex_t mutex;
+ pthread_cond_t wait_for_free;
+ pthread_cond_t wait_for_pending;
+ struct cache_entry *free_list;
+ struct cache_entry *hash_table[65536];
+};
+
+/* struct describing a cache entry passed between threads */
+struct cache_entry {
+ struct cache *cache;
+ long long block;
+ int size;
+ int used;
+ int error;
+ int pending;
+ struct cache_entry *hash_next;
+ struct cache_entry *hash_prev;
+ struct cache_entry *free_next;
+ struct cache_entry *free_prev;
+ char *data;
+};
+
+/* struct describing queues used to pass data between threads */
+struct queue {
+ int size;
+ int readp;
+ int writep;
+ pthread_mutex_t mutex;
+ pthread_cond_t empty;
+ pthread_cond_t full;
+ void **data;
+};
+
+/* default size of fragment buffer in Mbytes */
+#define FRAGMENT_BUFFER_DEFAULT 256
+/* default size of data buffer in Mbytes */
+#define DATA_BUFFER_DEFAULT 256
+
+#define DIR_ENT_SIZE 16
+
+struct dir_ent {
+ char name[SQUASHFS_NAME_LEN + 1];
+ unsigned int start_block;
+ unsigned int offset;
+ unsigned int type;
+};
+
+struct dir {
+ int dir_count;
+ int cur_entry;
+ unsigned int mode;
+ uid_t uid;
+ gid_t guid;
+ unsigned int mtime;
+ unsigned int xattr;
+ struct dir_ent *dirs;
+};
+
+struct file_entry {
+ int offset;
+ int size;
+ struct cache_entry *buffer;
+};
+
+
+struct squashfs_file {
+ int fd;
+ int blocks;
+ long long file_size;
+ int mode;
+ uid_t uid;
+ gid_t gid;
+ time_t time;
+ char *pathname;
+ char sparse;
+ unsigned int xattr;
+};
+
+struct path_entry {
+ char *name;
+ regex_t *preg;
+ struct pathname *paths;
+};
+
+struct pathname {
+ int names;
+ struct path_entry *name;
+};
+
+struct pathnames {
+ int count;
+ struct pathname *path[0];
+};
+#define PATHS_ALLOC_SIZE 10
+
+/* globals */
+extern struct super_block sBlk;
+extern squashfs_operations s_ops;
+extern int swap;
+extern char *inode_table, *directory_table;
+extern struct hash_table_entry *inode_table_hash[65536],
+ *directory_table_hash[65536];
+extern unsigned int *uid_table, *guid_table;
+extern pthread_mutex_t screen_mutex;
+extern int progress_enabled;
+extern int inode_number;
+extern int lookup_type[];
+extern int fd;
+extern struct queue *to_reader, *to_inflate, *to_writer;
+extern struct cache *fragment_cache, *data_cache;
+
+/* unsquashfs.c */
+extern int lookup_entry(struct hash_table_entry **, long long);
+extern int read_fs_bytes(int fd, long long, int, void *);
+extern int read_block(int, long long, long long *, int, void *);
+extern void enable_progress_bar();
+extern void disable_progress_bar();
+extern void dump_queue(struct queue *);
+extern void dump_cache(struct cache *);
+
+/* unsquash-1.c */
+extern void read_block_list_1(unsigned int *, char *, int);
+extern int read_fragment_table_1(long long *);
+extern struct inode *read_inode_1(unsigned int, unsigned int);
+extern struct dir *squashfs_opendir_1(unsigned int, unsigned int,
+ struct inode **);
+extern int read_uids_guids_1();
+
+/* unsquash-2.c */
+extern void read_block_list_2(unsigned int *, char *, int);
+extern int read_fragment_table_2(long long *);
+extern void read_fragment_2(unsigned int, long long *, int *);
+extern struct inode *read_inode_2(unsigned int, unsigned int);
+
+/* unsquash-3.c */
+extern int read_fragment_table_3(long long *);
+extern void read_fragment_3(unsigned int, long long *, int *);
+extern struct inode *read_inode_3(unsigned int, unsigned int);
+extern struct dir *squashfs_opendir_3(unsigned int, unsigned int,
+ struct inode **);
+
+/* unsquash-4.c */
+extern int read_fragment_table_4(long long *);
+extern void read_fragment_4(unsigned int, long long *, int *);
+extern struct inode *read_inode_4(unsigned int, unsigned int);
+extern struct dir *squashfs_opendir_4(unsigned int, unsigned int,
+ struct inode **);
+extern int read_uids_guids_4();
+#endif
diff --git a/squashfs-tools/squashfs-tools/unsquashfs_info.c b/squashfs-tools/squashfs-tools/unsquashfs_info.c
new file mode 100644
index 0000000..7d4f7af
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/unsquashfs_info.c
@@ -0,0 +1,140 @@
+/*
+ * Create a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2013
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * unsquashfs_info.c
+ */
+
+#include <pthread.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <signal.h>
+#include <sys/time.h>
+#include <stdio.h>
+#include <math.h>
+#include <stdarg.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <dirent.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <string.h>
+
+#include "squashfs_fs.h"
+#include "unsquashfs.h"
+#include "error.h"
+
+static int silent = 0;
+char *pathname = NULL;
+
+pthread_t info_thread;
+
+
+void disable_info()
+{
+ if(pathname)
+ free(pathname);
+
+ pathname = NULL;
+}
+
+
+void update_info(char *name)
+{
+ if(pathname)
+ free(pathname);
+
+ pathname = name;
+}
+
+
+void dump_state()
+{
+ disable_progress_bar();
+
+ printf("Queue and cache status dump\n");
+ printf("===========================\n");
+
+ printf("file buffer read queue (main thread -> reader thread)\n");
+ dump_queue(to_reader);
+
+ printf("file buffer decompress queue (reader thread -> inflate"
+ " thread(s))\n");
+ dump_queue(to_inflate);
+
+ printf("file buffer write queue (main thread -> writer thread)\n");
+ dump_queue(to_writer);
+
+ printf("\nbuffer cache (uncompressed blocks and compressed blocks "
+ "'in flight')\n");
+ dump_cache(data_cache);
+
+ printf("fragment buffer cache (uncompressed frags and compressed"
+ " frags 'in flight')\n");
+ dump_cache(fragment_cache);
+
+ enable_progress_bar();
+}
+
+
+void *info_thrd(void *arg)
+{
+ sigset_t sigmask;
+ int sig, err, waiting = 0;
+
+ sigemptyset(&sigmask);
+ sigaddset(&sigmask, SIGQUIT);
+ sigaddset(&sigmask, SIGHUP);
+ sigaddset(&sigmask, SIGALRM);
+
+ while(1) {
+ err = sigwait(&sigmask, &sig);
+
+ if(err == -1) {
+ switch(errno) {
+ case EINTR:
+ continue;
+ default:
+ BAD_ERROR("sigwait failed "
+ "because %s\n", strerror(errno));
+ }
+ }
+
+ if(sig == SIGQUIT && !waiting) {
+ if(pathname)
+ INFO("%s\n", pathname);
+
+ /* set one second interval period, if ^\ received
+ within then, dump queue and cache status */
+ waiting = 1;
+ alarm(1);
+ } else if (sig == SIGQUIT) {
+ dump_state();
+ } else if (sig == SIGALRM) {
+ waiting = 0;
+ }
+ }
+}
+
+
+void init_info()
+{
+ pthread_create(&info_thread, NULL, info_thrd, NULL);
+}
diff --git a/squashfs-tools/squashfs-tools/unsquashfs_info.h b/squashfs-tools/squashfs-tools/unsquashfs_info.h
new file mode 100644
index 0000000..f85efd1
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/unsquashfs_info.h
@@ -0,0 +1,30 @@
+#ifndef UNSQUASHFS_INFO_H
+#define UNSQUASHFS_INFO_H
+/*
+ * Create a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2013, 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * unsquashfs_info.h
+ */
+
+extern void disable_info();
+extern void update_info(char *);
+extern void init_info();
+#endif
diff --git a/squashfs-tools/squashfs-tools/unsquashfs_xattr.c b/squashfs-tools/squashfs-tools/unsquashfs_xattr.c
new file mode 100644
index 0000000..13f0e35
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/unsquashfs_xattr.c
@@ -0,0 +1,144 @@
+/*
+ * Unsquash a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2010, 2012
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * unsquashfs_xattr.c
+ */
+
+#include "unsquashfs.h"
+#include "xattr.h"
+
+#include <sys/xattr.h>
+
+#ifdef XATTR_NOFOLLOW /* Apple's xattrs */
+ #define lsetxattr(path_, name_, val_, sz_, flags_) \
+ setxattr(path_, name_, val_, sz_, 0, flags_ | XATTR_NOFOLLOW)
+#endif
+
+#define NOSPACE_MAX 10
+
+extern int root_process;
+extern int user_xattrs;
+
+void write_xattr(char *pathname, unsigned int xattr)
+{
+ unsigned int count;
+ struct xattr_list *xattr_list;
+ int i;
+ static int nonsuper_error = FALSE;
+ static int ignore_xattrs = FALSE;
+ static int nospace_error = 0;
+
+ if(ignore_xattrs || xattr == SQUASHFS_INVALID_XATTR ||
+ sBlk.s.xattr_id_table_start == SQUASHFS_INVALID_BLK)
+ return;
+
+ xattr_list = get_xattr(xattr, &count, 1);
+ if(xattr_list == NULL) {
+ ERROR("Failed to read xattrs for file %s\n", pathname);
+ return;
+ }
+
+ for(i = 0; i < count; i++) {
+ int prefix = xattr_list[i].type & SQUASHFS_XATTR_PREFIX_MASK;
+
+ if(user_xattrs && prefix != SQUASHFS_XATTR_USER)
+ continue;
+
+ if(root_process || prefix == SQUASHFS_XATTR_USER) {
+ int res = lsetxattr(pathname, xattr_list[i].full_name,
+ xattr_list[i].value, xattr_list[i].vsize, 0);
+
+ if(res == -1) {
+ if(errno == ENOTSUP) {
+ /*
+ * If the destination filesystem cannot
+ * suppport xattrs, print error, and
+ * disable xattr output as this error is
+ * unlikely to go away, and printing
+ * screenfulls of the same error message
+ * is rather annoying
+ */
+ ERROR("write_xattr: failed to write "
+ "xattr %s for file %s because "
+ "extended attributes are not "
+ "supported by the destination "
+ "filesystem\n",
+ xattr_list[i].full_name,
+ pathname);
+ ERROR("Ignoring xattrs in "
+ "filesystem\n");
+ ERROR("To avoid this error message, "
+ "specify -no-xattrs\n");
+ ignore_xattrs = TRUE;
+ } else if((errno == ENOSPC || errno == EDQUOT)
+ && nospace_error < NOSPACE_MAX) {
+ /*
+ * Many filesystems like ext2/3/4 have
+ * limits on the amount of xattr
+ * data that can be stored per file
+ * (typically one block or 4K), so
+ * we shouldn't disable xattr ouput,
+ * as the error may be restriced to one
+ * file only. If we get a lot of these
+ * then suppress the error messsage
+ */
+ ERROR("write_xattr: failed to write "
+ "xattr %s for file %s because "
+ "no extended attribute space "
+ "remaining (per file or "
+ "filesystem limit)\n",
+ xattr_list[i].full_name,
+ pathname);
+ if(++ nospace_error == NOSPACE_MAX)
+ ERROR("%d of these errors "
+ "printed, further error "
+ "messages of this type "
+ "are suppressed!\n",
+ NOSPACE_MAX);
+ } else
+ ERROR("write_xattr: failed to write "
+ "xattr %s for file %s because "
+ "%s\n", xattr_list[i].full_name,
+ pathname, strerror(errno));
+ }
+ } else if(nonsuper_error == FALSE) {
+ /*
+ * if extract user xattrs only then
+ * error message is suppressed, if not
+ * print error, and then suppress further error
+ * messages to avoid possible screenfulls of the
+ * same error message!
+ */
+ ERROR("write_xattr: could not write xattr %s "
+ "for file %s because you're not "
+ "superuser!\n",
+ xattr_list[i].full_name, pathname);
+ ERROR("write_xattr: to avoid this error message, either"
+ " specify -user-xattrs, -no-xattrs, or run as "
+ "superuser!\n");
+ ERROR("Further error messages of this type are "
+ "suppressed!\n");
+ nonsuper_error = TRUE;
+ }
+ }
+
+ free_xattr(xattr_list, count);
+}
diff --git a/squashfs-tools/squashfs-tools/xattr.c b/squashfs-tools/squashfs-tools/xattr.c
new file mode 100644
index 0000000..6cecb74
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/xattr.c
@@ -0,0 +1,819 @@
+/*
+ * Create a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2008, 2009, 2010, 2012, 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * xattr.c
+ */
+
+#ifndef linux
+#define __BYTE_ORDER BYTE_ORDER
+#define __BIG_ENDIAN BIG_ENDIAN
+#define __LITTLE_ENDIAN LITTLE_ENDIAN
+#else
+#include <endian.h>
+#endif
+
+#define TRUE 1
+#define FALSE 0
+
+#include <unistd.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <dirent.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sys/xattr.h>
+
+#ifdef XATTR_NOFOLLOW /* Apple's xattrs */
+ #define llistxattr(path_, buf_, sz_) \
+ listxattr(path_, buf_, sz_, XATTR_NOFOLLOW)
+ #define lgetxattr(path_, name_, val_, sz_) \
+ getxattr(path_, name_, val_, sz_, 0, XATTR_NOFOLLOW)
+#endif
+
+#include "squashfs_fs.h"
+#include "squashfs_swap.h"
+#include "mksquashfs.h"
+#include "xattr.h"
+#include "error.h"
+#include "progressbar.h"
+
+/* ANDROID CHANGES START*/
+#ifdef ANDROID
+#include "android.h"
+#ifdef __ANDROID__
+#include <linux/capability.h>
+#else
+#include <private/android_filesystem_capability.h>
+#endif
+static struct selabel_handle *sehnd = NULL;
+#endif
+/* ANDROID CHANGES END */
+
+/* compressed xattr table */
+static char *xattr_table = NULL;
+static unsigned int xattr_size = 0;
+
+/* cached uncompressed xattr data */
+static char *data_cache = NULL;
+static int cache_bytes = 0, cache_size = 0;
+
+/* cached uncompressed xattr id table */
+static struct squashfs_xattr_id *xattr_id_table = NULL;
+static int xattr_ids = 0;
+
+/* saved compressed xattr table */
+unsigned int sxattr_bytes = 0, stotal_xattr_bytes = 0;
+
+/* saved cached uncompressed xattr data */
+static char *sdata_cache = NULL;
+static int scache_bytes = 0;
+
+/* saved cached uncompressed xattr id table */
+static int sxattr_ids = 0;
+
+/* xattr hash table for value duplicate detection */
+static struct xattr_list *dupl_value[65536];
+
+/* xattr hash table for id duplicate detection */
+static struct dupl_id *dupl_id[65536];
+
+/* file system globals from mksquashfs.c */
+extern int no_xattrs, noX;
+extern long long bytes;
+extern int fd;
+extern unsigned int xattr_bytes, total_xattr_bytes;
+/* ANDROID CHANGES START*/
+extern char *context_file;
+extern char *mount_point;
+/* ANDROID CHANGES END */
+
+/* helper functions from mksquashfs.c */
+extern unsigned short get_checksum(char *, int, unsigned short);
+extern void write_destination(int, long long, int, void *);
+extern long long generic_write_table(int, void *, int, void *, int);
+extern int mangle(char *, char *, int, int, int, int);
+extern char *pathname(struct dir_ent *);
+/* ANDROID CHANGES START*/
+#ifdef ANDROID
+extern char *subpathname(struct dir_ent *);
+#endif
+/* ANDROID CHANGES END */
+
+/* helper functions and definitions from read_xattrs.c */
+extern int read_xattrs_from_disk(int, struct squashfs_super_block *);
+extern struct xattr_list *get_xattr(int, unsigned int *, int);
+extern struct prefix prefix_table[];
+
+
+static int get_prefix(struct xattr_list *xattr, char *name)
+{
+ int i;
+
+ xattr->full_name = strdup(name);
+
+ for(i = 0; prefix_table[i].type != -1; i++) {
+ struct prefix *p = &prefix_table[i];
+ if(strncmp(xattr->full_name, p->prefix, strlen(p->prefix)) == 0)
+ break;
+ }
+
+ if(prefix_table[i].type != -1) {
+ xattr->name = xattr->full_name + strlen(prefix_table[i].prefix);
+ xattr->size = strlen(xattr->name);
+ }
+
+ return prefix_table[i].type;
+}
+
+
+/* ANDROID CHANGES START*/
+#ifdef ANDROID
+static struct xattr_list *next_xattr_list(int *xattr_count, struct xattr_list **xattrs) {
+ struct xattr_list *x;
+ x = realloc(*xattrs, ++*xattr_count * sizeof(struct xattr_list));
+ if (x == NULL) MEM_ERROR();
+ *xattrs = x;
+ return &x[*xattr_count - 1];
+}
+
+static void read_selinux_xattr_from_sehnd(char *filename, int mode,
+ struct selabel_handle *sehnd, struct xattr_list *xattrs)
+{
+ char *attr_val;
+
+ xattrs->type = get_prefix(xattrs, "security.selinux");
+ attr_val = set_selabel(filename, mode, sehnd);
+ xattrs->value = (void *)attr_val;
+ xattrs->vsize = strlen(attr_val);
+}
+
+static void set_caps_xattr(uint64_t caps, struct xattr_list *xattrs)
+{
+ struct vfs_cap_data *attr_val;
+ attr_val = malloc(sizeof(*attr_val));
+ if (attr_val == NULL) MEM_ERROR();
+
+ xattrs->type = get_prefix(xattrs, "security.capability");
+ *attr_val = set_caps(caps);
+ xattrs->value = attr_val;
+ xattrs->vsize = sizeof(*attr_val);
+}
+#endif
+/* ANDROID CHANGES END */
+
+
+static int read_xattrs_from_system(char *filename, struct xattr_list **xattrs)
+{
+ ssize_t size, vsize;
+ char *xattr_names, *p;
+ int i;
+ struct xattr_list *xattr_list = NULL;
+
+ while(1) {
+ size = llistxattr(filename, NULL, 0);
+ if(size <= 0) {
+ if(size < 0 && errno != ENOTSUP) {
+ ERROR_START("llistxattr for %s failed in "
+ "read_attrs, because %s", filename,
+ strerror(errno));
+ ERROR_EXIT(". Ignoring");
+ }
+ return 0;
+ }
+
+ xattr_names = malloc(size);
+ if(xattr_names == NULL)
+ MEM_ERROR();
+
+ size = llistxattr(filename, xattr_names, size);
+ if(size < 0) {
+ free(xattr_names);
+ if(errno == ERANGE)
+ /* xattr list grew? Try again */
+ continue;
+ else {
+ ERROR_START("llistxattr for %s failed in "
+ "read_attrs, because %s", filename,
+ strerror(errno));
+ ERROR_EXIT(". Ignoring");
+ return 0;
+ }
+ }
+
+ break;
+ }
+
+ for(i = 0, p = xattr_names; p < xattr_names + size; i++) {
+ struct xattr_list *x = realloc(xattr_list, (i + 1) *
+ sizeof(struct xattr_list));
+ if(x == NULL)
+ MEM_ERROR();
+ xattr_list = x;
+
+ xattr_list[i].type = get_prefix(&xattr_list[i], p);
+ p += strlen(p) + 1;
+ if(xattr_list[i].type == -1) {
+ ERROR("Unrecognised xattr prefix %s\n",
+ xattr_list[i].full_name);
+ free(xattr_list[i].full_name);
+ i--;
+ continue;
+ }
+
+ while(1) {
+ vsize = lgetxattr(filename, xattr_list[i].full_name,
+ NULL, 0);
+ if(vsize < 0) {
+ ERROR_START("lgetxattr failed for %s in "
+ "read_attrs, because %s", filename,
+ strerror(errno));
+ ERROR_EXIT(". Ignoring");
+ free(xattr_list[i].full_name);
+ goto failed;
+ }
+
+ xattr_list[i].value = malloc(vsize);
+ if(xattr_list[i].value == NULL)
+ MEM_ERROR();
+
+ vsize = lgetxattr(filename, xattr_list[i].full_name,
+ xattr_list[i].value, vsize);
+ if(vsize < 0) {
+ free(xattr_list[i].value);
+ if(errno == ERANGE)
+ /* xattr grew? Try again */
+ continue;
+ else {
+ ERROR_START("lgetxattr failed for %s "
+ "in read_attrs, because %s",
+ filename, strerror(errno));
+ ERROR_EXIT(". Ignoring");
+ free(xattr_list[i].full_name);
+ goto failed;
+ }
+ }
+
+ break;
+ }
+ xattr_list[i].vsize = vsize;
+
+ TRACE("read_xattrs_from_system: filename %s, xattr name %s,"
+ " vsize %d\n", filename, xattr_list[i].full_name,
+ xattr_list[i].vsize);
+ }
+ free(xattr_names);
+ *xattrs = xattr_list;
+ return i;
+
+failed:
+ while(--i >= 0) {
+ free(xattr_list[i].full_name);
+ free(xattr_list[i].value);
+ }
+ free(xattr_list);
+ free(xattr_names);
+ return 0;
+}
+
+
+static int get_xattr_size(struct xattr_list *xattr)
+{
+ int size = sizeof(struct squashfs_xattr_entry) +
+ sizeof(struct squashfs_xattr_val) + xattr->size;
+
+ if(xattr->type & XATTR_VALUE_OOL)
+ size += XATTR_VALUE_OOL_SIZE;
+ else
+ size += xattr->vsize;
+
+ return size;
+}
+
+
+static void *get_xattr_space(unsigned int req_size, long long *disk)
+{
+ int data_space;
+ unsigned short c_byte;
+
+ /*
+ * Move and compress cached uncompressed data into xattr table.
+ */
+ while(cache_bytes >= SQUASHFS_METADATA_SIZE) {
+ if((xattr_size - xattr_bytes) <
+ ((SQUASHFS_METADATA_SIZE << 1)) + 2) {
+ xattr_table = realloc(xattr_table, xattr_size +
+ (SQUASHFS_METADATA_SIZE << 1) + 2);
+ if(xattr_table == NULL)
+ MEM_ERROR();
+ xattr_size += (SQUASHFS_METADATA_SIZE << 1) + 2;
+ }
+
+ c_byte = mangle(xattr_table + xattr_bytes + BLOCK_OFFSET,
+ data_cache, SQUASHFS_METADATA_SIZE,
+ SQUASHFS_METADATA_SIZE, noX, 0);
+ TRACE("Xattr block @ 0x%x, size %d\n", xattr_bytes, c_byte);
+ SQUASHFS_SWAP_SHORTS(&c_byte, xattr_table + xattr_bytes, 1);
+ xattr_bytes += SQUASHFS_COMPRESSED_SIZE(c_byte) + BLOCK_OFFSET;
+ memmove(data_cache, data_cache + SQUASHFS_METADATA_SIZE,
+ cache_bytes - SQUASHFS_METADATA_SIZE);
+ cache_bytes -= SQUASHFS_METADATA_SIZE;
+ }
+
+ /*
+ * Ensure there's enough space in the uncompressed data cache
+ */
+ data_space = cache_size - cache_bytes;
+ if(data_space < req_size) {
+ int realloc_size = req_size - data_space;
+ data_cache = realloc(data_cache, cache_size +
+ realloc_size);
+ if(data_cache == NULL)
+ MEM_ERROR();
+ cache_size += realloc_size;
+ }
+
+ if(disk)
+ *disk = ((long long) xattr_bytes << 16) | cache_bytes;
+ cache_bytes += req_size;
+ return data_cache + cache_bytes - req_size;
+}
+
+
+static struct dupl_id *check_id_dupl(struct xattr_list *xattr_list, int xattrs)
+{
+ struct dupl_id *entry;
+ int i;
+ unsigned short checksum = 0;
+
+ /* compute checksum over all xattrs */
+ for(i = 0; i < xattrs; i++) {
+ struct xattr_list *xattr = &xattr_list[i];
+
+ checksum = get_checksum(xattr->full_name,
+ strlen(xattr->full_name), checksum);
+ checksum = get_checksum(xattr->value,
+ xattr->vsize, checksum);
+ }
+
+ for(entry = dupl_id[checksum]; entry; entry = entry->next) {
+ if (entry->xattrs != xattrs)
+ continue;
+
+ for(i = 0; i < xattrs; i++) {
+ struct xattr_list *xattr = &xattr_list[i];
+ struct xattr_list *dup_xattr = &entry->xattr_list[i];
+
+ if(strcmp(xattr->full_name, dup_xattr->full_name))
+ break;
+
+ if(memcmp(xattr->value, dup_xattr->value, xattr->vsize))
+ break;
+ }
+
+ if(i == xattrs)
+ break;
+ }
+
+ if(entry == NULL) {
+ /* no duplicate exists */
+ entry = malloc(sizeof(*entry));
+ if(entry == NULL)
+ MEM_ERROR();
+ entry->xattrs = xattrs;
+ entry->xattr_list = xattr_list;
+ entry->xattr_id = SQUASHFS_INVALID_XATTR;
+ entry->next = dupl_id[checksum];
+ dupl_id[checksum] = entry;
+ }
+
+ return entry;
+}
+
+
+static void check_value_dupl(struct xattr_list *xattr)
+{
+ struct xattr_list *entry;
+
+ if(xattr->vsize < XATTR_VALUE_OOL_SIZE)
+ return;
+
+ /* Check if this is a duplicate of an existing value */
+ xattr->vchecksum = get_checksum(xattr->value, xattr->vsize, 0);
+ for(entry = dupl_value[xattr->vchecksum]; entry; entry = entry->vnext) {
+ if(entry->vsize != xattr->vsize)
+ continue;
+
+ if(memcmp(entry->value, xattr->value, xattr->vsize) == 0)
+ break;
+ }
+
+ if(entry == NULL) {
+ /*
+ * No duplicate exists, add to hash table, and mark as
+ * requiring writing
+ */
+ xattr->vnext = dupl_value[xattr->vchecksum];
+ dupl_value[xattr->vchecksum] = xattr;
+ xattr->ool_value = SQUASHFS_INVALID_BLK;
+ } else {
+ /*
+ * Duplicate exists, make type XATTR_VALUE_OOL, and
+ * remember where the duplicate is
+ */
+ xattr->type |= XATTR_VALUE_OOL;
+ xattr->ool_value = entry->ool_value;
+ /* on appending don't free duplicate values because the
+ * duplicate value already points to the non-duplicate value */
+ if(xattr->value != entry->value) {
+ free(xattr->value);
+ xattr->value = entry->value;
+ }
+ }
+}
+
+
+static int get_xattr_id(int xattrs, struct xattr_list *xattr_list,
+ long long xattr_disk, struct dupl_id *xattr_dupl)
+{
+ int i, size = 0;
+ struct squashfs_xattr_id *xattr_id;
+
+ xattr_id_table = realloc(xattr_id_table, (xattr_ids + 1) *
+ sizeof(struct squashfs_xattr_id));
+ if(xattr_id_table == NULL)
+ MEM_ERROR();
+
+ /* get total uncompressed size of xattr data, needed for stat */
+ for(i = 0; i < xattrs; i++)
+ size += strlen(xattr_list[i].full_name) + 1 +
+ xattr_list[i].vsize;
+
+ xattr_id = &xattr_id_table[xattr_ids];
+ xattr_id->xattr = xattr_disk;
+ xattr_id->count = xattrs;
+ xattr_id->size = size;
+
+ /*
+ * keep track of total uncompressed xattr data, needed for mksquashfs
+ * file system summary
+ */
+ total_xattr_bytes += size;
+
+ xattr_dupl->xattr_id = xattr_ids ++;
+ return xattr_dupl->xattr_id;
+}
+
+
+long long write_xattrs()
+{
+ unsigned short c_byte;
+ int i, avail_bytes;
+ char *datap = data_cache;
+ long long start_bytes = bytes;
+ struct squashfs_xattr_table header;
+
+ if(xattr_ids == 0)
+ return SQUASHFS_INVALID_BLK;
+
+ /*
+ * Move and compress cached uncompressed data into xattr table.
+ */
+ while(cache_bytes) {
+ if((xattr_size - xattr_bytes) <
+ ((SQUASHFS_METADATA_SIZE << 1)) + 2) {
+ xattr_table = realloc(xattr_table, xattr_size +
+ (SQUASHFS_METADATA_SIZE << 1) + 2);
+ if(xattr_table == NULL)
+ MEM_ERROR();
+ xattr_size += (SQUASHFS_METADATA_SIZE << 1) + 2;
+ }
+
+ avail_bytes = cache_bytes > SQUASHFS_METADATA_SIZE ?
+ SQUASHFS_METADATA_SIZE : cache_bytes;
+ c_byte = mangle(xattr_table + xattr_bytes + BLOCK_OFFSET, datap,
+ avail_bytes, SQUASHFS_METADATA_SIZE, noX, 0);
+ TRACE("Xattr block @ 0x%x, size %d\n", xattr_bytes, c_byte);
+ SQUASHFS_SWAP_SHORTS(&c_byte, xattr_table + xattr_bytes, 1);
+ xattr_bytes += SQUASHFS_COMPRESSED_SIZE(c_byte) + BLOCK_OFFSET;
+ datap += avail_bytes;
+ cache_bytes -= avail_bytes;
+ }
+
+ /*
+ * Write compressed xattr table to file system
+ */
+ write_destination(fd, bytes, xattr_bytes, xattr_table);
+ bytes += xattr_bytes;
+
+ /*
+ * Swap if necessary the xattr id table
+ */
+ for(i = 0; i < xattr_ids; i++)
+ SQUASHFS_INSWAP_XATTR_ID(&xattr_id_table[i]);
+
+ header.xattr_ids = xattr_ids;
+ header.xattr_table_start = start_bytes;
+ SQUASHFS_INSWAP_XATTR_TABLE(&header);
+
+ return generic_write_table(xattr_ids * sizeof(struct squashfs_xattr_id),
+ xattr_id_table, sizeof(header), &header, noX);
+}
+
+
+int generate_xattrs(int xattrs, struct xattr_list *xattr_list)
+{
+ int total_size, i;
+ int xattr_value_max;
+ void *xp;
+ long long xattr_disk;
+ struct dupl_id *xattr_dupl;
+
+ /*
+ * check if the file xattrs are a complete duplicate of a pre-existing
+ * id
+ */
+ xattr_dupl = check_id_dupl(xattr_list, xattrs);
+ if(xattr_dupl->xattr_id != SQUASHFS_INVALID_XATTR)
+ return xattr_dupl->xattr_id;
+
+ /*
+ * Scan the xattr_list deciding which type to assign to each
+ * xattr. The choice is fairly straightforward, and depends on the
+ * size of each xattr name/value and the overall size of the
+ * resultant xattr list stored in the xattr metadata table.
+ *
+ * Choices are whether to store data inline or out of line.
+ *
+ * The overall goal is to optimise xattr scanning and lookup, and
+ * to enable the file system layout to scale from a couple of
+ * small xattr name/values to a large number of large xattr
+ * names/values without affecting performance. While hopefully
+ * enabling the common case of a couple of small xattr name/values
+ * to be stored efficiently
+ *
+ * Code repeatedly scans, doing the following
+ * move xattr data out of line if it exceeds
+ * xattr_value_max. Where xattr_value_max is
+ * initially XATTR_INLINE_MAX. If the final uncompressed
+ * xattr list is larger than XATTR_TARGET_MAX then more
+ * aggressively move xattr data out of line by repeatedly
+ * setting inline threshold to 1/2, then 1/4, 1/8 of
+ * XATTR_INLINE_MAX until target achieved or there's
+ * nothing left to move out of line
+ */
+ xattr_value_max = XATTR_INLINE_MAX;
+ while(1) {
+ for(total_size = 0, i = 0; i < xattrs; i++) {
+ struct xattr_list *xattr = &xattr_list[i];
+ xattr->type &= XATTR_PREFIX_MASK; /* all inline */
+ if (xattr->vsize > xattr_value_max)
+ xattr->type |= XATTR_VALUE_OOL;
+
+ total_size += get_xattr_size(xattr);
+ }
+
+ /*
+ * If the total size of the uncompressed xattr list is <=
+ * XATTR_TARGET_MAX we're done
+ */
+ if(total_size <= XATTR_TARGET_MAX)
+ break;
+
+ if(xattr_value_max == XATTR_VALUE_OOL_SIZE)
+ break;
+
+ /*
+ * Inline target not yet at minimum and so reduce it, and
+ * try again
+ */
+ xattr_value_max /= 2;
+ if(xattr_value_max < XATTR_VALUE_OOL_SIZE)
+ xattr_value_max = XATTR_VALUE_OOL_SIZE;
+ }
+
+ /*
+ * Check xattr values for duplicates
+ */
+ for(i = 0; i < xattrs; i++) {
+ check_value_dupl(&xattr_list[i]);
+ }
+
+ /*
+ * Add each out of line value to the file system xattr table
+ * if it doesn't already exist as a duplicate
+ */
+ for(i = 0; i < xattrs; i++) {
+ struct xattr_list *xattr = &xattr_list[i];
+
+ if((xattr->type & XATTR_VALUE_OOL) &&
+ (xattr->ool_value == SQUASHFS_INVALID_BLK)) {
+ struct squashfs_xattr_val val;
+ int size = sizeof(val) + xattr->vsize;
+ xp = get_xattr_space(size, &xattr->ool_value);
+ val.vsize = xattr->vsize;
+ SQUASHFS_SWAP_XATTR_VAL(&val, xp);
+ memcpy(xp + sizeof(val), xattr->value, xattr->vsize);
+ }
+ }
+
+ /*
+ * Create xattr list and add to file system xattr table
+ */
+ get_xattr_space(0, &xattr_disk);
+ for(i = 0; i < xattrs; i++) {
+ struct xattr_list *xattr = &xattr_list[i];
+ struct squashfs_xattr_entry entry;
+ struct squashfs_xattr_val val;
+
+ xp = get_xattr_space(sizeof(entry) + xattr->size, NULL);
+ entry.type = xattr->type;
+ entry.size = xattr->size;
+ SQUASHFS_SWAP_XATTR_ENTRY(&entry, xp);
+ memcpy(xp + sizeof(entry), xattr->name, xattr->size);
+
+ if(xattr->type & XATTR_VALUE_OOL) {
+ int size = sizeof(val) + XATTR_VALUE_OOL_SIZE;
+ xp = get_xattr_space(size, NULL);
+ val.vsize = XATTR_VALUE_OOL_SIZE;
+ SQUASHFS_SWAP_XATTR_VAL(&val, xp);
+ SQUASHFS_SWAP_LONG_LONGS(&xattr->ool_value, xp +
+ sizeof(val), 1);
+ } else {
+ int size = sizeof(val) + xattr->vsize;
+ xp = get_xattr_space(size, &xattr->ool_value);
+ val.vsize = xattr->vsize;
+ SQUASHFS_SWAP_XATTR_VAL(&val, xp);
+ memcpy(xp + sizeof(val), xattr->value, xattr->vsize);
+ }
+ }
+
+ /*
+ * Add to xattr id lookup table
+ */
+ return get_xattr_id(xattrs, xattr_list, xattr_disk, xattr_dupl);
+}
+
+
+int read_xattrs(void *d)
+{
+ struct dir_ent *dir_ent = d;
+ struct inode_info *inode = dir_ent->inode;
+ char *filename = pathname(dir_ent);
+/* ANDROID CHANGES START*/
+#ifdef ANDROID
+ // NOTE: xattr_list has to point to an array of xattr_list elements
+ struct xattr_list *xattr_list = NULL, *next_xattr = NULL;
+ int xattrs = 0;
+#else
+ struct xattr_list *xattr_list;
+ int xattrs;
+#endif
+/* ANDROID CHANGES END */
+
+ if(no_xattrs || IS_PSEUDO(inode) || inode->root_entry)
+ return SQUASHFS_INVALID_XATTR;
+
+/* ANDROID CHANGES START*/
+#ifdef ANDROID
+ if (context_file) {
+ if (sehnd == NULL)
+ sehnd = get_sehnd(context_file);
+ if (mount_point) {
+ char *mounted_path;
+ alloc_mounted_path(mount_point, subpathname(dir_ent), &mounted_path);
+ next_xattr = next_xattr_list(&xattrs, &xattr_list);
+ read_selinux_xattr_from_sehnd(mounted_path, inode->buf.st_mode,
+ sehnd, next_xattr);
+ free(mounted_path);
+ } else {
+ next_xattr = next_xattr_list(&xattrs, &xattr_list);
+ read_selinux_xattr_from_sehnd(filename, inode->buf.st_mode,
+ sehnd, next_xattr);
+ }
+ }
+ if (dir_ent->capabilities != 0) {
+ next_xattr = next_xattr_list(&xattrs, &xattr_list);
+ set_caps_xattr(dir_ent->capabilities, next_xattr);
+ }
+#else
+ xattrs = read_xattrs_from_system(filename, &xattr_list);
+#endif
+/* ANDROID CHANGES END */
+
+ if(xattrs == 0)
+ return SQUASHFS_INVALID_XATTR;
+
+ return generate_xattrs(xattrs, xattr_list);
+}
+
+
+/*
+ * Add the existing xattr ids and xattr metadata in the file system being
+ * appended to, to the in-memory xattr cache. This allows duplicate checking to
+ * take place against the xattrs already in the file system being appended to,
+ * and ensures the pre-existing xattrs are written out along with any new xattrs
+ */
+int get_xattrs(int fd, struct squashfs_super_block *sBlk)
+{
+ int ids, res, i, id;
+ unsigned int count;
+
+ TRACE("get_xattrs\n");
+
+ res = read_xattrs_from_disk(fd, sBlk);
+ if(res == SQUASHFS_INVALID_BLK || res == 0)
+ goto done;
+ ids = res;
+
+ /*
+ * for each xattr id read and construct its list of xattr
+ * name:value pairs, and add them to the in-memory xattr cache
+ */
+ for(i = 0; i < ids; i++) {
+ struct xattr_list *xattr_list = get_xattr(i, &count, 0);
+ if(xattr_list == NULL) {
+ res = 0;
+ goto done;
+ }
+ id = generate_xattrs(count, xattr_list);
+
+ /*
+ * Sanity check, the new xattr id should be the same as the
+ * xattr id in the original file system
+ */
+ if(id != i) {
+ ERROR("BUG, different xattr_id in get_xattrs\n");
+ res = 0;
+ goto done;
+ }
+ }
+
+done:
+ return res;
+}
+
+
+/*
+ * Save current state of xattrs, needed for restoring state in the event of an
+ * abort in appending
+ */
+void save_xattrs()
+{
+ /* save the current state of the compressed xattr data */
+ sxattr_bytes = xattr_bytes;
+ stotal_xattr_bytes = total_xattr_bytes;
+
+ /*
+ * save the current state of the cached uncompressed xattr data.
+ * Note we have to save the contents of the data cache because future
+ * operations will delete the current contents
+ */
+ sdata_cache = malloc(cache_bytes);
+ if(sdata_cache == NULL)
+ MEM_ERROR();
+
+ memcpy(sdata_cache, data_cache, cache_bytes);
+ scache_bytes = cache_bytes;
+
+ /* save the current state of the xattr id table */
+ sxattr_ids = xattr_ids;
+}
+
+
+/*
+ * Restore xattrs in the event of an abort in appending
+ */
+void restore_xattrs()
+{
+ /* restore the state of the compressed xattr data */
+ xattr_bytes = sxattr_bytes;
+ total_xattr_bytes = stotal_xattr_bytes;
+
+ /* restore the state of the uncomoressed xattr data */
+ memcpy(data_cache, sdata_cache, scache_bytes);
+ cache_bytes = scache_bytes;
+
+ /* restore the state of the xattr id table */
+ xattr_ids = sxattr_ids;
+}
diff --git a/squashfs-tools/squashfs-tools/xattr.h b/squashfs-tools/squashfs-tools/xattr.h
new file mode 100644
index 0000000..9260255
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/xattr.h
@@ -0,0 +1,150 @@
+#ifndef XATTR_H
+#define XATTR_H
+/*
+ * Create a squashfs filesystem. This is a highly compressed read only
+ * filesystem.
+ *
+ * Copyright (c) 2010, 2012, 2013, 2014
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * xattr.h
+ */
+
+#define XATTR_VALUE_OOL SQUASHFS_XATTR_VALUE_OOL
+#define XATTR_PREFIX_MASK SQUASHFS_XATTR_PREFIX_MASK
+
+#define XATTR_VALUE_OOL_SIZE sizeof(long long)
+
+/* maximum size of xattr value data that will be inlined */
+#define XATTR_INLINE_MAX 128
+
+/* the target size of an inode's xattr name:value list. If it
+ * exceeds this, then xattr value data will be successively out of lined
+ * until it meets the target */
+#define XATTR_TARGET_MAX 65536
+
+#define IS_XATTR(a) (a != SQUASHFS_INVALID_XATTR)
+
+struct xattr_list {
+ char *name;
+ char *full_name;
+ int size;
+ int vsize;
+ void *value;
+ int type;
+ long long ool_value;
+ unsigned short vchecksum;
+ struct xattr_list *vnext;
+};
+
+struct dupl_id {
+ struct xattr_list *xattr_list;
+ int xattrs;
+ int xattr_id;
+ struct dupl_id *next;
+};
+
+struct prefix {
+ char *prefix;
+ int type;
+};
+
+extern int generate_xattrs(int, struct xattr_list *);
+
+#ifdef XATTR_SUPPORT
+extern int get_xattrs(int, struct squashfs_super_block *);
+extern int read_xattrs(void *);
+extern long long write_xattrs();
+extern void save_xattrs();
+extern void restore_xattrs();
+extern unsigned int xattr_bytes, total_xattr_bytes;
+extern void write_xattr(char *, unsigned int);
+extern int read_xattrs_from_disk(int, struct squashfs_super_block *);
+extern struct xattr_list *get_xattr(int, unsigned int *, int);
+extern void free_xattr(struct xattr_list *, int);
+#else
+static inline int get_xattrs(int fd, struct squashfs_super_block *sBlk)
+{
+ if(sBlk->xattr_id_table_start != SQUASHFS_INVALID_BLK) {
+ fprintf(stderr, "Xattrs in filesystem! These are not "
+ "supported on this version of Squashfs\n");
+ return 0;
+ } else
+ return SQUASHFS_INVALID_BLK;
+}
+
+
+static inline int read_xattrs(void *dir_ent)
+{
+ return SQUASHFS_INVALID_XATTR;
+}
+
+
+static inline long long write_xattrs()
+{
+ return SQUASHFS_INVALID_BLK;
+}
+
+
+static inline void save_xattrs()
+{
+}
+
+
+static inline void restore_xattrs()
+{
+}
+
+
+static inline void write_xattr(char *pathname, unsigned int xattr)
+{
+}
+
+
+static inline int read_xattrs_from_disk(int fd, struct squashfs_super_block *sBlk)
+{
+ if(sBlk->xattr_id_table_start != SQUASHFS_INVALID_BLK) {
+ fprintf(stderr, "Xattrs in filesystem! These are not "
+ "supported on this version of Squashfs\n");
+ return 0;
+ } else
+ return SQUASHFS_INVALID_BLK;
+}
+
+
+static inline struct xattr_list *get_xattr(int i, unsigned int *count, int j)
+{
+ return NULL;
+}
+#endif
+
+#ifdef XATTR_SUPPORT
+#ifdef XATTR_DEFAULT
+#define NOXOPT_STR
+#define XOPT_STR " (default)"
+#define XATTR_DEF 0
+#else
+#define NOXOPT_STR " (default)"
+#define XOPT_STR
+#define XATTR_DEF 1
+#endif
+#else
+#define NOXOPT_STR " (default)"
+#define XOPT_STR " (unsupported)"
+#define XATTR_DEF 1
+#endif
+#endif
diff --git a/squashfs-tools/squashfs-tools/xz_wrapper.c b/squashfs-tools/squashfs-tools/xz_wrapper.c
new file mode 100644
index 0000000..e77ec59
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/xz_wrapper.c
@@ -0,0 +1,540 @@
+/*
+ * Copyright (c) 2010, 2011, 2012, 2013
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * xz_wrapper.c
+ *
+ * Support for XZ (LZMA2) compression using XZ Utils liblzma
+ * http://tukaani.org/xz/
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <lzma.h>
+
+#include "squashfs_fs.h"
+#include "xz_wrapper.h"
+#include "compressor.h"
+
+static struct bcj bcj[] = {
+ { "x86", LZMA_FILTER_X86, 0 },
+ { "powerpc", LZMA_FILTER_POWERPC, 0 },
+ { "ia64", LZMA_FILTER_IA64, 0 },
+ { "arm", LZMA_FILTER_ARM, 0 },
+ { "armthumb", LZMA_FILTER_ARMTHUMB, 0 },
+ { "sparc", LZMA_FILTER_SPARC, 0 },
+ { NULL, LZMA_VLI_UNKNOWN, 0 }
+};
+
+static int filter_count = 1;
+static int dictionary_size = 0;
+static float dictionary_percent = 0;
+
+
+/*
+ * This function is called by the options parsing code in mksquashfs.c
+ * to parse any -X compressor option.
+ *
+ * Two specific options are supported:
+ * -Xbcj
+ * -Xdict-size
+ *
+ * This function returns:
+ * >=0 (number of additional args parsed) on success
+ * -1 if the option was unrecognised, or
+ * -2 if the option was recognised, but otherwise bad in
+ * some way (e.g. invalid parameter)
+ *
+ * Note: this function sets internal compressor state, but does not
+ * pass back the results of the parsing other than success/failure.
+ * The xz_dump_options() function is called later to get the options in
+ * a format suitable for writing to the filesystem.
+ */
+static int xz_options(char *argv[], int argc)
+{
+ int i;
+ char *name;
+
+ if(strcmp(argv[0], "-Xbcj") == 0) {
+ if(argc < 2) {
+ fprintf(stderr, "xz: -Xbcj missing filter\n");
+ goto failed;
+ }
+
+ name = argv[1];
+ while(name[0] != '\0') {
+ for(i = 0; bcj[i].name; i++) {
+ int n = strlen(bcj[i].name);
+ if((strncmp(name, bcj[i].name, n) == 0) &&
+ (name[n] == '\0' ||
+ name[n] == ',')) {
+ if(bcj[i].selected == 0) {
+ bcj[i].selected = 1;
+ filter_count++;
+ }
+ name += name[n] == ',' ? n + 1 : n;
+ break;
+ }
+ }
+ if(bcj[i].name == NULL) {
+ fprintf(stderr, "xz: -Xbcj unrecognised "
+ "filter\n");
+ goto failed;
+ }
+ }
+
+ return 1;
+ } else if(strcmp(argv[0], "-Xdict-size") == 0) {
+ char *b;
+ float size;
+
+ if(argc < 2) {
+ fprintf(stderr, "xz: -Xdict-size missing dict-size\n");
+ goto failed;
+ }
+
+ size = strtof(argv[1], &b);
+ if(*b == '%') {
+ if(size <= 0 || size > 100) {
+ fprintf(stderr, "xz: -Xdict-size percentage "
+ "should be 0 < dict-size <= 100\n");
+ goto failed;
+ }
+
+ dictionary_percent = size;
+ dictionary_size = 0;
+ } else {
+ if((float) ((int) size) != size) {
+ fprintf(stderr, "xz: -Xdict-size can't be "
+ "fractional unless a percentage of the"
+ " block size\n");
+ goto failed;
+ }
+
+ dictionary_percent = 0;
+ dictionary_size = (int) size;
+
+ if(*b == 'k' || *b == 'K')
+ dictionary_size *= 1024;
+ else if(*b == 'm' || *b == 'M')
+ dictionary_size *= 1024 * 1024;
+ else if(*b != '\0') {
+ fprintf(stderr, "xz: -Xdict-size invalid "
+ "dict-size\n");
+ goto failed;
+ }
+ }
+
+ return 1;
+ }
+
+ return -1;
+
+failed:
+ return -2;
+}
+
+
+/*
+ * This function is called after all options have been parsed.
+ * It is used to do post-processing on the compressor options using
+ * values that were not expected to be known at option parse time.
+ *
+ * In this case block_size may not be known until after -Xdict-size has
+ * been processed (in the case where -b is specified after -Xdict-size)
+ *
+ * This function returns 0 on successful post processing, or
+ * -1 on error
+ */
+static int xz_options_post(int block_size)
+{
+ /*
+ * if -Xdict-size has been specified use this to compute the datablock
+ * dictionary size
+ */
+ if(dictionary_size || dictionary_percent) {
+ int n;
+
+ if(dictionary_size) {
+ if(dictionary_size > block_size) {
+ fprintf(stderr, "xz: -Xdict-size is larger than"
+ " block_size\n");
+ goto failed;
+ }
+ } else
+ dictionary_size = block_size * dictionary_percent / 100;
+
+ if(dictionary_size < 8192) {
+ fprintf(stderr, "xz: -Xdict-size should be 8192 bytes "
+ "or larger\n");
+ goto failed;
+ }
+
+ /*
+ * dictionary_size must be storable in xz header as either
+ * 2^n or as 2^n+2^(n+1)
+ */
+ n = ffs(dictionary_size) - 1;
+ if(dictionary_size != (1 << n) &&
+ dictionary_size != ((1 << n) + (1 << (n + 1)))) {
+ fprintf(stderr, "xz: -Xdict-size is an unsupported "
+ "value, dict-size must be storable in xz "
+ "header\n");
+ fprintf(stderr, "as either 2^n or as 2^n+2^(n+1). "
+ "Example dict-sizes are 75%%, 50%%, 37.5%%, "
+ "25%%,\n");
+ fprintf(stderr, "or 32K, 16K, 8K etc.\n");
+ goto failed;
+ }
+
+ } else
+ /* No -Xdict-size specified, use defaults */
+ dictionary_size = block_size;
+
+ return 0;
+
+failed:
+ return -1;
+}
+
+
+/*
+ * This function is called by mksquashfs to dump the parsed
+ * compressor options in a format suitable for writing to the
+ * compressor options field in the filesystem (stored immediately
+ * after the superblock).
+ *
+ * This function returns a pointer to the compression options structure
+ * to be stored (and the size), or NULL if there are no compression
+ * options
+ */
+static void *xz_dump_options(int block_size, int *size)
+{
+ static struct comp_opts comp_opts;
+ int flags = 0, i;
+
+ /*
+ * don't store compressor specific options in file system if the
+ * default options are being used - no compressor options in the
+ * file system means the default options are always assumed
+ *
+ * Defaults are:
+ * metadata dictionary size: SQUASHFS_METADATA_SIZE
+ * datablock dictionary size: block_size
+ * 1 filter
+ */
+ if(dictionary_size == block_size && filter_count == 1)
+ return NULL;
+
+ for(i = 0; bcj[i].name; i++)
+ flags |= bcj[i].selected << i;
+
+ comp_opts.dictionary_size = dictionary_size;
+ comp_opts.flags = flags;
+
+ SQUASHFS_INSWAP_COMP_OPTS(&comp_opts);
+
+ *size = sizeof(comp_opts);
+ return &comp_opts;
+}
+
+
+/*
+ * This function is a helper specifically for the append mode of
+ * mksquashfs. Its purpose is to set the internal compressor state
+ * to the stored compressor options in the passed compressor options
+ * structure.
+ *
+ * In effect this function sets up the compressor options
+ * to the same state they were when the filesystem was originally
+ * generated, this is to ensure on appending, the compressor uses
+ * the same compression options that were used to generate the
+ * original filesystem.
+ *
+ * Note, even if there are no compressor options, this function is still
+ * called with an empty compressor structure (size == 0), to explicitly
+ * set the default options, this is to ensure any user supplied
+ * -X options on the appending mksquashfs command line are over-ridden
+ *
+ * This function returns 0 on sucessful extraction of options, and
+ * -1 on error
+ */
+static int xz_extract_options(int block_size, void *buffer, int size)
+{
+ struct comp_opts *comp_opts = buffer;
+ int flags, i, n;
+
+ if(size == 0) {
+ /* set defaults */
+ dictionary_size = block_size;
+ flags = 0;
+ } else {
+ /* check passed comp opts struct is of the correct length */
+ if(size != sizeof(struct comp_opts))
+ goto failed;
+
+ SQUASHFS_INSWAP_COMP_OPTS(comp_opts);
+
+ dictionary_size = comp_opts->dictionary_size;
+ flags = comp_opts->flags;
+
+ /*
+ * check that the dictionary size seems correct - the dictionary
+ * size should 2^n or 2^n+2^(n+1)
+ */
+ n = ffs(dictionary_size) - 1;
+ if(dictionary_size != (1 << n) &&
+ dictionary_size != ((1 << n) + (1 << (n + 1))))
+ goto failed;
+ }
+
+ filter_count = 1;
+ for(i = 0; bcj[i].name; i++) {
+ if((flags >> i) & 1) {
+ bcj[i].selected = 1;
+ filter_count ++;
+ } else
+ bcj[i].selected = 0;
+ }
+
+ return 0;
+
+failed:
+ fprintf(stderr, "xz: error reading stored compressor options from "
+ "filesystem!\n");
+
+ return -1;
+}
+
+
+void xz_display_options(void *buffer, int size)
+{
+ struct comp_opts *comp_opts = buffer;
+ int dictionary_size, flags, printed;
+ int i, n;
+
+ /* check passed comp opts struct is of the correct length */
+ if(size != sizeof(struct comp_opts))
+ goto failed;
+
+ SQUASHFS_INSWAP_COMP_OPTS(comp_opts);
+
+ dictionary_size = comp_opts->dictionary_size;
+ flags = comp_opts->flags;
+
+ /*
+ * check that the dictionary size seems correct - the dictionary
+ * size should 2^n or 2^n+2^(n+1)
+ */
+ n = ffs(dictionary_size) - 1;
+ if(dictionary_size != (1 << n) &&
+ dictionary_size != ((1 << n) + (1 << (n + 1))))
+ goto failed;
+
+ printf("\tDictionary size %d\n", dictionary_size);
+
+ printed = 0;
+ for(i = 0; bcj[i].name; i++) {
+ if((flags >> i) & 1) {
+ if(printed)
+ printf(", ");
+ else
+ printf("\tFilters selected: ");
+ printf("%s", bcj[i].name);
+ printed = 1;
+ }
+ }
+
+ if(!printed)
+ printf("\tNo filters specified\n");
+ else
+ printf("\n");
+
+ return;
+
+failed:
+ fprintf(stderr, "xz: error reading stored compressor options from "
+ "filesystem!\n");
+}
+
+
+/*
+ * This function is called by mksquashfs to initialise the
+ * compressor, before compress() is called.
+ *
+ * This function returns 0 on success, and
+ * -1 on error
+ */
+static int xz_init(void **strm, int block_size, int datablock)
+{
+ int i, j, filters = datablock ? filter_count : 1;
+ struct filter *filter = malloc(filters * sizeof(struct filter));
+ struct xz_stream *stream;
+
+ if(filter == NULL)
+ goto failed;
+
+ stream = *strm = malloc(sizeof(struct xz_stream));
+ if(stream == NULL)
+ goto failed2;
+
+ stream->filter = filter;
+ stream->filters = filters;
+
+ memset(filter, 0, filters * sizeof(struct filter));
+
+ stream->dictionary_size = datablock ? dictionary_size :
+ SQUASHFS_METADATA_SIZE;
+
+ filter[0].filter[0].id = LZMA_FILTER_LZMA2;
+ filter[0].filter[0].options = &stream->opt;
+ filter[0].filter[1].id = LZMA_VLI_UNKNOWN;
+
+ for(i = 0, j = 1; datablock && bcj[i].name; i++) {
+ if(bcj[i].selected) {
+ filter[j].buffer = malloc(block_size);
+ if(filter[j].buffer == NULL)
+ goto failed3;
+ filter[j].filter[0].id = bcj[i].id;
+ filter[j].filter[1].id = LZMA_FILTER_LZMA2;
+ filter[j].filter[1].options = &stream->opt;
+ filter[j].filter[2].id = LZMA_VLI_UNKNOWN;
+ j++;
+ }
+ }
+
+ return 0;
+
+failed3:
+ for(i = 1; i < filters; i++)
+ free(filter[i].buffer);
+ free(stream);
+
+failed2:
+ free(filter);
+
+failed:
+ return -1;
+}
+
+
+static int xz_compress(void *strm, void *dest, void *src, int size,
+ int block_size, int *error)
+{
+ int i;
+ lzma_ret res = 0;
+ struct xz_stream *stream = strm;
+ struct filter *selected = NULL;
+
+ stream->filter[0].buffer = dest;
+
+ for(i = 0; i < stream->filters; i++) {
+ struct filter *filter = &stream->filter[i];
+
+ if(lzma_lzma_preset(&stream->opt, LZMA_PRESET_DEFAULT))
+ goto failed;
+
+ stream->opt.dict_size = stream->dictionary_size;
+
+ filter->length = 0;
+ res = lzma_stream_buffer_encode(filter->filter,
+ LZMA_CHECK_CRC32, NULL, src, size, filter->buffer,
+ &filter->length, block_size);
+
+ if(res == LZMA_OK) {
+ if(!selected || selected->length > filter->length)
+ selected = filter;
+ } else if(res != LZMA_BUF_ERROR)
+ goto failed;
+ }
+
+ if(!selected)
+ /*
+ * Output buffer overflow. Return out of buffer space
+ */
+ return 0;
+
+ if(selected->buffer != dest)
+ memcpy(dest, selected->buffer, selected->length);
+
+ return (int) selected->length;
+
+failed:
+ /*
+ * All other errors return failure, with the compressor
+ * specific error code in *error
+ */
+ *error = res;
+ return -1;
+}
+
+
+static int xz_uncompress(void *dest, void *src, int size, int outsize,
+ int *error)
+{
+ size_t src_pos = 0;
+ size_t dest_pos = 0;
+ uint64_t memlimit = MEMLIMIT;
+
+ lzma_ret res = lzma_stream_buffer_decode(&memlimit, 0, NULL,
+ src, &src_pos, size, dest, &dest_pos, outsize);
+
+ if(res == LZMA_OK && size == (int) src_pos)
+ return (int) dest_pos;
+ else {
+ *error = res;
+ return -1;
+ }
+}
+
+
+void xz_usage()
+{
+ fprintf(stderr, "\t -Xbcj filter1,filter2,...,filterN\n");
+ fprintf(stderr, "\t\tCompress using filter1,filter2,...,filterN in");
+ fprintf(stderr, " turn\n\t\t(in addition to no filter), and choose");
+ fprintf(stderr, " the best compression.\n");
+ fprintf(stderr, "\t\tAvailable filters: x86, arm, armthumb,");
+ fprintf(stderr, " powerpc, sparc, ia64\n");
+ fprintf(stderr, "\t -Xdict-size <dict-size>\n");
+ fprintf(stderr, "\t\tUse <dict-size> as the XZ dictionary size. The");
+ fprintf(stderr, " dictionary size\n\t\tcan be specified as a");
+ fprintf(stderr, " percentage of the block size, or as an\n\t\t");
+ fprintf(stderr, "absolute value. The dictionary size must be less");
+ fprintf(stderr, " than or equal\n\t\tto the block size and 8192 bytes");
+ fprintf(stderr, " or larger. It must also be\n\t\tstorable in the xz");
+ fprintf(stderr, " header as either 2^n or as 2^n+2^(n+1).\n\t\t");
+ fprintf(stderr, "Example dict-sizes are 75%%, 50%%, 37.5%%, 25%%, or");
+ fprintf(stderr, " 32K, 16K, 8K\n\t\tetc.\n");
+}
+
+
+struct compressor xz_comp_ops = {
+ .init = xz_init,
+ .compress = xz_compress,
+ .uncompress = xz_uncompress,
+ .options = xz_options,
+ .options_post = xz_options_post,
+ .dump_options = xz_dump_options,
+ .extract_options = xz_extract_options,
+ .display_options = xz_display_options,
+ .usage = xz_usage,
+ .id = XZ_COMPRESSION,
+ .name = "xz",
+ .supported = 1
+};
diff --git a/squashfs-tools/squashfs-tools/xz_wrapper.h b/squashfs-tools/squashfs-tools/xz_wrapper.h
new file mode 100644
index 0000000..ce2545c
--- /dev/null
+++ b/squashfs-tools/squashfs-tools/xz_wrapper.h
@@ -0,0 +1,71 @@
+#ifndef XZ_WRAPPER_H
+#define XZ_WRAPPER_H
+/*
+ * Squashfs
+ *
+ * Copyright (c) 2010
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * xz_wrapper.h
+ *
+ */
+
+#ifndef linux
+#define __BYTE_ORDER BYTE_ORDER
+#define __BIG_ENDIAN BIG_ENDIAN
+#define __LITTLE_ENDIAN LITTLE_ENDIAN
+#else
+#include <endian.h>
+#endif
+
+#if __BYTE_ORDER == __BIG_ENDIAN
+extern unsigned int inswap_le32(unsigned int);
+
+#define SQUASHFS_INSWAP_COMP_OPTS(s) { \
+ (s)->dictionary_size = inswap_le32((s)->dictionary_size); \
+ (s)->flags = inswap_le32((s)->flags); \
+}
+#else
+#define SQUASHFS_INSWAP_COMP_OPTS(s)
+#endif
+
+#define MEMLIMIT (32 * 1024 * 1024)
+
+struct bcj {
+ char *name;
+ lzma_vli id;
+ int selected;
+};
+
+struct filter {
+ void *buffer;
+ lzma_filter filter[3];
+ size_t length;
+};
+
+struct xz_stream {
+ struct filter *filter;
+ int filters;
+ int dictionary_size;
+ lzma_options_lzma opt;
+};
+
+struct comp_opts {
+ int dictionary_size;
+ int flags;
+};
+#endif