CVS log for emstar/fusd/include/kfusd.h
	Help

Request diff between arbitrary revisions / Display revisions graphically / Jump to LXR

integrated dustin's patches for 2.6
thanks, dustin!

My attempt at creating a version of FUSD that does not require devfs
and also requires no corresponding userspace daemon.  The kernel module
does the mknod from inside the kernel, calling sys_mknod. Unfortunately,
kernel hackers consider this an evil thing to do, and the sys_* symbols
are no longer exported in later kernels.  So, this code does not work.
But it's nice, so I thought I'd at least check it in for posterity.

Last fixes to kfree/vfree stuff

One more fix to vmalloc macros...

Fixed the VMALLOC macro definition... duh

GRRR

Minor fixes to error messages, added todo list..

Lots of changes to fusd!

* NON-DEVFS daemon work:
  * fusdd daemon uses a sorted list to improve lookup performance
  * test code added to fusdd daemon
  * major bug in fusdd fixed: was not unlinking devices
  * fixed a few error cases to be more correct

* changes to kernel module:
  * devfs and non-devfs modes unified for upgrade to 2.6 kernel
    allocates its own device and just uses devfs for doing the mknod
  * "specific waitfor" mode implemented, enables more efficient waiting for
    a specified device
  * single device list and lock broken up into hash table, with
    finer grained locking and separate wait queues for device waitfors

* Modified FUSD to support unlimited numbers of devices in non-devfs mode
* Modified FUSD status protocol to support diffs with a 10-second refresh

FUSD no longer depends on DevFS!!!

TO use this feature, compile on a system with a non-devfs kernel,
insert the module, and run the fusdd user daemon.  Otherwise it
works identically to devfs fusd.

This also involves a change to the fusd status output, so old fusd's
are not compatible with the new fusd.

1) significantly expanded the information returned by /dev/fusd/status;
there is now per-client state printed such as what that client is doing,
whether it's readable or writable, etc.

2) made (yet another) small change to the semantics of FUSD's poll handling.
hard errors returned by a fusd server's poll_diff are propagated back to
the client as select failures, rather than putting them in the exception
set.

added the copyright notice to all the source code in the cens repository

- added a copyright notice to all the source code files in the cens
repository

Added an additional case where forging a close might be necessary.
Was sometimes causing processes not to see balanced open/close pairs.
Mainfested by emrun thinking that a process had not yet died when it had,
but it simply hadn't gotten the close() notification for the log or
control device.

** FINALLY FIXED BUG CAUSING PROCESSES TO GET STUCK IN D STATE -- in
fusd_client_poll, there was a call to LOCK_FUSD_FILE followed by
LOCK_FUSD_DEV.  The LOCK_FUSD_DEV call might jump out if the dev was
a zombie, leaving the file locked.  WHOO HOO!!!!

** Changed (slightly) semantics of callback returns: changes to
device_info made in fusd_file_info are no longer honored.  device_info
can ONLY be set when the device is registered.

** Various other cleanups in handling of zombies -- zombie checks are
now never performed unless the device is locked.  A lot of "zombie_dev"
goto targets are, as a result, gone.  But I think this is a good thing,
as they can be confusing (see first entry in changelog!)

Checked in the epic bugfix to finally remove what I think are the very last
of the SMP-unsafe problems: the infamous race between clients opening and
unregistration.  Passes a whole slew of regression tests, including one
that was able to consistently deadlock the old code.

Added a global process list -- the first step towards being able to
notify processes (such as emrun) that devices are ready for use.

Since we now have a global process list, the kernel module notifies the
library of EEXIST in case of a repeated registration (e.g. registering
a device whose name has already been registered with fusd in the past).
This uses a (potentially slow) linear search for now, but it's something
we only pay on registration, that doesn't happen too often.

Because of the above check, I removed the check from libfusd.c.  That is,
libfusd does not any longer check to see if you are registering a device
that already exists.  This is much faster since it now no longer tickles
devfsd to try to load a kernel module to support your device (something
that really made starting the simulator very slow).  But, it no longer
allows detection of non-devfs devices (e.g., if you try to use FUSD to
register /dev/null, you'll get a confusing EIO and an error in dmesg,
not an EEXIST as would have previously happened.)

Took out the old VERYSAFE debugging mode, since I never use it.

Make sure that we never pass a null fusd_dev->name to printk

Merged FUSD with main branch again

Merged in the new FUSD from the main development branch

minor changes to comments

removed an unused flag from struct fusd_file

The C library now lets users discard state instead of spuriously
returning it, so kfusd no longer keeps track of how many
outstanding polldiffs there are.  It resets the polldiff state
every time a polldiff is received, not when the (former) refcount
drops to 0.

Major changes!!!!!

Restartable system calls have been implemented but this unfortunately
required quite a few changes to the guts of FUSD, which has not been
battle tested yet.  It passes my test suites but this thing needs to be
banged on for a while longer before I'll feel safe with it.

Some highlights of changes:
 -- restartable syscalls implemented
 -- fusd_fops_call() was split into a top half (that generates a message)
    and a bottom half (that waits for the reply).  This makes restartable
    syscalls much easier.
 -- fusd_fops_call_send() -- the top half as described above -- is now
    further decomposed into a function called dev_send_msg which puts a
    message on a device's outgoing message queue.  Used by fusd_fops_reply
    to easily forge a "close" request in response to a successful open
    request that has no connection.
 -- "hints" (i.e. the quick index hint into the fusd_dev's reply array)
    is now part of the fusd_msg instead of being kept internally.  This
    makes the handling of all that state much more scalable since it's
    kept with the request - why didn't I think of this earlier!?!??

Lots of other minor (and some not so minor) things - see diffs for details

Memory debugger code now reports size of the leak as well as its line num

Fixed a memory leak in the VERYSAFE mode code that would be triggered if
the kernel runs out of memory.

Initial step towards reworking a lot of FUSD code, in preparation of
fully implementing restartable syscalls.  More work done.  This version
should NOT be considered production quality yet.  More regression testing
needed.

Started implementation of restarted system calls

Took out the rather unfortunate use of atomic_inc_and_test, which was
incorrectly documented in Rubini's book.  Forced to roll my own.

Switched over to using CONFIG_FUSD_x for configuration, so it will play with the kernel configurator

Use atomic_t where appropriate to make us truly SMP safe

Fixed use of the null do-while 0 use

Did a lot of work in trying to optimize the scheduling of fusd drivers
and the processes using them.

In the kernel: the driver now immediately yields the processor when
it completes a syscall.

In the user-space library: we now try to read as many fusd messages as
possible in fusd_dispatch() before giving up; thanks to the new
yielding in the module, it is very likely (when doing bulk data
transfer) that the app will issue another syscall before the driver's
next read.  This minimizes the number of context switches and syscalls
and increased speed by about 50%.  In particular, bulk data transfers
look (to the driver) like a long series of successful reads; no select
or even blocking on read in between!

We also now (optionally) use wake_up_interruptible_sync instead of plain
wake_up_interruptible in cases when we know we are about to yield to
another process.

fusd_run has been changed to take no args and return no retval; it
simply runs forever doing a fusd_dispatch on any readable FDs.  Meant
to be the simplest of "simple" interfaces.  Changed many example
programs to use the new fusd_run().

Changed kfusd.c default debug level from 10 to 2

Changed __VERYSAFE__ to __FUSD_VERYSAFE__

Minor changes so that the debugging code compiles with more pedantic gccs

Fixed the semantics of poll_diff (i.e. the underlying implementation of
select).  Has been broken for a couple of months.

Important fix - poll_diff now converts from the constants used by the
fusd userspace API (FUSD_NOTIFY_INPUT, FUSD_NOTIFY_OUTPUT) to the
constants used internally by the kernel (POLLIN, POLLOUT)

switched back from vmalloc to kmalloc

major overhaul of internals: outgoing messages are now part of DEVICE state, not FILE state

added memory debugging support

fixes to make select work correctly

this either completely fucked everything up or implemented select

YANLS (yet another new locking scheme) and a fix to libfusd so that NOREPLY works

tried to make memory use safer by limiting malloc sizes and using vmalloc/free for large buffers.  still possible for malicious attackers to kill us though

took out debugging stuff

added the "hint" system to avoid linear searches through arrays in the common case

variable sized array patch

added VERYSAFE to make extra sanity checking optional

FIRST VERSION BELIEVED TO HAVE CORRECT LOCKING

select implemented for /dev/fusd, locking commented out for nwo

added locks for correctness

maybe read works now, god willing

holy shit, does this actually work?

*** empty log message ***

*** empty log message ***

first version of all files