* Use the std::nothrow behaviour of operator new
* Avoid to compare the CurrentDecorator at every iteration
* Avoid possible NULL dereference
Fix CID 10947 and CID 10889
* if an edid request for LVDS panel is detected, we now
return true and the VESA edid info.
* add #if 0'ed function to pull prefered timing info from atombios
on LVDS panels, still need to generate a fake EDID with this.
* not sure which method above is better... maybe a combination of both
* add HD 6480G PCI ID
* graphics memory is stored in bytes on IGP / APU evergreen+
* add an error and a fallback to PCI FB Bar size if we cannot
find full card memory size
* uncomment the building of libroot_build.a again
* add function remapper to HOST_STATIC_LIBROOT
* drop TODO about the function remapper not working with the static
libroot
Ingo: please review - I think this should work, but I'm not so sure
where HOST_STATIC_LIBROOT should be in the list of libraries of its
only user (<build>bfs_fuse): where it is now or right at the end?
As it is now, the resulting binary still contains references to
host-libc-implementations of close() & others, which are triggered by
the other libs (like libfuse.so). If I put HOST_STATIC_LIBROOT right at
the end, those references are gone, though. But which is correct?
* The vm86 code or the code running in virtual 8086 mode may clobber the
%fs register that we use for the CPU dependent thread local storage
(TLS). Previously the vm86 code would simply restore %fs on exit, but
this doesn't always work. If the thread got unscheduled while running
in virtual 8086 mode and was then rescheduled on a different CPU, the
vm86 exit code would restore the %fs register with the TLS value of
the old CPU, causing anything using TLS in userland to crash later on.
Instead we skip the %fs register restore on exit (as do the other
interrupt return functions) and explicitly update the potentially
clobbered %fs by calling x86_set_tls_context(). This will repopulate
the %fs register with the TLS value for the right CPU. Fixes#8068.
* Made the static set_tls_context() into x86_set_tls_context() and made
it available to others to faciliate the above.
* Sync the vm86 specific interrupt code with the changes from hrev23370,
using the iframe pop macro to properly return. Previously what was
pushed in int_bottom wasn't poped on return.
* Account for the time update macro resetting the in_kernel flag and
reset it to 1, as we aren't actually returning to userland. This
didn't cause any harm though as only the time tracking is using that
flag so far.
* Some minor cleanup.
The constructor may abort at various places and the destructor cleans up
everything already initialized. The mutex was however not initialized
early on, leading to #8153 where the mutex was destroied in the error
case, accessing uninitialized memory. Fixes#8153 though the reason for
the aborted constructor probably needs to be investigated as well.
Only get/remove/put the vnode when the node is actually known to the
VFS. This does not only save unnecessary work, it also solves a
(temporary) deadlock -- at least partially. If another thread caused a
call to our get_vnode() hook just before, it would block on the volume
lock we're holding when adding/removing packages. The vnode would be
marked busy until the other thread's request was fulfilled and our call
to get_vnode() would block until timing out. Now we're calling
get_vnode() only, if we already know that the VFS already has a valid
vnode.
There still remains a race condition. If the VFS discards the vnode
right before we call get_vnode(), we essentially have the same situation
as before (i.e. us calling get_vnode() although the vnode is no longer
known to the VFS) with the same potential problem. For a real solution
we need a get_vnode() variant which can be told not to block.
* Node::VFSInit() and VFSUninit() set/clear the new node flag
NODE_FLAG_KNOWN_TO_VFS. They need to be called by overriding methods,
now.
* Add Node::IsKnownToVFS() which returns the VFS init status.
* UnpackingLeafNode: Add a fFinalPackageNode attribute. It is set when
the node is about to be removed and will point to the node's previous
head package node and be used in its stead. From the perspective of
the FS hooks this leaves the node in an unchanged state.
* Unpacking[Leaf,Directory]Node:
- Add WillBeFirstPackageNode(), returning whether the given package
node would become the head package node when added.
- Add PrepareForRemoval() which removes all package nodes. In case of
UnpackingLeafNode it also sets fFinalPackageNode.
- Add CloneTransferPackageNodes(). It is only implemented for
UnpackingLeafNode. It clones the node, transfers all package nodes
to the clone and sets fFinalPackageNode on this node.
* Volume::_{Add,Remove}PackageNode(): Solved the following TODO: When a
package is added or removed and a file present in both the
added/removed package and another package with the version in the
former having precedence, we have to remove the node (leaving it
unchanged) and replace it by a new node. This prevents clients having
the node opened or mapped from suddenly seeing different data. It also
fixes unbalanced calls to PackageNode::VFSInit()/VFSUninit() which
would result in file descriptors to package files being leaked.
Volume::_RemovePackageContentRootNode(): Check whether a directory
corresponding to the package directory does actually exist. This might
not be the case when the package directory has been skipped due to
clashing with a shine-through directory. Would crash in this case.
Apparently I should have done a complete rebuild after moving
directories.h from headers/private/libroot to .../system, since a lot of
stuff didn't build anymore.
The implementation is temporary. Currently it reads through the packages
in the respective packages directory and checks against the package
links. Once package activation is tracked explicitly we'll use the
activation file/directory.
A BPackageContentHandler subclass that initializes a BPackageInfo from
the read package attributes. Pulled out of RepositoryWriterImpl's
PackageContentHandler.
* Remove InitCheck() and the initializing constructor.
* Rename PackageCount() to CountPackages().
* Use BOpenHashTable instead of HashMap for the internal PackageMap.
* Allow multiple packages with the same name. Equally named packages are
in a singly linked list after the first package with that name.
* Add an Iterator inner class and a GetIterator() method, so one can now
iterate through the packages in the repository.
* Add a new class ShineThroughDirectory for shine-through directories
instead of using UnpackingDirectory.
* Split up setting up the shine-through directories in two steps. First
the directories are only created. That happens before adding the
initial package domains. After publishing the root node we bind the
shine-through directories to the underlying directories.
* This makes adding a package directory with the same name as a
shine-through directory fail in _AddPackageNode() as originally
intended. Since we no longer want it to fail -- the package daemon
will copy the files in the respective directories as part of the
activation process -- we simply skip the directory now. Adjust
_AddPackageNode() and _AddPackageContentRootNode() accordingly.
When adding a new package link directory, the volume would only be
notified about the addition of the directory itself, not of the addition
of its contents. Add a new PackageLinkDirectory::NotifyDirectoryAdded()
which does the whole job and use it in
PackageLinksDirectory::AddPackage().
