Move all package specifics from now abstract Directory to new derived
class UnpackingDirectory and adjust the Volume implementation
accordingly. This concludes the Node/Directory refactoring. Neither
class is aware of packages anymore.
* Move package related methods from Node to new interface UnpackingNode.
* LeafNode and Directory derive from UnpackingNode now.
* Adjust Volume implementation accordingly.
* Introduce interface AttributeDirectoryCookie and currently only
implementation UnpackingAttributeDirectoryCookie. This is an interface
for reading/rewinding an attribute directory.
* Add abstract virtual Node::OpenAttributeDirectory() method that
returns an AttributeDirectoryCookie and implement it for derived
classes.
* In the kernel interface attribute directory hooks use
AttributeDirectoryCookie now.
* Introduce interface AttributeCookie and currently only implementation
UnpackingAttributeCookie. This is an interface for reading/stat()ing
an attribute.
* Add abstract virtual Node::OpenAttribute() method that returns an
AttributeCookie and implemented it for derived classes.
* In the kernel interface attribute hooks use AttributeCookie now. The
attribute directory hooks are unchanged.
* Introduce Version class representing a version.
* Introduce Dependency and Resolvable class and add lists of either to
Package.
* Parse package attributes and add dependencies and resolvables to
Package.
* Add a mount type to Volume and add a respective mount parameter
"mount-type" (values "system", "common", "home", "custom"). Also
implies the shine-through type, if that's not given.
* Introduce class PackageFamily which groups equally named and versioned
packages.
* Add class PackageFSRoot. Each instance represents a possible file
system root (separate roots for different chroot environments). Tracks
Volumes belonging to the same root and their packages.
We don't need to explicitly track the covered/covering nodes per mount
after all. In fs_unmount() we iterate through all vnodes multiple times
anyway and can deal with the covers/covered_by vnodes there. Also, the
root vnode doesn't need to be handled specially anymore.
* packagefs_mount(): Initialize the fs_volume earlier, so it is more
usuable in Volume::Mount().
* The new mount parameter "shine-through" can be used to specify which
shine-through mode shall be used. Can be "system", "common", "home",
and "none". Depending on the setting it is decided which directories
of the underlying file system are bind-mounted on top of ours.
* Fix infinite loop in Volume::_RemovePackageContent().
* Use the RETURN_ERROR() macro in more places to help with debugging.
* Add support function vfs_get_mount_point(), so a file system can get
its own mount point (i.e. the node it covers). Re-added
fs_mount::covers_vnode for that purpose -- the root node isn't know to
the VFS before the mount() hook returns.
* Add function vfs_bind_mount_directory() which bind-mounts a directory
to another. The Vnode::covers/covered_by mechanism is used, so this
isn't true bind-mounting, but sufficient for what we need ATM and
cheaper as well. The vnodes connected thus aren't tracked yet, which
is needed for undoing the connection when unmounting.
* get_vnode_name(): Don't use dir_read() to read the directory. Since we
have already resolved vnode to the covered vnode, we don't want the
dirents to be "fixed" to refer to the covering nodes. Such a vnode
simply wouldn't be found.
* Introduce Vnode flags for covered and covering. Can be used as a quick
check when one doesn't already hold sVnodeLock.
* Rename resolve_mount_point_to_volume_root() to
resolve_vnode_to_covering_vnode().
* Adjust all code that deals with transitions between mount points and
volume root vnodes to generally support covered/covering vnodes.
* Build system: Create packages haiku-devel, haiku-welcome,
haiku-userguide, and makefile-engine.
* The TimGMSoundFont and BeBook zip files have been repackaged as hpkg
files.
* Adjust the optional package definitions accordingly.
After failing to start the input server by signature, the fallback
didn't append the input server name to the servers directory returned by
find_directory().
* InstallOptionalHaikuImagePackage: In case of hpkg packages, copy them
to the target directory, instead of extracting them.
* Correct gcc 2 package download URL.
* The ICU gcc 2 optional packages has been repackaged as hpkg. Use that.
For gcc 4 things are broken, now.
* Introduce on-container jam variable HAIKU_CONTAINER_SYSTEM_DIR_TOKENS
containing the directory tokens relative to the container root to
refer to system.
* Use the variable in *ToContainer rules that need to put something in
system.
* AddFilesToContainer: Fix overlooked reference to AddFilesToHaikuImage.
* AddBootModuleSymlinksToContainer: Use relative symlinks. This avoids
special-casing in the boot loader for packagefs.
* PackageDirectory::Lookup(): Support "." and ".." lookups.
* PackageLoaderContentHandler::HandleEntry(): If the entry doesn't have
a parent directory, use the volume's root directory directly. This
makes PackageVolume::AddNode() superfluous and also always passes a
non-NULL parent directory to PackageNode::Init().
Fixes module loading. elf_load_image() checks the node ID to verify
whether an image was already loaded, so giving all nodes the same ID
only gets one image loaded. The IDs don't necessarily match the ones the
kernel packagefs assigns, which could be a problem later on.
* Add BOOT_VOLUME_PACKAGED boot volume message field name constant.
* register_boot_file_system():
- Now takes a BootVolume& parameter.
- If the boot volume is packaged, add that info to the boot volume
message.
* Add pread().
* Add Node::ReadLink() to read a symbolic link path.
* Add Directory::LookupDontTraverse() and make Lookup() non-abstract.
Lookup() is implemented via LookupDontTraverse() and Node::ReadLink().
* Adjust all FS implementations accordingly.
* Add a packagefs implementation. Unlike other FS implementations it
isn't a pseudo-module, but provides a function to explicitly mount a
package file (packagefs_mount_file()).
* Finish BootVolume::SetTo() implementation, mounting the package file
and replacing fSystemDirectory.
Now the boot loader can load the kernel and boot modules from a packaged
system. The kernel boots up to the point where the boot volume is
mounted.
Ingo Weinhold