Removes all traces of mds_req, mds_rep, ost_req, and ost_rep.  All subsystems
now use the functions in rpc/pack_generic.c, which are based around
struct lustre_msg.  That file is small and easily understood, see it for more
details.

Now that everyone uses the same functions, the code can probably be refactored
more sensibly.  This is left as an exercise for the reader.

Other, cleanups:
- we don't need to memset() after OBD_ALLOC
- the MDS and OST request and reply packets were so similar that they've been
merged, into struct mds_body and ost_body respectively.

Ensure that the file type is valid.

Remove use of ext2-specific inode flags to signal objid-in-i_data.  Just
use the check whether it is a regular file.

Also don't use memcpy when saving objid into inode - it should be endian
converted beforehand.

Ensure we undo everything in ll_read_super() on error.

Add a check in new_fs() to try and avoid overwriting an in-use block device.
Not perfect, because it will only check for mounted filesystems, but better
than nothing.

Add open/close methods for filterobd.
Other minor cleanups to replace "ext2obd" with "filter" in unused codepaths.

- Don't start acceptor in the background anymore

- Fixed lock tests--early indicates are that extents are working

Add journal wrapping calls to all of the mds_reint operations.  We also
use the mds_fs_setattr method to change the fields in the inode, as this
will properly mark the inode dirty and ensure it is written to disk.

This fixes the problem of updates to the MDS inode not being written to
disk because the dentry and inode are being discarded too quickly.

The journal wrapping of all reint operations will make the addition of
calls to atomically update last recieved trivial, so it is time well spent.

- Don't abort if fig2dev doesn't exist
- first chunk of DLM changes for new extents
- fixups to work with the new Portals tip

Add skeleton definition for struct obd_run_ctxt to quiet compiler warning.

Because we now return an error code from filter_prep() we have to make sure
we return 0 if we made it through OK...

The start of moving the MDS root out of the filesystem root.  A bit of
code reorg, and we now create ROOT and FH directories (no RCVD file yet).
Also moves MOD_INC_USE_COUNT earlier in mds_setup to avoid races.

Clean up strange loop variable usage in filter_preprw() and filter_commitrw(),
and make variables more local.

Have filter_prep() return an error code, and minor cleanups.
Move MOD_INC_USE_COUNT earlier in filter_setup() to avoid module unload races.

Remove simple_mkdir(), push_ctxt(), and pop_ctxt() from filterobd.c and
put them in lib/simple.c so we can use them in MDS.  Add simple.c to
files for obdfilter.

Add .eps files to ignored files for doc/ directory.

You don't need to specify the size for new_fs() if you are using a block
device (we just use the whole block device in that case).

Make some attempt to clean up ptlrpc_init_svc() if there are errors setting up
the ring buffer.

Move MOD_INC_USE_COUNT up in ost_setup() to avoid module unload races.

Add push_ctxt and pop_ctxt to simple.c from filter.c.

Move simple_mkdir() out of filterobd so that MDS can use it also.

- update a 3 year old message
- split the failing (uml) part of the io-failure mechanism into a separate patch

Fix the setattr and rename error messages and turn off shell verbosity.

Add checks into MDS failure test to verify operations failed.

- this Makefile.am re-builds the eps pictures and the master pdf document

add missing close to filter obd

Re-enable writes only after MDS has been shut down.

A script which sets up an ext3 testbed (ala llext3.sh), and then runs some
failure tests (setattr, create, unlink, rename) that would write to disk.

- add disk write instrumentation to 2.4.18 patch

- lustre_mds.h: just shrink_dcache on de
- file.c: reverse the order of the MDS/OST open RPCs
- runfailure-net: do unmount/mount after each test

- forgot to put the parent...

- second part of shrink fix

- part one of prune fix.

- add a target that automatically builds the pdf document.
- updates to the Lustre HOWTO, still incomplete
- include lock manager in master.

- runfailure-net fixes:
  - create /dev/request
  - the open() test needs to actually do an open()
  - don't use "run 0 foo" to avoid 'No such pid' error

- fixed up lustre_mds.h to allow inclusion in userspace testreq.c
- added ptlrpc_abort_bulk() to help cleanup aborted requests
- changed giant obd_support.h enum into #defines, which will save me hours of
  counting.
- fixed the ioctl interface to the MDC, so testreq works again
- gave testreq a real interface, to just run one test at a time
- ptlrpc_abort() was freeing a variable which would almost always still be NULL.
  Fixed.

Make the failure testing readonly stuff conditionally compiled based on
whether the kernel has been patched with support for it or not.

- fixes to filter obd
- move inode size update to file close time.

A bunch of minor cleanups when using sizeof().  This even appears to have
caught 3 minor bugs in the code.  Prompted by a couple of similar bugs that
were just found in the kernel.

Basically, with a variable like "struct foo *bar" it is preferrable to
use "sizeof(*bar)" everywhere instead of "sizeof(struct foo)".  The
former isolates us from errors in case the type of "bad" ever changes.

Apparent bugs were in filter/filter_obd.c and ldlm/ldlm_resource.c (we
were using __u32 when the variable was declared as __u64).  There also
appears to be a memory leak in ldlm_resource.c.

Add new simple test script "runtests" which automates a bunch of the basic
tests which I do before committing stuff to CVS (copy some files, check
they are OK, shutdown+restart, check files again, etc).

Add support in "new_fs" for using pre-built filesystems for testing (this
is considerably faster than building a new fs each time on loopback).

- add obdfilter to our setup, cleanup and debug environment
- fix tiny bug in filter.c

Clear the readonly state flags when we initially set up MDS and when we exit.

Remove READPAGE_BULK_NET (unused).  Without this minor change, the error
codes at the end of runfailure-net script are wrong.

It might be nice in the future to have a name->number conversion tool
which could always get this correct, but it isn't a big deal yet.

- add more infrastructure to handle extents and debug.
- some of this is going to change dramatically as we feel we
  are handling too many resources now.

Simple script to test all of the network packet loss scenarios.

Patch to allow disabling devices for testing failure/recovery scenarios.
By itself this patch does not enable failure testing, but when it is
applied to the kernel, the OBD_FAIL_WRITE() call will activate it.

Patch currently supports loopback, IDE, and UML ubd failures (ignore patch
reject for ubc.c if not using UML).

Enable MDS write failure testing via "echo <num> > /proc/sys/lustre/fail_loc"
where <num> is the number of a write failure breakpoint (OBD_FAIL_MDS_*_WRITE
as defined in the enum in obd_support.h).

Reinstate the delete_inode methods.  We now make a copy of the superblock
operations table for the MDS superblock so we don't affect other users of
that client filesystem type.

I also removed a duplicate call to rpc_unregister_service() in mds_cleanup.
This is what was causing the "rpc unable to unregister 12" type messages at
cleanup.

Set a flag in the inode if we have stored the objid there, so we know when
we should clear it.   Also make clear_inode() the default cl_delete_inode
method so we don't have to do an extra check for it.

In the end, I think that the objid issue is not a source of any problems,
because ext3_delete() will only call ext3_truncate() if i_blocks is non-zero,
and it isn't (this is why we weren't seeing any errors from ext3 trying to
truncate "blocks" that are not allocated).

Disable the delete_inode overloading for now.  It overloads the methods
for _all_ users of that filesystem type, which is obviously bad.

All of the "hack" and FIXME stuff in MDS is now handled by fs-specific methods
which are selected at mount time.  This includes journaling support.

Changes OBD_FAIL_WRITE() to include the block device which should be
disabled.  We conditionally compile the "make device readonly" support.

Add definitions of the MDS client filesystem methods to headers and Makefile.

Add in a delete_inode method for use when the inode is finally unlinked,
so that we can clear out the objid if necessary.  Since delete_inode
is handled by a callback from the VFS when n_link == 0 (and we don't
want to introduce race conditions by checking this at unlink time), we
replace the client delete_inode method with a filesystem-specific MDS
delete_inode call, and then call the client delete_inode method from
within our MDS delete_inode operation.

- Replace the complicated waitq story with a much less complicated
semaphore
- Move semaphore after allocation

Try using add_wait_queue_exclusive to avoid waking all (x - 32)
suspended request threads at once.

- Added a queue length and waitqueue to the client structure in an
attempt to limit the number of concurrent requests outstanding at a
given time.

Move mds_null.c back to mds_ext2.c - we have more than just the journaling
methods now (setattr, set_objid, get_objid, readpage), which extracts all
of the filesystem-specific hacks out of MDS.  We now have files with a very
high-density hacks for ext2 and ext3, but at least we can clean it up easily.

There was a race between ll_unlink and ll_create_node: notably,
ll_unlink would make the inode available on the MDS before the local
dentry/inode on the client was put away.  This could lead to re-using
inode numbers with a concurrent create going on.

We fixed this using the generation number.  We also added the
inode/generation to unlink as a sanity check.

- added a find_inode function that iget4() will use to compare inodes.
  find_inode simply compares generation number with what we get from MDS
- set rep->generation in mds_reint.c:mds_reint_create()

Actually mount the filesystem in llmount.sh.

The previously checked-in empty filesystem was dirty for some reason.

Increase MDS and OST request buffers to 128k each

Various llmount-client/server fixes

More 'rpc_register_service' removal

- simplified ptlrpc_service by using ME auto-unlinking
- merged ptlrpc_init_srv and rpc_register_service

Simple journal abstractions for the no-journal (ext2) and ext3 cases.

Empty filesystems for creating tests.  Using these is _much_ faster than
using "dd" to create an empty file and then mkfs to create the filesystem.
They are also highly compressed (1000:1) so they don't use much space.

The new_fs() helper in common.sh will use these files instead of dd+mkfs
if they match the parameters given to new_fs().

Set an initial value for return code.

Don't dereference "lock" before it is set.

 remove gid/rid's; minor cleanups.

- default to 5G
- run with -i 0 -i 1

- build truncate with LARGEFILE64_SOURCE
- truncate's second argument is now in KB

*** empty log message ***

- more of the locking infrastructure.
- BUG -> LBUG to work with the crashdump tools

- ll_file_open was not passing the correct file->f_flags to mdc_open.  Fixed.

- don't read the page if we're just about to completely overwrite it
- fixed one of the page invariant BUGs

Commit changes to use new setup_portals helper function.

mds/handler.c, mds/mds_reint.c: fixup the ext3 MDS code a bit to build on
the older 2.4.9 kernel (i_blkbits does not exist there), and add
in the missing fixup for i_diskblocks
ALL: add in test framework for simulating errors, dropped packets, etc.
does not yet integrate with the ext3 on-disk error interface

Remove yet another extraneous BUG()

Remove annoying output from the shell when acceptor is stopped.

Fixup logic a bit.

Move portals setup into a helper function "setup_portals" that uses the
enviroment variables "NETWORK={elan,tcp}", LOCALHOST, SERVER, and PORT.

Simple script to run vmstat and prepend the time, so we can see when vmstat
is not being scheduled instead of thinking that something is strange.

Remove silly BUG() that catches "erroneous" writes above 4G.

The ext3 MDS code.  Basically, we have to hack around the fact that ext3
does not have the directories in page cache, so we need to export the
ext3_bread() function in order to ensure we read the same data as what the
filesystem itself is using.  This will likely go away at some time in the
future as ext3 is ported to the pure page-cache-based directory handling
that is in ext2 (which is slightly more efficient).

use relative paths to insert the modules relative to the test script

- added non-fatal qswnal insertion to common.sh
- fixed up various scripts to use the common.sh variables

Script to use an existing ext3 MDS setup.  Useful for testing recoverability
of an MDS setup with llext3.sh.

Script to run iozone in a loop.  It probably doesn't have the right iozone
parameters that people want, but it is a start.

Update rundbench script for new debug control file.

Update ostreq.sh script to use new helper functions.

Minor cleanup.

The loopback device helper will use the next unused loopback device instead
of just starting at minor 0.

- Take advantage of new disconnect semantics to make llmountcleanup.sh a more
general script

Add ext3_bread to exported symbols.  Needed because ext3 does not have
directories in the page cache yet.

- Removed an overzealous BUG() that keeps us from cleaning up after C-c

Indenting only.

- Added UUID description to network document
- fixed leaked refcount in failed osc_request startup
- small debugging message fix
- removed extraneous PtlMDUnlink
- try to remove kqswnal in llmountcleanup

add path

dd kernel version deps
Cdd \7f\7f\7f\7fVS: ----------------------------------------------------------------------