- new file

- added, may prove useful as the first 20 lines of code.

Fixed build break

Fixed build break

WARNING - if an RPC times out you will crash older UML's.

Update your user mode linux to the 2.4.18 um15 + extra patch
  take source from ftp.lustre.org:/pub/people/robert
[call_usermode_helper has a bug in older versions of UML]

- new infrastructure for MDS failover recovery
  - recovd replaces the ha daemon. Now located in RPC directory
  - this comes with a service daemon to answer connect calls
  - wrapped it in an obd, for management purposes, and to be able
    to run multiple daemons on one system eventually
- commit callback daemon added to the lustre_lite directory
- removed small amounts of dead code from the rpc directory
- this code has seen little testing
- added the configuration management section to the master document

Populate 'peer' before using it.

Fixed some thinkos in the remote connection/token stuff.  Fixed a typo in the
previous lock init fix.

ptlrpc_client->cli_lock moved to ptlrpc_connection->c_lock, but I'd forgotten
to move the spin_lock_init().  Fixed.

- added connection structure which encompasses some (but perhaps not enough yet)
HA elements and a lustre_peer.  see rpc/connection.c or lustre_net.h for the
very-simple API
- removed many duplicated structure entries from the RPC path
- broke local_lock_enqueue into two functions; create the lock, do the remote
operation, do the local operation.
- the shadow local lock tree is implemented, but not tested.

Add elan config files (not sure if they are correct, but someone will fix
that).

- add a new directory for extN file system: ext3 with new features
 - placed large directory patch in this directory.

Renamed a few of the config files so that they are grouped more logically
together.

A regression test for networking (probably using the echo device).

It runs test_getattrs, test_brw (read, then write).  First simple tests,
then increasing in size, threads, etc.

This uses the new config setup, so it needs to be run like:

runregression-net.sh local.cfg echo.cfg client-echo.cfg

Still doesn't work correctly (details to be worked on include proper
cleanup, remote setup of the server, remote debugging, etc).

Split out the various common configurations into simple config files.
These will be used by various scripts for configuration, and can be
copied, combined, edited for each user as desired.

The llsetup.sh script will do the appropriate configuration based on
the config scripts that are passed.  For example:

llmount.sh == llsetup.sh local.cfg client-mount.cfg mds.cfg obdext2.cfg
llecho.sh  == llsetup.sh local.cfg client-echo.cfg echo.cfg
llmount-server.sh = llsetup.sh server-net.cfg mds.cfg obdext2.cfg
llmount-client.sh = llsetup.sh client-net.cfg client-mount.cfg

It is of course possible to combine several of the config files into a
single file for ease of typing, these ones are just the basics, e.g.

llsetup.sh peter.cfg
llsetup.sh adilger.cfg

By default it will also check in $HOME/.lustrerc for configuration before
parsing the specified config files.

None of the other scripts have been moved over to this config setup yet.

Still TODO: remote server setup

Consolidate verbose flag parsing.

Change the "silent" handling code to be "verbose" handling.  The devault is
still to print each item as it happens, but now there are more options.

- you can use letters 's' or 'q' to be silent/quiet
- you can use letter 'v' to be verbose (default, print each item)
- you can use positive numbers to show each Nth item (default = 1, like 'v')
- you can use negative numbers to show output every -N seconds

The "--threads" command now takes a mandatory "verbose" flag because with
large numbers of threads it is too much output.  Note that this flag only
applies to the spawning of the threads and not the individual commands
(which can have their verbosity specified separately).

Example:

          device number-v v-command    v------v-command args
obdctl --threads 100 20 2 test_getattr 10000 -5
    threads count-^   ^-threads verbosity     ^-test_getattr verbosity

- run 100 threads, and print status for each 20th thread started
- on device 2 run test_getattr for 10000 attrs and print status once per 5sec

Mention new --device flag for running obdctl commands instead of old way.

We already create /mnt/lustre in setup_lustre if it doesn't exist.

- More Peter's additions for the ha manager. This doesn't seem to break much -
  but this code hasn't been tested much.

No new functionality outside of the DLM.  ptlrpc_client no longer contains
a peer, so the peer is passed in and managed separately.

- All of the DLM calls are hooked up to the RPC system now
- Some unmaintained local processing code removed
- Added ldlm network-related bits to the test scripts

Support for running multiple threads with a single command.  This adds
the "--threads" parameter, which takes as arguments the number of threads
to fork, the device number, and the command (and optional arguments) to run.
Usage is similar to the "--device" command, with an additional argument.
("--threads 1 X <foo>" does about the same thing as "--device X <foo>").

Usage example:

# tests/llecho.sh

# utils/obdctl --threads 5 2 test_getattr 5000 q
--threads: starting 5 threads on device 2 running test_getattr
--threads: thread 1 (PID 6029) started
--threads: thread 2 (PID 6030) started
test_getattr-1: 5000 attrs (testing only): Tue Apr  9 22:45:25 2002
test_getattr-2: 5000 attrs (testing only): Tue Apr  9 22:45:25 2002
test_getattr-3: 5000 attrs (testing only): Tue Apr  9 22:45:25 2002
--threads: thread 3 (PID 6031) started
--threads: thread 4 (PID 6032) started
--threads: thread 5 (PID 6033) started
test_getattr-5: 5000 attrs (testing only): Tue Apr  9 22:45:25 2002
test_getattr-4: 5000 attrs (testing only): Tue Apr  9 22:45:25 2002
test_getattr-2: 5000 attrs in 17.24s (290.1 attr/s): Tue Apr  9 22:45:42 2002
test_getattr-3: 5000 attrs in 17.26s (289.7 attr/s): Tue Apr  9 22:45:42 2002
test_getattr-1: 5000 attrs in 17.29s (289.2 attr/s): Tue Apr  9 22:45:42 2002
test_getattr-4: 5000 attrs in 17.26s (289.8 attr/s): Tue Apr  9 22:45:42 2002
test_getattr-5: 5000 attrs in 17.31s (288.9 attr/s): Tue Apr  9 22:45:42 2002

# utils/obdctl --threads 5 2 test_brw 5000 w q
--threads: starting 5 threads on device 2 running test_brw
--threads: thread 1 (PID 5997) started
--threads: thread 2 (PID 5998) started
test_brw-2: reading 5000 (1x1 pages) (testing only): Tue Apr 9 22:37:28 2002
test_brw-1: reading 5000 (1x1 pages) (testing only): Tue Apr 9 22:37:28 2002
--threads: thread 3 (PID 5999) started
--threads: thread 4 (PID 6000) started
test_brw-3: reading 5000 (1x1 pages) (testing only): Tue Apr 9 22:37:28 2002
--threads: thread 5 (PID 6001) started
test_brw-4: reading 5000 (1x1 pages) (testing only): Tue Apr 9 22:37:28 2002
test_brw-5: reading 5000 (1x1 pages) (testing only): Tue Apr 9 22:37:28 2002
test_brw-1: read 1x1x5000 pages in 32.7s (152.9 pg/s): Tue Apr 9 22:38:01 2002
test_brw-2: read 1x1x5000 pages in 32.73s (152.8 pg/s): Tue Apr 9 22:38:01 2002
test_brw-3: read 1x1x5000 pages in 32.73s (152.8 pg/s): Tue Apr 9 22:38:01 2002
test_brw-4: read 1x1x5000 pages in 32.72s (152.8 pg/s): Tue Apr 9 22:38:01 2002
test_brw-5: read 1x1x5000 pages in 32.72s (152.8 pg/s): Tue Apr 9 22:38:01 2002

The first example runs 5 threads doing 5000 test_getattrs on device 2.
The second example runs 5 threads doing 5000 test_brw writes on device 2.

All output is prepended with the command and thread number which is running
that command, like "test_getattr-1", "test_getattr-2", etc.  This is done
via the "cmdline()" helper function, which should now be used at all times
for obdctl output instead of "argv[0]".  If we are not running with threads,
cmdline("foo") degenerates to just "foo".

Add new command to allow obdctl usage from command-line.
usage: --device <devno> <command [args ...]>

This is exactly the same thing as:
obdctl <<- EOF
device <devno>
connect
command [args ...]
disconnect
EOF

You can use it to run simple obdctl commands, for example:

tests/llecho.sh
util/obdctl --device 2 test_getattr 1000 q
util/obdctl --device 2 test_brw 1000 w q
tests/llmountcleanup.sh

Clean up obdctl code:
- all errors are now written to stderr, and have "error:" at the start
- all functions return non-zero on error (-1 = usage, -2 = params, +ve errno)

Start to abstract out the location of modules for LUSTRE and PORTALS.  It
doesn't actually do anything differently yet, but at least we have isolated
the paths into a single location.

Use "$(PORTALS)" and "$(top_srcdir)" instead of ".." so that we can build
in a different directory from the source tree (for UML and kernel builds).

osc/osc_request.c: replace "n" with "pages", as "n" is not defined anywhere.
others: minor cleanups.

Only try to run setup if there isn't already a Lustre filesystem set up.

Minor change - rename "run" to "test_fail" to match runfailure-mds.

common.sh: move all of the portals setup from setup() to setup_portals().
- make the NAL module conditional upon the network connection type.
- rename setup() to be setup_lustre().
all others:
- you need to call setup_portals() before setup_lustre() now.

Fix typo "lusre" -> "lustre"

- name switch:  "light" --> "lite"
                "/mnt/obd" --> "/mnt/lustre"
- small changes to RPC code to handle request packet freeing later,
  separate connection initialization and connect.
- rename event handlers and queues, add separate request_out and
  reply_out queue

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.