* Fixed the read with bounce buffer case. When skipping a partial bounce
buffer before the part we're interested in, we forgot to update "offset".
* Added some more comments for readability.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29999 a95241bf-73f2-0310-859d-f6bbb57e9c96
better, though :-)
* Also fixed a mixup of the unintuitive argument order of our
atomic_test_and_set(); I guess I will change that sooner or later.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29994 a95241bf-73f2-0310-859d-f6bbb57e9c96
page failed since the cache has been shrunk, we need not only remove the
page from the cache, we also need to remove all of its area mappings and
free it. Not removing the area mappings might have been the cause of #3110,
not freeing it would cause it to be leaked for good.
* vm_page_write_modified_page_range(): When writing failed for another reason
and the page wasn't in the modified queue before, we would lose the info
in which queue it was before and setting the page state to modified would
assume the active queue. This could potentially screw up our page queue
structures.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29992 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Renamed DoublyLinkedList::Size() to Count(), since it actually counts the
items (ie. O(n)).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29979 a95241bf-73f2-0310-859d-f6bbb57e9c96
* optimized unmapping of a single page that was rather inefficient
for large areas
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29978 a95241bf-73f2-0310-859d-f6bbb57e9c96
most importantly input_server, which then closes the drivers for input devices.
This in turn will do some cleanup. The touch pad driver will then be reset to
act as normal PS/2 mouse, so that OS like BeOS can use it again.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29948 a95241bf-73f2-0310-859d-f6bbb57e9c96
* We started the "main2" thread too late. Since the scheduler was already
started on all CPUs, the idle thread could wait (for a mutex) while
spawing the "main2" thread. This violated the assumption in the scheduler
that all idle threads would always be ready or running. We now create the
thread while the kernel runs still single-threaded.
* scheduler_start() is now invoked with interrupts still disabled. We enable
them after the function returns. This prevents scheduler_reschedule() from
potentially being invoked before scheduler_start().
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29914 a95241bf-73f2-0310-859d-f6bbb57e9c96
Don't really resume the undertaker thread after creating it, since at that
point the scheduler has not been started yet. Didn't do any harm, since it was
only the second thread anyway and the idle thread was rescheduled almost
immediately.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29908 a95241bf-73f2-0310-859d-f6bbb57e9c96
Check gKernelStartup to avoid sending ICI when entering the kernel debugger
(after ICI is enabled). Moreover it's more obvious than to use that instead
of relying on ICIs not being enabled.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29907 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Made the TimeZoneView less error prone, and also actually use Haiku code (the
previous check didn't work since it used #if, not #ifdef).
* Also took the liberty to rename our boot loader to haiku_loader, since I had
to update the nasm binary anyway. Updated the assembly sources to nasm 2.0.
* I haven't found where the synth location in the MIDI code is specified,
though.
* Also, NetBootArchive, and FloppyBootImage haven't been updated yet. Will do
so next.
* Some optional packages still put their license to beos/etc/licenses. I didn't
update them yet, as we'll probably do so anyway at some point. Also, I think
we might want to introduce a common/data/licenses instead for those.
* If you encounter any problems, please tell!
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29876 a95241bf-73f2-0310-859d-f6bbb57e9c96
(mostly at least). Also disables -Werror for the binutils, but those should
be fixed eventually.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29804 a95241bf-73f2-0310-859d-f6bbb57e9c96
spinlock for a long time. That should help to analyze system "freezes"
involving spinlocks. In VMware on a Core 2 Duo 2.2 GHz the panic() is
triggered after 20-30 seconds. The time will be shorter on faster machines.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29732 a95241bf-73f2-0310-859d-f6bbb57e9c96
newly created dir. The VFS really doesn't need it and for some file systems
it might not be easy to get by. Several file systems (e.g. rootfs and fat)
were ignoring the parameter anyway.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29719 a95241bf-73f2-0310-859d-f6bbb57e9c96
1) We now maintain a runqueue per CPU, rather than a single global shared queue. Idle threads are segregated into their own queue for simplicity.
2) Enqueueing threads is now somewhat more intelligent - if the thread is pinned, it is always enqueued onto that core. Otherwise we enqueue it on whichever CPU it previously ran, unless it either hasn't run before, or that core has been disabled via ProcessController. If so, we try to enqueue it on whichever core has been the most idle recently.
3) The above allow various simplifications to thread scheduling. Pinned threads and/or disabled cores are now no longer special cases that need to be dealt with. If a CPU has no threads ready, it looks for another one to steal a thread from, though that part still needs some tuning along with enqueueing for load balancing purposes.
The chief aim here is better load balancing and support for soft affinity. However, at the moment the overall behavior still exhibits some regressions compared to the old scheduler, so it's disabled by default. If you wish to experiment/debug with it, instructions for enabling it can be found in scheduler.cpp. Much thanks to Ingo, Axel and everyone who's helped with either code review/advice or testing so far.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29643 a95241bf-73f2-0310-859d-f6bbb57e9c96
are still allowed to delete semaphores of other teams...
* Anyway, this fixes bug #3585.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29621 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Use atomic_or() to update sig_pending of the main thread.
* We didn't call update_thread_signals_flag() for the main thread, so its
handle_signals() wouldn't be called, resulting in an infinite loop, if this
signal interrupted a restartable syscall. Calling exit() from another thread
than the main thread was likely to run into this problem. Should fix#3178.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29612 a95241bf-73f2-0310-859d-f6bbb57e9c96
it was done in SAS/C... (yeah, that was ages ago). This fixes bug #2030.
* Also, we should probably check if the area we're about to shrink/remove
actually is a reserved area.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29605 a95241bf-73f2-0310-859d-f6bbb57e9c96
to manage this, avoid locking the main sLock in notification handling methods. Instead fill up two lists which will be emptied later by the kernel daemon thread.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29603 a95241bf-73f2-0310-859d-f6bbb57e9c96
device additions/removals can be monitored.
* Minor cleanup.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29582 a95241bf-73f2-0310-859d-f6bbb57e9c96
makes them more convenient to use, since the caller doesn't need to know the
target threads' user thread structure.
* Adjusted the pthread rwlock implementation accordingly.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29578 a95241bf-73f2-0310-859d-f6bbb57e9c96
the free list. Do that with the threads lock held. This allows other threads
to freely access a thread's user thread structure while holding the threads
lock.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29577 a95241bf-73f2-0310-859d-f6bbb57e9c96
implementations that can be used by subsystems that want to have a pretty
standard service. Only the latter is really complete, though.
* The notification manager is now available earlier in the boot process.
* Added notifications to teams/ports (only add/remove).
* The network notification implementation is now using the
DefaultUserNotificationService.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29543 a95241bf-73f2-0310-859d-f6bbb57e9c96
can be checked.
* Make the usb_keyboard module check the presence of the needed debugger
commands to avoid the error messages in case of them being unavailable.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29472 a95241bf-73f2-0310-859d-f6bbb57e9c96
IORequest.{h,cpp}.
* Introduced public <io_requests.h> header. Currently it only declares the
single function BFS uses.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29446 a95241bf-73f2-0310-859d-f6bbb57e9c96
1) When searching the area for a place to allocate the next command, the case of the first command being the same as the last command (as is the case after adding the first message) was not correctly considered. This prevented a given area from ever containing more than one command.
2) The size of a command was incorrectly word-aligned. Rather than aligning to 32-bit boundaries, the size was truncated to between 1-3 bytes, leading to command corruption once multiple messages were in the area, eventually causing registrar to crash while retrieving the messages.
Combined these two changes result in us no longer constantly allocating/destroying areas during heavy node monitor activity.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29417 a95241bf-73f2-0310-859d-f6bbb57e9c96
could have caused a number of problems.
* Fixed coding style violation Ingo introduced.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29378 a95241bf-73f2-0310-859d-f6bbb57e9c96
* The I/O context related vfs_*() functions have io_context* instead of void*
parameters/return values, now.
* vfs_new_io_context(): Lock the parent I/O context before getting its table
size. Otherwise the table size could change until we do.
* vfs_resize_fd_table(): Fixed use of MutexLocker. We created only a temporary
object, not one with function scope.
* Renamed load_image_etc() to load_image_internal() and added a parameter for
specifying the parent team of the one to create.
* Introduced a kernel private load_image_etc() with a few more arguments than
load_image().
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29375 a95241bf-73f2-0310-859d-f6bbb57e9c96
many unclear bytes remained instead of how many were cleared. This caused
sparse files to show garbage instead of empty space. This fixes bug #2889.
* common_file_io_vec_pages() set "size" (size_t) from file_io_vecs::length
which is off_t without taking into account that important information could
be lost.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29339 a95241bf-73f2-0310-859d-f6bbb57e9c96
stored now.
* Extended the debugger message for B_DEBUGGER_MESSAGE_HANDED_OVER by the
causing thread.
* Also send B_DEBUGGER_MESSAGE_HANDED_OVER to the debugger to which the team
was handed over. The message will be the very first one the debugger gets
from the team in question.
* Some harmless refactoring (added thread_hit_serious_debug_event()).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29302 a95241bf-73f2-0310-859d-f6bbb57e9c96
otherwise a "rmdir ./" would still have caused the corruption.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29299 a95241bf-73f2-0310-859d-f6bbb57e9c96
to be in line with what other systems do as well. Also fixes bug #3476.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29296 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Added debugger commands to resolve usb_ids to pipes.
* Adjusted the physical memory allocator to be usable in a slimmed down mode
when running inside the kernel debugger.
* Implemented USB keyboard support for KDL through a kernel debugger add-on.
* Added kgetc() and made use of it where previously individual methods were used
to ensure that reading characters always goes through the kernel debugger
add-ons and the other methods.
This has some preconditions to meet though:
1) The keyboard must be in the boot protocol (currently the case but needs to
be revisited once we have a full usb_hid).
2) The keyboard must be attached to a UHCI root port (i.e. not use EHCI or OHCI,
also not through hubs unless those are USB 1.1).
3) the usb_hid driver has to be opened for this to work. This means that for the
time between initializing USB and when usb_hid is opened by the input_server
there is no keyboard support.
Also note that this has no way of detecting hot-plug, meaning that you can't
re-attach your USB keyboard from the hub to the root port once in KDL.
On the bright side of things, since this is a non-destructive mechanism it is
possible to enter and leave KDL without loosing the USB state.
Tested OK in QEMU, not tested on real hardware yet, will see in a few minutes.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29291 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Add attribute_overlay and write_overlay to the image/floppy instead.
* Mount a iso9660 boot volume with both write and attribute overlay for now.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29261 a95241bf-73f2-0310-859d-f6bbb57e9c96
needed at all when used as intended. Thanks Ingo for the explanation on how this
is intended to work. Adjusted the overlay fs accordingly and updated/reverted
the changes to the other filesystems.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29250 a95241bf-73f2-0310-859d-f6bbb57e9c96
been mounted. This is to allow layered filesystems to setup internal data that
requires all the sub/super volumes to be available.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29248 a95241bf-73f2-0310-859d-f6bbb57e9c96
It causes the interrupt handler to be inserted at the very end of the list
instead of at the top. It is intended to be used as a workaround when a
interrupt handler cannot know if it actually handled the interrupt. This
should never be used by native drivers. Also if we know that the result is
not valid because of this flag we won't disable the vector in case we count
many unhandled interrupts as those numbers are then unreliable.
* Moved B_NO_LOCK_VECTOR to be a private flag as well.
* Made the interrupt handler list a simple manually maintaned singly linked list
instead of the doubly linked one used with insque and remque as it greatly
simplifies things for such an easy use case and is more compact.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29241 a95241bf-73f2-0310-859d-f6bbb57e9c96
* When booting from an iso, mount the boot volume with the overlay layer.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29202 a95241bf-73f2-0310-859d-f6bbb57e9c96
additional layer by supplying "-t <actualFileSystem>:overlay" to a mount command.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29201 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Remove the previous method of applying the overlay by flags. In the future the
overlay can just be mounted as a filesystem layer. This is probably how layers
were intended to work in the first place.
* Move the filesystem module info and filesystem name from the fs_mount to the
fs_volume structure. Filesystem layering is done by having multiple layered
volumes and we want to be able to have a different fs per layer.
* Adapt VFS code to this move.
* Implement mounting layered filesystems. Specifying multiple filesystems
separated by a colon on mount will cause the layers to be set up and the
corresponding filesystems to be mounted at that layer.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29199 a95241bf-73f2-0310-859d-f6bbb57e9c96
node. That is needed for a layered filesystem to be able to construct a full
fs_vnode out of a volume/inode pair.
* Adapt places where get_vnode is used. Sadly this is a C API and we can't just
use a default NULL for that argument.
* Introduce a flag B_VNODE_WANTS_OVERLAY_SUB_NODE that can be returned in the
flags field of a fs get_vnode call. A filesystem can use this flag to indicate
that it doesn't support the full set of fs features (attributes, write support)
and it'd like to have unsupported calls emulated by an overlay sub node.
* Add a perliminary overlay filesystem that emulates file attributes using files
on a filesystem where attributes aren't supported. It does currently only
support reading attributes/attribute directories though. All other calls are
just passed through to the super filesystem.
* Adjust places where a HAS_FS_CALL() is taken as a guarantee that the operation
is supported. For the overlay filesystem we may later return a B_UNSUPPORTED,
so make sure that in that case proper fallback options are taken.
* Make the iso9660 filesystem request overlay sub nodes. This can be fine tuned
later to only trigger where there are features on a CD that need emulation
at all.
If you happened to know the attribute file format and location you could build
an iso with read-only attribute support now. Note that this won't be enough to
get a bootable iso-only image as the query and index support is yet missing.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29177 a95241bf-73f2-0310-859d-f6bbb57e9c96
add the const in any case. As Axel points out these are C functions and we do
not affect binary compatibility by changing their signature.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29124 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Replaced the use of offsetof() for structs that aren't PODs. Add a
offset_of_member() macro to util/khash.h because that's what it's used for
in our cases.
* Change the signature of add_debugger_command()/remove_debugger_command() on
GCC > 2 to avoid the depricated conversion from string constants to char *.
* Adding some "suggested" parenthesis. I know that not everyone likes that, but
it pointed out at least one bug that is fixed here as well.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29113 a95241bf-73f2-0310-859d-f6bbb57e9c96
* this fixes the use of SSE instructions here on a dual core.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29051 a95241bf-73f2-0310-859d-f6bbb57e9c96
get multiple definitions of them when building with GCC4 on a GCC4 host.
With that we can now build completely on a GCC4 host with native GCC 4.3.3.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29020 a95241bf-73f2-0310-859d-f6bbb57e9c96
to sAPMBiosEntry generates undefined symbols and I'm not in a condition to fix
this right now. Added a TODO.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28986 a95241bf-73f2-0310-859d-f6bbb57e9c96
won't call put_mount() before they are freed. Internally, this causes them
to grab a reference to the mount's root vnode.
* This fixes bug #3262.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28850 a95241bf-73f2-0310-859d-f6bbb57e9c96
#2919 (OMG :-)).
* While I was at it, I also cleaned up some style inconsistencies.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28842 a95241bf-73f2-0310-859d-f6bbb57e9c96
and colors for the on-screen debug output when leaving KDL. Thanks, Adrian!
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28841 a95241bf-73f2-0310-859d-f6bbb57e9c96
* UpdateUserListener() did not delete the copiedListener in case adding the
monitor listener failed.
* RemoveListener() did never delete UserNodeListeners, IOW user node monitors
were never freed!
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28787 a95241bf-73f2-0310-859d-f6bbb57e9c96
will now accepted and regarded as sparse file data. FileMap::_Add() also
correctly joins multiple vecs with that offset together, FileMap::Translate()
will always report offset -1 even for offsets into that extent.
* read_file_io_vec_pages() (or rather, its backend common_file_io_vec_pages())
now supports sparse files, and will just clear the memory it should read from
offset -1 instead of passing a request to the vnode.
* ext2 now correctly reports sparse files. This should close bug #2889, as well
as #975.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28648 a95241bf-73f2-0310-859d-f6bbb57e9c96
memory to free was empty, but didn't check the list with objects to
delete. So those were queued until someone used deferred_free().
Should fix#3128.
* Run the daemon once a second instead of every five seconds, so memory
is recycled a little quicker.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28644 a95241bf-73f2-0310-859d-f6bbb57e9c96
the fixes applied to the kernel version of it (most notably a correctly
working block_cache_discard(), and cache_detach_sub_transaction()).
Also switched to the new notification functions, even though it still works
synchronously in the fs_shell.
* Minor cleanup.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28617 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Whatever is the cause of #2733, this should at least not make it crash.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28615 a95241bf-73f2-0310-859d-f6bbb57e9c96
generic page mapping mechanism. This should fix#2902 (will test in a minute).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28584 a95241bf-73f2-0310-859d-f6bbb57e9c96
lock held - that was a relict of the past.
* This fixes bug #2535.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28551 a95241bf-73f2-0310-859d-f6bbb57e9c96
bug #3082.
* Also, it now allows to remove daemons in their hook function.
* Added a "daemons" KDL command that dumps all registered kernel daemons, and
resource resizers.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28550 a95241bf-73f2-0310-859d-f6bbb57e9c96
as public defines. They are now called THREAD_{MIN|MAX}_SET_PRIORITY to
better reflect what they are for. Minimum priority is now 1, ie. you no
longer can set another thread to the idle priority. This fixes part of
ticket #2959.
* set_thread_priority() will no longer allow to change the priority of the
idle thread to something else. This fixes the rest of ticket #2959.
* Automatic whitespace cleanup in OS.h.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28521 a95241bf-73f2-0310-859d-f6bbb57e9c96
in the cache is the same as in the condition variable. It now uses the
low-contention sCachesLock to accomplish this.
* Also added an ASSERT to make sure the notification is no longer part of the
list at this point.
* Improved KDL command output.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28516 a95241bf-73f2-0310-859d-f6bbb57e9c96
discarded blocks correctly as well.
* cache_detach_sub_transaction() left cached_block::original_data unchanged even
if the parent data was to become current (in case the sub transaction didn't
change the block yet). This could cause outdated blocks to be written back.
* cache_detach_sub_transaction() also set cached_block::previous_transaction
for all blocks, not just the ones with a previous transaction. This could
cause blocks to be written twice for no reason.
* cache_start_sub_transaction() did not change the num_blocks count for
discarded blocks.
* block_cache_discard() now panics if the block was already changed in the
current transaction.
* Improved test application, added more tests, revealing the above bugs in
cache_detach_sub_transaction().
* Minor cleanup.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28514 a95241bf-73f2-0310-859d-f6bbb57e9c96
from the block notifier, the cache could be deleted before we have the chance
to lock it. We now lock the sCachesLock, and see if this cache is still valid.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28512 a95241bf-73f2-0310-859d-f6bbb57e9c96
cache_end_transaction(), and cache_start_sub_transaction()).
* Further work on the test application, it's now actually usable, first test
passes.
* dump_block() did erroneously print 'B' for the dirty flag; now both dirty and
discard have the 'D' (3rd and 5th column).
* block_cache::LowMemoryHandler() is now private (and got an underscore prefix).
* Minor cleanup, shuffled some methods around.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28508 a95241bf-73f2-0310-859d-f6bbb57e9c96
discarding their changes. This functionality currently only works correctly
when no transactions are used.
* Started test application for the block cache, doesn't do anything yet.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28496 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Added new(mynothrow) operators which avoid clashes when also linking
against libgcc.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28474 a95241bf-73f2-0310-859d-f6bbb57e9c96
* For 8 bit, the palette is pretty messed up during the boot process
(thanks to the boot loader image), so that we might want to change
how the colors are set then.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28393 a95241bf-73f2-0310-859d-f6bbb57e9c96
print_demangled_call() will now use user_strlcpy() to copy the string
first (if that fails, it will printf '???' to show this).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28386 a95241bf-73f2-0310-859d-f6bbb57e9c96
suggestion by adding a "faults" command that now sets the
gInvokeCommandDirectly variable as wished.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28382 a95241bf-73f2-0310-859d-f6bbb57e9c96
demangle module (yet). This could cause a read fault in x86's
print_demangled_call() (as it assumed there must be a ':' when this is true).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28375 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Fixed some places that set an error return value but didn't actually
return.
* Fixed success case return value. The number of bytes received must be
returned, not B_OK.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28335 a95241bf-73f2-0310-859d-f6bbb57e9c96
stat::st_{dev,ino}.
* stat::st_rdev is unused, but at least initialize it with some
deterministing value. This makes Perl's lib/File/stat.t test happy.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28333 a95241bf-73f2-0310-859d-f6bbb57e9c96
* vm_clone_area() does now set the B_SHARED_AREA flag on both the source
and the cloned area. This is necessary, since it would no longer be
guaranteed that areas are backed by leaf caches only (after
fork()ing), which doesn't work with our cache merging strategy.
Fixes#2605.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28296 a95241bf-73f2-0310-859d-f6bbb57e9c96
This is not necessary, since userland teams' page directories also
contain the kernel mappings, and avoids unnecessary TLB flushes. To make
that possible the vm_translation_map_arch_info objects are reference
counted now.
This optimization reduces the kernel time of the Haiku build on my
machine with SMP disabled a few percent, but interestingly the total
time decreases only marginally. Haven't tested with SMP yet, but for
full impact CPU affinity would be needed.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28287 a95241bf-73f2-0310-859d-f6bbb57e9c96
that dprintf_no_syslog() can avoid sending something to the syslog.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28286 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Added deferred_delete() that takes a DeferredDeletable and deletes it
asynchronously.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28285 a95241bf-73f2-0310-859d-f6bbb57e9c96
the <DROP> marker at the place data was dropped, not somewhere else. See
ticket #156; this might already fix this bug.
* Minor cleanup.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28278 a95241bf-73f2-0310-859d-f6bbb57e9c96
scheduler_set_thread_priority(). Setting the thread priority was the
only situation in which it was used.
* Renamed scheduler.cpp to scheduler_simple.cpp.
* The scheduler functions are no longer called directly. Instead there's
an operation vector now, which is initialized at kernel init time.
This allows for picking the most suitable scheduler for the machine
(e.g. a non-SMP scheduler on a non-SMP machine).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28262 a95241bf-73f2-0310-859d-f6bbb57e9c96
scheduler tracing and scheduler analysis code into separate source
files.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28253 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Turned the checks for all those macros to "#if"s instead of "#ifdef"s.
* Introduced macro KDEBUG_LEVEL which serves as a master setting.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28248 a95241bf-73f2-0310-859d-f6bbb57e9c96
index into the sLastCaller array is vint32, so after overflowing the
modulo operation would yield negative indices. This would cause the
256 bytes before the array to be overwritten. Might also be the cause of
#2866.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28245 a95241bf-73f2-0310-859d-f6bbb57e9c96
added vm_memcpy_from_physical() and vm_memcpy_physical_page(), and
added respective functions to the vm_translation_map operations. The
architecture specific implementation can now decide how to implement
them most efficiently. Added generic implementations that can be used,
though.
* Changed vm_{get,put}_physical_page(). The former no longer accepts
flags (the only flag PHYSICAL_PAGE_DONT_WAIT wasn't needed anymore).
Instead it returns an implementation-specific handle that has to be
passed to the latter. Added vm_{get,put}_physical_page_current_cpu()
and *_debug() variants, that work only for the current CPU,
respectively when in the kernel debugger. Also adjusted the
vm_translation_map operations accordingly.
* Made consequent use of the physical memory operations in the source
tree.
* Also adjusted the m68k and ppc implementations with respect to the
vm_translation_map operation changes, but they are probably broken,
nevertheless.
* For x86 the generic physical page mapper isn't used anymore. It is
suboptimal in any case. For systems with small memory it is too much
overhead, since one can just map the complete physical memory (that's
not done yet, though). For systems with large memory it counteracts
the VM strategy to reuse the least recently used pages. Since those
pages will most likely not be mapped by the page mapper anymore, it
will keep remapping chunks. This was also the reason why building
Haiku in Haiku was significantly faster with only 256 MB RAM (since
that much could be kept mapped all the time).
Now we're using a different strategy: We have small pools of virtual
page slots per CPU that are used for the physical page operations
(memset_physical(), memcpy_*_physical()) with CPU-pinned thread.
Furthermore we have four slots per translation map, which are used to
map page tables.
These changes speed up the Haiku image build in Haiku significantly. On
my Core2 Duo 2.2 GHz 2 GB machine about 40% to 20 min 40 s (KDEBUG
disabled, block cache debug disabled). Still more than factor 3 slower
than FreeBSD and Linux, though.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28244 a95241bf-73f2-0310-859d-f6bbb57e9c96
delete. Therefore the constructor/destructor of the contained EntryCache is also
called. The manual call of the destructor to the OpenHashTable inside the
EntryCache was therefore superflous and the destructor would be called twice,
leading to bug #2869.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28232 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Introduced flag "invoke_scheduler" in the per CPU structure. It is
evaluated in hardware_interrupt() (x86 only ATM).
* Introduced SMP_MSG_RESCHEDULE_IF_IDLE message, which enters the
scheduler when the CPU currently runs an idle thread.
* Don't do dprintf() "CPU x halted!" when handling a SMP_MSG_CPU_HALT
ICI message. It uses nested spinlocks and could thus potentially
deadlock itself (acquire_spinlock() processes ICI messages, so it
could already hold one of the locks). This is a pretty likely scenario
on machines with more than two CPUs, but is also possible when the
panic()ing thread holds the threads spinlock. Probably fixes#2572.
* Reworked the way the kernel debugger is entered and added a "cpu"
command that allows switching the CPU once in KDL. It is thus possible
to get a stack trace of the thread not on the panic()ing CPU.
* When a thread is added to the run queue, we do now check, if another
CPU is idle and ask it to reschedule, if it is. Before this change, the
CPU was continuing to idle until the quantum of the idle thread
expired. Speeds up the libbe.so build about 8% on my machine (haven't
tested the full Haiku image build yet).
* When spinlock debugging is enabled (DEBUG_SPINLOCKS) we also record
the spinlock acquirer on non-smp machines. Added "spinlock" debugger
command to get the info.
* Added debugger commands "ici" and "ici_message", printing info on
pending ICI message respectively on a given one.
* Process not only a single ICI message in acquire_spinlock() and other
places, but all pending ones.
* Also process ICI messages when waiting for a free one -- avoids a
potential deadlock.
* Mask out non-existing CPUs in send_multicast_ici(). panic() instead of
just returning when there's no target CPU left.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28223 a95241bf-73f2-0310-859d-f6bbb57e9c96
* "iospace p" should only print the entries for actually existing
memory.
* Fixed output of "iospace v".
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28222 a95241bf-73f2-0310-859d-f6bbb57e9c96
{memset,memcpy_to}_physical() functions.
Mapping lots of physical pages at once as done before was an actual
problem on systems with enough RAM, as the physical page mapper can map
only 64 chunks at a time. So multiple threads could play dining
philosophers, each getting only one of two chopsticks, waiting for
another one to be freed.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28220 a95241bf-73f2-0310-859d-f6bbb57e9c96
the free queue.
* "thread" also prints the thread's I/O priority.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28218 a95241bf-73f2-0310-859d-f6bbb57e9c96
DoublyLinkedListLinkImpl, and fs_mount now uses a DoublyLinkedList instead
of a typeless struct list.
* Also added a constructor/destructor to fs_mount which simplifies and cleans
some code.
* This should not contain any functional changes :-)
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28215 a95241bf-73f2-0310-859d-f6bbb57e9c96
* This has the advantage that we no longer need to call get_vnode(), and
instead can use lookup_vnode().
* This means at least most of the "corrupted BFS inode" messages should be
gone; they were produced when fs_sync() tried to get already deleted vnodes.
This was actually harmless, but doesn't really help in trusting your system :-)
* Also, it no longer tries to write back removed vnodes.
* And finally, it now uses a marker vnode when iterating over the list, so
that it doesn't need to break out of the loop anymore, and can always sync
all willing vnodes.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28212 a95241bf-73f2-0310-859d-f6bbb57e9c96
pages have to be written and how tight the memory situation is.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28198 a95241bf-73f2-0310-859d-f6bbb57e9c96
interrupted, another thread closing the other end of the pipe could
invoke thread_unblock() while the first thread already entered
mutex_lock(). This would make the first thread think it successfully
locked the mutex, without removing its (on-stack) wait entry from the
mutex queue, thus leading to crashes.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28195 a95241bf-73f2-0310-859d-f6bbb57e9c96
This fixes a deadlock in SoundPlay that made it freeze when trying to play the 2nd sound.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28179 a95241bf-73f2-0310-859d-f6bbb57e9c96
Don't use the spinlock in arch_debug_serial_puts if we're inside the kernel
debugger. This fixes a tripplefault when faulting with said spinlock held
(due to a NULL string argument for example).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28155 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Add possibility to restart a complete pipe through B_KDEBUG_RESTART_PIPE.
* Implement tail in the kernel debugger making use of the former.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28154 a95241bf-73f2-0310-859d-f6bbb57e9c96
- initialize the time_base_frequency kernel arg (should be done in the bootloader though...). We will use MFP timer to support system_time(). At least try to.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28098 a95241bf-73f2-0310-859d-f6bbb57e9c96
the methods IsFile() and GetFilePath() to BDiskDevice, and
BDiskDeviceRoster::GetFileDeviceForPath().
* Added new syscalls to implement this functionality.
* Added new flag B_DISK_DEVICE_IS_FILE.
* Fixed wrong operator precedence assumption in the BDiskDevice class at
several places.
* Minor cleanup.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28052 a95241bf-73f2-0310-859d-f6bbb57e9c96
- remove dead ppc code
- add support for probing hardware registers the way linux does (early, hook with VBR to trap faults)
- detect MFPs this way.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28031 a95241bf-73f2-0310-859d-f6bbb57e9c96
This confused some USB card readers, that would stop working if you still
requested the geometry when they reported no media.
Note the case that the B_GET_MEDIA_STATUS fails (because it's not implemented or
an error occured) is still handeld in _GetMediaStatus() and then we still try to
get the geometry to check for media presence.
This should fix that some USB card readers wouldn't work and should also remove
the wrongly reported size in DriveSetup for CD drives that don't actually contain
a media.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28029 a95241bf-73f2-0310-859d-f6bbb57e9c96
* The stack_trace() command now also uses this call by default to give you
the arguments to all functions in a stack crawl (beware of templates for now,
though).
* Use the new option '-d' to disable the demangling. You can now also specify
'-d' in the "call" command which has the same meaning there.
* NULL pointers are now printed as "NULL", and NULL strings are printed as
well.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28019 a95241bf-73f2-0310-859d-f6bbb57e9c96
debugger add-on set a demangle hook, all modules under debugger/demangle/ are
now considered demangle modules.
* Added another function to the demangle module interface that gives you access
to the arguments.
* Implemented a demangling module for GCC2.
* The older demangling module is now called "gcc3+", but doesn't support
getting the arguments yet.
* The "call" KDL command is now using demangling to automatically show you
the arguments of a call from a stack crawl.
* Minor cleanup.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28018 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Actually call prepare_sleep_state() instead of calling enter_sleep_state()
twice...
* Commented out disabling interrupts when calling enter_sleep_state(), as our
ACPI modules would then crash (needs memory & uses sems with interrupts
disabled). This way, it at least works on some hardware, including emulators
(as before).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28004 a95241bf-73f2-0310-859d-f6bbb57e9c96
case it has to call the file map translation hook again to fulfill the whole
request; it already handled the partial case correctly.
* This fixes an occasional "Value too large" error when accesssing fragmented
files.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28001 a95241bf-73f2-0310-859d-f6bbb57e9c96
r27530 - allow faults with ints disabled if there is a handler
r27648 - call the end-of-interrupt thread callback
r27718 - add <asm_defs.h>, not used yet
r27722 - register the commpage as image and symbols (but we don't use it yet)
- remove dupped call to thread_get_current_thread()
- use 16MB iospace for now, 4MB seems too small.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27999 a95241bf-73f2-0310-859d-f6bbb57e9c96
PHYSICAL_PAGE_{NO,CAN}_WAIT into an actual flag
PHYSICAL_PAGE_DONT_WAIT.
* Pass the flags through to the chunk mapper callback.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27979 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Use the new VMCache::Read() flags parameter to directly read into the
physical page in the page fault handler instead of mapping it first.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27966 a95241bf-73f2-0310-859d-f6bbb57e9c96
* memset() is now available through the commpage.
* CPU modules can provide a model-optimized memset().
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27952 a95241bf-73f2-0310-859d-f6bbb57e9c96
subdirectories. Also moved the x86 kernel arch_string.S there.
* Moved memcpy.c from src/system/libroot/posix/string into the
arch/generic subdirectory.
* Dealt with the consequences of moving things around. Affected are also
the boot loader and runtime loader builds.
Adjust the m68k and ppc parts, too, but only the x86 build is tested.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27947 a95241bf-73f2-0310-859d-f6bbb57e9c96
- try to accomodate for low ram systems by making the first kernel heap allocation smaller
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27943 a95241bf-73f2-0310-859d-f6bbb57e9c96
arch_vm_aspace_swap().
* The x86 implementation does now maintain a bit mask per
vm_translation_map_arch_info indicating on which CPUs the address
space is active. This allows flush_tmap() to avoid ICI for user
address spaces when the team isn't currently running on any other CPU.
In this context ICI is relatively expensive, particularly since we map
most pages via vm_map_page() and therefore invoke flush_tmap() pretty
much for every single page.
This optimization speeds up a "hello world" compilation about 20% on
my machine (KDEBUG turned off, freshly booted), but interestingly it
has virtually no effect on the "-j2" haiku build time.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27912 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Added smp_send_multicast_ici(), which sends the message to all CPUs
specified via a mask.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27910 a95241bf-73f2-0310-859d-f6bbb57e9c96
timed out thread has a higher priority than the currently running one.
Maybe we should even restrict this behavior to realtime threads.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27897 a95241bf-73f2-0310-859d-f6bbb57e9c96
need to cast explicitly before the multiplication/shift, since the
former is 32 bit and the latter 64 bit. The worst instance was in
swap_file_add(), where the page count was int32, so that swap file
sizes between 2 and 4 GB resulted in a negative available swap space
size. Fixes bug #2721.
* Fixed and added optional debug output.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27877 a95241bf-73f2-0310-859d-f6bbb57e9c96
ignore every other cache (starting from the first).
* The consequence of this was that no blocks were written back automatically
for those caches, and their transactions were never idle, causing bug #2781.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27831 a95241bf-73f2-0310-859d-f6bbb57e9c96
Currently it only contains KDEBUG and the block cache debugging macros.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27816 a95241bf-73f2-0310-859d-f6bbb57e9c96
buffer format, the buffer can now also contain other events than just
stack traces. ATM these are only references to the image events
(created/deleted). Therefore we no longer have to flush the profiling
buffer after such an event, since the debugger can exactly match the
samples. Since we couldn't flush when the profiling timer hit while the
thread was in the kernel, that wasn't working that well anyway.
"profile -f" fails to translate stack trace addresses only very rarely,
now.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27775 a95241bf-73f2-0310-859d-f6bbb57e9c96
exec*()ed, the debugger never got notified that a runtime loader image
was created.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27773 a95241bf-73f2-0310-859d-f6bbb57e9c96
up module image paths in module_init_post_boot_device(). Not sure whether
it also could cause #2776.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27760 a95241bf-73f2-0310-859d-f6bbb57e9c96
* No longer send a SIGKILL when a page fault occurred, there was no
signal handler, and the debugger told us to continue as usual. Instead
we send a SIGSEGV. Instead in handle_signal() when not in the main
thread and there's no handler for the signal, we first send the main
thread a SIGKILL before letting the thread die.
So in cases where the main thread caused an unhandled page fault, the
team will die from the SIGSEGV, now. This fixes bug #2773.
* For the other hardware-caused signals we do now do the same as in case
of page faults, i.e. we first check whether the thread has a handler
for the signal in question. If so, we don't notify the debugger, but
send the signal right away.
* B_GENERAL_PROTECTION_FAULT is translated to SIGILL now. Seems better
than SIGKILL.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27757 a95241bf-73f2-0310-859d-f6bbb57e9c96
letting the boot loader provide full paths for the pre-loaded images.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27753 a95241bf-73f2-0310-859d-f6bbb57e9c96
been mounted, before anyone could try to load any modules from it.
Also pass it a flag whether the boot volume is where the boot loader
pre-loaded the modules from.
* module_init_post_boot_device() changes the pre-loaded module image
paths to normalized boot volume paths, now. Got rid of the code in
register_preloaded_module_image() which tried something like this.
* Changed module image ref counting. A referenced module has single
reference to its image, which is released when the module becomes
unreferenced.
* get_module() for a reference module will not try to re-get and re-set
the module's image anymore. That could lead to a similar module (from
different paths) being loaded at the same time. A module from a new
file can only be loaded when the old one has been put completely.
* Simplified B_KEEP_ALIVE module handling a bit. When the module is
initialized, we add another reference, which we'll never free. Thus
the module remains loaded without special handling. Removed
module_image::keep_loaded. A B_KEEP_ALIVE module remains referenced
and thus its image remains referenced, too.
* Removed module::file, a cached path to the module's image. An
optimization that wouldn't work with multiple root directories for
modules (/boot/beos/..., /boot/common/...) or when module files were
moved. get_module() does now always search the image file, when the
module is still unreferenced. This should be a bit slower than before,
but I didn't notice any difference in VMware at least. If it turns out
to be a problem we could introduce a more intelligent cache that stays
up to date by using node monitoring.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27752 a95241bf-73f2-0310-859d-f6bbb57e9c96
function (normalize_path()), now. There was some code duplication
before.
* Added "bool traverseLink" parameter to vfs_normalize_path(). When
true and the leaf component is a symlink, it will be resolved.
* KPath:
- Added similar leaf link traversal parameter to SetTo() and
SetPath().
- Added Normalize().
- Added DetachBuffer(), which returns the object's current buffer and
unsets itself.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27751 a95241bf-73f2-0310-859d-f6bbb57e9c96
code (like found in Firefox) that relies on get_next_image_info() to
return it first.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27732 a95241bf-73f2-0310-859d-f6bbb57e9c96
elf_add_memory_image_symbol(). The former creates and registers a new
image that has not been loaded from a file. The latter adds a symbol to
its symbol table. This is mainly a debug feature, allowing to name code
or data in memory regions that aren't associated with loaded ELF
objects.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27721 a95241bf-73f2-0310-859d-f6bbb57e9c96
added FUNCTION_END() calls for a good deal of functions. The respective
ELF symbols do now have a correct size.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27718 a95241bf-73f2-0310-859d-f6bbb57e9c96
team does have a runtime loader image. The "profile" tool can thus
translate addresses in the runtime loader correctly.
Note that this change will break code that assumes that the application
image is the first image returned by get_next_image_info().
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27715 a95241bf-73f2-0310-859d-f6bbb57e9c96
been called for a team, and fail installing the default debugger if it
is set. This makes disable_debugger() actually work. Fixes bug #2763.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27713 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Extended the profiling API by an option to record a variable number of
samples per tick. The stack depth is used as a maximum.
* Added new option "-f" to the "profile" tool. When specified it
increments the hit counts of all symbols in the full available caller
stack. I.e. the resulting hit counts will approximate the total time
spent in each function or any function directly or indirectly called
by it. Thus "_start" and "main" will usually get 100% and leaf
functions only what time has actually been spent in them.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27699 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Fixed hash_remove_current(): It didn't update "lastElement" and thus
always also removed all elements in the same bucket preceding the one
to be removed. Also got rid of the useless "for" loop.
Fixes#2757.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27689 a95241bf-73f2-0310-859d-f6bbb57e9c96
1 ms to 1 us. The long minimum timeout seriously screwed profiling,
since by default it works with 1 ms ticks, stopping the timer when the
thread is unscheduled and restarting it with the remaining time when it
is scheduled again.
I could also imagine that this had a negative effect on latencies and
the precision of thread wakeup times.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27672 a95241bf-73f2-0310-859d-f6bbb57e9c96
flags on the wrong thread (the current one instead of the newly created
one). This would cause the thread not to be debugged as it should, e.g.
profiling wouldn't work correctly.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27671 a95241bf-73f2-0310-859d-f6bbb57e9c96
buffer during a timer event that interrupted a kernel function: We do
now flush the buffer as soon as it is 70% full, *if* we didn't interrupt
a kernel function. When the buffer runs full and we still haven't hit a
user function, we drop the tick. The number of dropped ticks is recorded
and sent to the debugger with the next update message.
Reverted the previous partial solution (the temporary disabling of
profiling while in debugger support code).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27658 a95241bf-73f2-0310-859d-f6bbb57e9c96
is created or deleted (or exec*() has been invoked). The counter is
sent with several debugger messages.
* Track the image event counter that is used when samples are added to
the profiling buffer. If the current team counter differs, we flush
the buffer first (sending an update message to the debugger), so that
the debugger has a chance to match the addresses to the correct images.
* Disable profiling for a thread while it runs in the debugger support
code. This fixes potential deadlocks which could occur when a
profiling timer event occurred that would require the buffer to be
flushed while the thread was just sending something to the debugger or
waiting for a command. As it turns out, this is not sufficient either,
since we should never try to flush the buffer when the timer event
occurred in the kernel, since the thread might hold a lock that the
debugger thread could try to acquire. Will implement a more general
solution later.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27656 a95241bf-73f2-0310-859d-f6bbb57e9c96
* We can't enable interrupts in an interrupt handler. Instead we use the
newly introduced callback feature, which notifies the debugger right
before returning from the interrupt.
* We didn't indicate that the profiling buffer was full and that the
thread shouldn't be profiled ATM. Therefore it could happen that it
was profiled while trying to notify the debugger that the profiling
buffer was full, resulting in a deadlock. Introduce a respective flag
in the thread debug structure.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27649 a95241bf-73f2-0310-859d-f6bbb57e9c96
interrupt handler and will be executed right before returning from the
interrupt.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27648 a95241bf-73f2-0310-859d-f6bbb57e9c96
be tracked to the kernel, which then counts the hits, an area is
passed to kernel in which the hits are recorded. When the area is
full, the debugger is notified. For some reason that part doesn't work
yet -- the whole system freezes when waiting for a reply.
* Reorganized the profile tool code a bit. For one with respect to the
changed API, but also to prepare tracking of image creation/deletion.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27640 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Added global hash table for images.
* Improved a bit of code by using the new image hash table. E.g.
_get_image_info() can return infos for images of any team, now.
* Fixed remove_images() comment: The function must not be invoked with
the team lock being held.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27606 a95241bf-73f2-0310-859d-f6bbb57e9c96
creation), we didn't release the team debug info spinlock and reenabled
interrupts.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27602 a95241bf-73f2-0310-859d-f6bbb57e9c96
various system information.
* Implemented retrieving some VM stats via this call.
* The VM now maintains a page fault counter, and sets system_info::page_faults
accordingly.
* Added a (pretty simple) "vmstat" command line app.
* Minor cleanup.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27597 a95241bf-73f2-0310-859d-f6bbb57e9c96
messages easily hit the previous limit. Maybe another solution should be
sought.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27591 a95241bf-73f2-0310-859d-f6bbb57e9c96
still pretty much work in progress.
* Introduced init_thread_debug_info() which is used instead of
clear_thread_debug_info() when the thread is created. The latter
requires former initialization.
* user_debug_thread_deleted() is now already invoked in thread_exit(),
not in the undertaker.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27531 a95241bf-73f2-0310-859d-f6bbb57e9c96
disabled, as long as a fault handler is installed for the thread. It
allows user_memcpy() to be invoked with interrupts disabled -- in this
case it will simply fail, when the address is valid, but not mapped yet.
This is a more desirable behavior for debug facilities, though in all
other cases it is likely a bug. We should probably introduce a thread
flag to discriminate these situations.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27530 a95241bf-73f2-0310-859d-f6bbb57e9c96
many iframes are supposed to be skipped before recording the stack
trace. Currently implemented for x86 only.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27529 a95241bf-73f2-0310-859d-f6bbb57e9c96
When specified, the message is read but not removed from the port.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27527 a95241bf-73f2-0310-859d-f6bbb57e9c96
as we cannot do so with interrupts turned off (ACPI needs to allocate memory
dynamically).
* Turn off interrupts right before going to sleep (_GTS), this at least works
in VMware, maybe it also works on real hardware.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27500 a95241bf-73f2-0310-859d-f6bbb57e9c96
* CID 314 and CID 315: Same as above just for WriteLockPartition.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27476 a95241bf-73f2-0310-859d-f6bbb57e9c96
into two seperate checks instead and return B_BAD_VALUE on a passed NULL path.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27475 a95241bf-73f2-0310-859d-f6bbb57e9c96
need for a null check. Or the null check needs to be moved to after last is
initialized. But if the user_memcpy of cookie succeeds, last should not be null
since it is just a copy of cookie. Probably.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27429 a95241bf-73f2-0310-859d-f6bbb57e9c96
before being NULL checked on line 1234. I moved the null check to be after name
is initialized and removed it from line 1234.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27428 a95241bf-73f2-0310-859d-f6bbb57e9c96
be used now. Tested only with VMware so far.
* apm_shutdown() is now called with interrupts turned on.
* Renamed arch_cpu.c to arch_cpu.cpp.
* Minor cleanup.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27404 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Removed sXsiMessageCountLock in favor of atomic_* function utility
* free up any remaining messages when a queue gets destroyed
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27391 a95241bf-73f2-0310-859d-f6bbb57e9c96
pages into the team's address space. Doing that is relatively cheap and
saves later page faults.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27380 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Imported radix bitmap tree implementation from FreeBSD and adjusted it
for Haiku.
* Make use of the radix tree in the swap support implementation instead
of using simple bitmaps. This will allow for faster swap slot
allocations. ATM Haiku doesn't benefit that much, since we always
allocate single pages, but that will change eventually.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27355 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Fix comparison
send and receive simple message seems to work now.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27331 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Reworked the way IDs are geneterad in the same way they are in xsi semaphores
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27327 a95241bf-73f2-0310-859d-f6bbb57e9c96
remove a race condition pointed out by Ingo, hopefully in a clean way. The
set is now unlocked right before blocking
* Reworked the way ID were assgned: the current time is now used as ID. This
lower quite a lot the probability of having an ID reused.
* Introduced a sequence number field in the set class as a second ID, as
suggested by Ingo. It is used on wake up in order not to confuse a no more
existing set with a new one with the same ID
* Removed a now unnecessary UnsetID() method
* Increased the arbitraty limit of max sempahore allowed in the system, and
introduced a new one for the total number of set.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27320 a95241bf-73f2-0310-859d-f6bbb57e9c96
than that of the current thread has been woken up. I didn't see the
reason why the thread should otherwise relinquish the rest of its
quantum. I noticed for instance that client and app server window
threads were ping-ponging more than seemed necessary. In most cases
when the client sent a port message it would be unscheduled although it
had run only for a few microseconds and had still stuff to do.
I measured a relatively Terminal-heavy "find /boot" (second run), which
does now take 5-10% less time.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27314 a95241bf-73f2-0310-859d-f6bbb57e9c96
unscheduled was incorrect.
* Introduced _kern_analyze_scheduling() syscall. It requires scheduler
kernel tracing to be enabled. It uses the tracing entries for a given
period of time to do a similar analysis the "scheduler" debugger
command does (i.e. number of runs, run time, latencies, preemption
times) for each thread. Additionally the analysis includes for each
thread how long the thread waited on each locking primitive in total.
* Added kernel tracing for the creation of semaphores and initialization
of condition variables, mutexes, and rw locks. The enabling macro is
SCHEDULING_ANALYSIS_TRACING. The only purpose is to provide
_kern_analyze_scheduling() with more info on the locking primitives
(the name in particular).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27304 a95241bf-73f2-0310-859d-f6bbb57e9c96
tracing buffer entries even when not in the kernel debugger.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27302 a95241bf-73f2-0310-859d-f6bbb57e9c96
the ipc hash table lock along with the semaphore set hash table lock were
hold, thinking (wrongly) that the semaphore set lock itself was not needed.
What could happen was that another process on semop could have gained the lock
of the set itself, and then release the semaphore set hash table lock.
This would make it think that the set was still valid, while it could have
actually been deleted right after it release the semaphore set hash table lock.
Same would have happened for any other processes waiting on the semaphore set
mutex queue. By calling the lock on the mutex when deleting the set, it
*should be* safe to assume that there is no one else waiting on its queue,
since the list of waiters is handled in a FIFO way.
As far as I can see from the mutex_destroy code, it looks safe to hold the lock
when calling this function. Please confirm.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27268 a95241bf-73f2-0310-859d-f6bbb57e9c96
for message queue
* Removed unnecessary header Vector.h
* Removed HasSemaphoreSet method: since there will be an IPC table for each
subsystem, if a key exist, it already has a semaphore set associated
with it
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27256 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Implemented _kern_msgget()
Work in progress, some stuff may be removed.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27254 a95241bf-73f2-0310-859d-f6bbb57e9c96
inherit it.
* IOScheduler::ScheduleRequest() uses the request's thread and team now
instead of the current one. Otherwise for requests processed
iteratively this would always be the I/O scheduler's notifier thread.
* Also get the thread's I/O priority now. It's still ignored later,
though.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27248 a95241bf-73f2-0310-859d-f6bbb57e9c96
vector at the end of the file will be aligned to the given value.
* BFS uses an alignment of 512 bytes (should be block size of the
underlying device or BFS block size, whatever is less), which should
be fine, since file data are only stored in BFS blocks. This totally
avoids any partial operations at the I/O scheduler level, thus saving
disk operations. Not that I could measure any performance difference.
Theoretically it should help a lot though, particularly when dealing
with lots of small files, since we avoid using bounce buffers, which
are (a) limited in number and (b) require copying of the data.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27246 a95241bf-73f2-0310-859d-f6bbb57e9c96
* swap_file_add() open()s the swap file now with O_NOCACHE and
swap_file_delete() closes it. This squashes a TODO (the file cache
wasn't kept disabled for the swap file before).
* swap_file_add() only adds swap files that can actually be used (i.e.
non 0-sized ones).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27232 a95241bf-73f2-0310-859d-f6bbb57e9c96
overcommitting caches. If the page in question was just not mapped or
swapped out, we would increase the committment unnecessarily
(potentially even beyond the size of the cache).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27229 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Implement color palette generation for the boot splash images in the
generate_boot_screen build tool. Only 4-bit screen support is missing now.
* Adopted images.h with the new results from generate_boot_screen.
This should fix black boot screens for graphics cards that don't support
true color modes for the native resolution. I've tried to find the ticket,
#2177 almost looks like the one, but it looks more like the mode is out
of range if I understand the ticket right.
Thanks a lot, David, and sorry it took so very long to apply your patch!
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27223 a95241bf-73f2-0310-859d-f6bbb57e9c96
operation length.
* IORequest: Added owner (IORequestOwner). Also added a SetUnfinished()
method, which is invoked by the I/O scheduler after all operations of
the request have been finished, but the request isn't done yet.
* Added debugger commands "io_request_owner" and "io_scheduler" printing
information for a IORequestOwner and IOScheduler object respectively.
* Implemented an actual I/O scheduling algorithm. It's a simple round
robin strategy (a queue per thread) with a unidirectional elevator
serializing the operations. ATM priorities are ignored, the bandwidth
isn't adjusted to the device, and there are TODOs all over the place.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27216 a95241bf-73f2-0310-859d-f6bbb57e9c96
* The VMAnonymousCache destructor was unreserving too much physical
memory.
* Addressed TODO in _SwapBlockBuild(): When the swap block couldn't be
allocated we wait and loop until it can.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27202 a95241bf-73f2-0310-859d-f6bbb57e9c96
left hand side of assignments. IOW it is possible to modify memory, now.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27193 a95241bf-73f2-0310-859d-f6bbb57e9c96
referencing iframe registers. Their prefix is "$". E.g. "$eax" refers to
the eax register of the current iframe. The features cooperates with the
"in_context" command, i.e. "in_context 92 $eip = 0" will set the eip
register of thread 92 to 0 (thus sealing its fate ;-)).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27192 a95241bf-73f2-0310-859d-f6bbb57e9c96
debugged thread, if set. This makes "dis" without specified address work
when used with "in_context".
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27190 a95241bf-73f2-0310-859d-f6bbb57e9c96
executing them. Doesn't really make any difference ATM.
* Handle B_BUSY returned by DMAResource::TranslateNext() correctly.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27186 a95241bf-73f2-0310-859d-f6bbb57e9c96
dynamically assign one when needed. Under the assumption that in most
cases a bounce buffer isn't needed, we can thus prepare a lot more
operations.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27185 a95241bf-73f2-0310-859d-f6bbb57e9c96
TRACK_PAGE_USAGE_STATS): The page daemon tracks the distribution of page
usage counts. Can be printed using the "page_usage" command.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27182 a95241bf-73f2-0310-859d-f6bbb57e9c96
RAM Haiku uses (for debugging purposes).
* "page_stats" prints some more infos now.
* page_writer():
- Moved the low_resource_state() invocation out of the inner loop.
Reduces lock contention on the sLowResourceLock recursive lock.
- Additional debug output: Every 1024 written pages the page writer
prints a message.
* steal_pages(): Addressed the TODO: When there should be pages to
steal, but we can't get them ATM, we now timeout on the free pages
condition variable instead of snoozing unconditionally, so that we
wake up earlier when someone frees pages in the meantime.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27181 a95241bf-73f2-0310-859d-f6bbb57e9c96
due to alignment padding before.
* Reorganized merging of caches a bit. Renamed MergeStore() to Merge()
and moved some more functionality into it. The method also moves the
pages from source to consumer, now. This is necessary, since
VMAnonymousCache needs to consider both physical pages and swap pages
at the same time. Before we first moved the physical pages and the
swap pages later, which was broken for two reasons: (1) A swap page in
the consumer cache shadows a physical page of the source cache, which
we ignored. (2) A source cache's physical page that also had a swap
page would lose the latter in the process when moved to the consumer
cache, i.e. if the page was not marked modified, it could be stolen
and its data would be lost.
These changes improve the situation when building Haiku with 256 MB RAM
in that jam doesn't crash anymore, but in my test the system became
totally unusable after about an hour or 7000 targets (GUI froze). For
some reason it didn't manage to free pages anymore although swapping
heavily.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27179 a95241bf-73f2-0310-859d-f6bbb57e9c96
more information of the unscheduled thread, namely its new state and, if
waiting, also the object it is going to wait on. When scheduler tracing
level 2 is enabled, additionally the address where the thread was
preempted is recorded. The latter could be interesting for analyzing
race condition bugs.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27168 a95241bf-73f2-0310-859d-f6bbb57e9c96
* It can now also lookup userland symbols.
* By respecting the currently debugged thread it smoothly cooperates
with the "in_context" command. IOW it can lookup symbols in any team.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27167 a95241bf-73f2-0310-859d-f6bbb57e9c96
PC of the innermost iframe.
* The "in_context" command does now set the currently debugged thread
respectively.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27166 a95241bf-73f2-0310-859d-f6bbb57e9c96
debugger and added respective getter/setter methods
debug_{get,set}_debugged_thread(). By default the currently debugged
thread is the thread that dropped into the kernel debugger, but commands
like "in_context" can change it.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27164 a95241bf-73f2-0310-859d-f6bbb57e9c96
state_to_text().
* state_to_text() can now deal with a NULL thread argument.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27163 a95241bf-73f2-0310-859d-f6bbb57e9c96
line and executes the command line in the context of the specified
thread. E.g. "in_context <thread> db <addr>" allows to read memory from
a team that is not active ATM.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27156 a95241bf-73f2-0310-859d-f6bbb57e9c96
first command line argument of a given command line string.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27155 a95241bf-73f2-0310-859d-f6bbb57e9c96
short form (like "threads").
* "thread" allows to specify more than one thread now.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27152 a95241bf-73f2-0310-859d-f6bbb57e9c96
that possibility.
* It now has a "remove" argument instead, that decides whether or not the
image has to be removed from the hash still.
* Moved locking to put_module_image(), ie. both, {load|unload}_module_image()
need to be called with the sModulesLock held now.
* module_init_post_boot_device() needs to remove the image from the hash itself,
or else it messes up its hash iterator.
* check_module_image() could call unload_module_image() under certain
conditions - but this was completely wrong, and could have caused crashes.
* search_module()/check_module_image() now keep a reference to the module
image on success, thus a caller doesn't need to call get_module_image()
again afterwards - this also fixes another round of potential module
unloading to happen.
* That reference is leaked for built-in modules in get_module(), but it doesn't
matter for them, anyway.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27140 a95241bf-73f2-0310-859d-f6bbb57e9c96
as they aren't unloaded when there is no boot device yet.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27136 a95241bf-73f2-0310-859d-f6bbb57e9c96
dirent without the name first, and will then check if the d_reclen member
is valid before copying the name.
* This shows the problem with the FAT file system that was revealed by r26859.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27128 a95241bf-73f2-0310-859d-f6bbb57e9c96
synchronously; we use the resource resizer instead. This avoids another
potential deadlock.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27123 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Added a second kernel daemon service, resource resizer, which is
mainly supposed to be used for resizing allocations asynchrounously.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27122 a95241bf-73f2-0310-859d-f6bbb57e9c96
without object depot it should be complete. For the other stuff
internal_alloc() would need to pass the flag on to block_alloc(), but
that isn't possible yet.
* Adjusted the low memory handler to respect the minimum object reserve
of the object caches.
The swap_test_heap test does seem to pass reliably with 128 MB RAM and
128 MB allocation, now. It's quite slow, though. Particularly while the
allocation is filled, the system is completely unusable.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27118 a95241bf-73f2-0310-859d-f6bbb57e9c96
create_area_etc().
* When the new flag CREATE_AREA_DONT_WAIT is specified, the functions
don't wait for memory or pages to become available. They fail
immediately instead.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27117 a95241bf-73f2-0310-859d-f6bbb57e9c96
eventually the VIP heap would be exhausted.
* WriteAsync() didn't call the provided callback when an error occurred
before invoking vfs_asynchronous_write_pages(). The page writer would
get stuck in those cases.
* The object cache used for the swap blocks does now use the
asynchronous resizing feature to avoid deadlocks.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27101 a95241bf-73f2-0310-859d-f6bbb57e9c96
of free objects an object cache should try to have ready. If the number
of free objects drops below the threshold, a new urgent priority thread
is asked to asynchronously resize the object cache (pretty similar to
the heap grower thread). Such a mechanism is necessary for code paths
that are supposed to free pages, but may need memory themselves (like
the swap support).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27100 a95241bf-73f2-0310-859d-f6bbb57e9c96
calls the method unchecked, and the buffer can actually be NULL, if
Init() failed.
* panic() when running out of VIP memory, at least when KDEBUG is
set.
* Use heap_set_get_caller() for the VIP heap, so the heap leak checking
produces useful caller addresses.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27099 a95241bf-73f2-0310-859d-f6bbb57e9c96
is enabled to set a per-heap get_caller() function.
* Added "-h <heap>" option to the "allocations_per_caller" command. If
given only the allocation for the specified heap are considered.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27097 a95241bf-73f2-0310-859d-f6bbb57e9c96
we must use {read|write}_pages() instead of {read|write}().
* This should fix accessing other file systems than BFS (ie. those that doesn't
have an io() function) like ext3 and FAT.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27088 a95241bf-73f2-0310-859d-f6bbb57e9c96
global cache list before locking it. This allows to get rid of the
block_cache::deleting field, as well as simplifies some code.
* This also fixes a possible deadlock I recently introduced (on destruction,
the locking order was wrong).
* Now uses an anonymous condition variable instead.
* Moved the block_cache initialization code into a dedicated method that will
now also fail in case the low resource handler couldn't be registered (as
pointed out by Salvatore).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27074 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Fixed lock leak in Write().
* Fixed bug in _Commit(): swap_space_reserve() was fed with the wrong
value (could even be negative).
* swap_free_page_swap_space(): Removed incrementing of sAvailSwapSpace.
The function is only supposed to deallocate swap space, not to
unreserve it.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27071 a95241bf-73f2-0310-859d-f6bbb57e9c96
operation is available ATM, it will return NULL.
* _Finisher() does now re-schedule a request, if all of its operations
finished successfully, but there are still remaining bytes.
* _Scheduler() does now operate in two passes. First it creates as many
operations for a given request as possible, then it executes the
operations. This fixes bug #2644. The problem was that by creating and
executing the operations in a single loop, an operation could be
finished before the next one was added. The request would thus be
considered finished and the request owner be notified. This would
usually lead to the destruction of the request while it was still in
use.
* _Scheduler(): In case we don't have a DMA resource also advance the
request.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27070 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Moved memory unlocking from IORequest::OperationFinished() to
IORequest::NotifyFinished(). This way we can reschedule a request,
e.g. if we didn't have enough unused IOOperations at hand the first
time.
* Added some more debug output and asserts.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27069 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Some renaming: A location in a swap file where a page can be stored is
now called "slot" instead of "page" or "swap page".
* swap_slot_alloc(): Update the hint more correctly after allocating
slots at the hint.
* swap_space_reserve(): When less than the requested space could be
reserved, it always returned 0 and leaked the remaining pages.
* swap_file_delete(): sSwapFileListLock wasn't unlocked in error cases.
Use MutexLocker now.
* swap_free_page_swap_space(): sAvailSwapSpace wasn't updated.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27057 a95241bf-73f2-0310-859d-f6bbb57e9c96
be passed on to the IORequest. Most relevantly physical pages can now
be written directly by passing B_PHYSICAL_IO_REQUEST.
* Added VMCache::WriteAsync() which is supposed to write pages
asynchronously. The base class version version falls back to the
synchronous Write(). Only VMVnodeCache implements WriteAsync() ATM,
VMAnonymousCache (swap support) still has to be adjusted accordingly.
* write_page() doesn't need to map the page anymore as it can write the
physical page directly.
* Modified the page writer to write pages asynchronously. This shouldn't
have any noticeable effect yet. It will though as soon as the I/O
scheduler reorders I/O operations.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27056 a95241bf-73f2-0310-859d-f6bbb57e9c96
writes the given page iovecs asynchronously. The new class
AsyncIOCallback is used to inform the caller when the request has been
finished.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27055 a95241bf-73f2-0310-859d-f6bbb57e9c96
deleted automatically when it's finished.
* Added IORequest::Create() for creating a IORequest on the heap
(respectively the VIP heap).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27054 a95241bf-73f2-0310-859d-f6bbb57e9c96
many bytes to be read/written, which, among other things, could trigger
an assert in the IORequest code:
* In case of a partial (i.e. non-block-aligned) begin, transferLeft was
not adjusted correctly.
* The main loop was lacking a transferLeft check.
* Main loop: When finally using a bounce buffer, the unrestricted vec
length was used as base length for the bounce buffer.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27042 a95241bf-73f2-0310-859d-f6bbb57e9c96
stuff at all, anymore.
* Removed now unused get_device_for_path().
* unpublish_driver() now only deletes the device if unpublishing actually
worked out okay.
* Minor cleanup.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27038 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Added inode ID member to BaseDevice to make this possible.
* Removed unused and unmaintained legacy_driver::devices_published field.
* Implemented legacy driver's unpublish_driver().
* Reenabled legacy driver reloading on changes.
* Renamed devfs_driver_{added|removed}() to driver_{added|removed}(), and
made them private.
* Simplified deletion of device_node lists (no need to use an iterator here),
added device unpublishing.
* Minor cleanup.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27033 a95241bf-73f2-0310-859d-f6bbb57e9c96
Ingo suggestions: instead of having one global sem_undo list,
we now have two local list, one per semaphore set and one per team
which is held in its xsi_sem_context structure, along with a mutex.
A mutex has also been added to the semaphore set class in order to
protect the local list, but also in order to (hopefully) improve
concurrency.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26993 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Moved the static functions to the beginning of the file.
* Renamed several variables for more clarity, particularly
offset/cacheOffset to index/pageIndex in case where the unit is pages.
* _SwapBlock{Build,Free}() can deal with a range of pages now, which
should be more efficient.
* Additional checks/panics in swap_page_alloc().
* swap_file_add(): Wrong byte count was used when allocating and
clearing the bitmap.
* swap_page_alloc(): Fixed off-by-one check. The last page of the swap
file could not be used.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26975 a95241bf-73f2-0310-859d-f6bbb57e9c96
our dma_restrictions structure (but we're using blocks instead of bytes,
since unlike the block size, the restrictions attributes are constant).
* We might want to use blocks for the dma_restrictions structure as well in
the future...
* Fixed another bug in the device_node variant of DMAResource::Init(): the max
segment size was specified in blocks as well.
* Removed the "hardcode" block_io module and header.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26973 a95241bf-73f2-0310-859d-f6bbb57e9c96
heap.
* Allocate IOBuffers, IORequests, and cookies on the VIP I/O heap, if
necessary.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26969 a95241bf-73f2-0310-859d-f6bbb57e9c96
heap_class object now. Removed unused heap_allocator::heap_class.
* Made heap_class, heap_create_allocator(), heap_memalign(), heap_free()
public, so that a specialized allocator can be used elsewhere in the
kernel.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26965 a95241bf-73f2-0310-859d-f6bbb57e9c96
tracing entry classes.
* Added new "scheduler" command, available when scheduler tracing is
enabled. It analyzes the tracing entries for a given thread and prints
scheduling statistics for that thread. Should hopefully help to
understand the poor scheduling latencies in certain cases.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26956 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Fixed TraceEntryIterator::Current(): If fEntry was NULL, it would
return 0x4.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26955 a95241bf-73f2-0310-859d-f6bbb57e9c96
(fault address, pc, read/write) when a page fault occurs, and print them
in case this caused the termination of a debugger command.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26949 a95241bf-73f2-0310-859d-f6bbb57e9c96
marked modified again, so that we don't lose its data when someone
decides to steal it.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26939 a95241bf-73f2-0310-859d-f6bbb57e9c96
now also free swap space assigned to pages that are rather active.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26938 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Added functions swap_free_page_swap_space(), swap_available_pages(),
and swap_total_swap_pages(). They will be used by the page daemon
code.
* Free allocated swap space in the VMAnonymousCache destructor.
* Write(): First free swap space assigned to the pages to be written
(was leaked before) and update fAllocatedSwapSize upfront. Both is now
done with the cache locked, as it should be.
* Fixes several instance where the cache offset in bytes was used
instead of in pages.
* Print the correct error when _kern_write_stat() fails.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26926 a95241bf-73f2-0310-859d-f6bbb57e9c96
if after the main loop the transfer is already block aligned, we still
have to check whether the last vec is a bounce buffer that is shorter
than a complete block, but exceeds the original end of the request. If
so, we have to cut back to the previous block and add a block-sized
bounce buffer instead. Actually that's almost the same case as when the
transfer length is not yet block aligned, and thus we let the same code
handle it. Fixes bug #2584.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26910 a95241bf-73f2-0310-859d-f6bbb57e9c96
loop.
* This is probably the cause for file corruptions as well as bug #2595; will
have another look tomorrow.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26905 a95241bf-73f2-0310-859d-f6bbb57e9c96
* segmentCount was potentially set incorrectly. It could be too big,
since we considered all vecs, not only those remaining.
* The main loop condition was incorrect. This would lead to too few
DMABuffer vecs (or none at all) for any but the first IOOperation of a
request. Should fix#2586.
* Correctly offset by vecIndex in debug output.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26881 a95241bf-73f2-0310-859d-f6bbb57e9c96
specifying the protection of each page (4 bits per page).
* Added no-op implementation of posix_madvise().
* Replaced a few "addr_t size" parameters by "size_t size".
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26871 a95241bf-73f2-0310-859d-f6bbb57e9c96
with the VMCache lock held, and WriteModified() locks itself.
* Added an assertion that the lock is held when calling that method.
* This fixes a KDL as soon as you would have used O_NOCACHE with a file that
had already some pages read in.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26864 a95241bf-73f2-0310-859d-f6bbb57e9c96
* dir_read() now takes into account that we may have read more than one dir
entry, and calls fix_dirent() for each of them.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26859 a95241bf-73f2-0310-859d-f6bbb57e9c96
* If a segment violation occurs, we do now check whether the thread in
question has a handler for SIGSEGV. If so, we just send it the signal.
Otherwise we notify the debugger as before.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26851 a95241bf-73f2-0310-859d-f6bbb57e9c96
the cache locked, since it enters the VFS and might reenter VMCache,
thus causing deadlocks. Fixes bug #2577.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26849 a95241bf-73f2-0310-859d-f6bbb57e9c96
dedicated functions.
* Introduced gMappedPagesCount variable which counts the total number of
physical pages that are mapped.
* Added vm_page_get_stats() which fills in the memory related part of
the system_info structure. Used and cached pages are computed
differently, now. The "available" (== not committed) memory is no
longer used for the computation as it doesn't say anything about the
actually used/free pages (with swap support enabled it is even
less meaningful, since we first commit swap space when possible).
We do also consider the memory used by the block cache as cached
pages, now. All in all these changes should fix the memory statistics
reported by get_system_info(), IOW bug #2574.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26837 a95241bf-73f2-0310-859d-f6bbb57e9c96
reuse the block_io attributes in the node to build the dma_restrictions.
* DMAResource::Init() now dumps the dma_resources (should be done with the
TRACE() macro later).
* Turned off IOScheduler debug output.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26825 a95241bf-73f2-0310-859d-f6bbb57e9c96
include the guard pages. Adjusted the kernel and boot loader code
accordingly -- the guard pages size is added/not removed respectively.
The stack size passed to _kern_spawn_thread() is now the actually usable
size, and it is no longer possible to specify a size smaller than or
equal to the guard pages size.
* vm_create_anonymous_area(): Precommit two pages maximum -- a stack with
only one page usable size obviously doesn't need two pages.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26819 a95241bf-73f2-0310-859d-f6bbb57e9c96
userland. E.g. preparing a signal handler would terribly go wrong, since
we don't have a userland iframe. This fixes bug #2562 and maybe also
#2522.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26810 a95241bf-73f2-0310-859d-f6bbb57e9c96
* In case of a kernel iframe the iframe is shorter -- fixed the output
accordingly.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26807 a95241bf-73f2-0310-859d-f6bbb57e9c96
without filling it with zeros (ie. make use of B_STAT_SIZE_INSECURE).
* Added TODO that closing the file descriptor in swap_init_post_modules()
(that should probably renamed to swap_init_post_boot_device()) is not really
a good idea.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26797 a95241bf-73f2-0310-859d-f6bbb57e9c96
now a lot earlier.
* That makes it now possible to use modules pretty early in the kernel (like
before timer_init(), or int_init_post_vm()).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26790 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Added file_map_set_mode() function that you can use to keep a whole file
cached. This is needed for the swap file support: FILE_MAP_CACHE_ALL will
not only precache all file_io_vecs when called, but it will also cause all
file_map_translate() calls to fail that would require further caching (ie.
if the file size had changed).
* Updated the fs_shell file map code to the latest one (with several bug fixes).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26785 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Keep track of the stack space actually allocated for the cache and let
Write() fail when we've already allocated as much as reserved.
* Added second phase of swap initialization (swap_init_post_modules())
which reads the virtual memory driver settings and creates/resizes a
swap file. ATM truncate() is used to resize the swap file, but that is
a bit slow. We should probably introduce a VFS function to use BFS's
fast method.
This should make swap support work somewhat, but since swap space is
never freed ATM this would be a relatively short pleasure. Still
disabled by default.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26783 a95241bf-73f2-0310-859d-f6bbb57e9c96
actual caching in the file cache, i.e. all reads and writes go directly
to the underlying device. The implementation is not quite complete,
since the VM can still add pages to the cache when the file is mmap()ed,
which can lead to inconsistencies.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26779 a95241bf-73f2-0310-859d-f6bbb57e9c96
* When do_iterative_fd_io_iterate() fails, we must not invoke the
supplied finished hook explicitly, since it is invoked indirectly by
request->SetStatusAndNotify() anyway. Should fix#2557.
* We must detach the descriptor putter as soon as we have adjusted the
request's finished callback, since that will put the descriptor.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26776 a95241bf-73f2-0310-859d-f6bbb57e9c96
and size of the double fault stack.
* is_kernel_stack_address() does now also check whether the given
address is on the double fault stack. This fixes stack traces on
double faults, which were broken (i.e. went only to the double fault
iframe) since we started checking whether the addresses are on the
kernel stack at all.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26775 a95241bf-73f2-0310-859d-f6bbb57e9c96
- implemented arch_debug_get_stack_trace(), should allow building with TRACING enabled.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26771 a95241bf-73f2-0310-859d-f6bbb57e9c96
io() hook directly (it might not even have one).
* Fixed incorrect check in synchronous_io() which would cause requests
with more than one vec to finish early. Fixes bug #2558.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26751 a95241bf-73f2-0310-859d-f6bbb57e9c96
* {read,write}_pages() use vfs_{read,write}_pages() now, instead of
invoking the FS {read,write}_pages() hooks.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26750 a95241bf-73f2-0310-859d-f6bbb57e9c96
allocation size, which caused the Exec traced entry to crash when
printed.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26745 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Moved reservation of memory for the "locked" cases upfront.
Particularly if the would-be area is a kernel area, we don't want the
address space to be write locked while doing that, since that would
block the low memory handler.
* For full lock areas the pages are reserved upfront, too. The reasoning
is similar. Reserve the pages needed by the translation map backend for
mapping the area pages there too.
* Moved the cache locking/unlocking out of the individual cases. All
want to have the cache locked the whole time, now.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26741 a95241bf-73f2-0310-859d-f6bbb57e9c96
address, it is supposed to consider the worst case address range of the
given size.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26740 a95241bf-73f2-0310-859d-f6bbb57e9c96
empty thread structure. This causes the thread::team pointer to be NULL
during the early boot process, but our kernel debugger didn't like that.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26735 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Dumping the features as string is now a one time thing, that only happens
when DUMP_FEATURE_STRING is defined to 1.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26733 a95241bf-73f2-0310-859d-f6bbb57e9c96
gTeamSpinlock.
* Renamed the static global variables in smp.c to match our style guide.
* Minor other cleanup.
* Removed superfluous white space.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26730 a95241bf-73f2-0310-859d-f6bbb57e9c96
- Fixed deadlock in xsi_sem_undo - RecordUndo
- Fixed issue in xsi_sem_undo: if the semaphore set does not exist
anymore, ignore the request but do remove the process from the sUndoList,
which wasn't previously done.
- free() in ClearUndos was called with interrupts disabled
- when a semaphore set ends to exist, remove all it's sem_undo request as it's ID
will be reused in the future.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26727 a95241bf-73f2-0310-859d-f6bbb57e9c96
- iospace should now be initialized correctly, at least the kernel goes much further.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26726 a95241bf-73f2-0310-859d-f6bbb57e9c96
- push the address of the iframe before calling the C handler.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26724 a95241bf-73f2-0310-859d-f6bbb57e9c96
inode - unlike get_vnode() the busy flag won't prevent you from getting that
reference.
* Changed put_vnode() to return an error in case the vnode couldn't be found.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26713 a95241bf-73f2-0310-859d-f6bbb57e9c96
in steal_pages() which uses the number of pages in the inactive queue as
return criterion. It would thus return, if only marker pages were in the
queue and no page could be stolen. This led to a busy loop in
vm_page_allocate_page(). The whole system would become unusable when the
thread in question was the heap grower, since it would starve everyone
else due to its high priority.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26710 a95241bf-73f2-0310-859d-f6bbb57e9c96
user_{memcpy,memset}(), since that can cause a page fault, which needs
pages and might try to steal some from our cache.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26700 a95241bf-73f2-0310-859d-f6bbb57e9c96
partially (e.g. due to hitting the end of file). The respective
classes have grown new methods and attributes to deal with that. The
"finished" callbacks have got additional parameters to indicate
whether the transfer was only partial and how much has been
transferred. Other callbacks and functions have a size_t* in/out
parameter instead of a simple size_t, now.
* vfs_{read,write}_pages() do now use the I/O request framework instead
of the underlying FS's {read,write}_pages() hooks (those should be
unused now). Furthermore they've got an additional "flags" parameter,
which is passed to IORequest::Init(), i.e. it allows to specify that
the given vecs refer to physical addresses.
* The file cache's read_into_cache() reads directly into physical
pages, now.
* Fixed bug in DoIO::IO(): The offset was not adjusted, so that all
pages were incorrectly transferred from/to the same location.
* Fixed broken subrequest scheduling loop head in
do_iterative_fd_io_iterate().
* Adjusted the test driver and implemented its io() hook. Using this
driver I/O requests are passed all the way from the VFS/VM to the
driver and through the I/O scheduler. It even seems to work. :-)
* Added missing const to the iovec* parameter of the IORequest::Init()
methods.
* Disabled some debug output by default. Added new optional debug
output.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26692 a95241bf-73f2-0310-859d-f6bbb57e9c96
is defined to 1; this allows asserting the read lock case, too.
* Added ASSERT_{READ|WRITE}_LOCKED_RW_LOCK() macros. The read assertion is only
working when KDEBUG_RW_LOCK_DEBUG is defined to 1, the write assertion works
always.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26686 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Added "syslog" command that dumps the contents of the syslog ring buffer into
KDL. Use the '-n' option to only show what hasn't been sent to the syslog
daemon yet.
* When entering the kernel debugger, the current thread ID and name are also
printed (not only the current CPU).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26684 a95241bf-73f2-0310-859d-f6bbb57e9c96
by myself:
* renamed xsi_do_undo() to xsi_sem_undo() (there is more to XSI than sems).
* Fixed coding style issues in sys/sem.h and xsi_sem.cpp.
* Added _kern_*() syscall prototypes to syscalls.h.
* Added a TODO in xsi_sem.cpp and xsi_semaphore.h about moving union semun to
a shared header.
* Made the team::xsi_sem_undo_requests int32 - due to padding, it would have
needed 4 bytes anyway; please always use specific types over int/short/long.
* xsi_sem_undo() now checks if it needs to do anything - the calls in team.cpp
no longer needs to do this.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26676 a95241bf-73f2-0310-859d-f6bbb57e9c96
don't check any longer whether the given number is the address of a
condition variable in the global hash table; we just assume it is a
valid condition variable pointer.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26674 a95241bf-73f2-0310-859d-f6bbb57e9c96
vnode (falling back to synchronous I/O if the io() is not supported).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26672 a95241bf-73f2-0310-859d-f6bbb57e9c96
to provide asynchrounous (or only synchronous, if asynchronous is not
supported) I/O request support. It will eventually replace
{read,write}_pages(). None of the FS implementations implement them
yet.
* Implemented some support functions for request-based I/O. File system
implementations can use do_fd_io() which passes an I/O request to the
layer responsible for a given FD, and do_iterative_fd_io(), which
translates a request for a file to subrequests for the underlying
device and passes them on. Both fall back to synchrounous processing
when the io() hook is not supported.
Furthermore added vfs_synchronous_io() which should be handy for the
devfs to perform io_requests synchronously for devices that don't
support the io() hook.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26655 a95241bf-73f2-0310-859d-f6bbb57e9c96
added an IORequest::Init() version with that parameter. This makes
splitting an iovec array into IOBuffers/IORequests easier.
* Added IORequest::CreateSubRequest(). It creates and adds an IORequest
that covers a part of the range of the parent request, but may use
another file offset. This will be used e.g. in the way that the parent
request describes an I/O operation for a file while its subrequests
describe the same operation translated to the underlying device.
* Added IORequest::DeleteSubRequests(), which does the obvious. It's
also invoked in the destructor.
* Added method for iterating through subrequests.
* Made IORequestChunk::{Set,Reset}Status() protected. For both
subclasses some locking is needed (though different locking), so we
rather make this more explicit.
* Added IORequest::SetStatusAndNotify(), which is SetStatus() +
NotifyFinished() with proper locking.
* Changed the I/O request finished and iteration callback signatures.
The finished callback has got an additional "status" argument, since
the request itself may already be inaccessible at the time the
callback is executed.
* Changed IORequest::NotifyFinished(). The policy is now that if the
iteration callback fails, the method will do the finished
notifications. This simplifies things in the iteration callbacks.
* Fixed bug in IORequest::_CopyPhysical(): It didn't take into account
that the physical buffer could not be page aligned.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26654 a95241bf-73f2-0310-859d-f6bbb57e9c96
an invalid page state was supplied. The comment was misleading too,
as the pages weren't reserved upfront.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26650 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Renamed sModifiedTemporaryPages to sModifiedNoSwapPages to better
express what this variable is about.
* Changed tracking of sModifiedNoSwapPages. It really counts
non-swappable pages only, now (if swap support is enabled).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26641 a95241bf-73f2-0310-859d-f6bbb57e9c96
buffer lives in userland can easily be checked via IS_USER_ADDRESS.
* Added B_VIP_IO_REQUEST flag which will be used by the page writer and
should cause allocations to be made in a way that they cannot fail.
Not implemented yet, though.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26632 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Split IORequest::ChunkFinished() into OperationFinished() and
and SubrequestFinished(). Moved the notification part into a new
method NotifyFinished().
* Added new IOScheduler thread for notifying finished requests.
IOScheduler::_Finisher() hands over finished request to it, unless the
requests don't have callbacks. We need the separate thread, since the
callbacks can potentially reenter the scheduler and thus cause
deadlocks.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26631 a95241bf-73f2-0310-859d-f6bbb57e9c96
versions of the AddressSpaceReadLocker constructor and SetTo(). When
true it will get a new reference to the address space.
* Changed vm_soft_fault(): Now it gets the address space as a
parameter (for page faults getting it happens in vm_page_fault()).
This should fix lock_memory_etc() for other teams -- it used the
correct address space before, but the invoked vm_soft_fault() always
used the current team's address space.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26628 a95241bf-73f2-0310-859d-f6bbb57e9c96
- add 040 cpu and mmu stuff
- use leftover from the page root table to put interrupt vector table to set VBR to
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26627 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Init swap support in main().
* Added "bool swappable" parameter to
VMCacheFactory::CreateAnonymousCache(). A cache supporting swapping
is created when true. Adjusted invocations accordingly.
* The page writer does now write non-locked swappable pages (when
memory is low).
* Fixed header guard of VMAnonymousNoSwapCache.h.
* Swap support is compiled conditionally, controlled by the
ENABLE_SWAP_SUPPORT in src/system/kernel/vm/VMAnonymousCache.h. It is
disabled ATM. Since no swap files are added, it wouldn't have much
effect anyway.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26625 a95241bf-73f2-0310-859d-f6bbb57e9c96
swappable, since that happens before we can initialize swap support
(which requires the later initialized VFS).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26623 a95241bf-73f2-0310-859d-f6bbb57e9c96
the new team. Otherwise it would lose it's properties (full lock,
B_KERNEL_AREA).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26622 a95241bf-73f2-0310-859d-f6bbb57e9c96
happens in the I/O scheduler thread, we need to use unlock_memory_etc().
Changed the IOBuffer::{Lock,Unlock}Memory() methods accordingly.
The test driver seems to be working stable, now.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26609 a95241bf-73f2-0310-859d-f6bbb57e9c96
completed operations queue. That doesn't need to happen synchronously
either. So we have to restart the loop.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26607 a95241bf-73f2-0310-859d-f6bbb57e9c96
the scheduler thread doing that has no direct access to the
destination team's address space.
* Improved some debug output.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26601 a95241bf-73f2-0310-859d-f6bbb57e9c96
get_memory_map(), but has a saner semantics and allows specifying a
team.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26600 a95241bf-73f2-0310-859d-f6bbb57e9c96
- rewrote early_query() to use the TT0 mapping to remove the page_hole stuff.
- fixed natfeat, using a page set up from the bootloader for now as it wants physical address. At least it's enough to see from the debugger:
load kernel...
kernel entry at 8003711a
Welcome to kernel debugger output!
Haiku revision: 26582
PANIC: unknown cpu_type 68040
Welcome to Kernel Debugging Land...
Running on CPU 0
kdebug>
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26599 a95241bf-73f2-0310-859d-f6bbb57e9c96
using a lock and I'm not very much in favor of a global one.
* Added "finished" callback to IORequest.
* IOOperation::Finish() no longer invokes its parent request's
ChunkFinished(). The finisher does this instead. ChunkFinished()
can optionally remove the chunk from the parent.
* Added IORequest::Wait() which waits for the completion of the request.
* Introduced IORequestChunk::ResetStatus() to make setting the status to
"pending" somewhat more explicit.
* Implemented the missing IOScheduler::SetCallback() methods.
* The NotifyAll() calls on the IOScheduler's condition variables were
missing, so it just waited forever.
* Added some more debug output.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26597 a95241bf-73f2-0310-859d-f6bbb57e9c96
thread. Interrupting a thread only works when it is already waiting.
We do now use a flag to indicate whether the scheduler thread is
waiting (avoids thread_interrupt() calls when the thread is in driver
code). Furthermore before starting to wait, we check whether any
finisher work has to be done -- we do that (and the addition of the
entry to the condition variable) with the finisher lock being held to
avoid the race condition.
* Moved waiting for and getting the next unscheduled request into new
method _GetNextUnscheduledRequest().
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26594 a95241bf-73f2-0310-859d-f6bbb57e9c96
* As this was the last user of the READ_COUNT/WRITE_COUNT definitions in
vm_priv.h, I removed those as well.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26582 a95241bf-73f2-0310-859d-f6bbb57e9c96
It does its job by using part of libsupc++, with fake malloc and friends to make sure it won't double fault.
Works here, but cp-demangle must be extracted by hand from the lib, can't get the rule to work as I want, Ingo ?
Maybe using it directly without malloc hack would be ok with 16KB buffer, but I'm not sure of that.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26581 a95241bf-73f2-0310-859d-f6bbb57e9c96
fs_vnode_ops::write_pages() to be called with fsReenter = true. Since
this is no longer the case, the argument has become superfluous. For
read_pages() it always was. Removed the argument from the functions
and all functions that propagated it.
* Some whitespace at the end of lines was removed.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26579 a95241bf-73f2-0310-859d-f6bbb57e9c96
introduces the following relevant changes:
* VMCache:
- Renamed vm_cache to VMCache, merged it with vm_store and made it a
C++ class with virtual methods (replacing the store operations).
Turned the different store implementations into subclasses.
- Introduced MergeStore() callback, changed semantics of Commit().
- Changed locking and referencing semantics. A reference can only be
acquired/released with the cache locked. An unreferenced cache is
deleted and a mergeable cache merged when it is unlocked. This
removes the "busy" state of a cache and simplifies the page fault
code.
* Added VMAnonymousCache, which will implement swap support (work by
Zhao Shuai). It is not integrated and used yet, though.
* Enabled the mutex/recursive lock holder asserts.
* Fixed DoublyLinkedList::Swap().
* Generalized the low memory handler to a low resource handler. And made
semaphores and reserved memory handled resources. Made
vm_try_resource_memory() optionally wait (with timeout), and used that
feature to reserve memory for areas.
...
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26572 a95241bf-73f2-0310-859d-f6bbb57e9c96
