* driver_entry::api_version now stores the actual version instead of a
pointer to it.
* Renamed node_path_entry to path_entry and reused it for driver
reloading: handle_driver_events() will now also check for drivers to
add in the sDriversToAdd list.
* Added new devfs_driver_added(), and devfs_driver_removed() functions
that trigger certain driver actions.
* Implemented notifying devfs on B_ENTRY_CREATED, B_ENTRY_REMOVED, and
B_ENTRY_MOVED events in probe.cpp. The watched directory inode numbers
are now stored in a hash for B_ENTRY_MOVED.
* unpublish_driver() did not actually delete the node, it only marked
it removable since we never get/put the node. We now do, and so the
node is actually removed as intended.
* Added "devfs_driver" KDL command.
* Minor cleanup.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24152 a95241bf-73f2-0310-859d-f6bbb57e9c96
and made it public (within the kernel).
* _user_entry_ref_to_path() is now using that function.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24151 a95241bf-73f2-0310-859d-f6bbb57e9c96
vector are unhandled, it is disabled if it is not a shared interrupt vector
(as before). Otherwise a message is printed to indicate the condition. I
reduced the amount of interrupts to 10000, as with 100000 it would take over
half an hour on my machine to trigger. Feel free to adjust.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24146 a95241bf-73f2-0310-859d-f6bbb57e9c96
* load_driver() now uses republish_driver() instead of publishing all
devices every time. This allows published nodes to remain stable, no
matter if the driver has been unloaded in the mean time or not.
* Offloaded driver reloading to a kernel daemon. Since this is regarded
to happen rarely, a simple event variable will be set when something
happened, and the daemon will then check all known drivers.
* devfs_open() will now check if the driver has to be reloaded, and will
do so before opening the device.
* Moved republish_driver() around again.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24141 a95241bf-73f2-0310-859d-f6bbb57e9c96
{get|put}_node() is not really what we want either; moved the maintenance
into the open() and free_cookie() hooks.
* This should fix driver reloading on change for drivers that have been used
before.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24135 a95241bf-73f2-0310-859d-f6bbb57e9c96
unhandled. Otherwise it brings more trouble than it solves as it also disables
the interrupt of other devices (most often USB or network).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24120 a95241bf-73f2-0310-859d-f6bbb57e9c96
NodeMonitor.h.
* The latter will be set in "statFields" for interim updates when you have
asked to get them via the former.
* BFS now uses the B_STAT_INTERIM_UPDATE flag for sending updates to actively
written files.
* This makes us more compatible with BeOS again; if you only asked for
B_WATCH_STAT, you will now only receive a notification if the file in
question has been closed.
* Tracker now uses B_WATCH_INTERIM_STAT to always get all updates (ie.
downloading a file will update its size and modification time in Tracker
periodically during the download).
* Wether "needsTrimming" was true or not has no influence on wether or not
the size index needs to be updated in BFS - only the actual file size is
stored there, not the on-disk size.
* Added a TODO comment in Inode::WriteAt() that it would actually need to
update the size index when changing the file size, not when the file has
been closed (but that's probably too slow).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24114 a95241bf-73f2-0310-859d-f6bbb57e9c96
need to make sure that we never get that far with a negative timeout or
we'll wait forever.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24083 a95241bf-73f2-0310-859d-f6bbb57e9c96
timeout, not just -1. Paranoia only, since that should happen anyway.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24082 a95241bf-73f2-0310-859d-f6bbb57e9c96
interrupted early, i.e. when signals were already pending when we
started waiting. Fixes#1832.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24063 a95241bf-73f2-0310-859d-f6bbb57e9c96
utilizes the THREAD_FLAG_DONT_RESTART_SYSCALL (but only in SIGCONT
for now).
* resume_thread() is now using that flag to be compatible with BeOS.
* This fixes the Terminal hanging on close.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24045 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Added team::flags. Currently only used for setting a flag when a team
has exec()ed.
* Some improvements of _user_setpgid():
- It failed incorrectly when the target process was a process group
leader. According to the standard it shall fail when the process is
a session leader. Moving a process group leader to another process
group is fine, even if that leaves the group leaderless.
- Fixed race conditions. We need to recheck the error conditions when
we hold the team spinlock. Otherwise the situation could change
while we allocated the new process group. This was one of the
reasons for bug #1799 -- after the shell fork()'s both parent and
child invoke setpgid() for the child.
- Fixed behavior for pid == pgid. It doesn't necessarily mean that a
new group has to be created.
- Fixed update of target process group orphaned state.
- Squashed TODO: setpgid() on a child is supposed to fail after the
child has exec()ed.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24041 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Right now, only already known loaded drivers will be monitored for changes;
their devices aren't republished, though, since that would cause a deadlock
in the node notification mechanism (listeners are called synchronously);
need to offload that the event handling to another thread.
* On changes of (known) driver directories, the device manager will now print
some info to the syslog.
* Fixed republish_driver() I broke recently (would skip every other node), and
moved it to the driver functions section of the devfs.cpp.
* Implemented currently unused unpublish_driver() function that would have to
be called before reloading a driver.
* If a driver is in use when it's updated, we mark it, but we don't do anything
with that info when we could.
* Minor cleanup.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24036 a95241bf-73f2-0310-859d-f6bbb57e9c96
* our flock::l_len was inclusive, while it's exclusive (the last byte locked
is (l_start - 1 + l_len) not just (l_start + l_len).
* F_UNLCK removes all locks of the calling process that are within the specified
region - existing locks might also cut or divided.
* Apparently, a single team can lock the same region as often as it wants.
* advisory_locking is now using a DoublyLinkedList instead of its C counterpart.
* advisory_lock now has start + end fields, instead of offset + len, it's
handier this way.
* This fixes bug #1791.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24020 a95241bf-73f2-0310-859d-f6bbb57e9c96
name of the drivers.
* Allow driver::publish_devices() to return NULL to hint that it has no devices
to publish anymore (ie. existing devices will be unpublished in this case).
* republish_driver() now also calls load_driver() in case the driver is not
loaded.
* publish_device() and unpublish_node() now maintain the new
driver_entry::devices_published field, so we always know how many devices
a driver has now.
* Minor cleanup.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24016 a95241bf-73f2-0310-859d-f6bbb57e9c96
size of a reallocated block. If you had kernel heap leak checking on, this
could have caused the first four bytes of the next block to be overwritten
with the size of the reallocation of the previous block.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24011 a95241bf-73f2-0310-859d-f6bbb57e9c96
allocated on the stack, condition variable related structures would be
trashed, causing all kinds of problems. Fixes#1811 and #1812.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24009 a95241bf-73f2-0310-859d-f6bbb57e9c96
This eliminates the edge case where the grow thread would not be able to create
a new area because no memory could be allocated for the allocation of the area.
As this case cannot happen anymore, it is also not possible to deadlock in
memalign. Therefore the timeout (which would only have prevented the deadlock
but wouldn't have solved the edge case anyway) has been removed too.
Add options to dump the dedicated grow heap and to only print the current heap
count to the "heap" debugger command.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23994 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Implemented automatic syscall restarts:
- A syscall can indicate that it has been interrupted and can be
restarted by setting a respective bit in thread::flags. It can
store parameters it wants to be preserved for the restart in
thread::syscall_restart::parameters. Another thread::flags bit
indicates whether it has been restarted.
- handle_signals() clears the restart flag, if the handled signal
has a handler function installed and SA_RESTART is not set. Another
thread flag (THREAD_FLAGS_DONT_RESTART_SYSCALL) can prevent syscalls
from being restarted, even if they could be (not used yet, but we
might want to use it in resume_thread(), so that we stay
behaviorally compatible with BeOS).
- The architecture specific syscall handler restarts the syscall, if
the restart flag is set. Implemented for x86 only.
- Added some support functions in the private <syscall_restart.h> to
simplify the syscall restart code in the syscalls.
- Adjusted all syscalls that can potentially be restarted accordingly.
- _user_ioctl() sets new thread flag THREAD_FLAGS_IOCTL_SYSCALL while
calling the underlying FS's/driver's hook, so that syscall restarts
can also be supported there.
* thread_at_kernel_exit() invokes handle_signals() in a loop now, as
long as the latter indicates that the thread shall be suspended, so
that after waking up signals received in the meantime will be handled
before the thread returns to userland. Adjusted handle_signals()
accordingly -- when encountering a suspending signal we don't check
for further signals.
* Fixed sigsuspend(): Suspending the thread and rescheduling doesn't
result in the correct behavior. Instead we employ a temporary
condition variable and interruptably wait on it. The POSIX test
suite test passes, now.
* Made the switch_sem[_etc]() behavior on interruption consistent.
Depending on when the signal arrived (before the call or when already
waiting) the first semaphore would or wouldn't be released. Now we
consistently release it.
* Refactored _user_{read,write}[v]() syscalls. Use a common function for
either pair. The iovec version doesn't fail anymore, if anything could
be read/written at all. It also checks whether a complete vector
could be read/written, so that we won't skip data, if the underlying
FS/driver couldn't read/write more ATM.
* Some refactoring in the x86 syscall handler: The int 99 and sysenter
handlers use a common subroutine to avoid code duplication.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23983 a95241bf-73f2-0310-859d-f6bbb57e9c96
Before starting to wait on a condition variable check for pending
signals first, if the call is interruptable.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23980 a95241bf-73f2-0310-859d-f6bbb57e9c96
The return value of Inode::WaitForRequest() is status_t not bool. So the
method would always fail when it actually succeeded. This affected reads
from pipes which didn't have data. The bug was hidded since VFS code
mostly checks error codes only against < B_OK, so that such a read would
be treated as 0 byte read.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23976 a95241bf-73f2-0310-859d-f6bbb57e9c96
total count of allocations and bytes.
* Also add a few more bin sizes (for 8, 24 and 48 bytes) turns out especially
allocations of 20-24 bytes are pretty common. And as it only wastes a few
bytes per page this doesn't hurt at all.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23961 a95241bf-73f2-0310-859d-f6bbb57e9c96
heap leak check info would otherwise be overwritten for allocations that still
fit the 16 byte bin (i.e. allocations of 0-4 bytes).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23956 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Tracing of allocations, reallocations and frees
* Leak checking infrastructure to dump allocations
The leak checking code records the team and thread id when an allocation is
made as well as stores the originally requested size. It also adds the
"allocations" debugger command that can dump all current allocations (usually
a huge list) or filter by either a team or thread id. This way it's easily
possible to find leftover allocations of no more active teams/threads.
Combined with the tracing support one might be able to track down the time and
reason of an allocation and possibly find the corresponding leak if it is one.
Note that kernel heap leak checking has to be enabled manually by setting the
KERNEL_HEAP_LEAK_CHECK define to 1.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23953 a95241bf-73f2-0310-859d-f6bbb57e9c96
and pages are now kept in lists as well. This allows to return free pages once
a bin does not need them anymore. Partially filled pages are kept in a sorted
linked list so that allocation will always happen on the fullest page - this
favours having full pages and makes it more likely lightly used pages will get
completely empty so they can be returned. Generally this now goes more in the
direction of a slab allocator.
The allocation logic has been extracted, so a heap is now simply attachable to
a region of memory. This allows for multiple heaps and for dynamic growing. In
case the allocator runs out of free pages, an asynchronous growing thread is
notified to create a new area and attach a new heap to it.
By default the kernel heap is now set to 16MB and grows by 8MB each time all
heaps run full.
This should solve quite a few issues, like certain bins just claiming all pages
so that even if there is free space nothing can be allocated. Also it obviously
does aways with filling the heap page by page until it overgrows.
I think this is now a well performing and scalable allocator we can live with
for quite some time. It is well tested under emulation and real hardware and
performs as expected. If problems come up there is an extensive sanity checker
that can be enabled by PARANOID_VALIDATION that covers most aspects of the
allocator. For normal operation this is not necessary though and is therefore
disabled by default.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23939 a95241bf-73f2-0310-859d-f6bbb57e9c96
not use a single static variable to synchronize CPUs at two points. In an
environment where CPUs do not really run concurently (in emulation or with
logical processors) it would be possible for CPUs to get trapped in the first
synchronization while another CPU might just do its thing and change the
sync variable again. These CPUs would then never leave the first loop as the
exit condition has already passed again. The key is to use two different sync
variables like it is done in early kernel initialization. As I didn't manage
to trigger this code though I am not sure if this is gonna work.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23926 a95241bf-73f2-0310-859d-f6bbb57e9c96
using the int 99 syscall method. Otherwise it would remain set e.g.
after _kern_restore_signal_frame() and the next syscall would look like
one returning a 64 bit value.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23918 a95241bf-73f2-0310-859d-f6bbb57e9c96
function has the old behavior. When false, it just calls the scheduler
without any priority adjustment or other stuff.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23906 a95241bf-73f2-0310-859d-f6bbb57e9c96
Not sure if this is the right place, Ingo might want to review that one.
* This fixes unmounting sessions of a multi-session CD, ie. the BeOS CD (it currently panics
when trying to access a device that's not there anymore - for debugging only, of course :-)
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23894 a95241bf-73f2-0310-859d-f6bbb57e9c96
already knows this driver.
* This should also allow to have a driver in home/config/add-ons/... overlays
a driver with the same name in system/add-ons/...
* This should also fix bug #1750.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23892 a95241bf-73f2-0310-859d-f6bbb57e9c96
This is not safe when already freed memory is overwritten. But since we also
store the next pointer of the freelist in there, overwriting would break the
freelist and cause a crash in that case. This gives a drastic performance
boost when freelists grow during use and especially when opening and closing
a lot of programs.
* Optimize filling the freed element with 0xdeadbeef by writing 4 bytes at a
time instead of using single byte writes. Works as all our bins have an
element size that is a multiple of four. Put a panic in there just in case
this assumption isn't met for some reason.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23879 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Stumbled upon a possible bug while trying to understand the reuse of large
allocations. The "first" variable was always set to the current index at the
end of the loop, even if it was already set. This should have caused that
the success condition to never be reached.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23866 a95241bf-73f2-0310-859d-f6bbb57e9c96
TraceOutput for output options instead.
* Added "traced" option --difftime. Instead of the absolute system time
it prints the difference time to the previously printed entry.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23864 a95241bf-73f2-0310-859d-f6bbb57e9c96
When specified it desigantes that the interrupt handler should not lock the
vector with a spinlock when executing the installed interrupt handlers. This
is necessary to allow the same interrupt vector to be handled in parallel on
different CPUs. And it is required for the CPU halt to work synchronously when
there is more than one AP CPU. Though the acquire_spinlock() should cause IPIs
to be processed, only this fixed the SMP_MSG_FLAG_SYNC problem for me.
Not locking is safe as long as it is guaranteed that no interrupt handler is
registered or removed while the interrupt handler is running. We can guarantee
this for the SMP interrupt handlers we install in arch_smp_init() as they are
never uninstalled. Probably this flag should be made private though.
Restored the SMP_MSG_FLAG_SYNC when entering the kernel debugger.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23838 a95241bf-73f2-0310-859d-f6bbb57e9c96
(must also compare to BSD; I've looked at their sources, but I might have
missed something).
* Added sys/file.h and the flock() system call.
* common_fcntl() could forget to put back the file descriptor on some error
conditions (I guess we should introduce and use a DescriptorGetter class).
* Cleaned up fcntl.h, moved the BSD extensions S_IREAD and S_IWRITE to
sys/stat.h where they belong, and added the missing S_IEXEC to them.
* Added some more comments.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23836 a95241bf-73f2-0310-859d-f6bbb57e9c96
file position in case an offset was specified.
* Reverted r23828-r23830 in File.cpp: don't fix the symptoms but the cause
of the problem (hey, that has to be in the kernel, right? :))
* Cleanup of File.cpp, removed OpenBeOS namespace.
* Moved user_fd_kernel_ioctl() to the section where it belongs to (that
function should be renamed, though).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23832 a95241bf-73f2-0310-859d-f6bbb57e9c96
to fix bug #1731.
* However, it turns out that depot destruction obviously doesn't work
correctly, at least we keep partial or full slabs around when we're
using them (which causes the code to panic).
* Therefore, I've now disabled depots completely, until I find the time
to really work on that code.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23825 a95241bf-73f2-0310-859d-f6bbb57e9c96
* While this is not a really good idea for a lock with supposedly little
contention, but it'll fix bug #1731. I haven't tested it yet, but will
do so in a minute :-)
* I will need to rework the slab anyway so that it's possible to use it
as a replacement for our heap, and then I'll switch back to a benaphore
again.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23822 a95241bf-73f2-0310-859d-f6bbb57e9c96
_kern_ktrace_output() syscall, since it will be stored in a separate
entry anyway.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23807 a95241bf-73f2-0310-859d-f6bbb57e9c96
* The kernel now opens up to 8 debugger modules (and puts them into an array;
maybe we'll want to switch to a doubly linked list when there is the need).
* Implemented an example debugger module that prints a stack trace of the
current thread when the kernel debugger is entered (not included in the
image).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23794 a95241bf-73f2-0310-859d-f6bbb57e9c96
was a race condition when more than one CPU would enter the debugger at the
same time (or rather before one CPU could stop all the others). We now use the
inDebugger variable to tell if someone is already in the debugger and then
only process inter CPU messages and retry entering the debugger.
Since sending the synchronous broadcast most of the time hung over here with
SMP enabled I removed the synchronous flag and added a simple spin to give the
other CPUs a chance to process the halt request. Added comments that explain
the reasons and a ToDo to revert to synchronous delivery once we fixed the
problem. The kernel debugger is now usable on my quad core.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23751 a95241bf-73f2-0310-859d-f6bbb57e9c96
systems it can easily happen that the thread gets removed from the queue (when
it times out for example) during the time we don't hold the sem lock.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23749 a95241bf-73f2-0310-859d-f6bbb57e9c96
at the end of that loop we guaranteed a crash when this special handling was
triggered.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23748 a95241bf-73f2-0310-859d-f6bbb57e9c96
"teams".
* "team" without arg prints info about the current team.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23746 a95241bf-73f2-0310-859d-f6bbb57e9c96
path. Makes the "teams" output prettier and "team <name>" becomes
usable.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23745 a95241bf-73f2-0310-859d-f6bbb57e9c96
This should be in line with all uses of scheduler_enqueue_in_run_queue() and
simplifies a few places where it is used.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23738 a95241bf-73f2-0310-859d-f6bbb57e9c96
enqueued into the run_queue again. Modified the workaround to a panic in the
scheduler so we notice when something else does the same.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23731 a95241bf-73f2-0310-859d-f6bbb57e9c96
A thread that just missed a semaphore and put itself into the sems notify
queue could be enqueued into the run queue by release_sem_etc() of another
CPU before the CPU running the thread had a chance to reschedule it. Therefore
there is a timeframe where a thread can be running on one CPU and already be
in the run queue again. In this case no other CPU may schedule this thread
because then it would overwrite the threads' CPU pointer which kills the rest
of the scheduler logic, smp_get_current_cpu() and everything that depends on
that (like the kernel debugger). The more CPUs you have the easier this could
happen, up to the point where it was always triggered during boot on my quad
core system. The system would freeze and you could not enter the kernel
debugger, because two CPUs thought they were the same and disabled each other
through SMP communication. This makes booting my system stable and might fix
the occasional hang on boot for other SMP systems with only 2 CPUs/cores.
I've put a ToDo comment that details this above the workaround. Maybe we
should fix this in another way. Reviews, comments and suggestions welcome ;-)
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23721 a95241bf-73f2-0310-859d-f6bbb57e9c96
the command would overwrite its own output, not always on the bottom of the
screen.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23699 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Added block_writer thread that continuously writes back blocks for all current
block caches.
* A block cache now maintains the number of dirty blocks if it doesn't use
transactions. That knowledge could also be used in block_cache_sync()...
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23698 a95241bf-73f2-0310-859d-f6bbb57e9c96
For commands with this flag set, the parser won't parse the
arguments provided (it will only check for matching parentheses and
brackets), but will pass the unparsed argument list string to the
command instead.
* Set the new flag for the "expr" command, so one doesn't have to quote
the expression to evaluate anymore (or put it in parentheses).
* Fixed tokenizing of quoted and unquoted strings in expression mode.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23697 a95241bf-73f2-0310-859d-f6bbb57e9c96
* This should speed up writing a transaction considerably.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23694 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Removed the public hash_grow() function again (at least for now, it's only
private).
* Removed the newSize argument from hash_grow(); it will compute the new size
automatically.
* The block cache is now using hash_insert_grow() instead of hash_insert()
which should make hash lookups much faster with some 10 thousand blocks,
also increased the initial table size from 32 to 1024...
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23692 a95241bf-73f2-0310-859d-f6bbb57e9c96
printing the last 30 entries, it continues the last iteration, thus
making the more common use case more comfortable. The old functionality
is still available via "traced 0".
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23689 a95241bf-73f2-0310-859d-f6bbb57e9c96
kSyscallParametersInfos to kExtendedSyscallInfos) and added "name"
field. Now the classes for syscall kernel tracing don't need to lookup
the syscall function symbol anymore, which speeds up printing/filtering
of those entries dramatically.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23687 a95241bf-73f2-0310-859d-f6bbb57e9c96
is recorded in a kernel trace entry (if tracing is enabled).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23686 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Added "printteam" switch to "traced" command, enabling the printing of
the team ID.
* Added "team" filter to the "traced" command expression language.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23684 a95241bf-73f2-0310-859d-f6bbb57e9c96
comfortable number. Somewhat more complex "traced" filter expressions
tended to exceed the old limit easily.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23683 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Made the iterator static, so that it's possible to move from the
iteration position of the previous invocation to the current start,
instead of always having to start from the beginning or the end.
* Filtered backward iteration:
- Restrict the range to dump to the entries between the first and the
last filter match.
- Use new FILTER_MATCH entry flag to avoid applying the filter a
second time in the print loop.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23681 a95241bf-73f2-0310-859d-f6bbb57e9c96
vm_cache_write_modified() here anymore since quite some time, it actually
doesn't make any sense to call the file system's "fsync" method here.
This should make syncing all file systems much faster when many vnodes are
in use.
* If a file system doesn't use the file cache, it can still just sync everything
it needs to in its "sync" method.
* Added a TODO item on how to improve sync speed further, if necessary.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23679 a95241bf-73f2-0310-859d-f6bbb57e9c96
write code aligned to what one has written in the comment (or the
other way around).
* Made trace_entry structure doubly linked, by introducing a
previous_size member. By using bit fields, shrinking the flags field
to 4 bits, and not saving the lower two bits of size and previous_size
(which are always 0 due to alignment), the structure remains 4 byte
sized and can still address the same entry size.
* kBufferSize is no longer one less than it could be.
* "traced" command:
- Use static variable for the iteration state rather then cluttering
the temporary debug variable name space.
- The <count> parameter can now be negative, in which case the entries
before (and including) <start> are printed.
- Added a new optional parameter, specifying the maximal number of
entries to be filtered. Filtered iteration is beautifully
comfortable now.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23678 a95241bf-73f2-0310-859d-f6bbb57e9c96
command usage texts, which can be too long for kprintf().
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23677 a95241bf-73f2-0310-859d-f6bbb57e9c96
We use an indirect page descriptor instead of pointing the page to itself like on x86.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23668 a95241bf-73f2-0310-859d-f6bbb57e9c96
disabled in most cases.
* Wrapping in make_space() was broken. When wrapping the second time or
later, sFirstEntry would already be greater than sAfterLastEntry and
resetting sAfterLastEntry to the beginning of the buffer would
erroneously "free" all entries between the buffer start and the
original sAfterLastEntry. If the tracing buffer was small enough,
the odds were that a not yet fully initialized entry would already
be re-allocated, causing all kinds of weird behavior.
* When an entry that is not yet fully initialized needs to be
freed, we let the allocation causing the freeing fail. We can't wait
for the entry, since we've interrupts disabled and since the entry
initialization might even try to allocate more (buffer) entries.
* make_space() is now safe to be called in any situation, and
allocate_entry() will do that, which simplifies things there and
avoids a few duplicate checks.
* Moved maximum allocation size check from alloc_tracing_buffer() to
allocate_entry(). Just in case... :-)
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23662 a95241bf-73f2-0310-859d-f6bbb57e9c96
boolean operators ("not", "and", "or") and filters matching thread IDs
or contained strings.
I'm still not fully happy with the command. It should be possible to
define a filter and then comfortably scroll through the matching
entries. Currently having to specify an index range of the unfiltered
entries is rather unhandy in combination with filtering.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23658 a95241bf-73f2-0310-859d-f6bbb57e9c96
So now there's a central place to enable tracing in general and for
individual components.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23645 a95241bf-73f2-0310-859d-f6bbb57e9c96
"block_cache" to dump info about transactions.
* Improved tracing.
* Now uses the new add_debugger_command_etc().
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23644 a95241bf-73f2-0310-859d-f6bbb57e9c96
used it for an hour or so, I really wonder how we could live without it.
:-)
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23640 a95241bf-73f2-0310-859d-f6bbb57e9c96
incorrectly recognized as iframe. Fixes the read fault when doing "sc"
for a kernel thread.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23628 a95241bf-73f2-0310-859d-f6bbb57e9c96
its parent while still holding the team spinlock. We were racing with
wait_for_child(), since after the child invoked
team_set_job_control_state(), the parent thread could continue as soon
as the team spinlock was released. The SIGCHLD could thus arrive way
later and interrupt another syscall. This could be reproduced with the
compile_bench.sh script from time to time: When interrupted while
waiting for the next subprocess, the gcc frontend would delete a still
needed temporary file.
The whole thing is actually only a problem, because we don't support
automatic syscall restarts yet.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23625 a95241bf-73f2-0310-859d-f6bbb57e9c96
parameters, now. We print 64 bit values correctly, and also fetch
strings from userland and print them.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23620 a95241bf-73f2-0310-859d-f6bbb57e9c96
checks it now.
* Check for NULL pointer in alloc_tracing_buffer_strcpy(), and also
determine the length of userland strings before allocating the buffer
(using user_strlcpy()).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23619 a95241bf-73f2-0310-859d-f6bbb57e9c96
with a 0 size to user_strlcpy() is OK. This way one can use it as a safe
strnlen().
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23617 a95241bf-73f2-0310-859d-f6bbb57e9c96
we use a uint16 size internally (and that has to include the length of
the trace_entry structure, too.
* We now track how many entries have been written to the log during the
runtime.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23613 a95241bf-73f2-0310-859d-f6bbb57e9c96
blocks into the new transaction, but it would set that transaction on all
blocks of the old transaction, too. Also, it did not correctly update the
num_blocks/sub_num_blocks fields of the old transaction. Even worse, it did
return B_OK instead of the ID of the new transaction...
* get_writable_cached_block() did not correctly maintain the number of blocks
in the sub transaction.
* write_cached_block() did not free the original_data of a block when it wrote
it back as part of a previous transaction.
* Changed "cookie" for cache_next_block_in_transaction() to "long", so it will
be 64 bits when needed.
* Improved the API for detaching sub transactions: you can now get the blocks
of only the main (parent) transaction as well, added new
cache_block_in_main_transaction() function.
* BFS now flushes the log when there is no space left for the current
transaction.
* _WriteTransactionToLog() allocated a "vecs" array, but never freed it.
* _WriteTransactionToLog() now also supports detaching the current sub
transaction if the whole thing is getting too large (it will now also panic
if that doesn't work out).
* Removed a useless optimization: making the blocks available in the cache
isn't really needed, as all blocks in a transaction are locked into the
cache, anyway.
* Implemented Transaction::WriteBlocks().
* Minor cleanup, removed some dead code, fixed warnings in the fs_shell's
block_cache when compiled with debug output on.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23610 a95241bf-73f2-0310-859d-f6bbb57e9c96
flag -- in fact we were setting it -- so after the first syscall with 64
bit return value we were always taking the slow kernel exit.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23609 a95241bf-73f2-0310-859d-f6bbb57e9c96
* "traced" command:
- Was printing one more entry than asked to.
- Fixed broken index handling. They were starting at 0, but the last
one was sEntries nevertheless. We consistently let them start at 1,
now. 0 can be passed as special index, causing the last entries to
be printed.
- Added options "backward"/"forward" which will print the entries
preceding respectively succeeding the ones printed on the previous
invocation. The command is continuable in this case, i.e. simply
pressing RET afterwards will reinvoke the command, allowing for
comfortable scrolling through a long list of entries.
- Added detailed usage message.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23607 a95241bf-73f2-0310-859d-f6bbb57e9c96
* With post syscall debugging enabled, the x86 syscall handling didn't
remove all parameters from the stack after calling the respective user
debugger hook. Should have been harmless though, since the following
code didn't rely on the stack being in order.
* Added syscall pre/post (kernel) tracing functions
trace_{pre,post}_syscall(). They are generic, but need to be invoked
by the architecture specific syscall code. Currently only done for
x86.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23600 a95241bf-73f2-0310-859d-f6bbb57e9c96
since that's seriously unhealthy.
* Added TODO that uninitialized entries must not be discarded.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23599 a95241bf-73f2-0310-859d-f6bbb57e9c96
invoke_debugger_command() is now automatically preceded by
"usage: <command name>", so the string passed to
add_debugger_command_etc() shouldn't contain it anymore.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23584 a95241bf-73f2-0310-859d-f6bbb57e9c96
before releasing our cache reference. Otherwise removing a vnode (triggered
by releasing the cache in our thread) could need pages we still own.
* Put the caches and pages into a union to save stack space; they are not
needed at the same time.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23580 a95241bf-73f2-0310-859d-f6bbb57e9c96
add_debugger_command(), but additionally takes parameters "usage"
and "flags".
* Added add_debugger_command_alias() which creates another name for an
existing command.
* Added print_debugger_command_usage() to print a command's usage.
* invoke_debugger_command() intercepts invocations with "--help" and
prints the command's usage text, if it is known. If unknown, the
command will be called normally.
* Made use of the new functions in debug.cpp.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23573 a95241bf-73f2-0310-859d-f6bbb57e9c96
a command is executed anymore. Instead the least recently used
temporary variable is overwritten, if there's no free slot for a new
temporary variable.
* Removed the special handling for the command result variable ("_"). It
just works like any other temporary variable, now.
* Individual temporary variables can be removed (e.g. using the "unset"
command).
* Added unset_all_debug_variables() and "unset_all" command to unset
all persistent and temporary variables.
* Removed remove_all_temporary_debug_variables and renamed
remove_debug_variable() to unset_debug_variable().
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23568 a95241bf-73f2-0310-859d-f6bbb57e9c96
(so we can't allocate more physical pages than virtual address space
anymore, but so what?).
* Used the new CACHE_LARGE_SLAB flag as a temporary work-around; else
the slab would easily create several thousands of areas, which our
area code (and kernel heap) can't really handle that well (gets
awfully slow).
* Block caches with the same size could share the same slab, but we
don't do that yet.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23567 a95241bf-73f2-0310-859d-f6bbb57e9c96
paging support to KDL (but not the on-screen debug output for now).
* Defaults to "on", use the new "paging" KDL command to turn it off (or on
again).
* When pressing 'q' while it is waiting for a key, it will now eat the rest
of the commands output (helpful for slow screen output of a large data set).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23566 a95241bf-73f2-0310-859d-f6bbb57e9c96
* Fixed the usage text of the "help" KDL command.
* Made the "ambiguous command" warning shorter, so that it will still fit in
the exception buffer.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23565 a95241bf-73f2-0310-859d-f6bbb57e9c96
* As a temporary work-around for the current slab allocator's area usage,
I added the CACHE_LARGE_SLAB flag, which will force the allocator to
use larger areas.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23564 a95241bf-73f2-0310-859d-f6bbb57e9c96
value greater or equal its size (actually untested, but at least Haiku
still boots with these changes :-)).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23563 a95241bf-73f2-0310-859d-f6bbb57e9c96
