shorten lock for item allocation more

after pulling an item off of the LRU, there's no reason to hold the cache lock
while we initialize a few values and memcpy some junk.
clean up the do_item_alloc logic

Fix an unlikely bug where search == NULL and the first alloc fails, which then
attempts to use search.

Also reorders branches from most likely to least likely, and removes all
redundant tests that I can see. No longer double checks things like refcount
or exptime for the eviction case.
clean do_item_get logic a bit. fix race.

the race here is absolutely insane:
- do_item_get and do_item_alloc call at the same time, against different
  items
- do_item_get wins cache_lock lock race, returns item for internal testing
- do_item_alloc runs next, pulls item off of tail of a slab class which is the
  same item as do_item_get just got
- do_item_alloc sees refcount == 0 since do_item_get incrs it at the bottom,
  and starts messing with the item
- do_item_get runs its tests and maybe even refcount++'s and returns the item
- evil shit happens.

This race is much more likely to hit during the slab reallocation work, so I'm
fixing it even though it's almost impossible to cause.

Also cleaned up the logic so it's not testing the item for NULL more than
once. Far fewer branches now, though I did not examine gcc's output to see if
it is optimized differently.
slab reassignment

Adds a "slabs reassign src dst" manual command, and a thread to safely process
slab moves in the background.

- slab freelist is now a linked list, reusing the item structure
- is -o slab_reassign is enabled, an extra background thread is started
- thread attempts to safely free up items when it's been told to move a page
  from one slab to another.

-o slab_automove is stubbed.

There are some limitations. Most notable is that you cannot repeatedly move
pages around without first having items use up the memory. Slabs with newly
assigned memory work off of a pointer, handing out chunks individually. We
would need to change that to quickly split chunks for all newly assigned pages
into that slabs freelist.

Further testing is required to ensure such is possible without impacting
performance.
initial slab automover

Enable at startup with -o slab_reassign,slab_automove

Enable or disable at runtime with "slabs automove 1\r\n"

Has many weaknesses. Only pulls from slabs which have had zero recent
evictions. Is slow, not tunable, etc. Use the scripts/mc_slab_mover example to
write your own external automover if this doesn't satisfy.
no same-class reassignment, better errors

Add human parseable strings to the errors for slabs ressign. Also prevent
reassigning memory to the same source and destination.
reap items on read for slab mover

popular items could stuck the slab mover forever, so if a move is in progress,
check to see if the item we're fetching should be unlinked instead.
close some idiotic race conditions

do_item_update could decide to update an item, then wait on the cache_lock,
but the item could be unlinked in the meantime.

caused this to happen on purpose by flooding with sets, then flushing
repeatedly. flush has to unlink items until it hits the previous second.
fix braindead linked list fail

I re-implemented a linked list for the slab freelist since we don't need to
manage the tail, check the previous item, and use it as a FIFO. However
prev/next must be managed so the slab mover is safe.

However I neglected to clear prev on a fetch, so if the slab mover was
zeroing the head of the freelist it would relink the next item in the freelist
with one in the main LRU.

Which results in chaos.
Fix a race condition from 1.4.10 on item_remove

Updates the slab mover for the new method.

1.4.10 lacks some crucial protection around item freeing and removal,
resulting in some potential crashes. Moving the cache_lock around item_remove
caused a 30% performance drop, so it's been reimplemented with GCC atomics.

refcount of 1 now means an item is linked but has no reference, which allows
us to test an atomic sub and fetch of 0 as a clear indicator of when to free
an item.
more portable refcount atomics

Most credit to Dustin and Trond for showing me the way, though I have no way
of testing this myself.

These should probably just be defines...
test for the error code, not the full message

bad practice.
binary deletes were not ticking stats counters

Thanks to Stephen Yang for the bug report.
fix 'age' stat for stats items

credit goes to anton.yuzhaninov for the report and patch
bug237: Don't compute incorrect argc for timedrun

Since spawn_and_wait doesn't use argc anyway, might as well just not
send a value in.
update protocol.txt
fix slabs_reassign tests on 32bit hosts

32bit pointers are smaller... need more items to fill the slabs, sigh.
tests: loop on short binary packet reads

Awesome bug goes like this:

let "c1" be the commit of the "good state" and "c2" be the commit
immediately after (in a bad state).  "t1" is the state of the tree in "c1"
and "t2" is the state of the tree in "c2"

In their natural states, we have this:

c1 -> t1 -> success
c1 -> t2 -> fail

However, if you take

c1 -> t1 -> patch to t2 -> success
c2 -> t2 -> patch to t1 -> fail

So t1 *and* t2 both succeed if the committed tree is c1, but both fail of
the committed tree is c2.

The difference?  c1 has a tag that points to it so the version number is
"1.2.10" whereas the version number for the unreleased c2 is
"1.4.10-1-gee486ab" -- a bit longer, breaks stuff in tests that try to
print stats.
properly detect GCC atomics

I was naive. GCC atomics were added in 4.1.2, and not easily detectable
without configure tests. 32bit platforms, centos5, etc.
fix warning in UDP test