kernel/fs: Refactor file_descriptor seek-disabled behavior.

* Default "pos" to "-1" instead of 0 and check for this value
instead of ops->fd_seek directly in IO operations.

* Set "pos" to "0" only for seekable vnodes.

* Return ESPIPE in read() and write() if the specified pos is not
-1, but the descriptor->pos is.

Fixes the VFS part of #18836.

Change-Id: Ib4da1652b06798588abedc98963aeb63511d3e41
Reviewed-on: https://review.haiku-os.org/c/haiku/+/7544
Reviewed-by: waddlesplash <waddlesplash@gmail.com>

kernel/vfs: Remove "count" parameter from first vnode_path_to_vnode variant.

All callers just set it to "0", and it's not clear
that it's actually useful outside vnode_path_to_vnode's
own usage of it, anyway.

Makes the two function variants more distinct and harder
to accidentally mix up.

kernel/vfs: Make vnode_path_to_vnode use VnodePutter internally.

Eliminates the "goto"s. Should not have any functional change.

kernel/vfs: Fix reference leaks in vnode_and_path_to_dir_vnode.

Fixes #18805.

kernel/vfs: Fix some potential edge cases around vnode creation.

Noticed as part of investigating #18805.

Change-Id: I158126979996f8527728d073ac2101f2f834bfb2

vfs: rename is a no-op when same path.

The old behavior was introduced by the commit f40c5e32115c22bd1b76ee1abe607040c09681a9 (05 Nov 2009),
while the new behavior is specified by POSIX: https://pubs.opengroup.org/onlinepubs/9699919799/functions/rename.html

The new behavior permits to rename an empty folder to itself without error, which was
encountered here: https://github.com/ocaml/ocaml/blob/trunk/testsuite/tests/lib-sys/rename.ml#L85

Fixes #18851.

Change-Id: Ie4e2999b695b8bb3ee69b1e3ae487323d8315d5e
Reviewed-on: https://review.haiku-os.org/c/haiku/+/7527
Reviewed-by: waddlesplash <waddlesplash@gmail.com>

vfs: log in syslog which inode is preventing an unmount

This may be somewhat helpful to investigate problems when unmounting
fails.

Change-Id: I72b70a34ca43697f22a13db6aff342abce38cd78
Reviewed-on: https://review.haiku-os.org/c/haiku/+/7501
Reviewed-by: nephele nephele <nep-git@packageloss.eu>
Tested-by: Commit checker robot <no-reply+buildbot@haiku-os.org>
Reviewed-by: Rene Gollent <rene@gollent.com>

kernel/fs: Add missing initialization.

kernel/vfs: create_vnode should also create non existing entries when traversing

Fixes #18355.

Change-Id: I96abb95c14a74bcf9fec802badeb16c978a3b3d1
Reviewed-on: https://review.haiku-os.org/c/haiku/+/6321
Reviewed-by: waddlesplash <waddlesplash@gmail.com>

kernel/fs: Make vnode_path_to_vnode and derived methods take VnodePutter&.

Upcoming changes will make this method return values in _vnode even
when they return error codes under some conditions. To avoid easily-
caused memory leaks, this commit refactors the output variable to
be VnodePutter&, and all consuming methods to thus make use of Putters.

Should not be a functional change.

Change-Id: Id7b9066f8cd50c159d52c921b16e475e4e1de806
Reviewed-on: https://review.haiku-os.org/c/haiku/+/7301
Reviewed-by: waddlesplash <waddlesplash@gmail.com>

kernel/vfs: Convert from custom VNodePutter to the generic VnodePutter.

The latter is actually an AutoDeleter based on CObjectDeleter.
No functional change intended.

kernel/fs: More usage of FileDescriptorDeleter.

Remaining non-uses are mostly in specialized functions that e.g. operate
on many file descriptors at once (like vfs_exec_io_context.)

Reduces "goto"s. Should not have any functional change.

kernel/fs: Standardize AutoDeleters for file_descriptor on FileDescriptorPutter.

No functional change intended.

vfs/preallocate: fix file descriptor leak

Fixes #18724.

Change-Id: I1a17a36106d13853888342a397ecd03087b1fdcf
Reviewed-on: https://review.haiku-os.org/c/haiku/+/7299
Reviewed-by: waddlesplash <waddlesplash@gmail.com>

kernel/vfs: Fix missing lock in fs_mount().

At least a read lock of the sVnodeLock must be held when calling
lookup_vnode, but we held none at all. This rectifies that problem.

This bug appears to have been around for many years, but no-one
noticed since ASSERT_READ_LOCKED_RW_LOCK only works with more
debug options turned on than the kernel is built with. I discovered
this while working on a new version of those additional options.

kernel & add-ons: Adjustments to use DoublyLinkedList::InsertBefore.

The Insert(before, element) function has been marked deprecated since
2010, but still had many usage and kept accumulating more. It's long
past time we got rid of all them and actually deprecated the function
itself.

Insert(before, element) just calls InsertBefore, so no functional change.

kernel/vfs: Remove read sizing hack in common_file_io_vec_pages.

All drivers using IORequest should have any problems here already caught
by it, and overruns in other drivers would overrun the buffer and cause
corruptions, so we should no longer silently be ignoring this,
presuming it is still a problem at all.

As the TODO comment indicated that this logic could also be used for
writes if this wasn't a problem, I have added a separate TODO for that.

kernel/vfs: Use new/delete for advisory_lock structures.

No functional change intended.

kernel/vfs: Validate that only one of O_RDWR or O_WRONLY is used, if any.

Otherwise we will have open modes that could have both and lead to
confusion in code that presumes only one will be set.

This catches the cause of some ported software (e.g. Wayland layer)
misbehaving with ramfs mounted in /var/shared_memory: the ramfs does not
properly handle both flags set, and due to another bug, they are for
shm_open'ed files.
(cherry picked from commit 9bc250e28d3bb4293c39a283807b67b6e82dda1d)

Change-Id: I9e98be89b6d4a2da90f74c048b4f762ca9cf8738
Reviewed-on: https://review.haiku-os.org/c/haiku/+/5852
Reviewed-by: waddlesplash <waddlesplash@gmail.com>

kernel/vfs: Fix locking behavior in acquire_vnode and add a missing ASSERT.

vnode deletion is prevent either by owning a reference to the node,
or by being at least a reader of the vnodes lock. Thus, in acquire_vnode,
we have to inc_ref_count while still holding the lock in order to prevent
a race.

This function is used so rarely and quite deep inside FS drivers that
I'm not sure this race would ever have been a problem. Nonetheless
the old code was incorrect.

kernel/vfs: Do not wait for removed vnodes to become unbusy.

Most of the time, that is harmless and will just cause a slight delay
before the vnode is removed and we return NULL instead of finding it.
However, in rare circumstances involving renames, we can wind up in
a deadlock with the thread that is trying to remove the vnode, and
would have to wait all the way to the timeout (a full ten seconds!).

The only vnodes not about to disappear from the table that can be both
"removed" and "busy" seem to be special vnodes like pipes, which will
be in an "unpublished" state while they are initially "busy" which we
can check for, in case something wants to wait for them.

The "dirconc" test readily triggered a pathological case of this behavior.
Before this commit, it ran for over 15 minutes before I killed it (and
it was not close to done at that point, either.) After this change,
it completes successfully in around 3 minutes or so on my test VM.

Thanks to mjg@freebsd.org for pointing out this testcase and its
misbehavior on Haiku!

Change-Id: Id1accf0aaf0724e1aec927a437d3a2ac1596cd98

kernel/fs: Check HAS_FS_CALL(..., open_dir) in open_dir_vnode.

All filesystems have open_dir calls in their vnode hooks,
but there are some vnode hooks that do not, like FIFOs.
Thus we need to check the hook actually exists.

Fixes #17870.

kernel/fs: Print the vnode or mount in question in FS_CALL panics.

May help to diagnose #17870.

kernel/vfs: lstat a symlinked dir with a trailing slash should traverse

golang's TestSymlinkWithTrailingSlash exhibits the bug.

Change-Id: I7e16bad9857e9be042fc215a587c861bc4eef716
Reviewed-on: https://review.haiku-os.org/c/haiku/+/5395
Reviewed-by: waddlesplash <waddlesplash@gmail.com>
Tested-by: Commit checker robot <no-reply+buildbot@haiku-os.org>

Revert "vfs: functions to change a vnode busy status and ID"

This reverts commit 8497a2cc289f6d991147995507e4efc0ae189147.

The VFS layer is not at all ready for this. Many places in the
code implicitly assume ino_t values will never change. This
functionality is only necessary for live shrinking of partitions,
which is a feature niche enough we do not need to worry about
implementing it in the first round of resizing (if ever.)

kernel/vfs: Fix mismatched frees of vnodes.

Regression from yesterday's commit. Fixes #17642.
Hopefully this is all of them.

kernel/vfs: Create an object_cache for vnodes.

In addition to being slightly more efficient, this also allows one
to see precisely how many vnodes are currently "alive" across all
mounts via the "slabs" KDL command.

kernel/vfs: Use correct select pointer type in allocation of IO context.

All pointers are the same size of course, so this is not a functional change.

Adjust all struct dirent creations (again), this time to use offsetof().

The dirent struct is not packed, so offsetof(dirent, d_name) != sizeof(dirent).
Thus in order not to waste the alignment bytes (which are significant,
on x86_64 at least, sizeof(dirent)==32, but offsetof(...)=26.)

This is also the most portable way to handle things, and should
work just fine in cross-platform code that has a non-zero-sized d_name.

kernel: Break thread-related AutoLockers into a separate header.

Including thread.h brings a massive array of things with it from
the kernel thread arch headers, team and thread definitions,
hash tables, linked lists, Referenceable, etc. that the vast majority
of AutoLock.h consumers neither want nor need.

So, put these in a separate header, and adjust all consumers of these
lockers to include the new file.

This change exposes the fact that a lot of files were inadvertently
making use of headers included indirectly through thread.h. Those
will be fixed in the next commit.

kernel: remove stray dprintf about acquire_advisory_lock

Change-Id: I306e2816e59a621a4c478babad5f3aa2cc69fc8d

POSIX: lseek: support SEEK_DATA and SEEK_HOLE constants

this is queued for issue 8: https://www.austingroupbugs.net/view.php?id=415
this implementation calls the ioctl hook of the filesystem with BSD-like constants
FIOSEEKDATA and FIOSEEKHOLE. if the hook doesn't know the constants, we use the stat size
to return the last hole (as proposed in the draft spec).

Change-Id: I5d052eed87e29b70491a7ff534e244896469d03e
Reviewed-on: https://review.haiku-os.org/c/haiku/+/3385
Reviewed-by: Jérôme Duval <jerome.duval@gmail.com>

POSIX: add posix_fallocate and a preallocate syscall

the preallocate syscall will call the preallocate filesystem hook, if available.

fix #6285

Change-Id: Ifff4595548610c8e009d4e5ffb64c37e0884e62d
Reviewed-on: https://review.haiku-os.org/c/haiku/+/3382
Reviewed-by: Jérôme Duval <jerome.duval@gmail.com>

kernel/vfs: Fix array size off by one in _user_open_query.

The BStackOrHeapArray was allocated with one byte less than user_strlcpy
would write to, corrupting random heap memory. The error was introduced
as part of hrev53864.

Fixes #16175.

Change-Id: I80e1a1bb104183545fbd2a2702cdf3dec089908d
Reviewed-on: https://review.haiku-os.org/c/haiku/+/2860
Reviewed-by: waddlesplash <waddlesplash@gmail.com>

kernel/vfs: follow up for hrev54107

_user_read_link: don't write after the buffer end, anytime the buffer is too
short. It should honor the user bufferSize, instead of using the link length.
normalize_path: null-terminates when bufferSize is lower than B_PATH_NAME_LENGTH.

Change-Id: If3892dc1ffc4aa7a79a333bbe607449ca409a7f0
Reviewed-on: https://review.haiku-os.org/c/haiku/+/2752
Reviewed-by: waddlesplash <waddlesplash@gmail.com>

kernel/vfs: Replace the mount mutex with a rw_lock.

Since the entry_cache operations go through the mount lock,
this may considerably speed up parallel entry cache operations.

Change-Id: Ib2f841e288eb593ee3f795922103459c77764c22
Reviewed-on: https://review.haiku-os.org/c/haiku/+/2362
Reviewed-by: waddlesplash <waddlesplash@gmail.com>

kernel/vfs: Add some missing initializations and BStackOrHeapArray.

Part of #14961.

kernel/fs: Add support for setting custom VMCaches in vnodes.

This adds one (private) VFS function, and checks in all usages of
the vnode->cache as a VMVnodeCache that it really is one. (Generic
usages, for the moment just the ReleaseRef() calls in vnode
destruction, are intentionally not touched.)

This will be used by ramfs to set the cache from its own,
so that map_file() calls on a ramfs can work.

kernel/fs: Free file descriptors via put_fd(), not free().

FDs are now object_cached, so this triggered an assert-failure panic
trying to put them through the regular allocator. Just use put_fd
to free these instead, so that there is only one "destruction" path
for FDs.

Fixes #15213.

kernel/fs: Fix copy/paste error.

kernel/fs: Use an object_cache for the file_descriptor structs.

file_descriptor structs were (following the original packagefs changes)
the 4th most allocated item during the boot, with 11903 instances.
These are of course all rather ephemeral, as after the boot finished
there were only 70-some-odd remaining (which is surprisingly low,
I though.)

During heavy system use, this will of course get hit much more often.
So making them object_cached for both performance and memory reasons
makes a lot of sense.

kernel/vfs: Unlock KPath buffers after copying them.

Otherwise we will call UnlockBuffer() when we potentially never
called LockBuffer().

Fixes #15157.

KPath: Use an object_cache for the path buffers in the normal case.

This was (following the packagefs changes) the number-one (by call
count) consumer of malloc() during the boot -- 52866 calls, and 100%
of them either 1024 or 1025 bytes!

Virtually all of these are ephemeral (indeed, the object_cache
stats after a boot with this patch shows there is only a single slab
of 64 buffers allocated, and most of them unused), so this is
probably a significant performance boost.

Change-Id: I659f5707510cbfeafa735d35eea7b92732ead666

vfs: fail only truncate on file descriptors opened read-only.

chmod is allowed.

Change-Id: Idcac38bdd7f0d614538421a41dfd30066a0c316f
Reviewed-on: https://review.haiku-os.org/c/1444
Reviewed-by: Adrien Destugues <pulkomandy@gmail.com>
Reviewed-by: Axel Dörfler <axeld@pinc-software.de>

kernel/fs/vfs: apply CLOEXEC on the new fd instead of the old one.

fix a failure for test-cloexec.c of gltests.

Change-Id: I340cc88a787a59d55f93cc80883f57e6627f38cf
Reviewed-on: https://review.haiku-os.org/c/1332
Reviewed-by: Adrien Destugues <pulkomandy@gmail.com>

kernel/fs: Make fs_mount::lock a mutex instead of a recursive_lock.

Solves a TODO.

kernel: fix mount arguments checks from userland

Since NULL is not considered a user address anymore, we must check for
it first.

This fixes the "mount: Bad address" error after hrev52905.

Change-Id: If60ea58bb81b6c35c6bf27ecfa9b29bd7a25d8aa

vfs: functions to change a vnode busy status and ID

The kernel version is only partially tested.

Change-Id: I9a2f6c78087154ab137eadbced99062a8a2dd688
Reviewed-on: https://review.haiku-os.org/c/918
Reviewed-by: waddlesplash <waddlesplash@gmail.com>

kernel/vfs: Fix shadowed variables.

The -Werror=uninitialized caught this, but I fixed it the wrong way
rather than looking at the code a little closer.

Should fix the strange bugs that cropped up after the first VFS patch.

kernel/vfs: Fix -Werror=maybe-uninitialized.

kernel/fs/vfs: add truncation check for user_strlcpy calls

**Lots** of syscalls here don't check if strlcpy truncated the user
supplied argument. This commit adds them where appropriate.

Closes #2642

Change-Id: Iff89055aeb3a1870c8baf327b60873ce85815cd7
Reviewed-on: https://review.haiku-os.org/c/890
Reviewed-by: waddlesplash <waddlesplash@gmail.com>

kernel/fs: Account for vnode being NULL in vfs_release_posix_lock.

When the FD is put() but not freed while O_DISCONNECTED, its "ops"
and "vnode" are cleared. Thus it is entirely valid for a non-NULL
file FD to have a NULL vnode, so we should just treat such FDs
as if the locks had already been cleared (which they should have.)

Fixes #14294.

kernel/fs: Consumers of context->fds[] must check O_DISCONNECTED.

Since these do not go through get_fd, which would check for them,
we need to do these checks manually in the relevant locations.

Some of these changes were broken out from axeld's original commit,
and some were found by my own auditing.

Revert "VFS: Slight rework of the FD disconnect feature."

This reverts commit eb62d3337b82f4dce6b1a0b3f116e38491c66f14.

vfs: fail write_stat() on file descriptors opened read-only.

Change-Id: I20d586c606c47df6625cc9272f153250a5a621d6
Reviewed-on: https://review.haiku-os.org/706
Reviewed-by: waddlesplash <waddlesplash@gmail.com>

kernel/fs: Flush the underlying device's write cache as part of sync().

BFS does this as part of journal management, but not as part of block
cache synchronization (which makes sense, as flushing it then would
defeat the purpose of the drive's write cache.) No other file system
seems to touch it at all, so we should do it as part of an explicit sync.

This may help with some of the filesystem corruption issues, as it seems
that on slow disks, the drive might not have enough time to flush the cache
before it is powered off (or on some SATA/AHCI based disks, it is not flushed
before close at all), so triggering it here and, as the ioctl is supposed to be
synchronous, waiting for it also, seems to make sense.

Change-Id: I7d9992c21ca4b59c839711dcc96c973b4b8df052
Reviewed-on: https://review.haiku-os.org/530
Reviewed-by: Jérôme Duval <jerome.duval@gmail.com>
Reviewed-by: waddlesplash <waddlesplash@gmail.com>

vfs: panic() if volume->ops is NULL but status == B_OK.

This panic, unlike the NULL dereference that would otherwise occur, is
at least continuable.

vfs: Move volume->ops NULL check to just after call to mount().

As Rene pointed out on the mailing list, if this is NULL after the file system
mount call occurs, then something has gone very wrong and we should treat it
as an error.

vfs: Add missing NULL check of volume->ops.

I got a reproducible KDL that upon close inspection seems to have been
a NULL dereference of this, thanks to GCC's mix-source-and-assembly
functionality.

Unfortunately, I deleted my mount_server settings before I fully understood
what was going on, and afterwards it no longer reproduced, so it seems to
have been related to that. I'm confident enough this is the correct fix to
commit it anyway.

kernel: vfs: common_fcntl() now uses memcpy() for kernel calls.

instead of user_memcpy().

* fix #14204: the NTFS filesystem kernel addon uses the fcntl system call to
lock the underlying device. The user_memcpy replacement in the x86 compat
branch adds range checks for the user pointer, which exposes such problems.

Revert the rest of the COMPAT_MODE changes (back to hrev52003.)

This reverts commit 458e758f3792ef11ca26d6ff7e24600c88326e83.
This reverts commit ce5eb94a82b1b377ef5909e65411e031f54ceb15.
This reverts commit aac8d4c317ca11a9a6e194e2c668e8183ec23dd6.
This reverts commit c70cba914aa79c01bbc2da38085936f589899c8c.
This reverts commit 2ffbe7aaca8668c5a68ac7488459bace7a0700f2
This reverts commit c6e120e2d2f909d95f95839fa99fccf811fdb3c5.

kernel/x86_64: compatibility syscalls for vfs.cpp.

* define compat_flock, compat_timespec, compat_stat, compat_attr_info,
compat_fs_info, compat_fd_info to be used for respective 32-bit types
of syscalls in compatibility mode.
* handle 32-bit types in common_fcntl(), _user_read_stat(), _user_stat_attr(),
_user_read_index_stat, _user_read_fs_info, _user_write_fs_info,
_user_get_next_fd_info, other syscalls are compatible as is.

Change-Id: I5b372169fe142f67b81fd6c27e0627d5119ba687

vfs: Bind flock locks to file descriptors

* File locks created by flock should only apply for the file descriptor
that was used to lock the file. Another fd on the same file should then
be denied access (calling flock should fail).
* fcntl based locks, however, are in a separate namespace and are global
to a team.
* This issue was found when running webkitpy test suite, and should close
ticket #13795.
* Don't use session or team as comparison in release_advisory_lock(), as
that information might not be available anymore (e.g. when called from
Team::~Team()). This fixes #14121.

Change-Id: I9efb96cfcefe7e72b0060220c635a665e7e643cc
Co-authored-by: Axel Dörfler <axeld@pinc-software.de>

vfs: _user_flock() did not use FS advisory locking calls

* The kernel's advisory locking implemenation must not be used if the
file system has its own (ie. network file systems).
* Added ASSERT to free_vnode() that assures there is no locking left;
I recently had a lot of them around.

kernel: vfs: don't notify output-only select events by default

Output-only events (B_EVENT_ERROR, B_EVENT_DISCONNECTED and
B_EVENT_INVALID, with B_EVENT_INVALID masked out before passing down
events) are used to indicate error, so they should not be notified if
the vnode does not have select().

Bug: 13965

kernel: vfs: don't use the attribute name user buffer directly.

instead copy the name on the stack.

vfs: check userland buffers before reading them.

VFS: Add proper locking of the team structure in disconnect_mount_or_vnode_fds.

The KDL in #13861 was apparently caused by a NULL io_context. I read over
the Team code and have applied the following fixes here as a result:

1. A NULL io_context is entirely possible, as implied by the NULL check
before deinitializing it in Team's destructor, so account for that.

2. Team objects have a class-wide lock which must be acquired before
directly accessing class members, so use that here.

First part of the fix for #13861.

POSIX: F_DUPFD_CLOEXEC support (POSIX.1-2008).

* fix #12187.

Revert "vfs.cpp: Fix gcc6 crash."

This reverts commit 5b55f6dba9d905e26729961a146de825277c9d79.

vfs.cpp: Fix gcc6 crash.

Signed-off-by: Jérôme Duval <jerome.duval@gmail.com>

VFS: Pass on NULL for NULL paths, if allowed.

* Uses the new KPath::LAZY_ALLOC feature.
* This closes ticket #9625.

KPath: Replaced booleans with flags field.

* No functional change intended; I chose the flags in a way that it
should still work even if I missed a reference.

vfs: Let new_vnode() and publish_vnode() wait for busy vnodes.

* Both functions need to wait when encountering a busy vnode, in order
not to create a race condition in combination with get_vnode().
* This should fix both #5262, and #9839.
* I did not implement Ingo's suggestion to burden the file systems with
solving the problem for the following reasons:
- I think the file system interface should be as simple as possible.
- I can't think of a possible locking issue at least for BFS.
- The solution on the file system side would look pretty similar to
what the VFS already does or has to do (minus controlling the locking
directly), so it would cause quite a functional duplication.

NodeMonitor: Resolve mount points for B_WATCH_CHILDREN.

* When a watched directory contains a mount point, we need to resolve
the actual parent directory of the mount point in the file system to
serve the monitor.

vfs: Cleanup: Move functions around for more logical grouping.

Move static internal functions out of the API functions block and drop
their vfs_ prefix and move an API function into the API functions block.

kernel: Use anonymous namespaces to avoid type collisions.

The anonymous namespace makes type definitions local to the translation
unit (like static does for objects). For pretty much any type not shared
across multiple files this is what one wants to happen (and might
erroneously expect to happen automatically).

This commit solves some actual collisions that were present:

* The VFS and the rootfs both used an incompatible VnodeHash struct for
their BOpenHashTable.
* XSI semaphores and message queues both used queued_thread, Ipc and
IpcHashTableDefinition.

For release builds these did not cause problems as the types were fully
inlined. Debug builds would crash at boot however because parts of a
BOpenHashTable<VnodeHash> from the rootfs meant to operate on struct
rootfs_vnode would be applied to one from the VFS expecting struct
vnode.

As such collisions are violations of the one definition rule, the code
is at fault and unfortunatley the compiler isn't required to diagnose
such problems across translation units (which isn't actually trivial).
This can lead to subtle and hard to debug problems and it's therefore
best to avoid leaking types into the global namespace whenever possible.

VFS: pass correct vnode to fs calls in default get_vnode_name

The opendir and closedir/free_dircookie hooks were called with
mismatched vnode. It seems only googlefs is actually affected by this,
since all other fs without a get_vnode_name just don't are about the
passed vnode arg to closedir and free_dircookie.

Now I should really get some sleep!

VFS: typo

Fix GCC 5 maybe-uninitialized warnings.

Signed-off-by: Adrien Destugues <pulkomandy@pulkomandy.tk>

Fixes #12020

Implement stat.st_rdev for block and character devices.

* devfs: set st_rdev to the inode number of the node being queried. This
may not be the best thing to do, as it does not match what is set in
st_dev for other files, so it can't be used to find which device
stores a particular file. I'm not sure if st_rdev is actually used that
way anywhere, however.
* vfs: do not clobber st_rdev with -1 for "special" (device) files.
Refactor the code a little so setting the common attributes is done in
a single place.

Fixes #12390.

Implement stat.st_rdev for block and character devices.

* devfs: set st_rdev to the inode number of the node being queried. This
may not be the best thing to do, as it does not match what is set in
st_dev for other files, so it can't be used to find which device
stores a particular file. I'm not sure if st_rdev is actually used that
way anywhere, however.
* vfs: do not clobber st_rdev with -1 for "special" (device) files.
Refactor the code a little so setting the common attributes is done in
a single place.

Fixes #12390.

VFS: Slight rework of the FD disconnect feature.

* This should fix ticket #4157, although I probably have missed
something.
* In any case, it no longer messes with the ref counts of the
file descriptor, and the race condition in put_fd() should be
gone.
* It's still rather messy all in all.

VFS: prevent FD inheritance for the kernel completely.

* Each io_context now has a "inherit_fds" member that decides whether
or not this context allows to inherit FDs to its children.
* This replaces the former O_CLOEXEC mechanism.

VFS: Always open kernel FDs with O_CLOEXEC.

* Avoids leaking them into userland.

Assorted whitespace cleanup and typo fixes.

EntryCache: Add entry_cache_add_missing() for negative caching.

It provides a way for filesystems to cache a lookup failure and
therefore prevents repeated lookups of missing entries. This is a
common scenario for example in command lookup and compiling, where
each directory in PATH or each include directory is searched for the
given entry.

gcc4 build fix.

* offsetof is not allowed on non-POD types so we need to use
offset_of_member (gcc2 accepts offsetof, and C++11 relaxed the
constraints on where it is allowed so it should work there too)
* we have offset_of_member as a workaround until we switch to C++11,
move it from khash (which is soon to be removed) to list.h which is the
other place where it is used (for this one single call in our whole
codebase)

Also fix a typo in vfs.cpp.

VFS: migrate to BOpenHashTable.

Implement lseek(SEEK_END) on devices

While the partitioning system does publish partitions as block
devices and report their size in stat(), the old BeOS-style
drivers have no means of reporting it this way.
So we fall back to ioctl(B_GET_GEOMETRY) to find out the size.

access: fix to be POSIX compliant

Make vfs_resize_fd_table() accessible in the kernel

Also update some types from int to uint32.

vfs/{b|btr|package|b}fs/ext2/exfat: common access check.

* Added VFS helper function check_access_permissions() that combines
several partially correct versions to the one true version (tm).
* All but BFS (since recently) missed the S_IXOTH for root on directories,
and all but packagefs missed proper group handling.

vfs: check the X permission on set cwd.

* When you change the current working directory, you actually
should have the permission to enter that directory.
* This gives us a 0.04% better score on the perl test suite :-)

Typo: Fix doubled "not" in comment.

vfs: checks whether the mount's unmounting flag is already set.

* thanks to Ingo for suggesting the idea, quoting him:
"by holding sVnodeLock read-locked, get_mount() ensures that fs_unmount() can't
process the nodes. If it is already past that point, the root node check
(not NULL, not busy, ref count > 0) is supposed to detect that. But it doesn't
look like this can work. fs_unmount() doesn't set the root node to NULL (the
root node field is NULL only during a short period in fs_mount()), but it just
frees the nodes after releasing sVnodeLock. So the not busy and ref count > 0
checks could already access freed memory".
* tested OK, this fixes #10522.
* replaced mount->root_vnode by the local variable with the same value.

VFS FIFO: Add "fifo" KDL command

Prints information about a FIFO node and, optionally, its data buffer
content.

dir_vnode_to_path(): Fix uninitialized status variable

VFS: Fix broken zero_pages()

Besides that it failed to actually iterate through the vectors, it
shouldn't try to clear physical memory in the first place. The iovecs
refer to virtual address ranges. Rename it to zero_iovecs() to avoid
confusion.

vfs: dir_vnode_to_path(): Fix bug with chroot on mount

Simplify the code, which also fixes the bug that the I/O context's root
was ignored when it was a mount point, thus resulting in globally rooted
paths in this case.

vfs:Remove extra put_vnode call on error B_LINK_LIMIT exit

Fixing the autoconf test: attempt to create file in place of already
existing symlink. On error exit put_vnode was called explicitly before
returning error. The second, implicit call to put_vnode was issued on
destroying the VNodePutter instance that references the same vnode. At
this time the vnode has references count equal to 0 so corresponding
panic was executed. Great thanks to Ingo for pointing it out!

Fixes #9140.

VFS: fs_mount(): fix FS name leak

Fixes #9909.

vfs: fixed two warnings.

* warnings about comparison between signed and unsigned integer expressions.

Fix _user_entry_ref_to_path() in chroot

* Add "bool kernel" parameter to vfs_entry_ref_to_path(), so it can be
specified for which I/O context the entry ref shall be translated.
* _user_entry_ref_to_path(): Use the calling team's I/O context instead
of the kernel's. Fixes the bug that in a chroot the syscall would
return a path for outside the chroot.

VFS: _kern_open_dir(): Fix NULL path case

It would create an empty path buffer and pass that on to dir_open(),
which accepts NULL, but not empty paths.

Fixed compilation errors with ENABLE_TRACING set.

Fixed compilation of VFS/IORequest trace messages.

Fix #8661: fcntl(fd, F_GETLK, ...) violates POSIX

The standard states that F_GETLK should check whether given lock would be
blocked by another one and return description of the conflicting one (or
set l_type to F_UNLCK if there is no collision).

Current implementation of F_GETLK performs completely different actions, it
"Retrieves the first lock that has been set by the current team". Moreover,
if there are no locks (advisory_locking == NULL) an error is returned
instead of l_type set to F_UNLCK.

Use format macros in debug output.

Changed argument type of fcntl syscall from uint32 to size_t.

Since this argument may be used to pass pointers, uint32 is not
correct for 64-bit. Effectively no change on 32-bit targets, both
size_t and uint32 are unsigned long there.

Fixed formatting of output in some debugger commands.

Currently all debugger commands assume 32-bit pointers when formatting their
output. This means that on x86_64 the output is incorrectly formatted. Fixed
this by adding a B_PRINTF_POINTER_WIDTH definition (16 on 64-bit, 8 on
32-bit), and using this to correctly format the output. Not all commands have
been fixed yet, but all VM, slab, VFS, team, thread and image commands should
be correct.

Allow file systems to manage file locks

Haiku implements file locking at vfs level. That would not work for remote
and shared file systems, since they need to negotiate locks with peers.
This patch introduces three additional hooks in fs_interface that allow
file system module to take over the management of file locks.

More 64-bit compilation/safety fixes.

More 'GCC4.6 variable set but not used' fixes.

Revert "Finally applying the patch that adds support to add path information to stat and attr monitor messages."

Will recommit it when I have more time to work on the todos.

This reverts commit 610ef6c00781522022455c0cbf34495420b2db1d.

Finally applying the patch that adds support to add path information to stat and attr monitor messages.
* for all open FD the path information is stored in a map
* this info is used to fill the missing fields in the node monitor

Completed vfs_bind_mount_directory() support

We don't need to explicitly track the covered/covering nodes per mount
after all. In fs_unmount() we iterate through all vnodes multiple times
anyway and can deal with the covers/covered_by vnodes there. Also, the
root vnode doesn't need to be handled specially anymore.

vfs_bind_mount_directory(): Fail if unmounting

fix_dirent(): Fix ref count leaks

* Only get an additional parent reference, when going to call
vnode_path_to_vnode().
* Put the reference of the vnode vnode_path_to_vnode() returns.

remove_vnode(): Also consider covering vnode busy

Add support for bind-mounting directories

* Add support function vfs_get_mount_point(), so a file system can get
its own mount point (i.e. the node it covers). Re-added
fs_mount::covers_vnode for that purpose -- the root node isn't know to
the VFS before the mount() hook returns.
* Add function vfs_bind_mount_directory() which bind-mounts a directory
to another. The Vnode::covers/covered_by mechanism is used, so this
isn't true bind-mounting, but sufficient for what we need ATM and
cheaper as well. The vnodes connected thus aren't tracked yet, which
is needed for undoing the connection when unmounting.
* get_vnode_name(): Don't use dir_read() to read the directory. Since we
have already resolved vnode to the covered vnode, we don't want the
dirents to be "fixed" to refer to the covering nodes. Such a vnode
simply wouldn't be found.

Add vfs_ prefix to resolve_vnode_to_covering_vnode()

Generalize use of Vnode::covered_by/covers

* Introduce Vnode flags for covered and covering. Can be used as a quick
check when one doesn't already hold sVnodeLock.
* Rename resolve_mount_point_to_volume_root() to
resolve_vnode_to_covering_vnode().
* Adjust all code that deals with transitions between mount points and
volume root vnodes to generally support covered/covering vnodes.

Replaced fs_mount::covers_vnode by Vnode::covers

Introduce a Vnode::covers field. It is currently only used for the root
node of an fs_mount, replacing fs_mount::covers_vnode.

Comment typo fixes

Align all filesystem relevant places to use B_UNSUPPORTED for unsupported
instead of a mix of B_NOT_SUPPORTED and B_UNSUPPORTED. This allows checking for
a specific error code. Probably one of those should be phased out...


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@43025 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Introduced new fs_lopen_attr_dir() function that opens the attribute
directory of a file without traversing leaf links (just like lstat()).
* Minor cleanup.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@42620 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Fixed reversed handling of O_NOTRAVERSE in attr_open(), and attr_create().
* Added support for O_NOFOLLOW for those two as well.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@42619 a95241bf-73f2-0310-859d-f6bbb57e9c96

Completed vfs_bind_mount_directory() support

We don't need to explicitly track the covered/covering nodes per mount
after all. In fs_unmount() we iterate through all vnodes multiple times
anyway and can deal with the covers/covered_by vnodes there. Also, the
root vnode doesn't need to be handled specially anymore.

vfs_bind_mount_directory(): Fail if unmounting

fix_dirent(): Fix ref count leaks

* Only get an additional parent reference, when going to call
vnode_path_to_vnode().
* Put the reference of the vnode vnode_path_to_vnode() returns.

remove_vnode(): Also consider covering vnode busy

Add support for bind-mounting directories

* Add support function vfs_get_mount_point(), so a file system can get
its own mount point (i.e. the node it covers). Re-added
fs_mount::covers_vnode for that purpose -- the root node isn't know to
the VFS before the mount() hook returns.
* Add function vfs_bind_mount_directory() which bind-mounts a directory
to another. The Vnode::covers/covered_by mechanism is used, so this
isn't true bind-mounting, but sufficient for what we need ATM and
cheaper as well. The vnodes connected thus aren't tracked yet, which
is needed for undoing the connection when unmounting.
* get_vnode_name(): Don't use dir_read() to read the directory. Since we
have already resolved vnode to the covered vnode, we don't want the
dirents to be "fixed" to refer to the covering nodes. Such a vnode
simply wouldn't be found.

Add vfs_ prefix to resolve_vnode_to_covering_vnode()

Generalize use of Vnode::covered_by/covers

* Introduce Vnode flags for covered and covering. Can be used as a quick
check when one doesn't already hold sVnodeLock.
* Rename resolve_mount_point_to_volume_root() to
resolve_vnode_to_covering_vnode().
* Adjust all code that deals with transitions between mount points and
volume root vnodes to generally support covered/covering vnodes.

Replaced fs_mount::covers_vnode by Vnode::covers

Introduce a Vnode::covers field. It is currently only used for the root
node of an fs_mount, replacing fs_mount::covers_vnode.

Comment typo fixes

Merged signals-merge branch into trunk with the following changes:
* Reorganized the kernel locking related to threads and teams.
* We now discriminate correctly between process and thread signals. Signal
handlers have been moved to teams. Fixes #5679.
* Implemented real-time signal support, including signal queuing, SA_SIGINFO
support, sigqueue(), sigwaitinfo(), sigtimedwait(), waitid(), and the addition
of the real-time signal range. Closes #1935 and #2695.
* Gave SIGBUS a separate signal number. Fixes #6704.
* Implemented <time.h> clock and timer support, and fixed/completed alarm() and
[set]itimer(). Closes #5682.
* Implemented support for thread cancellation. Closes #5686.
* Moved send_signal() from <signal.h> to <OS.h>. Fixes #7554.
* Lots over smaller more or less related changes.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@42116 a95241bf-73f2-0310-859d-f6bbb57e9c96

dir_remove() now handles a path which ends with "/./" and fixed #6817.
Another way would be to disallow removing such a path, as Linux does.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@40819 a95241bf-73f2-0310-859d-f6bbb57e9c96

* if ioctl hook wasn't found, now returns B_DEV_INVALID_IOCTL
* in case fd_ioctl() was about to return B_DEV_INVALID_IOCTL, translate to ENOTTY to satisfy #7279.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@40787 a95241bf-73f2-0310-859d-f6bbb57e9c96

* add implementation of bindfs, which can be used to bind-mount
a folder to some other place in the filesystem hierarchy
* add helper function to VFS that encapsulates the "conversion" of a
vnode-pointer to a fs_vnode-pointer (used by bindfs)

git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@40238 a95241bf-73f2-0310-859d-f6bbb57e9c96

Merged the signals branch into trunk, with these changes:
* The team and thread kernel structures have been renamed to Team and Thread
respectively and moved into the new BKernel namespace.
* Several (kernel add-on) sources have been converted from C to C++ since
private kernel headers are included that are no longer C compatible.

Changes after merging:
* Fixed gcc 2 build (warnings mainly in the scary firewire bus manager).


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@40196 a95241bf-73f2-0310-859d-f6bbb57e9c96

common_rename(): Fixed incorrect check (array address instead of first
element, CID 4077).


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@40082 a95241bf-73f2-0310-859d-f6bbb57e9c96

Fix build with VFS_PAGES_IO_TRACING.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@39566 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Fixed CID 1262: waitForLock was not only -1 when exiting the loop, it didn't
make much sense to wake up any waiters either in this case.
* Fixed doubled semaphore deletion.
* Minor cleanup.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@38418 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Fixed CID 1199-1202: only call the cache listener in case the open succeeded
(this might also have derefenced a potentially freed vnode).


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@38196 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Changed some POSIX error codes to native ones.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@37842 a95241bf-73f2-0310-859d-f6bbb57e9c96

Added detail to the comment about why we can't call the create() hook without
O_EXCL.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@37555 a95241bf-73f2-0310-859d-f6bbb57e9c96

The vnode cache also considers the address space low resource state, now.
Together with vnode associated structures like file cache, VMCache, and file
system specific structures the impact on heap usage (and thus address space)
is considerable.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@37169 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Introduced type generic_io_vec, which is similar to iovec, but uses types
that are wide enough for both virtual and physical addresses.
* DMABuffer, IORequest, IOScheduler,... and code using them: Use
generic_io_vec and generic_{addr,size}_t where necessary.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@36997 a95241bf-73f2-0310-859d-f6bbb57e9c96

Changed the type of the "op" parameter of the fs_vnode_ops::ioctl() hook and
the _kern_ioctl() syscall from ulong to uint32.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@36927 a95241bf-73f2-0310-859d-f6bbb57e9c96

bonefish+mmlr:
The O_CLOEXEC open mode wasn't actually set in the close-on-exec bitmap causing
all files opened with O_CLOEXEC (like done in the storage kit classes) to still
be inherited. This caused for example to be unable to unmount volumes when
opening apps while Tracker touched some files (i.e. copying some large files)
since these apps would inherit the file descriptor and therefore keep the
volume busy.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@36273 a95241bf-73f2-0310-859d-f6bbb57e9c96

bonefish+mmlr:
* Add file descriptor and IO context tracing.
* Some minor cleanup.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@36272 a95241bf-73f2-0310-859d-f6bbb57e9c96

debug_resolve_vnode_path(): Avoid duplicate slash at the beginning of the
path.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@35642 a95241bf-73f2-0310-859d-f6bbb57e9c96

Added option "-p" to the "vnode" debugger command. Using the entry cache it
tries to resolve the vnode's path.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@35626 a95241bf-73f2-0310-859d-f6bbb57e9c96

Beautified the output of the "io_context" command.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@35582 a95241bf-73f2-0310-859d-f6bbb57e9c96

"vnode" does now also print the node type.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@35280 a95241bf-73f2-0310-859d-f6bbb57e9c96

Eliminated sVnodeCoveredByMutex. The Vnode::covered_by field is now also
protected by the global vnodes lock. The contention mostly moves to other
locks, though. The total -j8 Haiku image build time is only reduced
minimally.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@34938 a95241bf-73f2-0310-859d-f6bbb57e9c96

fs_unmount(): We need to hold the vnodes write lock after all. The upside is
that it saves us from locking the individual vnodes.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@34872 a95241bf-73f2-0310-859d-f6bbb57e9c96

* free_unused_vnodes(): Be a good citizen and use vnode_used() instead of
playing with the unused list manually. This also clears the vnode's unused
flag, which wasn't done before and would thus cause corruption of the
unused list a bit later.
* fs_unmount():
- Fixed an iteration bug I introduced previously. The iterator would be
advanced twice per iteration, leading to NULL pointer dereferencing
when the vnode count was odd and skipping the checks for every other
vnode.
- All vnodes are going to be freed, so vnode_to_be_freed() has to invoked
for every one of them. The code wasn't adjusted correctly when
introducing the hot vnodes handling.
* Adjusted/improved some comments.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@34871 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Moved the unused vnode management to a new file. Well the few variables
used for it that is.
* The main cause for the heavy contention of the unused vnodes mutex was that
relatively few vnodes are actually used for a longer time. Mainly those are
the volume roots, mmap()ed files, and the files opened by programs. A good
deal of nodes -- particularly directories -- are just referenced for a very
short time, e.g. to resolve a path to a contained entry. This caused those
nodes to be added to and removed from the unused vnodes list very
frequently, thus resulting in a high contention of the mutex guarding it.
To address the problem I've introduced an approximation of a set of "hot"
vnodes, i.e. vnodes that have recently been marked unused. They are stored
in an array that by means of an r/w locker and atomic operations can most
of the time be accessed concurrently. Whenever it gets full, it is flushed
to the actual unused vnodes list.
* dec_vnode_ref_count(): No longer check the unused vnode count every time.
The called new vnode_unused() does only from time to time and returns when
the caller is expected to free some of the unused vnodes. As a side effect
this also fixes a bug I previously introduced: The unused vnode to be freed
was marked busy without being locked first.

The -j8 Haiku image test build shows that the changes reduce the contention
of the unused vnode list mutex to virtually zero without introducing any
significant contention of the new r/w lock. The VMCache lock contention also
seems to be decreased somewhat, which is probably not that surprising
considering that the page writer acquires/releases vnode references with the
cache lock held. The "pages" lock takes over even more contention, now
causing more than 100000 waits per second.
The total build time reduction is about 4.5%. Kernel time drops more than
10%.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@34866 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Moved the vnode structure (to by Vnode class at some time in the future) into
its own header/source files.
* Changed vnode's bit fields to a single, atomically changeable int32 using
flags instead. Added respective accessor methods.
* Added a per-vnode mutex-like lock, which uses 2 bits of the structure and
32 global "buckets" which are used for waiter lists for the vnode locks.
* Reorganized the VFS locking a bit:
Renamed sVnodeMutex to sVnodeLock and made it an r/w lock. In most situations
it is now only read-locked to reduce its contention. The per-vnode locks guard
the fields of the vnode structure and the newly introduced sUnusedVnodesLock
has taken over the job to guard the unused vnodes list.

The main intent of the changes was to reduce the contention of the sVnodeMutex,
which was partially successful. In my standard -j8 Haiku image build test the
new sUnusedVnodesLock took over about a fourth of the former sVnodeMutex
contention, but the sVnodeLock and the vnode locks have virtually no contention
to speak of, now. A lot of contention migrated to the unrelated "pages" mutex
(another bottleneck). The overall build time dropped about 10 %.



git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@34865 a95241bf-73f2-0310-859d-f6bbb57e9c96

Removed TODO again. I tried a similar event mechanism as used for busy pages
in VMCache, but, if anything, that makes a -j8 build marginally slower. I
guess busy vnodes are encountered so rarely that the additional overhead for
a more intelligent algorithm isn't really worth it. Reduced the wait time,
though.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@34845 a95241bf-73f2-0310-859d-f6bbb57e9c96

Moved the entry cache implementation into its own file.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@34843 a95241bf-73f2-0310-859d-f6bbb57e9c96

Made vnode::type private, renamed it to fType, and added accessor methods. It
stores the value right-shifted by 12 bits, now, since those bits are not
relevant. This saves some bits and also resolves a TODO.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@34842 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Resolved TODO in free_vnode(): There was a race condition between vnode
destruction and VMVnodeCache::AcquireUnreferencedStoreRef(). Solved by
adding a flag to VMVnodeCache and letting AcquireUnreferencedStoreRef()
fail, if set.
* Added TODO regarding replacing the snooze() waiting for busy vnodes.
* get_vnode(): Unlock sVnodeMutex while calling the put_vnode() hook on
error.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@34841 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Moved the VM headers into subdirectory vm/.
* Renamed vm_cache.h/vm_address_space.h to VMCache.h/VMAddressSpace.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@34449 a95241bf-73f2-0310-859d-f6bbb57e9c96

Finished renaming of vm_cache to VMCache.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@34424 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Use O_CLOEXEC when open directories, attribute directories, indexes, and
queries.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@34291 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Forgot to add linkat(), this really closes #4928 now.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@34289 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Added missing AT_EACCESS.
* Implemented renameat(), faccessat(), fchownat(), fchmodat(), and mkfifoat().
* Added stub for mknodat().
* The kernel backend for faccessat() does not yet differentiate between
effective and real user/group IDs, though.
* Removed B_ENABLE_INCOMPLETE_POSIX_AT_SUPPORT, as we now support everything
(more or less). This also closes ticket #4928.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@34288 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Eliminated the extra buffer in dir_vnode_to_path(); we write directly to the
specified buffer now.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@34282 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Added support for O_NOFOLLOW.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@34279 a95241bf-73f2-0310-859d-f6bbb57e9c96

* dir_vnode_to_path() now uses B_* error codes instead of POSIX ones, and also
returns the correct error code if the buffer was too small (should be ERANGE
instead of ENOBUF).
* Also, it is now independent of B_PATH_NAME_LENGTH, and therefore should
fulfill POSIX getcwd() requirements. This should also close ticket #3352.
* Is there any reason to allocate another buffer instead of using memmove()
at the end instead of memcpy()?


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@34276 a95241bf-73f2-0310-859d-f6bbb57e9c96

* load_image() now has exec() semantics wrt file descriptors; before each team
would always inherit them all, causing quite a number of open files.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@34247 a95241bf-73f2-0310-859d-f6bbb57e9c96

Added fs_read_attr().


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@34085 a95241bf-73f2-0310-859d-f6bbb57e9c96

_user_open_dir(): Allow a NULL path to be passed.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@33973 a95241bf-73f2-0310-859d-f6bbb57e9c96

* common_rename() now checks the name for validity before passing it on to the
file systems, so those checks don't have to be duplicated there, anymore.
* Minor cleanup, mostly automatic whitespace.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@33895 a95241bf-73f2-0310-859d-f6bbb57e9c96

using chroot with a mount point wrongly exposed the mount point name: we now avoid resolving the volume root in case we hit the IO context root.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@33645 a95241bf-73f2-0310-859d-f6bbb57e9c96

* VFS:
- Fixed vfs_get_vnode_from_fd() return type.
- Added vfs_open_vnode().
- Added a "bool traverseLeafLink" parameter to vfs_get_fs_node_from_path().
It was always resolving symlinks.
* device manager/devfs:
- devfs: get_node_for_path() no longer resolves leaf symlinks. That still
doesn't help with file disk devices, as creating partition wouldn't work
anyway.
- Pulled the module-related implementation part of BaseDevice into new class
AbstractModuleDevice and made all methods of BaseDevice virtual. Small
adjustments to devfs to be happy with the new BaseDevice interface.
- Added BaseDevice subclass FileDevice, which maps the interface to a file's
file descriptor. Still got a few TODOs, but should basically work.
- Use FileDevice for publishing file disk devices in devfs. Now those do
actually work, though there's some BFS trouble with one of the images I
tested.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@33385 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Cleanup, no functional change.

+ alphabranch


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@32890 a95241bf-73f2-0310-859d-f6bbb57e9c96

* _user_read_dir(): Allocate a temporary heap buffer passed into the kernel
instead of using the user buffer. This frees the VFS and FS implementations
from handling user buffers.
* Adjusted fix_dirent() accordingly.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@32384 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Also have the uppper limit check in the assert.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@32323 a95241bf-73f2-0310-859d-f6bbb57e9c96

* We also shouldn't try to copy if the dirent is too large, obviously.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@32314 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Let fix_dirent() handle invalid reclen's gracefully.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@32306 a95241bf-73f2-0310-859d-f6bbb57e9c96

* cdda_read_dir() could copy too many bytes into the provided buffer (worst
case was an unterminated string, though).
* fix_dirent() did not copy the trailing null-byte.
* Not yet entirely sure why, but this caused #4214.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@32254 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Replaced all "status < B_OK" with != B_OK - this should make the VFS layer
more robust against broken (userland) file systems.
* 80 character column cleanup.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@32184 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Creating a symlink now fails with B_NOT_SUPPORTED instead of
B_READ_ONLY_DEVICE if it has a write hook.
* This fixes bug #4141.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@32004 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Introduced dedicated syscalls for the deprecated BeOS fs_attr API. Before,
each attribute access needed 3 syscalls, now only one as it should.
* Renamed the new Haiku call fs_open_attr() to fs_fopen_attr(), and added a new
function fs_open_attr() that takes a path (same semantics as the
fs_[f]open_attr_dir() functions already present in BeOS).
* Merged former _kern_open_attr(), and _kern_create_attr() into one syscall.
* Cleaned up vfs.h.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@31881 a95241bf-73f2-0310-859d-f6bbb57e9c96

headers/private/kernel/util/OpenHashTable.h, Hugo's version, is a bit nicer than
Tracker's OpenHashTable.h which it should eventually replace. We've renamed the
class to BOpenHashTable and changed the interface slightly so that HashTableLink
became superfluous.
Adapted all the code that used it. Since the OpenHashTables no longer clash,
this should fix the GCC4 build.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@31791 a95241bf-73f2-0310-859d-f6bbb57e9c96

* In order to resolve mount points, fix_dirents() retrieved all vnodes from
disk; but since mount points are always kept in memory, it makes much more
sense to use lookup_vnode() instead.
* As a side effect, directory listings are no longer aborted when they contain
broken files that could not be retrieved anymore.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@31775 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Returning random stat data isn't really nice.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@31010 a95241bf-73f2-0310-859d-f6bbb57e9c96

vnode_path_to_vnode(): Don't propagate the traverseLeafLink flag, if we've
decided to recursively resolve a symlink. We only have to do the resolution
when the flag is true anyway or the symlink is not the last component of
our path, in which case we have to resolve it anyway. Fixes #3986.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@30937 a95241bf-73f2-0310-859d-f6bbb57e9c96

* The covered vnode release was never put when it already was a mount point
during fs_mount(). This fixes bug #3934.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@30773 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Removed the get_next_removed_vnode() call again - besides the problems Ingo
pointed out, there is also an unsolvable race condition with BFS that other
file systems should share.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@30204 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Introduced new call get_next_removed_vnode() to be able to iterate over
removed but not yet deleted vnodes.
* Simplified get_vnode_removed().
* Header cleanup.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@30176 a95241bf-73f2-0310-859d-f6bbb57e9c96

Removed the fs_vnode_ops::create_dir() parameter for returning the ID of the
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

* Minor cleanup, no functional change.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29480 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Renamed src/system/kernel/device_manager/io_requests.{h,cpp} to
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

* Fixed wrong use of MutexLocker as pointed out by Korli - nice catch! This
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

* Introduced ref-counting for the I/O contexts.
* 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

Fixed duplicate parameter name.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29342 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Consolidated '*' style.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29341 a95241bf-73f2-0310-859d-f6bbb57e9c96

* zero_pages() did not fill in the _bytes parameter correctly - it returned how
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

Better do the check for "." and ".." after stripping off superflous leafs as
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

Disallow removing the "." entry. We do the same for ".." already and it seems
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

We need a longer filesystem string here to fit in all the possible layers.

git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29259 a95241bf-73f2-0310-859d-f6bbb57e9c96

Remove the additional fs_vnode_ops arugment from get_vnode() again as it's not
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

Add a new fs_volume op all_layers_mounted() that is called when all layers have
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

* Adding volume ops to the overlay filesystem.
* 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

Handle the overlay request flag in publish_vnode() as well.

git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29196 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Add an additional argument to get_vnode() that gets the fs_vnode_ops of the
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

Fixing warnings under GCC4 in preparation to enable -Werror there as well:
* 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

* _user_flock() will no longer accept invalid operations, thus fixing bug #3141.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28889 a95241bf-73f2-0310-859d-f6bbb57e9c96

* fs_write() is optional for read-only file systems. This fixes bug #3062 and
also #3083 (although I could not reproduce the latter).


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28881 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Removed a left-over mutex_unlock() that could cause a panic on removing
a busy vnode.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28851 a95241bf-73f2-0310-859d-f6bbb57e9c96

* All file descriptors that only refer to a mount now keep the mount, ie. they
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

* When a file system reports -1 offsets in its fs_get_file_map() function, this
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

* Use parse_expression() for argument parsing.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28515 a95241bf-73f2-0310-859d-f6bbb57e9c96

* fs_unmount() removed the vnodes of the fs_mount twice since r28215,
triggering an assert.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28344 a95241bf-73f2-0310-859d-f6bbb57e9c96

* vfs_stat_node_ref(): Added missing initialization of
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

Consistently use KDEBUG. It is always defined and therefore must be
checked with "#if".


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28247 a95241bf-73f2-0310-859d-f6bbb57e9c96

The fs_mount structure now has a constructor/destructor and is used with new and
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

* Instead of having the mount_link, struct vnode now subclasses from
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

* fs_sync() now holds the sVnodeMutex while iterating over the mount list.
* 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

* vfs_normalize_path() and _user_normalize_path() use a common helper
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

Implemented a simple directory entry cache to speed up path resolution.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27366 a95241bf-73f2-0310-859d-f6bbb57e9c96

extended debug check for FS_CALL() to others FS_CALL() versions


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27189 a95241bf-73f2-0310-859d-f6bbb57e9c96

added a check in FS_CALL() for null hooks in KDEBUG mode


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27188 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Changed the way fix_dirent() copies the entry: it will now copy the complete
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

Handy on-demand debug tracing, I've used a few times already. So I leave
it commented out in the code for the time being.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26907 a95241bf-73f2-0310-859d-f6bbb57e9c96

* fix_dirent() now correctly handles buffers from userland.
* 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

* Added tracing for vfs_{read,write}_pages).
* {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

* Renamed thread_spinlock and team_spinlock to gThreadSpinlock and
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

* Added acquire_vnode() call that you can use to get another reference to an
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

* It is now supported that I/O operations and requests are only handled
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

Added handy function volume_for_vnode() which returns the fs_volume for
a given given fs_vnode.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26669 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Added FS interface hooks io() and cancel_io(). The former is supposed
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

Remove extraneous put_vnode(). This would result in decrementing the vnode ref count even if an unmount operation failed, which in turn would cause other fun problems. This fixes tickets 1982 and 2538. However, there seems to be another problem remaining with unmounting: the placeholder dir in the rootfs is not removed when the volume is unmounted, or it's not reused correctly. As a consequence, on subsequent remounts of the same volume via Tracker or mountvolume, a new dir is created each time, leaving empty placeholders. (i.e. remounting the volume HaikuData results in the creation of /HaikuData1, 2, 3, 4, etc.).



git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26586 a95241bf-73f2-0310-859d-f6bbb57e9c96

* bfs_fsync() was the only place which could cause the
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

Merged branch haiku/branches/developer/bonefish/vm into trunk. This
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

Add (not really necessary) locking of the sMountMutex in case of KDEBUG to keep the assert in find_mount() happy.

git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26484 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Added "partition_id partition" field to fs_volume, so that file
systems can get the partition they reside on easily.
* Updated TODO.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26401 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Reverted r26293 again, as that "subtle" change also prevented any device I/O
from happening...


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26294 a95241bf-73f2-0310-859d-f6bbb57e9c96

* file_{read|write}() now only accept regular files, and will return either
B_BAD_VALUE or B_IS_A_DIRECTORY depending on the vnode type.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26293 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Since we now have a vnode::type field, several calls of read_stat() were no
longer necessary.
* Optimized file_seek() using this field, too; reading the stat is now only done
when necessary.
* file_read() and file_write() will now return B_IS_A_DIRECTORY so that not
every file system has to care about that particular error code.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26292 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Added some optional KDL command and statistics to the file map implementation.
* Turned them on for now.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26291 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Removed -Wno-unused from all KernelMergeObjects in kernel Jamfiles.
* Fixed most of the warnings resulting from that by removing actually not used
variables or moving declaration into the #IF. Left unused functions there
though, as I wouldn't know if they are supposed to be used again.
* Fixed two statements with no effect (clamping to MAX_ANCILLARY_DATA_LEN in
socket.cpp and unsetting fCounterSem in MessagingService.cpp).
* Some style cleanups.

git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26253 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Replaced the global cache pages hash table by an IteratableSplayTree
per cache.
* Changed the strategy vm_cache_acquire_page_cache_ref() uses to ensure
that the cache isn't deleted while trying to get a reference. Instead
of the global cache pages hash table lock, it holds the global cache
list lock now. We acquire + release this lock in delete_cache() after
removing all pages and just before deleting the object.
* Some small optimizations using the property that the cache's pages are
ordered, now (vm_cache_resize(), vm_page_write_modified_page_range(),
vm_page_schedule_write_page_range()).
* Replaced some code counting a cache's pages by simply using
vm_cache::page_count.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26160 a95241bf-73f2-0310-859d-f6bbb57e9c96

* dec_vnode_ref_count() can now also directly free the vnode if requested
(and if it isn't used anymore).
* vnode_low_memory_handler() now just calls it this way, so it doesn't have
to use two passes anymore, and can always write back vnodes without having
the busy flag set.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26124 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Initialize all static mutexes in the kernel through a MUTEX_INITIALIZER()
and remove the then unneeded mutex_init() for them.
* Remove the workaround for allowing uninitialized mutexes on kernel startup.
As they are all initialized statically through the MUTEX_INITIALIZER() now
this is not needed anymore.
* An uninitialized mutex will now cause a panic when used to find possibly
remaining cases.
* Remove now unnecessary driver_settings_init_post_sem() function.

git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@25812 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Fixed an endless loop when using vfs_get_vnode_name() or the "wrong"
get_vnode_name() variant.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@25750 a95241bf-73f2-0310-859d-f6bbb57e9c96

Fix build with TRACE_VFS enabled and also fix a warning.

git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@25726 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Changed recursive_lock to use a mutex instead of a semaphore.
* Adjusted code using recursive locks respectively. The initialization
cannot fail anymore, and it is possible to use recursive locks in the
early boot process (even uninitialized, if in BSS), which simplifies
things a little.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@25687 a95241bf-73f2-0310-859d-f6bbb57e9c96

* get_vnode() now accepts a NULL parameter for the fsNode argument.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@25660 a95241bf-73f2-0310-859d-f6bbb57e9c96

Advisory locking fixes:
* Made the access strategy to vnode::advisory_locking consistent.
get_advisory_locking() was guarding it with sVnodeMutex,
create_advisory_locking() was using atomic_pointer_test_and_set(), and
release_advisory_lock() just set it unguardedly. We do use sVnodeMutex
consequently, now.
* Beautified create_advisory_locking() (got rid of the gotos,
reorganized the control flow).
* Fixed race conditions in acquire_advisory_lock(). It was always
unlocking and relocking the advisory_locking object when it didn't
have to wait, but in the meantime someone else could have changed the
locking situation. Reorganized the control flow, so that it only drops
the lock when it has to fail or wait. Using create_advisory_locking()
upfront simplifies the code quite a bit (and fixes another race
condition).

APR's testprocmutex test seems happy now, at least.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@25407 a95241bf-73f2-0310-859d-f6bbb57e9c96

Replaced benaphores with mutexes.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@25378 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Removed old mutex implementation and renamed cutex to mutex.
* Trivial adjustments of code using mutexes. Mostly removing the
mutex_init() return value check.
* Added mutex_lock_threads_locked(), which is called with the threads
spinlock being held. The spinlock is released while waiting, of
course. This function is useful in cases where the existence of the
mutex object is ensured by holding the threads spinlock.
* Changed the two instances in the VFS code where an IO context of
another team needs to be locked to use mutex_lock_threads_locked().
Before it required a semaphore-based mutex implementation.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@25283 a95241bf-73f2-0310-859d-f6bbb57e9c96

Fixed the case that a file to be created non-exclusively is a symlink
(bug #2183).


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@25271 a95241bf-73f2-0310-859d-f6bbb57e9c96

Removed superfluous uint32 ref parameter from select() FS hook.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@25268 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Added an atomic.h header that provides a C++ file with a templatized
64-bit safe version of atomic_test_and_set() for pointers:
atomic_pointer_test_and_set().
* The VFS is now using this function (it's not used anywhere else in the
kernel this way).


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@25260 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Renamed temporary KDL variable from _cookie to _volume in the "mount"
command.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@25251 a95241bf-73f2-0310-859d-f6bbb57e9c96

* attribute dirs shouldn't be locked out either; I've inverted the type check,
so that it now only checks for the type that allow locking.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@25168 a95241bf-73f2-0310-859d-f6bbb57e9c96

FS gurus, please review.

- get_new_fd() now checks if we are dealing with attributes before deciding to
bail out on a locked vnode.
- Enabled locking in MailSettings again as it now works.



git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@25162 a95241bf-73f2-0310-859d-f6bbb57e9c96

vfs_create_special_node() always tried to create the node in "/".


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@25139 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Added fd_ops::set_flags() hook. It's only implemented by socket FDs
ATM.
* Changed common_fcntl() to also work for non-vnode-based FDs. Only the
operations that require a vnode do fail now. F_SETFL uses the new
fd_ops::set_flags() if available, falling back to the vnode respective
operation.
* Changed some direct accesses to file_descriptor::u::vnode. It was safe
in those cases, but might not be anymore if we ever change fd_vnode().

ftp can at least connect to servers again, now, but apparently we still
have a problem with syscall restarts -- downloads fail after one second,
when the timer goes off.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24917 a95241bf-73f2-0310-859d-f6bbb57e9c96

The fs_sync() function (or any other, for that matter) must not hold the
sMountMutex lock when calling sync() on a file system. This fixes a potential
deadlock (I just encountered for the first time).


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24915 a95241bf-73f2-0310-859d-f6bbb57e9c96

Applied patch by Christian Fasshauer:
* get_dir_path_and_leaf() now removes trailing slashes from the path.
* This fixes bug #2016, thanks!


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24913 a95241bf-73f2-0310-859d-f6bbb57e9c96

Resolved TODO: We can check for sockets, now.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24906 a95241bf-73f2-0310-859d-f6bbb57e9c96

New service function vfs_create_special_node() to create special nodes.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24883 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Cleaned up KernelExport.h completely, removed deprecated and non implemented
API, uses the _PRINTFLIKE macro where appropriate.
* Got rid of the "qent" structure, struct timer now contains everything we
need. This makes the affected code in sem.cpp, signal.cpp, and timer.c much
cleaner, and resolves a few TODOs.
* Minor cleanup in vfs.cpp.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24871 a95241bf-73f2-0310-859d-f6bbb57e9c96

Rename vfs_stat_entry_ref() to vfs_stat_node_ref() as that's what a dev_t and
ino_t combination really is.

git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24825 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Added _kern_create_pipe() syscall, creating a pipe as an entryless
FIFO. Reimplemented pipe() to use it.
* pipefs is no longer mounted. Will remove the superfluous code soon.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24823 a95241bf-73f2-0310-859d-f6bbb57e9c96

We get a reference to the node from create_special_node(), so we have to
release it.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24817 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Reorganized the FS interface a little:
- Moved most file_system_module_info hooks into separate structures.
Those that operate on mounted volumes to fs_volume_ops, those
operating on a vnode to fs_vnode_ops.
- Got rid of the fs_volume, fs_cookie, fs_vnode typedefs. We use void*
again.
- Instead of a void* volume and node cookie hooks are passed a
fs_volume and fs_vnode structure pointer, which contain the cookie
and an ops pointer (fs_volume a few more things).
- The VFS {new,publish,get,...}_vnode() functions take a fs_volume*
instead of the volume ID. So does vfs_get_fs_node_from_path().
- Added type and flags arguments to publish_vnode() and the
get_vnode() hook and removed the type argument from lookup() hook.
Added vnode::type using formerly unused bits to store the node type.
Simplified a few things in the VFS due to the now always available
node type.
- Added fs_volume_ops::{create,delete}_sub_vnode() and
fs_vnode_ops::get_super_vnode() hooks. They are used to support file
system layers, e.g. allowing to extend an FS not supporting BeOS
attribute with attribute support. Needs some more work in the VFS.
- Added fs_vnode_ops::create_special_node() hook for creating special
nodes (e.g. FIFOs).
* Adjusted the built-in file systems and BFS according to the interface
changes. Removed all other FSs from the image for the time being.
We'll see whether further API changes are necessary before porting
them.
* Adjusted the bfs_shell accordingly.
* Implemented create_special_node() in rootfs to support special nodes.
* Added support for FIFOs:
- Added syscall _kern_create_fifo() (used by mkfifo()), which creates
a special node (type S_IFIFO) in the respective file system.
- When a special node is published the VFS creates a respective sub
node. Currently only FIFOs are supported.
- Added a little support for FIFO subnodes by using functionality from
the pipefs.
- Added mkfifo to the image. It can create FIFOs in the rootfs, but
the FIFOs aren't really usable ATM, since they still work like
pipes, i.e. readers and writers need to have them open at the same
time.
* Some smaller changes in the VFS:
- Made the *_CALL macros nicer to use (vargs).
- Refactored FS entry lookup into new function lookup_dir_entry().
- create_vnode() no longer just calls the FS create() hook. First it
looks up the entry and uses open_vnode(), if it already exists. This
is necessary for two reasons: 1) The FS might not support create()
while still allowing to open() entries. 2) When the FS has other
layers on to of it (or the respective node) it might not be
responsible for opening the node.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24816 a95241bf-73f2-0310-859d-f6bbb57e9c96

Introduce vfs_stat_entry_ref() that allows to stat a vnode based on a dev_t
and ino_t instead of a path. Supposed to work with node monitoring messages.
Took the name from vfs_entry_ref_to_path() that takes the same arguments, but
suggestions for a better name are welcome.

git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24813 a95241bf-73f2-0310-859d-f6bbb57e9c96

Also check whether the supplied vnode is a directory, if there's only
one path component.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24736 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Fixed resolution of symlinks path components, broken since
r24721/r24722. After resolving a symlink we weren't updating the local
type variable to the type of the link target, so that the directory
check in the next iteration would always fail.
* Added TODO.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24735 a95241bf-73f2-0310-859d-f6bbb57e9c96

Revised my previous patch as outlined in the previous one:
* No longer checks for the path delimiter twice.
* Now also checks if the first part of the path is a directory.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24722 a95241bf-73f2-0310-859d-f6bbb57e9c96

Reverted r24720, and at least fixed the problematic return code after the
first loop - the vnode passed in would still need to be checked, though.
Eventually, it would be nice to move the check to the top, though, so that
we don't need to search for the patch delimiter twice.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24721 a95241bf-73f2-0310-859d-f6bbb57e9c96

- vnode_path_to_vnode() now returns B_NOT_A_DIRECTORY instead of B_NOT_ALLOWED
as expected by POSIX programs. This allowed be to compile Haiku under itself
without any hacks at all, so I guess this means that now we are officially
self-hosting!



git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24720 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Implemented support for chroot:
- Added a "root" vnode to the io_context. It is used for resolving
paths and converting nodes to paths instead of sRoot. Some more
passing around of io_context structures was necessary.
- Introduced a new lock sIOContextRootLock to protect
io_context::root. The current uses of io_context::io_mutex
(put_vnode(), remove_vnode() while holding it) looked too suspicious
to use that mutex in vnode_path_to_vnode().
- Added _kern_change_root() syscall and chroot() libroot function.
- Added chroot coreutils program to the image. Funnily it seems to be
much easier to set up a little jail than under Linux (just copy
bash and libroot.so into respective subdirs; mount another pipefs
if you want pipe support).
With Haiku allowing direct access to directories via inode IDs
jailing is obviously not very secure at the moment.
- Added /var/empty to the image. It will be the chroot target for ssh.
* Changed vfs.cpp:get_cwd() so that the io_context::io_mutex is no
longer held when calling dir_vnode_to_path().


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24673 a95241bf-73f2-0310-859d-f6bbb57e9c96

Added function vfs_read_stat() that also allows for stat()ing files in
the user IO context from within the kernel.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24667 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Reverted r22315 as far as free_vnode() is concerned: removing the
vnode from the hash before putting it caused all sorts of problems.
* For example, BFS would trim its preallocations when the vnode is put;
if someone would read that same vnode after it had been removed, but
before BFS could trim it, it would read the old vnode which still
seemed to own the blocks which would subsequently be freed.
* This fixes bug #1914, and should also fix bug #1956.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24607 a95241bf-73f2-0310-859d-f6bbb57e9c96

* entry_ref_to_vnode() now gets a "traverse" argument, so that it is
able to resolve symlinks.
* file_open_entry_ref() now evaluates the openMode and passes the
correct "traverse" argument to entry_ref_to_vnode(). This fixes bug
#1932 (symlink refs wouldn't be resolved).
* dir_open_entry_ref() now always resolves symlinks, all other uses of
entry_ref_to_vnode() keep their previous behaviour, though.
* Fixed warnings; since Ingo's header changes, NULL now causes a warning
when it is used as int.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24442 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Aligned the semantics of the read_symlink() FS module hook with the
readlink() function. It is no longer required to null-terminate the
string, shall not fail, if the buffer is too small, and shall return
the length of the string actually written into the buffer.
* Adjusted rootfs, devfs, and bfs accordingly. Also adjusted their
read_stat() hooks to return the correct symlink length in st_size.
* Our readlink() does now comply to the standard (and BeOS).
Additionally if the buffer is big enough it is nice to non-conforming
apps and null-terminates it.
* BSymLink::ReadLink() explicitly null-terminates the string now.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24425 a95241bf-73f2-0310-859d-f6bbb57e9c96

We didn't copy the close-on-exec flags on fork(), thus always leaving
all FDs in a fork()+exec()ed child open. Makes Perl test
t/run/cloexec.t pass.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24336 a95241bf-73f2-0310-859d-f6bbb57e9c96

* The module code now uses find_directory() and no hard-coded paths anymore.
* It now also supports the common directory path.
* search_module() checked the module paths in the wrong order, ie. it preferred
modules in the system directory over the user directory.
* Clarified comment in vfs_get_module_path().


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24323 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Explained under which circumstances vnode_path_to_vnode() will clobber the
buffer of the provided "path" argument.
* Applied patch by Vasilis to fix some warnings when build on Linux (missing
const on certain functions). We should probably fix the original
{add|remove}_debugger_command() functions in Haiku as well.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24322 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Minor cleanup.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24236 a95241bf-73f2-0310-859d-f6bbb57e9c96

"leaf" may be NULL, fixed crashing bug I introduced with
vfs_entry_ref_to_path().


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24154 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Factored a vfs_entry_ref_to_path() out of _user_entry_ref_to_path()
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

Improved (and tested) the advisory file locking mechanism a bit:
* 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

axeld + bonefish:
* 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

build fix for r23929


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23982 a95241bf-73f2-0310-859d-f6bbb57e9c96

_user_normalize_path() was broken for symlinks in absolute paths.
Fixes #1778.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23969 a95241bf-73f2-0310-859d-f6bbb57e9c96

Added new syscall _kern_normalize_path() to normalize a path.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23929 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Implemented flock() semantics to the advisory locking backend. Not tested
(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

* Rethought fs_sync(): since we no longer deadlock when calling
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

* Fixed the "vnodes" KDL command when called without any arguments.
* 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

* Added support for the "--help" argument for all VFS debugger commands.
* Added some temporary variables to the commands.
* Use parse_expression() where appropriate.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23556 a95241bf-73f2-0310-859d-f6bbb57e9c96

Fix comment.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23466 a95241bf-73f2-0310-859d-f6bbb57e9c96

Fix problem with CLOEXEC also being handled on fork(). For details on expected (BeOS) behaviour, see http://www.freelists.org/archives/openbeos/12-2001/msg00280.html

git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23456 a95241bf-73f2-0310-859d-f6bbb57e9c96

Added the cookie/private_node fields to the mounts/vnodes list in KDL.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23455 a95241bf-73f2-0310-859d-f6bbb57e9c96

Fixed two bugs in the vnode disconnecting code found by bonefish+mmlr:
* vfs_disconnect_vnode() did not put away its vnode reference.
* disconnect_mount_or_vnode_fds() did always throw the current working
directory of all apps on the same mount away, even if only a specific
vnode should have been disconnected.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23445 a95241bf-73f2-0310-859d-f6bbb57e9c96

Merged branch haiku/branches/developer/bonefish/optimization revision
23139 into trunk, with roughly the following changes (for details svn
log the branch):
* The int 99 syscall handler is now fully in assembly.
* Added a sysenter/sysexit handler and use it on Pentiums that support
it (via commpage).
* Got rid of i386_handle_trap(). A bit of functionality was moved into
the assembly handler which now uses a jump table to call C functions
handling the respective interrupt.
* Some optimizations to get user debugger support code out of the
interrupt handling path.
* Introduced a thread::flags fields which allows to skip handling of
rare events (signals, user debug enabling/disabling) on the
common interrupt handling path.
* Got rid of the explicit iframe stack. The iframes can still be
retrieved by iterating through the stack frames.
* Made the commpage an architecture independent feature. It's used for
the real time data stuff (instead of creating a separate area).
* The x86 CPU modules can now provide processor optimized versions for
common functions (currently memcpy() only). They are used in the
kernel and are provided to the userland via commpage entries.
* Introduced build system feature allowing easy use of C structure
member offsets in assembly code.

Changes after merging:
* Fixed merge conflict in src/system/kernel/arch/x86/arch_debug.cpp
(caused by refactoring and introduction of "call" debugger command).



git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23370 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Fixed a big bug in common_file_io_vec_pages(): vecOffset was not correctly
set when the first chunk of the file could be read in directly, causing it
to read data to a wrong place in the buffer.
* Reading in the first chunk directly would have also only worked if vecIndex
and vecOffset was 0 when calling the function.
* Applied the fs_shell changes in file_map to the kernel version as well (the
constructor already worked correctly, though).


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23265 a95241bf-73f2-0310-859d-f6bbb57e9c96

* vfs_unmount() can now safely be called from the kernel (fs_unmount() still
tried to access the uninitialized vnode in that case).
* That means that it's now safe to remove a mounted CD from the drive, it
will then be unmounted automatically.
* Added a check for partition::Device() - even though Ingo tells me it's
impossible, it was NULL once.
* Minor cleanup.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@22922 a95241bf-73f2-0310-859d-f6bbb57e9c96

axeld + bonefish: Missed those changes in the previous commit:
* Added vfs_unmount(), which allows unmounting by dev_t (used by the DDM).


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@22910 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Extracted file_map API out of the file cache - it's now an optional service
that can be used by file systems.
* Changed the way the file cache works: instead of reading/writing to the
underlying device directly, it can now be used for any data source, ie.
also network file systems.
* As a result, the former pages_io() moved to the VFS layer, and can now be
called by a file system via {read|write}_file_io_vec_pages() (naming
suggestions are always welcomed :-)). It now gets an FD, and uses that to
communicate with the device (via its fs_{read|write}_pages() hooks).
* The file_cache_{read|write}() functions must now be called without holding
an I/O relevant file system lock. That allows the file cache to prepare the
pages without colliding with the page writer, IOW the "mayBlock" flag can
go into the attic again (yay!).
* This also results in a much better performance when the system does I/O and
is low on memory, as the page writer can now finally write back some pages,
and that even without maxing out the CPU :)
* The API changes put slightly more burden on the fs_{read|write}_pages()
hooks, but in combination with the file_map it's still pretty straight
forward. It just will have to dispatch the call to the underlying device
directly, usually it will just call its fs_{read|write}_pages() hooks
via the above mentioned calls.
* Ported BFS and FAT to the new API, the latter has not been tested, though.
* Also ported the API changes to the fs_shell. I also completely removed its
file cache level page handling - the downside is that device access is no
longer cached (ie. depends on the host OS now), the upside is that the code
is greatly simplified.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@22886 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Got rid of the B_PARTITION_DESCENDANT_BUSY flag.
* Added CheckAndMarkBusy() and UnmarkBusy() methods to KPartition.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@22801 a95241bf-73f2-0310-859d-f6bbb57e9c96

Folded KPhysicalPartition into KPartition. Removed the notion of shadow
partitions from the disk device manager.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@22800 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Moved partition scanning back to KDiskDeviceManager. ATM only
synchronous scanning is supported.
* Removed the disk device job support from the disk device manager.
* K{Disk,File,Partitioning}System:
- Remove querying and validation methods.
- Commented out the modification methods until their fate is decided.
* Removed obsolete _user_get_partitionable_spaces().


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@22799 a95241bf-73f2-0310-859d-f6bbb57e9c96

It's not a good idea to write back large files while keeping the vnode busy.
The low memory handler now has two passes which should help there; however, it
might also accidently remove recently used vnodes, too. We could mark the clean
ones in some way if that turns out to be a problem.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@22678 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Added a "canWait" argument to vfs_get_vnode() - you can use this to ignore
busy vnodes.
* dir_create_entry_ref() used get_vnode() incorrectly (and could therefore
potentially prevent a file system from doing proper locking when called
from the kernel).
* The vnode_store now uses this for its acquire_unreferenced_ref()
implementation (and therefore for the page writer).
* read_into_cache() and write_to_cache() were still marked inline.
* The system will now wait 10 secs for a busy vnode before returning an error.
* It will also no longer panic in that case.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@22485 a95241bf-73f2-0310-859d-f6bbb57e9c96

Some types of files cannot be seeked and we need to fail in those cases.
We actually need to fail for sockets, too, but until I'm mistaken, we
can't identify them in the VFS. Fixes bug #1539.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@22480 a95241bf-73f2-0310-859d-f6bbb57e9c96

* struct vnode is an opaque type now, removed void* where it was used incorrectly.
* Minor cleanup.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@22461 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Reviewed checking of empty paths and fixed some occurrences. Thanks to
mjw for the hint. Fixes bug #1516.
* Changed _{kern,user}_create_symlink() to no longer check the supplied
link string. BeOS seems to do that, but this is not standard
conforming. The previous implementation even used the path processed
by check_path(), which would potentially have appended a ".".
* Some style cleanup.



git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@22451 a95241bf-73f2-0310-859d-f6bbb57e9c96

* fs_{write|read}_pages() now has an additional argument "mayBlock".
* the page writer don't allow to block, while all other writers do. This fixes
bug #1509. The reason the page writer needs this is because it marks several
pages from different caches as busy.
* Fixed a warning about ASSERT being defined already in BFS, since
util/DoublyLinkedList.h now includes debug.h.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@22434 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Renamed fs/vfs_select.cpp to wait_for_objects.cpp and got rid of
vfs_select.h, respectively moved most of it into the new kernel
private header wait_for_objects.h.
* Added new experimental API functions wait_for_objects[_etc](). They
work pretty much like poll(), but also for semaphores, ports, and
threads.
* Removed the "ref" parameter from notify_select_events() and the
select_sync_pool functions as well as from fd_ops::fd_[de]select(). It
is no longer needed. The FS interface select() hook still has it,
though -- the VFS will always pass 0.
* de]select_fd() take a select_info* instead of a select_sync* + ref
pair, now. Added respective functions for semaphores, ports, and
threads.



git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@22416 a95241bf-73f2-0310-859d-f6bbb57e9c96

* fd.c -> fd.cpp
* Reworked the select support:
- The io_context additionally stores a table of lists of select_infos,
which enables it to deselect events of a pending select() when
closing a FD. This prevents a race condition potentially causing a
write to stale memory.
- The opaque selectsync* passed to FSs is now actually a select_info*.
This was necessary, since the FDs deselect() hook (unlike the
select() hook) doesn't take a "ref" argument and deselecting a
single info (e.g. caused by a premature close()) was not possible.
The select() hook's "ref" argument has become superfluous.
- It should now be relatively easy to implement a poll_on_steroids()
that can also wait for objects other than FDs (e.g. semaphores,
ports, threads etc.).
* Set/reset the signal mask in common_select(). This makes pselect()
work as required.
* Reorganized vfs_resize_fd_table().



git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@22391 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Added some more debug output.
* Cleanup.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@22375 a95241bf-73f2-0310-859d-f6bbb57e9c96

bonefish+axeld:
* Removed the vm_cache/vm_store ref_count duality that besides being a bit ugly
also created the page dameon cache retrieval problem: now, only areas (and
cache consumers) retrieve a reference to the store (and therefore, the vnode).
The page daemon doesn't need to care about this at all anymore, and the pseudo
references of the vm_cache could be removed again.
* Rearranged deletion of vnodes such that its ID can be reused directly after
fs_remove_vnode() has been called.
* vm_page_allocate_page() no longer panics when it runs out of pages, but just
waits for new pages to become available using the new sFreeCondition condition
variable - to make sure this happens in an acceptable time frame, it'll
trigger a run of the low memory handlers.
* Implemented a page_thief() that steals inactive pages from caches and puts
them into the free queue. It runs as a low memory handler.
* The file cache now sets the usage count on the pages it inserts into the
cache (needs some rework though, cache_io() doesn't do it yet).
* Instead of panicking, the kernel will currently dead lock in low memory
situations, since BFS does a bit too much in bfs_release_vnode().
* Some minor cleanup.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@22315 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Added a clarifying comment to free_vnode() and prevented the vnode
reference count to drop below 0 there.
* Added TODO describing a serious race condition between free_vnode()
and the page daemon.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@22209 a95241bf-73f2-0310-859d-f6bbb57e9c96

Fixed get_mount(). It must also acquire the vnode lock before trying to
increment the root node vnode reference count. Otherwise it could race
with fs_unmount(). Fixes bug #1438.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@22203 a95241bf-73f2-0310-859d-f6bbb57e9c96

Some cleanup. Fixed gcc 4 warning.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@22202 a95241bf-73f2-0310-859d-f6bbb57e9c96

FD_CLOEXEC is a flag, other bits may be set


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@21829 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Merged vm_cache_ref and vm_cache to a single structure (Axel & Ingo).
* Renamed vm_cache.c to vm_cache.cpp


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@21642 a95241bf-73f2-0310-859d-f6bbb57e9c96

remove_vnode() will now return an error code if the vnode to be removed did not exist.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@21614 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Reserving areas never put down their reference of their address space when
removed in several cases.
* vfs_get_vnode_cache() now always gives out a reference to the cache it
returns; if it needs to allocate a new one, the vnode owns one reference,
and the caller another.
* therefore, file_cache_create() now owns a reference to its vm_cache_ref, and
frees it in file_cache_delete().


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@21533 a95241bf-73f2-0310-859d-f6bbb57e9c96

Got rid of vnode_id and mount_id, replaced with ino_t and dev_t.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@21485 a95241bf-73f2-0310-859d-f6bbb57e9c96

* create_vnode() now panicks when it could not find the freshly created vnode
in the vnode hash; that's a bug in the FS that shouldn't be ignored that way.
* Minor cleanup.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@21262 a95241bf-73f2-0310-859d-f6bbb57e9c96

added a missing newline, dunno why this message is displayed :)


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@21250 a95241bf-73f2-0310-859d-f6bbb57e9c96

get_vnode_name():
* read_dir() is supposed to return B_OK and and a count of 0 when
reaching the end of the directory. In case the node in question could
not be found, we were looping infinitely.
* free_dir_cookie() was not invoked.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@20519 a95241bf-73f2-0310-859d-f6bbb57e9c96

* The close-on-exit bitmap vfs_new_io_context() created was a byte
short, if the FD table size wasn't a multiple of 8.
* vfs_resize_fd_table() didn't seem to know at all about the
close-on-exit bitmap. The pointer in the io_context would point to
free()d memory afterwards. This explains the sporadically closed
stdin/out/err descriptors in programs started from Tracker and
Deskbar.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@20413 a95241bf-73f2-0310-859d-f6bbb57e9c96

Renamed the FS interface hook read_link() to read_symlink().


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@20330 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Removed write_link from the FS module interface. Adjusted all FS
add-ons accordingly and removed the syscall.
* Removed send_notification().
* Reimplemented notify_listener(). It used the unimplemented
send_notification(). Now it has a chance to work. Note that
notify_listener() is obsolete. I would already have removed it, if
there weren't lots of FS implementations still using it (Hint!).


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@20329 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Introduced the new static lock sVnodeCoveredByMutex to guard the
vnode::covered_by fields. Together with sMountOpLock it allows write
access, either lock alone suffices for read access. Before
sMountOpLock had to be acquired for read (and write) access, which
meant that while mounting/unmounting a FS path resolution would have
to wait. In case of the UserlandFS this would even cause a deadlock
while mounting if the client tried to resolve the path of the device
to be mounted (e.g. by opening it).
* Added a clarifying comment about read access to the
fs_mount::covers_vnode/root_vnode field and removed locking in
resolve_volume_root_to_mount_point() which was not necessary for
explained reasons.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@20308 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Changed get_vnode_name() to take a dirent* parameter instead of the
name (saves copying the name, if that has to be done anyway) and added a
wrapper version with the old interface.
* dir_vnode_to_path() was broken for file systems that didn't support
the get_vnode_name() hook. It resolved the mount point too early, so
that it was searching the mount point and not the FS root dir for the
node. It uses the get_vnode_name() function now (before resolving the
mount point).


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@20305 a95241bf-73f2-0310-859d-f6bbb57e9c96

is_vnode_removed() is now known as get_vnode_removed() and returns its
answer through a reference parameter.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@20297 a95241bf-73f2-0310-859d-f6bbb57e9c96

Be nicer to FSs and fill in the known part of the fs_info *after* the FS
had its go. BeOS does the same.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@20262 a95241bf-73f2-0310-859d-f6bbb57e9c96

Resurrected is_vnode_removed().


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@20256 a95241bf-73f2-0310-859d-f6bbb57e9c96

Return sensible errors instead of -1. Added some TODO comments.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@20166 a95241bf-73f2-0310-859d-f6bbb57e9c96

Implemented get/setrlimit(RLIMIT_NOVMON). Note the kernel calls don't set errno... but they're called by user versions. Might want to split them if needed.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@20165 a95241bf-73f2-0310-859d-f6bbb57e9c96

Added a comment about the outcome of a potential problem.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@18717 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Reverted the changes r17693 made to vfs_get_vnode_cache(); instead, vm_create_vnode_cache()
will now grab a reference to the vnode as well if successful. This way, vfs_get_vnode_cache()
now actually works how it should: it will now always grab a reference to the cache and
its underlying vnode. This removes an extra reference to the vnode (and vm_cache) that
got ignored before and prevented volumes to be unmounted (or file caches to be removed).
Thanks to Korli for pointing this out.
* file_cache_create() is now aware of that extra vnode reference and releases it; unmounting
volumes is now working again as it should.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@18716 a95241bf-73f2-0310-859d-f6bbb57e9c96

improve debug command vnode_cache: it now accepts a device arg


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@18618 a95241bf-73f2-0310-859d-f6bbb57e9c96

Use B_MAX_SYMLINKS instead of SYMLINKS_MAX (which also fixes the build, btw).


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@17900 a95241bf-73f2-0310-859d-f6bbb57e9c96

Implemented mandatory file locking, BeOS style. BNode::Lock() and BNode::Unlock()
are now working as expected.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@17697 a95241bf-73f2-0310-859d-f6bbb57e9c96

_vm_map_file() did in fact not work correctly, but the main problem was
vfs_get_vnode_cache() which did not acquire an extra reference to the
cache_ref when the cache had to be created.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@17693 a95241bf-73f2-0310-859d-f6bbb57e9c96

Made _user_open_entry_ref() a bit more relaxed and return B_BAD_VALUE on some
obvious errors.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@17586 a95241bf-73f2-0310-859d-f6bbb57e9c96

common_lock_node() now pretends to be successful - this should fix Vision not being
able to store its settings for now (bug #589).


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@17505 a95241bf-73f2-0310-859d-f6bbb57e9c96

When you try to mount a file image, BFS now only sees the normalized path instead
of the one supplied to fs_mount() (but not the /dev/disk/virtual/... entry, as that
wouldn't be that clear to the user).


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@17335 a95241bf-73f2-0310-859d-f6bbb57e9c96

* KDiskDeviceManager::_ScanPartition() can now run synchronously (and execute the
scan job in the calling thread).
* KDiskDeviceManager::InitialDeviceScan() now runs synchronously, so that
get_boot_partitions() doesn't need to do this ugly wait hack.
* KDiskDeviceManager::CreateFileDevice() can now run synchronously as well, which
fixes a deadlock in fs_mount() - note, mounting file devices still doesn't work,
though as Haiku's BFS doesn't allow this right now.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@17334 a95241bf-73f2-0310-859d-f6bbb57e9c96

Fixed a bug in the VFS that could cause BFS to corrupt an inode:
dir_remove() did not normalize the path, and thus, could forward a "." as
name for the removed directory - which BFS didn't catch because it assumed
our VFS would work correctly...


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@17165 a95241bf-73f2-0310-859d-f6bbb57e9c96

Instead of ending up in an endless loop, fs_sync() will now bail out in
case get_vnode() fails.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@17162 a95241bf-73f2-0310-859d-f6bbb57e9c96

Instead of waiting forever, get_vnode() will now fail after 3 seconds if the
vnode is not becoming unbusy (right now it even panics, but that can be removed
later on).


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@17161 a95241bf-73f2-0310-859d-f6bbb57e9c96

Fixed bug #483:
* vfs_get_fs_node_from_path() now also work for absolute paths again (but
still for relative ones from the volume root) - it just tests if the
mount IDs fit, so it only returns successful if the path really is on
the desired mount.
* the Disk Device Manager publish functions now call devfs_publish_*()
correctly (by omitting the "/dev/" mount point).
* devfs_publish_partition() now accepts absolute device paths but relative
partition paths.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@17138 a95241bf-73f2-0310-859d-f6bbb57e9c96

vfs_get_fs_node_from_path() didn't work correctly and ignored the mount_id
(ie. it only worked for absolute paths, but it shouldn't work for those at
all).


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@17127 a95241bf-73f2-0310-859d-f6bbb57e9c96

Added a "reenter" parameter to the {read|write}_pages() functions to give file
systems a chance to know if they have locked already.
This fixes a locking problem in BFS where one thread tried to acquire two read
locks (where someone else trying to acquire a write lock would have caused a
dead lock).


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@17108 a95241bf-73f2-0310-859d-f6bbb57e9c96

* fs_sync() and free_vnode() now use the file system's fsync() hook to write back
changes made to a file instead of directly using vm_cache_write_modified() -
besides making the file system more independent from the file cache, this also
works around a possible dead lock (that is to be fixed in a later commit).
* fs_sync() no longer uses vnodes from the mount's vnode list directly to write
back the changes made to them, but gets them via ID instead - this makes sure
the vnode is in a valid state and fixes a race condition with free_vnode().


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@17059 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Factored out the vnode disconnection code from fs_unmount() to a separate
function, and added a vfs_disconnect_vnode() for other kernel components.
* devfs_unpublish_device() can now optionally make use of this call.
* Fixed the type check of devfs' unpublish_node().


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@16907 a95241bf-73f2-0310-859d-f6bbb57e9c96

Minor cleanup.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@16784 a95241bf-73f2-0310-859d-f6bbb57e9c96

Removing the nodes from the unused list in fs_unmount() had the side effect that
the root vnode was tried to be removed as well (which resulted in a crash).
Since playing with the root node reference count is a bad idea anyway and opens
a big race condition (with regards to the unused list), we no longer do that
now, until it's safe.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@16665 a95241bf-73f2-0310-859d-f6bbb57e9c96

Fixed a couple of bugs:
* fs_unmount() freed vnodes, but didn't remove them from the unused list if
needed.
* vfs_get_module_path() could put a vnode twice under several situations.
* vnode_path_to_vnode() now always puts the dir vnode, even if the provided
path is NULL. Documented the fact that it does eat the ref, too.
* Added a to-do item in vfs_get_vnode_cache() about a possible problem.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@16662 a95241bf-73f2-0310-859d-f6bbb57e9c96

Fixed a possible deadlock I've introduced earlier (since create_sem() calls
vfs_free_unused_vnodes()); the vnode mutex is now hold for much shorter times
only:
* Rewrote advisory_locking creation/maintenance to hold the vnode mutex only
for very short times.
* the vnode mutex is no longer held during file cache construction; instead,
the vnode is marked busy.
* Implemented an (incorrect for now) get_advisory_lock()


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@16635 a95241bf-73f2-0310-859d-f6bbb57e9c96

* get_vnode() did not decrease the sUnusedVnodes counter when taking one node
of that list.
* Added a vfs_free_unused_vnodes() function that calls the low memory handler
directly.
* create_sem_etc() now calls the above function in case there are no semaphores
available anymore; this usually frees up to 2 semaphores per node (one from
the cache if there is a file cache attached, and eventually one from the
file system).


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@16610 a95241bf-73f2-0310-859d-f6bbb57e9c96

Added debugger command that dumps info about the vnode usage.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@16607 a95241bf-73f2-0310-859d-f6bbb57e9c96

It's not so problematic if a busy vnode was released; what is problematic is
if that was the last ref.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@16590 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Reduced the stack usage of most of the I/O paths - there were several places
that put one or more full paths on the stack before, which could cause some
problems under certain conditions.
* Cleaned up KPath, ie. use size_t instead of int32 where appropriate, added
license.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@16585 a95241bf-73f2-0310-859d-f6bbb57e9c96

* Finally implemented B_WATCH_MOUNT, ie. Tracker now shows newly mounted volumes
(mounting still only works from the Terminal).
* Shuffled functions in node_monitor.cpp around to clearly differentiate between
private, private kernel, and public kernel functions.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@16575 a95241bf-73f2-0310-859d-f6bbb57e9c96