CVS log for pvfs2/src/io/job/job.c
	Help

Request diff between arbitrary revisions / Display revisions graphically

initial working versionof usrint code
auto configures usrint on an ucache off (not working yet)
new acl repimplemented - old one has #def
some minor format edits

merge with Orange-Branch

remove extents, handle ranges, precreate pools and various other things that aren't needed in their current forms with UUIDs

Committed Windows client code to Orange-Branch.

uuid converstation, PVFS_x_position changes, server/client side first pass done

checkpoint on the uuid road

move PVFS_ds_position to different types when appropriate, pass a flag around instead of using special canary values in the handle. Things will be broken for a while.

mark places using position with handle for review

change to #defined calls to uuids

migrate from uint64_t type assignments to uuids

merge with Orange-Branch

In function trove_thread_mgr_callback, added #ifndef __PVFS2_JOB_THREADED__ block
around decrement of trove_pending_count.  The value of trove_pending_count is only
used to direct execution when job threads are not being used.  Wasn't causing a
problem other than helgrind complaining about it!

Porting flow etc.

Set up 64-bit compilation

Additional changes from merging with Orange-Branch

Merged in changes from Orange-Branch. There were a number of bugs fixed there since this branch was created.

merge with Orange-Branch

Bump Trove DBPF version for new precreate-handle storage format. Include migration to 0.1.5. Add job_trove_fs_del_eattr() function and associated lower level calls

*** empty log message ***

per-dataspace handle type precreate pools implementation

merging Orange Branch changes in

initial merge with Orange-Branch. much will be broken

merge final precreate race fixes from trunk to 2-8 branch

revert cu-security-branch to before the attempted merge with Orange-Branch

remove misguided job assertion; trove_pending counter is not meant to be atomic

another correction to precreate race fix

experimental update of fix for precreate bug reported by Bart Taylor (original
fix led to a seg fault).

merge fix for precreate bug reported by Bart Taylor from trunk to 2-8 branch

Fix race condition in operation counting for precreate pool usage in
unstuff operation.  This fixes the bug reported by Bart Taylor in which a
system upgraded from 2.6.3 to 2.8.2 fails to write large files until the
daemons are restarted.

merge of B2O-Blue-Sync,HEAD,and latest of Orange.

commiting changes from merge of Orange and Blue into test branch.

Merged failover with tree code.
Modified Files:
  Tag: Orange-Branch
 	prepare src/apps/kernel/linux/pvfs2-client-core.c
 	src/client/sysint/client-state-machine.c
 	src/client/sysint/client-state-machine.h
 	src/client/sysint/finalize.c
	src/client/sysint/sys-getattr.sm
 	src/client/sysint/sys-io.sm
	src/client/sysint/sys-small-io.sm
 	src/common/gossip/gossip.h
	src/common/misc/msgpairarray.sm
 	src/common/misc/pint-event.c
	src/common/misc/pint-event.h
 	src/io/bmi/bmi.c
	src/io/dev/pint-dev.c
	src/io/job/job.c
 	src/kernel/linux-2.6/devpvfs2-req.c
 	src/kernel/linux-2.6/file.c
	src/kernel/linux-2.6/pvfs2-mod.c
 	src/proto/PINT-le-bytefield.c
	src/proto/pvfs2-req-proto.h
 	src/server/create-immutable-copies.sm
	src/server/get-attr.sm
 	src/server/small-io.sm
	src/server/tree-communicate.sm
 	src/server/request-scheduler/request-scheduler.c
 	src/server/request-scheduler/request-scheduler.h

merge flow deadlock bugfix from trunk to 2-8 branch

bug fix for flow protocol deadlock reported by Bart Taylor; make sure that
we don't deadlock on the completion mutex if a flow cancels immediately and
triggers a callback from within the cancel() function itself.

bug and memory fixes to getvalue operation

checkpoint

merge from HEAD:

make sure that js_p->actual_size and *out_size_p agree for
job_trove_bstream_read/write_list().  Also remove unused (and not working
properly) read_at() and write_at() functions at the job level.

merged in changes from latest Orange-Branch

merged in changes from summer at LANL

get-path implemenation work

initial get-path state machine and associated changes

merged Orange with Blue - first merging

Merge range query changes and other fixes

Initial import of branch supporting keyval attribute/value lookup

Merged changes in Blue branch into Orange branch

Applied Phil's patch that fixes size mismatches between js_p->actual_size and *out_size_p in the job_trove_bstream_{read,write}_list call, and revised pipeline.sm accordingly.

make sure that js_p->actual_size and *out_size_p agree for
job_trove_bstream_read/write_list().  Also remove unused (and not working
properly) read_at() and write_at() functions at the job level.

reverse merge fixes made to HEAD since 2.8 branch point.

bug fix: single server configurations will not have any precreation pools,
so make sure we handle that case cleanly within iterator.  This bug causes
server to crash when pvfs2-validate (and possibly fsck and fs dump?) are
run on a single server file system.

properly cancel bmi unexpected jobs and cleanup unexpected state machines on shutdown.

update precreation code to handle the case of multiple file systems hosted
on the same pvfs2-server daemon

merging hints/events code into trunk.

reverse merge from HEAD.

reverse merge from HEAD to directio branch

bug fix to previous commit to make sure we handle the single server case

fixed bug in precreation that caused servers to tend to pick the same layout
for datafiles 2 through N:
https://trac.mcs.anl.gov/projects/pvfs/ticket/63

reverse merge of changes to HEAD since branch.  Includes small file changes.

Merging small files branch to head.  Includes server side precreation of
data files and file stuffing.

dspace, keyval, coll_attr dbs are now created within the environment.
A whole lot of other things try to make replication work

db-replication state machine which processes the incomming replication message

bug fixes

to use it on bb, in case there's inconsistence...

Reverse merged and ported to HEAD.

implemented function to iterate through handles contained within precreate
pool.  Not tested yet, but intended for use in fsck and similar tools to
prevent precreated handles from showing up as stranded objects.

fix bug in partitioning of local and remote handles; fill in all remaining
error handling paths (needs further testing)

dspace_remove_list operation for trove; untested

add flag field to control trove sync in get_handles() for completeness

remove depricated comment

Updated branch with code from HEAD

trying to be a little smarter about when to sync in the precreate path

hints and events.

syncing small-file-branch back up with trunk at small-file-branch-point2 tag
(reverse merge)

Push use of named enumerations for request scheduling parameters all the
way down into request-scheduler.c rather than converting to integer flags.
This fixes a bug that allowed server modification operations to proceed
concurrently as if they were read only.

job function to go with new trove_dspace_create_list()

added a mechanism for pool fillers to signal the job interface when they
think that they will not be able make progress soon.  This prevents callers
waiting on handles from hanging indefinitely.

merge job error handling fixes to trunk.

fix return codes for job layer to prevent returning negative values from state actions.

tweak to queue handling, more gossip

dynamic allocation of a large array in job descriptor

change logic controlling pool fill callback path; op id didn't seem to be
reliable for this purpose.  Leaving a bunch of bonus gossip messages in
place for now.

rearchitected get_handles() to make error handling more tenable and make it
possible to implement timeout/cancel.  There is some bug running around in
here that causes the handle_info counting to run amok, though.

handle immediate completion in get handle path

more trivial error handling

clean up some old comments and an incorrect error message

another trivial error case

deal with one of the easier precreate job error cases

merging job/dev bug fix from trunk

merging job/dev bug fix from trunk

Fixed a bug in handling unexpected device jobs.  With a big enough load of
concurrent operations (particularly with threaded pvfs2-client) could cause
client-core assertion, and would likely happen repeatedly when client-core
restarted.

Big pile-o' changes to make Pete go mad.

The main changes are the implementation of the stuffed create path (now just the create state machine and operation), and the beginnings of the "unstuff" operation.

This also includes the request scheduler and state machine cleanups (required for using prelude with batch_remove) and whatever else I may have happened to change along the way.

This code is able to create files, but writing to them is almost guaranteed to break.

function comments

added ability to have get_handles() sleep if the pool is empty and complete
later when it is populated again

pool refillers wake back up now if the pool gets low

Sam's prelude and scheduler updates

Added support for specifying specific server layout in get_handles()
interface.  Also added commented out code block in setparam to test usage

that gossip log message ended up being pretty annoying

The normal path for a server request operation is to jump to the prelude state machine, which tries schedule the request based on the handle+fsid.  This meant that the request scheduler code had a switch/case returning the handle+fsid for each request we defined.  The function was also overloaded with a readonly parameter (whether the request modified any objects on the server), and a scheduling policy parameter (as the return code), which specified whether the request scheduling could be bypassed for this request.

I moved all that to a per-request parameter structure, that gets specified within the server state machine for the request.  Now there is one array of server requests (moved to pvfs2-server-req.c) which the request scheduler and prelude state machine can poke at to get parameters (defined in the state machine for that request), and based decisions on.

The patch includes some other minor changes:

* A fix to the BMI addr ref count increment/decrement.  Previously, the addr ref count was being incremented/decremented in the prelude/final-response state machines.  That requires that those state machines get invoked, which I don't want to have to depend on.  I've moved the INC call to the unexpected_sm, and the DEC call to where the state machine gets finished in the server.  That way we don't have to worry about whether we're using prelude/final-response.

* Cleanup of the request scheduler.  The way we were changing the mode from normal to admin was sort of embedded into the request scheduling code, so we had to hack the mode change from prelude_sm instead of in setparam.  Also, the request scheduler had to be aware of the setparam fields in the request.  I've moved the mode change code to separate request scheduler and job calls.  I think something similar could be done for the timer code (it doesn't really belong in the request scheduler), but I'll leave that for another patch.

* Changed the way we compile the server binary in Makefile.in to allow for multiple object files.

preliminary ability to hand out precreated handles.  Some functionality
still missing:
- no signaling in place yet to wake up refiller
- no ability to place handles yet by server id
- some servers are chewing a lot of CPU on first launch (if more than 2
  servers)

Use setparam state machine as a temporary test harness for get_handles()
interface to precreate pools.  Added test program to trigger it.  Stub for
get_handles() function.

make keyval_write_list() keep up with handle counts

first cut at function to block until precreate pool count gets low.  Mostly
works, except the pool count isn't being intialized properly

shuffled some things around

first cut at job functionality to fill precreate pools; untested

merging fixes from trunk to branch for multithreaded sysint library usage

inode stuffing operation.  also added a keyval_remove_list.

the function that pushes job progress if the libary itself isn't threaded has
to be serialized if multiple application threads could call it

more fixes related to id_gen_fast/safe

broke job layer switching to id_gen_fast from id_gen_safe.  reverting...

Replace id_gen_safe with id_gen_fast.  id_gen_safe is only needed for ids that are getting handed back to us through the system interfaces.  If our own internal ids (pointers) are getting corrupted or freed...Hello valgrind!

Merge HEAD changes to TAS-branch.

merge of the WALT3 branch to HEAD.  This patch changes the way state actions
are represented as C structures (what statecomp generates).  It also changes
the main state action parameter from a s_op on the server or an sm_p on the client
to a unified smcb pointer (state machine control block) for all state actions (both client and server).  Finally, initial support for concurrent state machines has
been added to allow state actions to be invoked concurrently .. a first step for
server-to-server.

Created a better interface for load values in the performance counter.

Added real load statistics for bmi, flow and trove operations.

Update migration branch to current CVS version

lock_callback and job_lock_wait_block_bytes added.

Upgrade to current CVS version

reverse merge of HEAD to WALT3 branch.

commit of trove method capabilities.  We should now be able to support multiple trove methods.  The TroveMethod option to the config file can set the method to something other than the default (dbpf).

Modified job layer to give hint to event manager.
Added UNECPECTED_DECODE to log first possible hint...

hint is given down to Trove

added hint to flow layer

add hints to job layer

backmerging of HEAD to branch...

use HANDLE_NULL rather than zero, for consistency

Merge HEAD into Walt's branch.
Rework new state machines to the new cleanups introduced by Walt.

Merge posix-extensions-branch to HEAD
This branch implemented patches to the 2.6.16 kernel for the proposed POSIX I/O extensions and those patches are under
the patches subdirectory.
It also implements the PVFS2 specific hooks for these system calls.

Tools that may be of immediate use to the pvfs2 general audience is the pvfs2-lsplus utility in src/apps/admin
that should be noticeably faster than the pvfs2-ls utility if there are a lot of objects in a single directory.
Other features are left out by configure and are not even built if the kernels do not support those features
and callbacks.

Reverse merge changes from HEAD to posix-extensions-branch.

revert style changes back to previous versions.

run maint/pvfs2indent-80col.sh on all .c files to correct style :)

Simple pint/ls/cp/diff test works

merge of murali's changes from trunk.

[pcarns]: Patch to allow modifying distribution, distribution parameters and number of
data files to use within a given directory. Such setting will only impact creation of future files
within the same directory. It does not change existing files' parameters. All such hints
are inherited by newly created directories as well..
[pcarns]: Allow trove to continue to read a list of xattrs/keyvals
without stopping if some subset of keys dont exist in the keyval db. Modifies the keyval_read_list() function
to return an array of completely independant error codes for each key that is read.
[pcarns]: adjust encode_string() macro to make it safe to call on NULL strings
[pcarns]: bug in the getattr state machine that would cause it to read dirent_count most of the time
regardless of whether the attribute mask requested it or not.
[slang]: fix a couple of bugs in the get-attr server-side state machine whereby the dirent_count was being read
using the dirent handle instead of the dirdata handle. Fixed a return value from dbpf_keyval_get_handle_info_op_svc
so that get-attr would not needlessly hang..
[vilayann]: fixes for the viewdist utility yet again, since the keys for the xattrs have changed...

reverse merge of recent bug fixes from trunk

commit of keyval handle info changes.  This allows info to be stored on a per handle basis in a 'null key' inside the database.  Right now we just use it to store the count of directory entries, so that we don't have to do a read/modify/write in crdirent and rmdirent.

Also includes changes to the keyval strings to use #define values instead of the actual strings.  This just makes that code lest prone to bugs in the future.

First cut of the sys_readdirplus implementation where clients can issue a single
system interface call to get the directory entries as well as the attribute information
of the directory entries.
What this means is that we do not need to call a sys_getattr of the individual directory entries
anymore.
(The kernel version is still untested and won't work until the VFS patch is in place! :))

On the server, there is now a new request/state machine called listattr(poor name, i know!)
which essentially does a vectored getattr for a list of handles as opposed to a getattr
which only does for 1. Perhaps, we need to consolidate them into 1 at a later point of time after
others have given this code a look-see!
On the client, there is a new system interface, and a corresponding statemachine implementation
called readdirplus which does the following algorithm
a) Step 1 - Do a regular readdir
b) Step 2 - Collate all meta handles (obtained from the readdir) and send out 1 listattr
to every server that owns atleast 1 handle from the set.
c) Step 3 - Handles that refer to metafiles (determined by the attributes of the response)
need an additional step to retrieve their file sizes. So we collate all data file handles
of all metafiles, and send out 1 listattr to every server that owns atleast 1 handle from
the set.
d) Step 4 - Copy object attributes obtained for all objects into the sys response structure and
also compute file sizes of regular files since we know the individual dfile handles' file sizes
from Step 3.

Clearly, this is a huge win in terms of performance of listing directories which have large number of directory
entries.
Next step is to hammer out the VFS patches and coreutils patch for ls to get the same benefit.
Also added a new utility called pvfs2-lsplus in src/apps/admin that uses this API.

[pcarns]: improve flow debugging: more messages if flow cancled, log how many
flow and dbpf operations in progress, make it easier to match up the different
flows.

merge of phil's fixes for small-io and job error codes to HEAD.

fixed error handling in job api and fixed file descriptor leaks in dbpf open cache.  Both fixes are from Phil.  Thanks Phil!

merge from trunk

[pcarns]:  removed unecessary check in io_release() function and made sure that
job_req_sched_release() reports an error if the job descriptor cannot be found.

fixes to immediate completion code.

[pcarns]: make job callbacks check if job interface is still initialized before
performing work.  any jobs pending after job interface shuts down will silently
return early.

fix for immediate completion of trove_dspace_verify.  Thanks Julian Kunkel!

merging small I/O changes to trunk.  The majority of this commit includes the
new small I/O state machines on client and server, and the modifications to
the client IO state machine.  It also includes mods to the zero-fill code
to perform zero-fill of holes only if they exist instead of zero-ing the entire
memory region initially.  Also, some debug stuff has been added to the
state machine processing code to print enter/exit of state machines if sm
debug is enabled.  The genconfig now includes ioports/metaports for running
multiple servers on the same host for testing.

fixed a bug in flow caused by outsize being updated correctly in trove now.  Also, s/transfered/transferred/.

small I/O changes in sio branch for now

This patch adds a new system interface (listeattr) to list the extended attributes
of a file.
Also adds support in the VFS kernel module to support the listxattr
system call and a bunch of test programs to debug these.

Updated the FAQ to reflect usage of xattrs through VFS and acls through
VFS.

fixes after branch point shift

updates to my event changes to bring them inline with trunk

merge changes from trunk since branch point into branch.  Effectively moves the branchpoint to the latest trunk.

added extended attribute support

updates for adding extended attributes

event changes

The last of phil's feb 2005 insure++ fixes.  "locking was added to the job-desc
queue at some point, but I found a couple of problems: each new queue
construction destroyed a global (rather than per queue) lock, some functions
were unprotected, and some functions were protected in duplicate at the job
layer.  To fix, I removed these locks from the job-desc-queue and expanded the
locking at the job layer a bit to make sure that every queue access is
protected by an external mutex."

* added event logging for states
* moved state debug code to state-machine so all state start/end
points get debug messages automatically
* added textlog stuff.  This allows us to write the default event
queue out to a text file that can be converted to slog2 later.

make id parameter non-mandatory; clarify some function return values

remove a couple extranneous includes

reduce flow.h include usage

reverted last job locking change- causes more problems than it solved; will
revisit later

fixed a possible (but not yet triggered to my knowledge) race in job.c:
- expand locking of completion queues to include post time on network ops
- make sure that it isn't possible for a 2nd thread to complete a really
  fast network operation before the 1st thread has exited post function

- fixed possible flow mutex memory leak (ptr set to null before free
  check was done)
- try to keep the existing mutex (if any) throughout the flow_reset
- make pass over kernel code making sure that out link counts are
  correct again
- fixed directory inode mtime and ctime changes on updates
- misc cleanups

fix typo that gets caught on older compilers

expand completion queue locking in some cases to make sure that condition
variable signals are protected from race conditions

rewrite non threaded job_testsome() following model from job_testcontext
implementation

rewrite threaded version of job_testsome() following model in new
job_testcontext() implementation

rework non-threaded job-testcontext to be simpler and avoid extra
gettimeofday() calls

rewrite threaded version of job_testcontext:
- simplify logic
- less gettimeofday calls
- properly hold completion mutex lock while checking wait conditions

next step in job test reorganization- split entire job_testcontext() and
job_testsome() functions into threaded version and nonthreaded version.  For
the moment this means duplicate code, but they each be simplified shortly

fixed typo

next step job in job_testXXX() overhaul- reorganize completion queue query
functions:
- push locks outside of query function so that they can be held properly
  while sleeping on conditions
- return 1 when query has succeeded
- make completion_query_some() do nothing until all requested jobs have
  finished to help simplify calling logic

first steps in cleaning up job level test functions:
- implement job_test() in terms of job_testsome()
- update some old job test harness programs

reversing last commit - will fix on monday

potential fix to a nasty job performance bug:
- expand completion condition mutex locking to eliminate condition wait race
  that could cause job_testcontext() to sleep unecessarily
- needs more testing, will post explanation on list if this patch does the
  trick and doesn't break anything

- make sure job_req_sched_release makes sure that the called supplied
  id looked up is valid (non-null)
- modify I/O state machine to not release an id that wasn't posted
- the above two changes fix a pvfs2-server crash bug on I/O where it
  was possible to try to release a req_sched job that was never posted
  (e.g. i/o during admin mode change)

- apply previous fix to test and testsome
- misc cleanups

- fixed the 'other' (rare) server abort bug on failed job_testcontext
  calls by finally tracking it down to an unexpected
  pthread_cond_timedwait return value of EINVAL (not in manpage, but
  POSIX/NPTL comply) when abstime arg is invalid (i.e. smaller than or
  equal to current system time)
- verified that this won't affect trove's usage of pthread_cond_timedwait
- misc formatting fixes

- fixed race condition that triggers when server is getting more incoming
  unexpected requests than it has posted operations for: don't tell thread
  mgr about willingness to accept another unexpected operation until it
  has been added to internal job queues
- this hopefully fixes an assertion I have seen on heavily loaded servers;
  needs more testing to verify

disable dev support in job component unless code is compiled for client
library use; this allows us to avoid starting an unused thread on the server

- applied Nathan's expandtab patch (expandtab-2.patch.gz)

  first referenced at:
  http://www.beowulf-underground.org/pipermail/pvfs2-developers/2004-July/000745.html

- fix a typo
- replace scaling timeout and write_ack_transfer_timeout with pre-posting
  with an infinite timeout and adjusting it after the flow completes

added job function that lets the caller reset the timeout on a previously
posted job; untested

Added a new job type: "null" jobs.  These are jobs that complete through the
usual test() or testcontext() mechanism, but don't actually do any work.
They simply pass along the error code that was given at post time.
This is useful for manually triggering state changes in arbitrary client
or server state machines.  It is intended as a building block for concurrent
state machine synchronization (not used yet).

- add some error handling; null out ptrs that are no longer in use
  (fixes several crash bugs found in the job expiration case); add
  some sanity checks, etc
- make server continue processing, rather than abort on
  BMI_testcontext errors (these are recoverable)

- merging in the pvfs2-nm-nb-branch with the main tree
  see ChangeLog for details, or browse the cvs history of the branch
  for full details

- if there are bmi or flow operations pending, don't block in the device
  by adjusting the timeout to 0

NOTE THAT THIS IS A BRANCH COMMIT (tagged as nm-nb-branch).  Feel free
to ignore it completey as it's a snapshot of a work in progress and it
will crash your computer and reformat your hard drive.

This is almost the initial draft of the pvfs2-client-core that
operates in a non-blocking manner.  While it runs, there are still
issues that need to be resolved (that are keeping it out of the main
CVS trunk).  Many other changes were made along the way, so it's more
than just that.

- added compile time option for disabling thread-safety in the client
  library (enabled by default; --disable-thread-safety to disable)
- improved configure summary information emitted at configure time
- added missing non-blocking sysint declarations to sysint header
- re-wrote pvfs2-client-core to use sysint non-blocking operations
  where possible
- made sysint test and testsome() calls more useable from a user point
  of view
- merged dev unexp polling/handling with system interface
- added PINT_sys_dev_unexp call that allows posting unexpected device
  messages so that they can be returned from the sysint testsome
  method in addition to completed sysint operations
- many memory leaks fixed -- many more to go (started adding macros
  for freeing the server response objects)
- added a id_gen_fast_unregister macro that is a no op, to make the
  api more consistent with the id_gen_safe_* calls
- server-config-mgr: report mutex still in use if it is, but also make
  sure not to unlock an already unlocked mutex (valgrind complains)
- many assertions added
- many formatting changes
- many ptr assignments to NULL after freeing in the job interface;
  done while tracking down a problem
- modified the pint-dev device interface to make sure it can handle
  the pvfs2 device in a non-blocking manner
- pint-dev was using buffers larger than it needed across the device;
  fixed them to be the right size
- added a method to free the memory region mapped into the kernel
  through the device
- freed that mapped memory region on pvfs2-client-core shutdown
  (valgrind complained)
- modified device driver to work properly in non-blocking mode from
  userspace by implementing the character device poll method
- modified pint-dev test function to properly handle non-blocking
  responses from the device driver
- modified PINT_flow_reset to not allocate a new mutex unless the old
  one was destroyed
- modified all job uses of the id-generator to use the safe, rather
  than fast, methods (useful for several reasons including safe
  cancellation)
- modified cancellation methods to be able to handle ops that have
  already completed
- modified the job_dev_unexp method to have (and honor) the no
  immediate completion flag if passed (used in the pvfs2-client-core)
- modified the job completion callbacks to make sure to NOT add a
  completed job desc to the completion queue if it's already been
  added (by checking a flag, not scanning).  this is a safety and
  should only be used when a non-thread-safe client library is being
  used in a thread safe env, but we should handle it gracefully anyway
- replaced all kernel allocations of ops through the slab allocator
  handled op_cache to be replaced by a wrapper method (op_alloc(), as
  suggested by Murali) -- the other cache allocations will probably be
  replaced later.  this allows the removal of the extern op_cache
  declaration
- added macros for freeing some of the most heavily used server
  response messages (readdir, lookup, getattr) -- the others are
  coming later
- freed dirents coming out of sysint response object in the
  pvfs2-client

put idle detecting logic back in (for non-threaded case, handles retry
situations when there is no work to do while delaying for retry), along with
a bug fix that keeps it from wrecking performance for small I/O - should
have been checking pending count before servicing operations (my bad)

- fix performance problem (most noticeable during many small i/o accesses)
- phil: we need to rethink this -- in simple cases like pvfs2-import using
  small byte sizes, we have nothing to do, but we will soon after ; revert
  for now

prevent job interface from busy spinning in nonthreaded case when no jobs
are posted (becomes an issue in some client retry cases)

slight modification; allow non-threaded job interface to query underlying
interfaces without blocking even if job test timeout is zero

tie flows into the job timer mechanism

tie the time management functions into the bmi job calls, still not doing
anything to trigger the actual timeout check, though

add timeout arguments to bmi and flow related job calls, not used yet

fix the api to job_flow_cancel()

job level hook to cancel flows; untested

job level hook to trove cancellation; untested

implement job_bmi_cancel(), some minor job cancel api changes, seems to work
fine in some small msgpair test cases induced with gdb

added event level instrumentation to most of the job calls, reorganized
definitions for operation types in pvfs2-event.h (make it so that the same
op type defines can be used in multiple api's, get rid of power of two values
for op types), probably need to rethink how (if at all) to mask off individual
operations for analysis

remove unneeded header

- transition to error state if there's a failure posting a msgpair recv

cruft removal

removed some out of date comments

new and improved locking

- make flush only sync keyval spaces if metafile and only bstreams if datafiles
- some cleanups

- bad type replacement

- extend the job interface to take a flags argument, which is passed to various
  trove operations, rather than hard-coding TROVE_SYNC
- make changes to server to pass in the mode value matching the config option
- update test programs (hardcode TROVE_SYNC)

Move from bmi_addr_t to PVFS_BMI_addr_t for consistency.

- add hooks to the job interface for various cancellation methods

- during dev_stop, drop the dev_mutex, as it's possible that the
  thread can't be joined if we hold this lock (this fixes a hang on
  server shutdown via signal)

shuffled support for device handling thread over into thread mgr; cleans up
core job code and makes sure that thread handling is consistent at job level

- don't allow anything to be posted to a job_desc_q that's already
  been torn down

This is a full merge of my pvfs2-dbpf-attr-cache-branch, so this is
the cumulative changelog (based on existing cvs messages).

- initial dbpf-attr-cache implementation and cleanups
- added all the hooks to grab configurable cacheable metadata keys
  from a config file.  re-arranged the config file by separating out
  fs specific hints into a StorageHints area.  updated genconfig to
  account for these changes.
- initial working implementation of the unified dbpf-attr and
  keyval/data pair cache.  holy cow this thing is fast... much work to
  be done still.
- initial locking added
- replaced debug level with a new DBPF_ATTRCACHE_DEBUG level
- added safe to/from cache data copies
- added write-through caching for keyval data (still need to do generic attrs)
- updated simple.conf
- allow config file to have multiple AttrCacheKeywords lines
- fix some cache parts that allow symlinks to work (i.e. be cached)
- added a verbose warning for a particular kind of configuration error
  for a user to see if it should happen
- some more robust configure checks
- more configure related changes
  disable vis build if sdl is detected, but sdl-ttf isn't
- fix broken ifdef nesting that caused compilation failure on non
  aio-threaded configurations
- safe copy of attributes (to/from, preparing for write-through impl)
- server cleanups (making way for pre-caching of a number of attrs on server
  startup since it reads them from disk during handle iterate anyway)
- update create test program to report human readable creation error
- put some quick human readable error reporting in pvfs2-client-core
- added some quickhash method we've been wanting but never had
- implemented policy to limit previously unbounded size of attr cache
- adjusted simple.conf to have some good defaults
- adjusted pvfs2-genconfig to match those defaults
- fixed some htable cleanups
- started write-through attr updates
- update changelog and version info, preparing for mainline merge
- implement write-through of dbpf-resize operation
- make sys-truncate return -PVFS_EINVAL if truncate is called on an object
  that can't be truncated
- fix error code return value of sys-truncate
- cosmetic changes to truncate test program output
- added some comments
- updated showconfig with copyright info
- updated sample configs for showconfig
- added a default handle purgatory value if a value of zero is specified
  (e.g. not specified in config file at all)
- for now, remove the cached dbpf-attr object on i/o writes
- slightly robustify the glibc aio callback detection

initial dbpf-attr-cache implementation and cleanups

- metadata storage overhaul (remove the METADATA_KEY from Trove_Common_Keys,
meaning that metadata is now properly stored in the dspace generic attributes
rather than as a separate key/val pair)
- clean up the 'find' test program to handle more than a fixed number of
  dirent entries
- misc other cleanups
- ChangeLog update

big structural change/simplification of the flow code.  job api remains
unchanged.  notification from flow level back to job level is now done
through callbacks rather than by testing.  works for both threaded and
non threaded code path.

some changes to the old flow protocol; trying to unify code paths for
threaded and non-threaded case.  hopefully will be able to push in some
api tweaks soon...

reworked the way that the threaded vs. nonthreaded compilation paths are
handled at the job level.  simplifies things a bit and reuses more code.
also paves the way for similar changes at the flow level.

added event logging macros to read_list and write_list in dbpf (though
they do not record sizes yet), adjusted some other even macros here and there

fixed a warning when compiled without job threads

fixed naming conventions

bug fix to event macro, instrumented flows at the job level (not triggering
actual logging yet, however)

shuffled PVFS_aint in pvfs2-types.h over to job_aint in job.h, hopefully
fixing one of the kernel space type problems

augmented request scheduler with an extra "index" argument that allows the
caller to specify which handle in an array of list operation should be
scheduled

job level hooks for trove iterate handles function

make req sched post failures non-critical

job level hooks for request scheduler timers

removed some old #if 0'd code

. landing a new and improved client-side truncate.
. completing the landing of a fully-functioning server-side truncate.

Add some casts to callers of BMI send_list functions that now
expect const void **.  The C spec says this is necessary, even though it
appears obvious that the call is safe, because qualifier mismatch fixups
are not applied recursively down the type tree

converted msgpairarray and io client side state machines to use new
status_user_tag feature of job interface, removed id field from status,
modified job code to fill in status_user_tag in status on immediate
completion as well as at test time

added an extra argument to all of the job API post fuctions: status_user_tag.
... similar to user_ptr semantically (set by caller at post time, returned
by API at test time), except that it is an integer type and is returned
through the status struct.  Not used yet, but intended to help in client
side state machines that have multiple transitions to the same state and
need a way to differentiate between them.

updated job code to use thread mgr callbacks for trove when in threaded mode

added asserts in some places where i've hit null pointers

modified flowproto to use trove_dspace_testcontext() as well

converted job code to use trove_dspace_testcontext() rather than
trove_dspace_testsome(); still need to do the same for flowprotocol
- note, hardcoding collection id until I have time to put
  another mechanism in place for tracking those independent of
  the pending op ids

some minor work towards supporting status_user_tag in the job api, just
checking in so I can switch to looking at something else for a bit...

integrated support for the external thread manager into the job interface,
just for BMI operations.  this is the first step towards allowing one
thread to drive BMI for both the job and flow interface.  No performance
benefit yet, but verifies that this stuff works.  Still need to do flow half.

- implemented job_trove_dspace_verify
- implemented ROOT_CHECK parameter in admin interface
- finished up pvfs2-ping and marked "NEEDS TESTING" in todo file

more cleanup of job code to handle optional trove support, removed trove
objects from client side pvfs2 library, shuffled some functions between
mkspace.c and server-config.c to break up trove dependence - just a short
term fix, will sort out better shortly...

modified job.c to allow trove support to be toggled on and off with defines
at compile time

took a stab at improving dbpf_testsome when threads are enabled.  renamed some
stray 'foo' function args.

added a coll_id arg to trove_[open|close]_context calls.  threaded trove.
things may be badly broken now as it's on by default.  even if things appear
to work, don't be fooled.  much work is left to be done.

forgot to allocate the job description

Added stubs for using contexts in trove.  None of this is working right now,
but the code *should* still work as before.  The idea is to get contexts into
the trove interface to play better with the job interface like the existing
bmi and flow interfaces.  This is the first step toward that end.

sorry. forgot to compile before checking in. errors fixed.

add job_trove_{keyval,bstream}_flush

Lots of random return value fixes; hopefully nothing is messed up too badly.

job status structure now also reports the id of the operation

Made necessary changes for sending handle ranges over to the server.  This
required changes to the trove_dspace_create call, so a lot of stuff had to
change to make this compile.  mkdir is broken and may be for a while.

Server receives handle ranges now for creates, but doesn't do anything with
them yet.  That's to come.

Renamed id_gen_t to PVFS_id_gen_t and moved it definition into pvfs2-types.h.
Also took the #include for id-generator.h out of header files and into .c
files where possible.

filled in the rest of the PINT_dev support in job.c; untested

filled in test() support for device operations; untested

filled in some of the basic work cycle code for the device interface

stubbed in job level hooks to device interface

got rid of some extra typedefs, cleaned up some naming conventions

clean up of ds_attributes (naming convention)

got rid of PVFS_ds_state type, TROVE_ds_state now defined in terms of
PVFS_error type.

got rid of PVFS_ds_id type, TROVE_op_id is now defined in terms of id generator
type

got rid of the PVFS_coll_id type- it was a duplicate of PVFS_fs_id.

cleaned up vtag type

cleaned up PVFS_ds_keyval type (mainly just naming convention) and moved
definition to pvfs2-storage.h

turned the "bmi_flag_t buffer_flag" variable into a named enumeration
"enum bmi_buffer_type buffer_type"

got rid of PVFS_flag type and bmi_flag_t.  need to come back later and
convert the buffer_flag variables in BMI to named enumerations; they are
ints for now

modified to use trove id queue API, now should be able to handle
operations from different collections simultaneously

minor step towards replacing trove queue in job interface

fixed bug in logic that counts the number of pending flow operations;
caused the job interface to think there was work to do and burn up cpu
when really the system was idle

Removed bitmask arguments along the trove_dspace_create call path; needs
testing; I'll be looking into this.

Filled in missing bits of true context support at the job level.
Still not using it in any useful manner in higher level code yet.

took out another request scheduler queue that wasn't really being used
for anything anymore

removed an extra request scheduler queue that wasn't really doing
anything useful.

Added contexts to the job API, and updated all job calls to reflect it.
Contexts aren't actually implemented yet.

job code now uses flow_testcontext()

Added contexts to the flow API.  Not doing anything with it yet.

fixed a bug (forgot to decrement count of pending bmi operations)

got rid of BMI_testsome() and associated job descriptor queue; replaced
with BMI_testcontext()

simplified the way the unexpected BMI jobs are tracked

just renamed some variables

modified existing BMI API functions to support the concept of
"contexts" and added hooks to create and destroy them.  This is just a
placeholder, contexts aren't actually implemented yet.

removed queue searching code from testsome(); it now checks status of
job descriptors directly

reworked job_test() so that it jumps directly to the desired job
descriptor and checks its state, rather than searching through
completion queue.

added a completion queue lock where one was missing before (whoops);
added a flag to the job descriptor to indicate when it has been
completed

reformatting

made the error handling a little bit more consistent

fixed some bugs in job_testsome(), still isn't 100%

fixed the handling of NULL ids in the testsome() call

fixed some bugs in the handling of NULL user pointers; not a very
elegant fix, but it will do for now

modified the job interface so that it takes _pointers_ to vtags as
arguments.  Adjusted everywhere that uses these functions to pass
in NULL for now.

modified so that all test functions return 1 if anything completes

added support for trove keyval read list

fixed a memory leak

fixed a memory leak

implemented dspace remove, untested

Added flags parameters to some of the dspace calls; updated all other code too.
Added coverage target in makefile; not working yet.

implemented job_trove_dspace_setattr(); untested, but probably works
:)

implemented job_trove_dspace_getattr(), verified that it appears to
work as one of the steps in an I/O operation

Trying to get rid of some gcc-3.2.2 warnings...

updated job_test() function to new implementation that handles timeouts
correctly

maybe fixed a bug in job_test() ?

moved new job_testsome() implementation (with correct timeout semantics)
into position; updated all code that calls it accordingly, tried out
several test cases to verify behavior, fixed some bugs

moved new job_testworld() implementation into position, tested, fixed a
couple of bugs, changed the way it was being used in one example program

finished implementation of new testworld function (testworld_HACK) with
proper timeout semantics.  Needs testing before pushing into use
anywhere, though

Implemented a new testsome function that handles timeout semantics
properly (job_testsome_HACK()).  Still needs testing before it can
replace the existing testsome and waitsome.

adjusted new test implementation (job_test_HACK) to support
infinite timeouts (kludge solution for now)

finished refactoring job_test_HACK(); need to test it before
using it as a replacement for job_test and job_wait.

refactored new job_test (job_test_HACK for now) implementation a
little

got rid of job_waitworld and added timeout argument to
job_testworld.  It isn't implemented right yet, but I wanted to
get the API change out of the way so that I don't have to modify
the server again later

made waitworld() poke the request scheduler api on its way through- needs to be
fixed in other wait functions as well -PHC, checking in as dalew

finished adding extra argument to job_bmi_unexp(); propigated changes
into server code and test programs that use that function.

fixed a bug in the way the timeout was being decremented.

finished a preliminary implementation of job_test (job_test_HACK) with
new timeout semantics.  Still needs testing and refactoring.

started work on a replacement for job_wait() and job_test(), that
will use a timeout argument

implemented the flags argument to job_bmi_unexp(), which can be used
to prevent the function from completing immediately.  For now it is
hidden with a #define trick until the server code is ready for the API
change.

renamed struct unexpected_info to struct BMI_unexpected_info, so that
it is more consistent with the rest of the API

big changes to various I/O API's- there are no longer any "wait"
functions in the BMI, flow, or request scheduling APIs.  In the
request scheduler case, they have simply been discarded.  In BMI
and flows, the testXXX() functions have been augmented with a
timeout argument so that they may perform the role of the
former waitXXX() functions.

fixed a bug (cleaned up the same queue twice on exit)

added in job code; added in request processor code where empty
files were accidentally checked in last time