1.1 --- a/tools/blktap/Makefile	Fri Jun 16 18:19:40 2006 +0100
     1.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.3 @@ -1,94 +0,0 @@
     1.4 -MAJOR    = 3.0
     1.5 -MINOR    = 0
     1.6 -SONAME   = libblktap.so.$(MAJOR)
     1.7 -
     1.8 -XEN_ROOT = ../..
     1.9 -include $(XEN_ROOT)/tools/Rules.mk
    1.10 -
    1.11 -SUBDIRS :=
    1.12 -SUBDIRS += ublkback
    1.13 -#SUBDIRS += parallax
    1.14 -
    1.15 -BLKTAP_INSTALL_DIR = /usr/sbin
    1.16 -
    1.17 -INSTALL            = install
    1.18 -INSTALL_PROG       = $(INSTALL) -m0755
    1.19 -INSTALL_DIR        = $(INSTALL) -d -m0755
    1.20 -
    1.21 -INCLUDES += -I. -I $(XEN_LIBXC) -I $(XEN_XENSTORE)
    1.22 -
    1.23 -LIBS     := -lpthread -lz
    1.24 -
    1.25 -SRCS     :=
    1.26 -SRCS     += blktaplib.c xenbus.c blkif.c
    1.27 -
    1.28 -CFLAGS   += -Werror
    1.29 -CFLAGS   += -Wno-unused
    1.30 -CFLAGS   += -fno-strict-aliasing
    1.31 -CFLAGS   += -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE
    1.32 -# get asprintf():
    1.33 -CFLAGS   += -D _GNU_SOURCE
    1.34 -# Get gcc to generate the dependencies for us.
    1.35 -CFLAGS   += -Wp,-MD,.$(@F).d
    1.36 -CFLAGS   += $(INCLUDES) 
    1.37 -DEPS     = .*.d
    1.38 -
    1.39 -OBJS     = $(patsubst %.c,%.o,$(SRCS))
    1.40 -IBINS   :=
    1.41 -#IBINS   += blkdump
    1.42 -
    1.43 -LIB      = libblktap.so libblktap.so.$(MAJOR) libblktap.so.$(MAJOR).$(MINOR)
    1.44 -
    1.45 -.PHONY: all
    1.46 -all: mk-symlinks libblktap.so #blkdump
    1.47 -	@set -e; for subdir in $(SUBDIRS); do \
    1.48 -		$(MAKE) -C $$subdir $@;       \
    1.49 -	done
    1.50 -
    1.51 -.PHONY: install
    1.52 -install: all
    1.53 -	$(INSTALL_DIR) -p $(DESTDIR)/usr/$(LIBDIR)
    1.54 -	$(INSTALL_DIR) -p $(DESTDIR)/usr/include
    1.55 -	$(INSTALL_PROG) $(LIB) $(DESTDIR)/usr/$(LIBDIR)
    1.56 -	$(INSTALL_PROG) blktaplib.h $(DESTDIR)/usr/include
    1.57 -	#$(INSTALL_PROG) $(IBINS) $(DESTDIR)$(BLKTAP_INSTALL_DIR)
    1.58 -	@set -e; for subdir in $(SUBDIRS); do \
    1.59 -		$(MAKE) -C $$subdir $@;       \
    1.60 -	done
    1.61 -
    1.62 -.PHONY: clean
    1.63 -clean:
    1.64 -	rm -rf *.a *.so *.o *.rpm $(LIB) *~ $(DEPS) xen TAGS blkdump
    1.65 -	@set -e; for subdir in $(SUBDIRS); do \
    1.66 -		$(MAKE) -C $$subdir $@;       \
    1.67 -	done
    1.68 -
    1.69 -.PHONY: rpm
    1.70 -rpm: all
    1.71 -	rm -rf staging
    1.72 -	mkdir staging
    1.73 -	mkdir staging/i386
    1.74 -	rpmbuild --define "staging$$PWD/staging" --define '_builddir.' \
    1.75 -		--define "_rpmdir$$PWD/staging" -bb rpm.spec
    1.76 -	mv staging/i386/*.rpm .
    1.77 -	rm -rf staging
    1.78 -
    1.79 -libblktap.so: $(OBJS) 
    1.80 -	$(CC) $(CFLAGS) -Wl,-soname -Wl,$(SONAME) -shared         \
    1.81 -	      -L$(XEN_XENSTORE) -l xenstore                       \
    1.82 -	      -o libblktap.so.$(MAJOR).$(MINOR) $^ $(LIBS)
    1.83 -	ln -sf libblktap.so.$(MAJOR).$(MINOR) libblktap.so.$(MAJOR)
    1.84 -	ln -sf libblktap.so.$(MAJOR) $@
    1.85 -
    1.86 -blkdump: libblktap.so
    1.87 -	$(CC) $(CFLAGS) -o blkdump -L$(XEN_LIBXC) -L. \
    1.88 -	      -l blktap blkdump.c
    1.89 -
    1.90 -.PHONY: TAGS clean install mk-symlinks rpm
    1.91 -
    1.92 -.PHONY: TAGS
    1.93 -TAGS:
    1.94 -	etags -t $(SRCS) *.h
    1.95 -
    1.96 --include $(DEPS)
    1.97 -

     2.1 --- a/tools/blktap/README	Fri Jun 16 18:19:40 2006 +0100
     2.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.3 @@ -1,149 +0,0 @@
     2.4 -Block Tap User-level Interfaces
     2.5 -Andrew Warfield
     2.6 -andrew.warfield@cl.cam.ac.uk
     2.7 -February 8, 2005
     2.8 -
     2.9 -NOTE #1: The blktap is _experimental_ code.  It works for me.  Your
    2.10 -mileage may vary.  Don't use it for anything important.  Please. ;)
    2.11 -
    2.12 -NOTE #2: All of the interfaces here are likely to change.  This is all
    2.13 -early code, and I am checking it in because others want to play with
    2.14 -it.  If you use it for anything, please let me know!
    2.15 -
    2.16 -Overview:
    2.17 ----------
    2.18 -
    2.19 -This directory contains a library and set of example applications for
    2.20 -the block tap device.  The block tap hooks into the split block device
    2.21 -interfaces above Xen allowing them to be extended.  This extension can
    2.22 -be done in userspace with the help of a library.
    2.23 -
    2.24 -The tap can be installed either as an interposition domain in between
    2.25 -a frontend and backend driver pair, or as a terminating backend, in
    2.26 -which case it is responsible for serving all requests itself.
    2.27 -
    2.28 -There are two reasons that you might want to use the tap,
    2.29 -corresponding to these configurations:
    2.30 -
    2.31 - 1. To examine or modify a stream of block requests while they are
    2.32 -    in-flight (e.g. to encrypt data, or add data-driven watchpoints)
    2.33 -
    2.34 - 2. To prototype a new backend driver, serving requests from the tap
    2.35 -    rather than passing them along to the XenLinux blkback driver.
    2.36 -    (e.g. to forward block requests to a remote host)
    2.37 -
    2.38 -
    2.39 -Interface:
    2.40 -----------
    2.41 -
    2.42 -At the moment, the tap interface is similar in spirit to that of the
    2.43 -Linux netfilter.  Requests are messages from a client (frontend)
    2.44 -domain to a disk (backend) domain.  Responses are messages travelling
    2.45 -back, acknowledging the completion of a request.  the library allows
    2.46 -chains of functions to be attached to these events.  In addition,
    2.47 -hooks may be attached to handle control messages, which signify things
    2.48 -like connections from new domains.
    2.49 -
    2.50 -At present the control messages especially expose a lot of the
    2.51 -underlying driver interfaces.  This may change in the future in order
    2.52 -to simplify writing hooks.
    2.53 -
    2.54 -Here are the public interfaces:
    2.55 -
    2.56 -These allow hook functions to be chained:
    2.57 -
    2.58 - void blktap_register_ctrl_hook(char *name, int (*ch)(control_msg_t *));
    2.59 - void blktap_register_request_hook(char *name, int (*rh)(blkif_request_t *));
    2.60 - void blktap_register_response_hook(char *name, int (*rh)(blkif_response_t *));
    2.61 -
    2.62 -This allows a response to be injected, in the case where a request has
    2.63 -been removed using BLKTAP_STOLEN.
    2.64 -
    2.65 - void blktap_inject_response(blkif_response_t *);
    2.66 -
    2.67 -These let you add file descriptors and handlers to the main poll loop:
    2.68 -
    2.69 - int  blktap_attach_poll(int fd, short events, int (*func)(int));
    2.70 - void blktap_detach_poll(int fd);
    2.71 -
    2.72 -This starts the main poll loop:
    2.73 -
    2.74 - int  blktap_listen(void);
    2.75 -
    2.76 -Example:
    2.77 ---------
    2.78 -
    2.79 -blkimage.c uses an image on the local file system to serve requests to
    2.80 -a domain.  Here's what it looks like:
    2.81 -
    2.82 ----[blkimg.c]---
    2.83 -
    2.84 -/* blkimg.c
    2.85 - *
    2.86 - * file-backed disk.
    2.87 - */
    2.88 -
    2.89 -#include "blktaplib.h"
    2.90 -#include "blkimglib.h"
    2.91 -
    2.92 -
    2.93 -int main(int argc, char *argv[])
    2.94 -{
    2.95 -    image_init();
    2.96 -    
    2.97 -    blktap_register_ctrl_hook("image_control", image_control);
    2.98 -    blktap_register_request_hook("image_request", image_request);
    2.99 -    blktap_listen();
   2.100 -    
   2.101 -    return 0;
   2.102 -}
   2.103 -
   2.104 -----------------
   2.105 -
   2.106 -All of the real work is in blkimglib.c, but this illustrates the
   2.107 -actual tap interface well enough.  image_control() will be called with
   2.108 -all control messages.  image_request() handles requests.  As it reads
   2.109 -from an on-disk image file, no requests are ever passed on to a
   2.110 -backend, and so there will be no responses to process -- so there is
   2.111 -nothing registered as a response hook.
   2.112 -
   2.113 -Other examples:
   2.114 ----------------
   2.115 -
   2.116 -Here is a list of other examples in the directory:
   2.117 -
   2.118 -Things that terminate a block request stream:
   2.119 -
   2.120 -  blkimg    - Use a image file/device to serve requests
   2.121 -  blkgnbd   - Use a remote gnbd server to serve requests
   2.122 -  blkaio    - Use libaio... (DOES NOT WORK)
   2.123 -  
   2.124 -Things that don't:
   2.125 -
   2.126 -  blkdump   - Print in-flight requests.
   2.127 -  blkcow    - Really inefficient copy-on-write disks using libdb to store
   2.128 -              writes.
   2.129 -
   2.130 -There are examples of plugging these things together, for instance
   2.131 -blkcowgnbd is a read-only gnbd device with copy-on-write to a local
   2.132 -file.
   2.133 -
   2.134 -TODO:
   2.135 ------
   2.136 -
   2.137 -- Make session tracking work.  At the moment these generally just handle a 
   2.138 -  single front-end client at a time.
   2.139 -
   2.140 -- Integrate with Xend.  Need to cleanly pass a image identifier in the connect
   2.141 -  message.
   2.142 -
   2.143 -- Make an asynchronous file-io terminator.  The libaio attempt is
   2.144 -  tragically stalled because mapped foreign pages make pfn_valid fail
   2.145 -  (they are VM_IO), and so cannot be passed to aio as targets.  A
   2.146 -  better solution may be to tear the disk interfaces out of the real
   2.147 -  backend and expose them somehow.
   2.148 -
   2.149 -- Make CoW suck less.
   2.150 -
   2.151 -- Do something more along the lines of dynamic linking for the
   2.152 -  plugins, so thatthey don't all need a new main().

     3.1 --- a/tools/blktap/README.sept05	Fri Jun 16 18:19:40 2006 +0100
     3.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.3 @@ -1,33 +0,0 @@
     3.4 -The blktap has been rewritten substantially based on the current
     3.5 -blkback driver.  I've removed passthrough support, as this is broken
     3.6 -by the move to grant tables and the lack of transitive grants.  A
     3.7 -blktap VM is now only capable of terminating block requests in
     3.8 -userspace.
     3.9 -
    3.10 -ublkback/ contains a _very_ initial cut at a user-level version of the block
    3.11 -backend driver.  It gives a working example of how the current tap
    3.12 -interfaces are used, in particular w.r.t. the vbd directories in
    3.13 -xenstore.
    3.14 -
    3.15 -parallax/ contains fairly recent parallax code.  This does not run on
    3.16 -the changed blktap interface, but should only be a couple of hours
    3.17 -work to get going again.
    3.18 -
    3.19 -All of the tricky bits are done, but there is plenty of cleaning to
    3.20 -do, and the top-level functionality is not here yet.  At the moment,
    3.21 -the daemon ignores the pdev requested by the tools and opens the file 
    3.22 -or device specified by TMP_IMAGE_FILE_NAME in ublkback.c.
    3.23 -
    3.24 -TODO:
    3.25 -1. Fix to allow pdev in the store to specify the device to open.
    3.26 -2. Add support (to tools as well) to mount arbitrary files...
    3.27 -   just write the filename to mount into the store, instead of pdev.
    3.28 -3. Reeximine blkif refcounting, it is almost certainly broken at the moment.
    3.29 -   - creating a blkif should take a reference.
    3.30 -   - each inflight request should take a reference on dequeue in blktaplib
    3.31 -   - sending responses should drop refs.
    3.32 -   - blkif should be implicitly freed when refcounts fall to 0.
    3.33 -4. Modify the parallax req/rsp code as per ublkback to use the new tap 
    3.34 -   interfaces. 
    3.35 -5. Write a front end that allows parallax and normal mounts to coexist
    3.36 -6. Allow blkback and blktap to run at the same time.

     4.1 --- a/tools/blktap/blkdump.c	Fri Jun 16 18:19:40 2006 +0100
     4.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
     4.3 @@ -1,62 +0,0 @@
     4.4 -/* blkdump.c
     4.5 - *
     4.6 - * show a running trace of block requests as they fly by.
     4.7 - * 
     4.8 - * (c) 2004 Andrew Warfield.
     4.9 - */
    4.10 - 
    4.11 -#include <stdio.h>
    4.12 -#include "blktaplib.h"
    4.13 - 
    4.14 -int request_print(blkif_request_t *req)
    4.15 -{
    4.16 -    int i;
    4.17 -    
    4.18 -    if ( (req->operation == BLKIF_OP_READ) ||
    4.19 -         (req->operation == BLKIF_OP_WRITE) )
    4.20 -    {
    4.21 -        printf("[%2u:%2u<%5s] (nr_segs: %03u, dev: %03u, %010llu)\n", 
    4.22 -                ID_TO_DOM(req->id), ID_TO_IDX(req->id), 
    4.23 -                blkif_op_name[req->operation], 
    4.24 -                req->nr_segments, req->handle, 
    4.25 -                req->sector_number);
    4.26 -        
    4.27 -        
    4.28 -        for (i=0; i < req->nr_segments; i++) {
    4.29 -            printf("              (gref: 0x%8x start: %u stop: %u)\n",
    4.30 -                   req->seg[i].gref,
    4.31 -                   req->seg[i].first_sect,
    4.32 -                   req->seg[i].last_sect);
    4.33 -        }
    4.34 -            
    4.35 -    } else {
    4.36 -        printf("Unknown request message type.\n");
    4.37 -    }
    4.38 -    
    4.39 -    return BLKTAP_PASS;
    4.40 -}
    4.41 -
    4.42 -int response_print(blkif_response_t *rsp)
    4.43 -{   
    4.44 -    if ( (rsp->operation == BLKIF_OP_READ) ||
    4.45 -         (rsp->operation == BLKIF_OP_WRITE) )
    4.46 -    {
    4.47 -        printf("[%2u:%2u>%5s] (status: %d)\n", 
    4.48 -                ID_TO_DOM(rsp->id), ID_TO_IDX(rsp->id), 
    4.49 -                blkif_op_name[rsp->operation], 
    4.50 -                rsp->status);
    4.51 -            
    4.52 -    } else {
    4.53 -        printf("Unknown request message type.\n");
    4.54 -    }
    4.55 -    return BLKTAP_PASS;
    4.56 -}
    4.57 -
    4.58 -int main(int argc, char *argv[])
    4.59 -{
    4.60 -    blktap_register_request_hook("request_print", request_print);
    4.61 -    blktap_register_response_hook("response_print", response_print);
    4.62 -    blktap_listen();
    4.63 -    
    4.64 -    return 0;
    4.65 -}

     5.1 --- a/tools/blktap/blkif.c	Fri Jun 16 18:19:40 2006 +0100
     5.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.3 @@ -1,212 +0,0 @@
     5.4 -/*
     5.5 - * blkif.c
     5.6 - * 
     5.7 - * The blkif interface for blktap.  A blkif describes an in-use virtual disk.
     5.8 - */
     5.9 -
    5.10 -#include <stdio.h>
    5.11 -#include <stdlib.h>
    5.12 -#include <errno.h>
    5.13 -#include <string.h>
    5.14 -#include <err.h>
    5.15 -
    5.16 -#include "blktaplib.h"
    5.17 -
    5.18 -#if 1
    5.19 -#define DPRINTF(_f, _a...) printf ( _f , ## _a )
    5.20 -#else
    5.21 -#define DPRINTF(_f, _a...) ((void)0)
    5.22 -#endif
    5.23 -
    5.24 -#define BLKIF_HASHSZ 1024
    5.25 -#define BLKIF_HASH(_d,_h) (((int)(_d)^(int)(_h))&(BLKIF_HASHSZ-1))
    5.26 -
    5.27 -static blkif_t      *blkif_hash[BLKIF_HASHSZ];
    5.28 -
    5.29 -blkif_t *blkif_find_by_handle(domid_t domid, unsigned int handle)
    5.30 -{
    5.31 -    blkif_t *blkif = blkif_hash[BLKIF_HASH(domid, handle)];
    5.32 -    while ( (blkif != NULL) && 
    5.33 -            ((blkif->domid != domid) || (blkif->handle != handle)) )
    5.34 -        blkif = blkif->hash_next;
    5.35 -    return blkif;
    5.36 -}
    5.37 -
    5.38 -blkif_t *alloc_blkif(domid_t domid)
    5.39 -{
    5.40 -    blkif_t *blkif;
    5.41 -
    5.42 -    blkif = (blkif_t *)malloc(sizeof(blkif_t));
    5.43 -    if (!blkif)
    5.44 -        return NULL;
    5.45 -
    5.46 -    memset(blkif, 0, sizeof(*blkif));
    5.47 -    blkif->domid = domid;
    5.48 -
    5.49 -    return blkif;
    5.50 -}
    5.51 -
    5.52 -static int (*new_blkif_hook)(blkif_t *blkif) = NULL;
    5.53 -void register_new_blkif_hook(int (*fn)(blkif_t *blkif))
    5.54 -{
    5.55 -    new_blkif_hook = fn;
    5.56 -}
    5.57 -
    5.58 -int blkif_init(blkif_t *blkif, long int handle, long int pdev, 
    5.59 -               long int readonly)
    5.60 -{
    5.61 -    domid_t domid;
    5.62 -    blkif_t **pblkif;
    5.63 -    
    5.64 -    if (blkif == NULL)
    5.65 -        return -EINVAL;
    5.66 -
    5.67 -    domid = blkif->domid;
    5.68 -    blkif->handle   = handle;
    5.69 -    blkif->pdev     = pdev;
    5.70 -    blkif->readonly = readonly;
    5.71 -
    5.72 -    /*
    5.73 -     * Call out to the new_blkif_hook. The tap application should define this,
    5.74 -     * and it should return having set blkif->ops
    5.75 -     * 
    5.76 -     */
    5.77 -    if (new_blkif_hook == NULL)
    5.78 -    {
    5.79 -        warn("Probe detected a new blkif, but no new_blkif_hook!");
    5.80 -        return -1;
    5.81 -    }
    5.82 -    new_blkif_hook(blkif);
    5.83 -
    5.84 -    /* Now wire it in. */
    5.85 -    pblkif = &blkif_hash[BLKIF_HASH(domid, handle)];
    5.86 -    while ( *pblkif != NULL )
    5.87 -    {
    5.88 -        if ( ((*pblkif)->domid == domid) && ((*pblkif)->handle == handle) )
    5.89 -        {
    5.90 -            DPRINTF("Could not create blkif: already exists\n");
    5.91 -            return -1;
    5.92 -        }
    5.93 -        pblkif = &(*pblkif)->hash_next;
    5.94 -    }
    5.95 -    blkif->hash_next = NULL;
    5.96 -    *pblkif = blkif;
    5.97 -
    5.98 -    return 0;
    5.99 -}
   5.100 -
   5.101 -void free_blkif(blkif_t *blkif)
   5.102 -{
   5.103 -    blkif_t **pblkif, *curs;
   5.104 -    
   5.105 -    pblkif = &blkif_hash[BLKIF_HASH(blkif->domid, blkif->handle)];
   5.106 -    while ( (curs = *pblkif) != NULL )
   5.107 -    {
   5.108 -        if ( blkif == curs )
   5.109 -        {
   5.110 -            *pblkif = curs->hash_next;
   5.111 -        }
   5.112 -        pblkif = &curs->hash_next;
   5.113 -    }
   5.114 -    free(blkif);
   5.115 -}
   5.116 -
   5.117 -void blkif_register_request_hook(blkif_t *blkif, char *name, 
   5.118 -                                 int (*rh)(blkif_t *, blkif_request_t *, int)) 
   5.119 -{
   5.120 -    request_hook_t *rh_ent, **c;
   5.121 -    
   5.122 -    rh_ent = (request_hook_t *)malloc(sizeof(request_hook_t));
   5.123 -    if (!rh_ent) 
   5.124 -    {
   5.125 -        warn("couldn't allocate a new hook");
   5.126 -        return;
   5.127 -    }
   5.128 -    
   5.129 -    rh_ent->func  = rh;
   5.130 -    rh_ent->next = NULL;
   5.131 -    if (asprintf(&rh_ent->name, "%s", name) == -1)
   5.132 -    {
   5.133 -        free(rh_ent);
   5.134 -        warn("couldn't allocate a new hook name");
   5.135 -        return;
   5.136 -    }
   5.137 -    
   5.138 -    c = &blkif->request_hook_chain;
   5.139 -    while (*c != NULL) {
   5.140 -        c = &(*c)->next;
   5.141 -    }
   5.142 -    *c = rh_ent;
   5.143 -}
   5.144 -
   5.145 -void blkif_register_response_hook(blkif_t *blkif, char *name, 
   5.146 -                                  int (*rh)(blkif_t *, blkif_response_t *, int)) 
   5.147 -{
   5.148 -    response_hook_t *rh_ent, **c;
   5.149 -    
   5.150 -    rh_ent = (response_hook_t *)malloc(sizeof(response_hook_t));
   5.151 -    if (!rh_ent) 
   5.152 -    { 
   5.153 -        warn("couldn't allocate a new hook");
   5.154 -        return;
   5.155 -    }
   5.156 -    
   5.157 -    rh_ent->func  = rh;
   5.158 -    rh_ent->next = NULL;
   5.159 -    if (asprintf(&rh_ent->name, "%s", name) == -1)
   5.160 -    {
   5.161 -        free(rh_ent);
   5.162 -        warn("couldn't allocate a new hook name");
   5.163 -        return;
   5.164 -    }
   5.165 -    
   5.166 -    c = &blkif->response_hook_chain;
   5.167 -    while (*c != NULL) {
   5.168 -        c = &(*c)->next;
   5.169 -    }
   5.170 -    *c = rh_ent;
   5.171 -}
   5.172 -
   5.173 -void blkif_print_hooks(blkif_t *blkif)
   5.174 -{
   5.175 -    request_hook_t  *req_hook;
   5.176 -    response_hook_t *rsp_hook;
   5.177 -    
   5.178 -    DPRINTF("Request Hooks:\n");
   5.179 -    req_hook = blkif->request_hook_chain;
   5.180 -    while (req_hook != NULL)
   5.181 -    {
   5.182 -        DPRINTF("  [0x%p] %s\n", req_hook->func, req_hook->name);
   5.183 -        req_hook = req_hook->next;
   5.184 -    }
   5.185 -    
   5.186 -    DPRINTF("Response Hooks:\n");
   5.187 -    rsp_hook = blkif->response_hook_chain;
   5.188 -    while (rsp_hook != NULL)
   5.189 -    {
   5.190 -        DPRINTF("  [0x%p] %s\n", rsp_hook->func, rsp_hook->name);
   5.191 -        rsp_hook = rsp_hook->next;
   5.192 -    }
   5.193 -}
   5.194 -
   5.195 -
   5.196 -long int vbd_size(blkif_t *blkif)
   5.197 -{
   5.198 -    return 1000000000;
   5.199 -}
   5.200 -
   5.201 -long int vbd_secsize(blkif_t *blkif)
   5.202 -{
   5.203 -    return 512;
   5.204 -}
   5.205 -
   5.206 -unsigned vbd_info(blkif_t *blkif)
   5.207 -{
   5.208 -    return 0;
   5.209 -}
   5.210 -
   5.211 -
   5.212 -void __init_blkif(void)
   5.213 -{    
   5.214 -    memset(blkif_hash, 0, sizeof(blkif_hash));
   5.215 -}

     6.1 --- a/tools/blktap/blktaplib.c	Fri Jun 16 18:19:40 2006 +0100
     6.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
     6.3 @@ -1,453 +0,0 @@
     6.4 -/*
     6.5 - * blktaplib.c
     6.6 - * 
     6.7 - * userspace interface routines for the blktap driver.
     6.8 - *
     6.9 - * (threadsafe(r) version) 
    6.10 - *
    6.11 - * (c) 2004 Andrew Warfield.
    6.12 - */
    6.13 -
    6.14 -#include <stdio.h>
    6.15 -#include <stdlib.h>
    6.16 -#include <sys/mman.h>
    6.17 -#include <sys/user.h>
    6.18 -#include <err.h>
    6.19 -#include <errno.h>
    6.20 -#include <sys/types.h>
    6.21 -#include <linux/types.h>
    6.22 -#include <sys/stat.h>
    6.23 -#include <fcntl.h>
    6.24 -#include <signal.h>
    6.25 -#include <sys/poll.h>
    6.26 -#include <sys/ioctl.h>
    6.27 -#include <string.h>
    6.28 -#include <unistd.h>
    6.29 -#include <pthread.h>
    6.30 -#include <xs.h>
    6.31 -                                                                     
    6.32 -#define __COMPILING_BLKTAP_LIB
    6.33 -#include "blktaplib.h"
    6.34 -
    6.35 -#if 0
    6.36 -#define DPRINTF(_f, _a...) printf ( _f , ## _a )
    6.37 -#else
    6.38 -#define DPRINTF(_f, _a...) ((void)0)
    6.39 -#endif
    6.40 -#define DEBUG_RING_IDXS 0
    6.41 -
    6.42 -#define POLLRDNORM     0x040 
    6.43 -
    6.44 -#define BLKTAP_IOCTL_KICK 1
    6.45 -
    6.46 -
    6.47 -void got_sig_bus();
    6.48 -void got_sig_int();
    6.49 -
    6.50 -/* in kernel these are opposite, but we are a consumer now. */
    6.51 -blkif_back_ring_t  fe_ring; /* slightly counterintuitive ;) */
    6.52 -blkif_front_ring_t be_ring; 
    6.53 -
    6.54 -unsigned long mmap_vstart = 0;
    6.55 -char *blktap_mem;
    6.56 -int fd = 0;
    6.57 -
    6.58 -#define BLKTAP_RING_PAGES       1 /* Front */
    6.59 -#define BLKTAP_MMAP_REGION_SIZE (BLKTAP_RING_PAGES + MMAP_PAGES)
    6.60 -    
    6.61 -int bad_count = 0;
    6.62 -void bad(void)
    6.63 -{
    6.64 -    bad_count ++;
    6.65 -    if (bad_count > 50) exit(0);
    6.66 -}
    6.67 -/*-----[ ID Manipulation from tap driver code ]--------------------------*/
    6.68 -
    6.69 -#define ACTIVE_RING_IDX unsigned short
    6.70 -
    6.71 -inline unsigned long MAKE_ID(domid_t fe_dom, ACTIVE_RING_IDX idx)
    6.72 -{
    6.73 -    return ( (fe_dom << 16) | idx );
    6.74 -}
    6.75 -
    6.76 -inline unsigned int ID_TO_IDX(unsigned long id) 
    6.77 -{ 
    6.78 -        return ( id & 0x0000ffff );
    6.79 -}
    6.80 -
    6.81 -inline domid_t ID_TO_DOM(unsigned long id) { return (id >> 16); }
    6.82 -
    6.83 -static int (*request_hook)(blkif_request_t *req) = NULL;
    6.84 -static int (*response_hook)(blkif_response_t *req) = NULL;
    6.85 -        
    6.86 -/*-----[ Data to/from Backend (server) VM ]------------------------------*/
    6.87 -
    6.88 -/*
    6.89 -
    6.90 -inline int write_req_to_be_ring(blkif_request_t *req)
    6.91 -{
    6.92 -    blkif_request_t *req_d;
    6.93 -    static pthread_mutex_t be_prod_mutex = PTHREAD_MUTEX_INITIALIZER;
    6.94 -
    6.95 -    pthread_mutex_lock(&be_prod_mutex);
    6.96 -    req_d = RING_GET_REQUEST(&be_ring, be_ring.req_prod_pvt);
    6.97 -    memcpy(req_d, req, sizeof(blkif_request_t));
    6.98 -    wmb();
    6.99 -    be_ring.req_prod_pvt++;
   6.100 -    pthread_mutex_unlock(&be_prod_mutex);
   6.101 -    
   6.102 -    return 0;
   6.103 -}
   6.104 -*/
   6.105 -
   6.106 -inline int write_rsp_to_fe_ring(blkif_response_t *rsp)
   6.107 -{
   6.108 -    blkif_response_t *rsp_d;
   6.109 -    static pthread_mutex_t fe_prod_mutex = PTHREAD_MUTEX_INITIALIZER;
   6.110 -
   6.111 -    pthread_mutex_lock(&fe_prod_mutex);
   6.112 -    rsp_d = RING_GET_RESPONSE(&fe_ring, fe_ring.rsp_prod_pvt);
   6.113 -    memcpy(rsp_d, rsp, sizeof(blkif_response_t));
   6.114 -    wmb();
   6.115 -    fe_ring.rsp_prod_pvt++;
   6.116 -    pthread_mutex_unlock(&fe_prod_mutex);
   6.117 -
   6.118 -    return 0;
   6.119 -}
   6.120 -
   6.121 -static void apply_rsp_hooks(blkif_t *blkif, blkif_response_t *rsp)
   6.122 -{
   6.123 -    response_hook_t  *rsp_hook;
   6.124 -    
   6.125 -    rsp_hook = blkif->response_hook_chain;
   6.126 -    while (rsp_hook != NULL)
   6.127 -    {
   6.128 -        switch(rsp_hook->func(blkif, rsp, 1))
   6.129 -        {
   6.130 -        case BLKTAP_PASS:
   6.131 -            break;
   6.132 -        default:
   6.133 -            printf("Only PASS is supported for resp hooks!\n");
   6.134 -        }
   6.135 -        rsp_hook = rsp_hook->next;
   6.136 -    }
   6.137 -}
   6.138 -
   6.139 -
   6.140 -static pthread_mutex_t push_mutex = PTHREAD_MUTEX_INITIALIZER;
   6.141 -
   6.142 -void blkif_inject_response(blkif_t *blkif, blkif_response_t *rsp)
   6.143 -{
   6.144 -    
   6.145 -    apply_rsp_hooks(blkif, rsp);
   6.146 -  
   6.147 -    write_rsp_to_fe_ring(rsp);
   6.148 -}
   6.149 -
   6.150 -void blktap_kick_responses(void)
   6.151 -{
   6.152 -    pthread_mutex_lock(&push_mutex);
   6.153 -    
   6.154 -    RING_PUSH_RESPONSES(&fe_ring);
   6.155 -    ioctl(fd, BLKTAP_IOCTL_KICK_FE);
   6.156 -    
   6.157 -    pthread_mutex_unlock(&push_mutex);
   6.158 -}
   6.159 -
   6.160 -/*-----[ Polling fd listeners ]------------------------------------------*/
   6.161 -
   6.162 -#define MAX_POLLFDS 64
   6.163 -
   6.164 -typedef struct {
   6.165 -    int (*func)(int fd);
   6.166 -    struct pollfd *pfd;
   6.167 -    int fd;
   6.168 -    short events;
   6.169 -    int active;
   6.170 -} pollhook_t;
   6.171 -
   6.172 -static struct pollfd  pfd[MAX_POLLFDS+2]; /* tap and store are extra */
   6.173 -static pollhook_t     pollhooks[MAX_POLLFDS];
   6.174 -static unsigned int   ph_freelist[MAX_POLLFDS];
   6.175 -static unsigned int   ph_cons, ph_prod;
   6.176 -#define nr_pollhooks() (MAX_POLLFDS - (ph_prod - ph_cons))
   6.177 -#define PH_IDX(x) (x % MAX_POLLFDS)
   6.178 -
   6.179 -int blktap_attach_poll(int fd, short events, int (*func)(int fd))
   6.180 -{
   6.181 -    pollhook_t *ph;
   6.182 -    
   6.183 -    if (nr_pollhooks() == MAX_POLLFDS) {
   6.184 -        printf("Too many pollhooks!\n");
   6.185 -        return -1;
   6.186 -    }
   6.187 -    
   6.188 -    ph = &pollhooks[ph_freelist[PH_IDX(ph_cons++)]];
   6.189 -    
   6.190 -    ph->func        = func;
   6.191 -    ph->fd          = fd;
   6.192 -    ph->events      = events;
   6.193 -    ph->active      = 1;
   6.194 -    
   6.195 -    DPRINTF("Added fd %d at ph index %d, now %d phs.\n", fd, ph_cons-1, 
   6.196 -            nr_pollhooks());
   6.197 -    
   6.198 -    return 0;
   6.199 -}
   6.200 -
   6.201 -void blktap_detach_poll(int fd)
   6.202 -{
   6.203 -    int i;
   6.204 -    
   6.205 -    for (i=0; i<MAX_POLLFDS; i++)
   6.206 -        if ((pollhooks[i].active) && (pollhooks[i].pfd->fd == fd)) {
   6.207 -            ph_freelist[PH_IDX(ph_prod++)] = i;
   6.208 -            pollhooks[i].pfd->fd = -1;
   6.209 -            pollhooks[i].active = 0;
   6.210 -            break;
   6.211 -        }
   6.212 -        
   6.213 -    DPRINTF("Removed fd %d at ph index %d, now %d phs.\n", fd, i, 
   6.214 -            nr_pollhooks());
   6.215 -}
   6.216 -
   6.217 -void pollhook_init(void)
   6.218 -{
   6.219 -    int i;
   6.220 -    
   6.221 -    for (i=0; i < MAX_POLLFDS; i++) {
   6.222 -        ph_freelist[i] = (i+1) % MAX_POLLFDS;
   6.223 -        pollhooks[i].active = 0;
   6.224 -    }
   6.225 -    
   6.226 -    ph_cons = 0;
   6.227 -    ph_prod = MAX_POLLFDS;
   6.228 -}
   6.229 -
   6.230 -void __attribute__ ((constructor)) blktaplib_init(void)
   6.231 -{
   6.232 -    pollhook_init();
   6.233 -}
   6.234 -
   6.235 -/*-----[ The main listen loop ]------------------------------------------*/
   6.236 -
   6.237 -int blktap_listen(void)
   6.238 -{
   6.239 -    int notify_be, notify_fe, tap_pfd, store_pfd, xs_fd, ret;
   6.240 -    struct xs_handle *h;
   6.241 -    blkif_t *blkif;
   6.242 -
   6.243 -    /* comms rings: */
   6.244 -    blkif_request_t  *req;
   6.245 -    blkif_response_t *rsp;
   6.246 -    blkif_sring_t    *sring;
   6.247 -    RING_IDX          rp, i, pfd_count; 
   6.248 -    
   6.249 -    /* pending rings */
   6.250 -    blkif_request_t req_pending[BLK_RING_SIZE];
   6.251 -    /* blkif_response_t rsp_pending[BLK_RING_SIZE] */;
   6.252 -    
   6.253 -    /* handler hooks: */
   6.254 -    request_hook_t   *req_hook;
   6.255 -    response_hook_t  *rsp_hook;
   6.256 -    
   6.257 -    signal (SIGBUS, got_sig_bus);
   6.258 -    signal (SIGINT, got_sig_int);
   6.259 -    
   6.260 -    __init_blkif();
   6.261 -
   6.262 -    fd = open("/dev/blktap", O_RDWR);
   6.263 -    if (fd == -1)
   6.264 -        err(-1, "open failed!");
   6.265 -
   6.266 -    blktap_mem = mmap(0, PAGE_SIZE * BLKTAP_MMAP_REGION_SIZE, 
   6.267 -             PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
   6.268 -
   6.269 -    if ((int)blktap_mem == -1) 
   6.270 -        err(-1, "mmap failed!");
   6.271 -
   6.272 -    /* assign the rings to the mapped memory */
   6.273 -/*
   6.274 -    sring = (blkif_sring_t *)((unsigned long)blktap_mem + PAGE_SIZE);
   6.275 -    FRONT_RING_INIT(&be_ring, sring, PAGE_SIZE);
   6.276 -*/  
   6.277 -    sring = (blkif_sring_t *)((unsigned long)blktap_mem);
   6.278 -    BACK_RING_INIT(&fe_ring, sring, PAGE_SIZE);
   6.279 -
   6.280 -    mmap_vstart = (unsigned long)blktap_mem +(BLKTAP_RING_PAGES << PAGE_SHIFT);
   6.281 -
   6.282 -
   6.283 -    /* Set up store connection and watch. */
   6.284 -    h = xs_daemon_open();
   6.285 -    if (h == NULL) 
   6.286 -        err(-1, "xs_daemon_open");
   6.287 -    
   6.288 -    ret = add_blockdevice_probe_watch(h, "Domain-0");
   6.289 -    if (ret != 0)
   6.290 -        err(0, "adding device probewatch");
   6.291 -    
   6.292 -    ioctl(fd, BLKTAP_IOCTL_SETMODE, BLKTAP_MODE_INTERPOSE );
   6.293 -
   6.294 -    while(1) {
   6.295 -        int ret;
   6.296 -        
   6.297 -        /* build the poll list */
   6.298 -        pfd_count = 0;
   6.299 -        for ( i=0; i < MAX_POLLFDS; i++ ) {
   6.300 -            pollhook_t *ph = &pollhooks[i];
   6.301 -            
   6.302 -            if (ph->active) {
   6.303 -                pfd[pfd_count].fd     = ph->fd;
   6.304 -                pfd[pfd_count].events = ph->events;
   6.305 -                ph->pfd               = &pfd[pfd_count];
   6.306 -                pfd_count++;
   6.307 -            }
   6.308 -        }
   6.309 -
   6.310 -        tap_pfd = pfd_count++;
   6.311 -        pfd[tap_pfd].fd = fd;
   6.312 -        pfd[tap_pfd].events = POLLIN;
   6.313 -
   6.314 -        store_pfd = pfd_count++;
   6.315 -        pfd[store_pfd].fd = xs_fileno(h);
   6.316 -        pfd[store_pfd].events = POLLIN;
   6.317 -        
   6.318 -        if ( (ret = (poll(pfd, pfd_count, 10000)) == 0) ) {
   6.319 -            if (DEBUG_RING_IDXS)
   6.320 -                ioctl(fd, BLKTAP_IOCTL_PRINT_IDXS);
   6.321 -            continue;
   6.322 -        }
   6.323 -
   6.324 -        for (i=0; i < MAX_POLLFDS; i++) {
   6.325 -            if ( (pollhooks[i].active ) && (pollhooks[i].pfd->revents ) )
   6.326 -                pollhooks[i].func(pollhooks[i].pfd->fd);
   6.327 -        }
   6.328 -        
   6.329 -        if (pfd[store_pfd].revents) {
   6.330 -            ret = xs_fire_next_watch(h);
   6.331 -        }
   6.332 -
   6.333 -        if (pfd[tap_pfd].revents) 
   6.334 -        {    
   6.335 -            /* empty the fe_ring */
   6.336 -            notify_fe = 0;
   6.337 -            notify_be = RING_HAS_UNCONSUMED_REQUESTS(&fe_ring);
   6.338 -            rp = fe_ring.sring->req_prod;
   6.339 -            rmb();
   6.340 -            for (i = fe_ring.req_cons; i != rp; i++)
   6.341 -            {
   6.342 -                int done = 0; 
   6.343 -
   6.344 -                req = RING_GET_REQUEST(&fe_ring, i);
   6.345 -                memcpy(&req_pending[ID_TO_IDX(req->id)], req, sizeof(*req));
   6.346 -                req = &req_pending[ID_TO_IDX(req->id)];
   6.347 -
   6.348 -                blkif = blkif_find_by_handle(ID_TO_DOM(req->id), req->handle);
   6.349 -
   6.350 -                if (blkif != NULL)
   6.351 -                {
   6.352 -                    req_hook = blkif->request_hook_chain;
   6.353 -                    while (req_hook != NULL)
   6.354 -                    {
   6.355 -                        switch(req_hook->func(blkif, req, ((i+1) == rp)))
   6.356 -                        {
   6.357 -                        case BLKTAP_RESPOND:
   6.358 -                            apply_rsp_hooks(blkif, (blkif_response_t *)req);
   6.359 -                            write_rsp_to_fe_ring((blkif_response_t *)req);
   6.360 -                            notify_fe = 1;
   6.361 -                            done = 1;
   6.362 -                            break;
   6.363 -                        case BLKTAP_STOLEN:
   6.364 -                            done = 1;
   6.365 -                            break;
   6.366 -                        case BLKTAP_PASS:
   6.367 -                            break;
   6.368 -                        default:
   6.369 -                            printf("Unknown request hook return value!\n");
   6.370 -                        }
   6.371 -                        if (done) break;
   6.372 -                        req_hook = req_hook->next;
   6.373 -                    }
   6.374 -                }
   6.375 -
   6.376 -                if (done == 0) 
   6.377 -                {
   6.378 -                    /* this was:  */
   6.379 -                    /* write_req_to_be_ring(req); */
   6.380 -
   6.381 -                    unsigned long id = req->id;
   6.382 -                    unsigned short operation = req->operation;
   6.383 -                    printf("Unterminated request!\n");
   6.384 -                    rsp = (blkif_response_t *)req;
   6.385 -                    rsp->id = id;
   6.386 -                    rsp->operation = operation;
   6.387 -                    rsp->status = BLKIF_RSP_ERROR;
   6.388 -                    write_rsp_to_fe_ring(rsp);
   6.389 -                    notify_fe = 1;
   6.390 -                    done = 1;
   6.391 -                }
   6.392 -
   6.393 -            }
   6.394 -            fe_ring.req_cons = i;
   6.395 -
   6.396 -            /* empty the be_ring */
   6.397 -/*
   6.398 -            notify_fe |= RING_HAS_UNCONSUMED_RESPONSES(&be_ring);
   6.399 -            rp = be_ring.sring->rsp_prod;
   6.400 -            rmb();
   6.401 -            for (i = be_ring.rsp_cons; i != rp; i++)
   6.402 -            {
   6.403 -
   6.404 -                rsp = RING_GET_RESPONSE(&be_ring, i);
   6.405 -                memcpy(&rsp_pending[ID_TO_IDX(rsp->id)], rsp, sizeof(*rsp));
   6.406 -                rsp = &rsp_pending[ID_TO_IDX(rsp->id)];
   6.407 -
   6.408 -                DPRINTF("copying a be request\n");
   6.409 -
   6.410 -                apply_rsp_hooks(rsp);
   6.411 -                write_rsp_to_fe_ring(rsp);
   6.412 -            }
   6.413 -            be_ring.rsp_cons = i;
   6.414 -*/
   6.415 -            /* notify the domains */
   6.416 -/*
   6.417 -            if (notify_be) {
   6.418 -                DPRINTF("notifying be\n");
   6.419 -pthread_mutex_lock(&push_mutex);
   6.420 -                RING_PUSH_REQUESTS(&be_ring);
   6.421 -                ioctl(fd, BLKTAP_IOCTL_KICK_BE);
   6.422 -pthread_mutex_unlock(&push_mutex);
   6.423 -            }
   6.424 -*/
   6.425 -            if (notify_fe) {
   6.426 -                DPRINTF("notifying fe\n");
   6.427 -                pthread_mutex_lock(&push_mutex);
   6.428 -                RING_PUSH_RESPONSES(&fe_ring);
   6.429 -                ioctl(fd, BLKTAP_IOCTL_KICK_FE);
   6.430 -                pthread_mutex_unlock(&push_mutex);
   6.431 -            }
   6.432 -        }        
   6.433 -    }
   6.434 -
   6.435 -
   6.436 -    munmap(blktap_mem, PAGE_SIZE);
   6.437 -
   6.438 - mmap_failed:
   6.439 -    close(fd);
   6.440 -
   6.441 - open_failed:
   6.442 -    return 0;
   6.443 -}
   6.444 -
   6.445 -void got_sig_bus() {
   6.446 -    printf("Attempted to access a page that isn't.\n");
   6.447 -    exit(-1);
   6.448 -}
   6.449 -
   6.450 -void got_sig_int() {
   6.451 -    DPRINTF("quitting -- returning to passthrough mode.\n");
   6.452 -    if (fd > 0) ioctl(fd, BLKTAP_IOCTL_SETMODE, BLKTAP_MODE_PASSTHROUGH );
   6.453 -    close(fd);
   6.454 -    fd = 0;
   6.455 -    exit(0);
   6.456 -} 

     7.1 --- a/tools/blktap/blktaplib.h	Fri Jun 16 18:19:40 2006 +0100
     7.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.3 @@ -1,171 +0,0 @@
     7.4 -/* blktaplib.h
     7.5 - *
     7.6 - * userland accessors to the block tap.
     7.7 - *
     7.8 - * Sept 2/05 -- I'm scaling this back to only support block remappings
     7.9 - * to user in a backend domain.  Passthrough and interposition can be readded
    7.10 - * once transitive grants are available.
    7.11 - */
    7.12 - 
    7.13 -#ifndef __BLKTAPLIB_H__
    7.14 -#define __BLKTAPLIB_H__
    7.15 -
    7.16 -#include <xenctrl.h>
    7.17 -#include <sys/user.h>
    7.18 -#include <xen/xen.h>
    7.19 -#include <xen/io/blkif.h>
    7.20 -#include <xen/io/ring.h>
    7.21 -#include <xen/io/domain_controller.h>
    7.22 -#include <xs.h>
    7.23 -
    7.24 -#define BLK_RING_SIZE __RING_SIZE((blkif_sring_t *)0, PAGE_SIZE)
    7.25 -
    7.26 -/* /dev/xen/blktap resides at device number major=10, minor=202        */ 
    7.27 -#define BLKTAP_MINOR 202
    7.28 -
    7.29 -/* size of the extra VMA area to map in attached pages. */
    7.30 -#define BLKTAP_VMA_PAGES BLK_RING_SIZE
    7.31 -
    7.32 -/* blktap IOCTLs:                                                      */
    7.33 -#define BLKTAP_IOCTL_KICK_FE         1
    7.34 -#define BLKTAP_IOCTL_KICK_BE         2
    7.35 -#define BLKTAP_IOCTL_SETMODE         3
    7.36 -#define BLKTAP_IOCTL_PRINT_IDXS      100   
    7.37 -
    7.38 -/* blktap switching modes: (Set with BLKTAP_IOCTL_SETMODE)             */
    7.39 -#define BLKTAP_MODE_PASSTHROUGH      0x00000000  /* default            */
    7.40 -#define BLKTAP_MODE_INTERCEPT_FE     0x00000001
    7.41 -#define BLKTAP_MODE_INTERCEPT_BE     0x00000002
    7.42 -#define BLKTAP_MODE_COPY_FE          0x00000004
    7.43 -#define BLKTAP_MODE_COPY_BE          0x00000008
    7.44 -#define BLKTAP_MODE_COPY_FE_PAGES    0x00000010
    7.45 -#define BLKTAP_MODE_COPY_BE_PAGES    0x00000020
    7.46 -
    7.47 -#define BLKTAP_MODE_INTERPOSE \
    7.48 -           (BLKTAP_MODE_INTERCEPT_FE | BLKTAP_MODE_INTERCEPT_BE)
    7.49 -
    7.50 -#define BLKTAP_MODE_COPY_BOTH \
    7.51 -           (BLKTAP_MODE_COPY_FE | BLKTAP_MODE_COPY_BE)
    7.52 -
    7.53 -#define BLKTAP_MODE_COPY_BOTH_PAGES \
    7.54 -           (BLKTAP_MODE_COPY_FE_PAGES | BLKTAP_MODE_COPY_BE_PAGES)
    7.55 -
    7.56 -static inline int BLKTAP_MODE_VALID(unsigned long arg)
    7.57 -{
    7.58 -    return (
    7.59 -        ( arg == BLKTAP_MODE_PASSTHROUGH  ) ||
    7.60 -        ( arg == BLKTAP_MODE_INTERCEPT_FE ) ||
    7.61 -        ( arg == BLKTAP_MODE_INTERPOSE    ) );
    7.62 -/*
    7.63 -    return (
    7.64 -        ( arg == BLKTAP_MODE_PASSTHROUGH  ) ||
    7.65 -        ( arg == BLKTAP_MODE_INTERCEPT_FE ) ||
    7.66 -        ( arg == BLKTAP_MODE_INTERCEPT_BE ) ||
    7.67 -        ( arg == BLKTAP_MODE_INTERPOSE    ) ||
    7.68 -        ( (arg & ~BLKTAP_MODE_COPY_FE_PAGES) == BLKTAP_MODE_COPY_FE ) ||
    7.69 -        ( (arg & ~BLKTAP_MODE_COPY_BE_PAGES) == BLKTAP_MODE_COPY_BE ) ||
    7.70 -        ( (arg & ~BLKTAP_MODE_COPY_BOTH_PAGES) == BLKTAP_MODE_COPY_BOTH )
    7.71 -        );
    7.72 -*/
    7.73 -}
    7.74 -
    7.75 -/* Return values for handling messages in hooks. */
    7.76 -#define BLKTAP_PASS     0 /* Keep passing this request as normal. */
    7.77 -#define BLKTAP_RESPOND  1 /* Request is now a reply.  Return it.  */
    7.78 -#define BLKTAP_STOLEN   2 /* Hook has stolen request.             */
    7.79 -
    7.80 -//#define domid_t unsigned short
    7.81 -
    7.82 -inline unsigned int ID_TO_IDX(unsigned long id);
    7.83 -inline domid_t ID_TO_DOM(unsigned long id);
    7.84 -
    7.85 -int  blktap_attach_poll(int fd, short events, int (*func)(int));
    7.86 -void blktap_detach_poll(int fd);
    7.87 -int  blktap_listen(void);
    7.88 -
    7.89 -struct blkif;
    7.90 -
    7.91 -typedef struct request_hook_st {
    7.92 -    char *name;
    7.93 -    int (*func)(struct blkif *, blkif_request_t *, int);
    7.94 -    struct request_hook_st *next;
    7.95 -} request_hook_t;
    7.96 -
    7.97 -typedef struct response_hook_st {
    7.98 -    char *name;
    7.99 -    int (*func)(struct blkif *, blkif_response_t *, int);
   7.100 -    struct response_hook_st *next;
   7.101 -} response_hook_t;
   7.102 -
   7.103 -struct blkif_ops {
   7.104 -    long int (*get_size)(struct blkif *blkif);
   7.105 -    long int (*get_secsize)(struct blkif *blkif);
   7.106 -    unsigned (*get_info)(struct blkif *blkif);
   7.107 -};
   7.108 -
   7.109 -typedef struct blkif {
   7.110 -    domid_t domid;
   7.111 -    long int handle;
   7.112 -
   7.113 -    long int pdev;
   7.114 -    long int readonly;
   7.115 -
   7.116 -    enum { DISCONNECTED, CONNECTED } state;
   7.117 -
   7.118 -    struct blkif_ops *ops;
   7.119 -    request_hook_t *request_hook_chain;
   7.120 -    response_hook_t *response_hook_chain;
   7.121 -
   7.122 -    struct blkif *hash_next;
   7.123 -
   7.124 -    void *prv;  /* device-specific data */
   7.125 -} blkif_t;
   7.126 -
   7.127 -void register_new_blkif_hook(int (*fn)(blkif_t *blkif));
   7.128 -blkif_t *blkif_find_by_handle(domid_t domid, unsigned int handle);
   7.129 -blkif_t *alloc_blkif(domid_t domid);
   7.130 -int blkif_init(blkif_t *blkif, long int handle, long int pdev, 
   7.131 -               long int readonly);
   7.132 -void free_blkif(blkif_t *blkif);
   7.133 -void __init_blkif(void);
   7.134 -
   7.135 -
   7.136 -/* xenstore/xenbus: */
   7.137 -extern int add_blockdevice_probe_watch(struct xs_handle *h, 
   7.138 -                                       const char *domname);
   7.139 -int xs_fire_next_watch(struct xs_handle *h);
   7.140 -
   7.141 -
   7.142 -void blkif_print_hooks(blkif_t *blkif);
   7.143 -void blkif_register_request_hook(blkif_t *blkif, char *name, 
   7.144 -                             int (*rh)(blkif_t *, blkif_request_t *, int));
   7.145 -void blkif_register_response_hook(blkif_t *blkif, char *name, 
   7.146 -                             int (*rh)(blkif_t *, blkif_response_t *, int));
   7.147 -void blkif_inject_response(blkif_t *blkif, blkif_response_t *);
   7.148 -void blktap_kick_responses(void);
   7.149 -
   7.150 -/* this must match the underlying driver... */
   7.151 -#define MAX_PENDING_REQS 64
   7.152 -
   7.153 -/* Accessing attached data page mappings */
   7.154 -#define MMAP_PAGES                                              \
   7.155 -    (MAX_PENDING_REQS * BLKIF_MAX_SEGMENTS_PER_REQUEST)
   7.156 -#define MMAP_VADDR(_req,_seg)                                   \
   7.157 -    (mmap_vstart +                                              \
   7.158 -     ((_req) * BLKIF_MAX_SEGMENTS_PER_REQUEST * PAGE_SIZE) +    \
   7.159 -     ((_seg) * PAGE_SIZE))
   7.160 -
   7.161 -extern unsigned long mmap_vstart;
   7.162 -
   7.163 -/* Defines that are only used by library clients */
   7.164 -
   7.165 -#ifndef __COMPILING_BLKTAP_LIB
   7.166 -
   7.167 -static char *blkif_op_name[] = {
   7.168 -    [BLKIF_OP_READ]       = "READ",
   7.169 -    [BLKIF_OP_WRITE]      = "WRITE",
   7.170 -};
   7.171 -
   7.172 -#endif /* __COMPILING_BLKTAP_LIB */
   7.173 -    
   7.174 -#endif /* __BLKTAPLIB_H__ */

     8.1 --- a/tools/blktap/list.h	Fri Jun 16 18:19:40 2006 +0100
     8.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.3 @@ -1,55 +0,0 @@
     8.4 -/*
     8.5 - * list.h
     8.6 - * 
     8.7 - * This is a subset of linux's list.h intended to be used in user-space.
     8.8 - * 
     8.9 - */
    8.10 -
    8.11 -#ifndef __LIST_H__
    8.12 -#define __LIST_H__
    8.13 -
    8.14 -#define LIST_POISON1  ((void *) 0x00100100)
    8.15 -#define LIST_POISON2  ((void *) 0x00200200)
    8.16 -
    8.17 -struct list_head {
    8.18 -        struct list_head *next, *prev;
    8.19 -};
    8.20 - 
    8.21 -#define LIST_HEAD_INIT(name) { &(name), &(name) }
    8.22 - 
    8.23 -#define LIST_HEAD(name) \
    8.24 -        struct list_head name = LIST_HEAD_INIT(name)
    8.25 -
    8.26 -static inline void __list_add(struct list_head *new,
    8.27 -                              struct list_head *prev,
    8.28 -                              struct list_head *next)
    8.29 -{
    8.30 -        next->prev = new;
    8.31 -        new->next = next;
    8.32 -        new->prev = prev;
    8.33 -        prev->next = new;
    8.34 -}
    8.35 -
    8.36 -static inline void list_add(struct list_head *new, struct list_head *head)
    8.37 -{
    8.38 -        __list_add(new, head, head->next);
    8.39 -}
    8.40 -static inline void __list_del(struct list_head * prev, struct list_head * next)
    8.41 -{
    8.42 -        next->prev = prev;
    8.43 -        prev->next = next;
    8.44 -}
    8.45 -static inline void list_del(struct list_head *entry)
    8.46 -{
    8.47 -        __list_del(entry->prev, entry->next);
    8.48 -        entry->next = LIST_POISON1;
    8.49 -        entry->prev = LIST_POISON2;
    8.50 -}
    8.51 -#define list_entry(ptr, type, member)                                   \
    8.52 -        ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
    8.53 -#define list_for_each_entry(pos, head, member)                          \
    8.54 -        for (pos = list_entry((head)->next, typeof(*pos), member);      \
    8.55 -             &pos->member != (head);                                    \
    8.56 -             pos = list_entry(pos->member.next, typeof(*pos), member))
    8.57 -
    8.58 -#endif /* __LIST_H__ */

     9.1 --- a/tools/blktap/parallax/Makefile	Fri Jun 16 18:19:40 2006 +0100
     9.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
     9.3 @@ -1,63 +0,0 @@
     9.4 -XEN_ROOT = ../../..
     9.5 -include $(XEN_ROOT)/tools/Rules.mk
     9.6 -
     9.7 -PARALLAX_INSTALL_DIR	= /usr/sbin
     9.8 -
     9.9 -INSTALL         = install
    9.10 -INSTALL_PROG    = $(INSTALL) -m0755
    9.11 -INSTALL_DIR     = $(INSTALL) -d -m0755
    9.12 -
    9.13 -INCLUDES += -I.. -I/usr/include -I $(XEN_LIBXC)
    9.14 -
    9.15 -LDFLAGS = -L.. -lpthread -lz -lblktap
    9.16 -
    9.17 -#PLX_SRCS := 
    9.18 -PLX_SRCS := vdi.c 
    9.19 -PLX_SRCS += radix.c 
    9.20 -PLX_SRCS += snaplog.c
    9.21 -PLX_SRCS += blockstore.c 
    9.22 -PLX_SRCS += block-async.c
    9.23 -PLX_SRCS += requests-async.c
    9.24 -VDI_SRCS := $(PLX_SRCS)
    9.25 -PLX_SRCS += parallax.c
    9.26 -
    9.27 -#VDI_TOOLS :=
    9.28 -VDI_TOOLS := vdi_create
    9.29 -VDI_TOOLS += vdi_list
    9.30 -VDI_TOOLS += vdi_snap
    9.31 -VDI_TOOLS += vdi_snap_list
    9.32 -VDI_TOOLS += vdi_snap_delete
    9.33 -VDI_TOOLS += vdi_fill
    9.34 -VDI_TOOLS += vdi_tree
    9.35 -VDI_TOOLS += vdi_validate
    9.36 -
    9.37 -CFLAGS   += -Werror
    9.38 -CFLAGS   += -Wno-unused
    9.39 -CFLAGS   += -fno-strict-aliasing
    9.40 -CFLAGS   += $(INCLUDES)
    9.41 -CFLAGS   += -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE
    9.42 -# Get gcc to generate the dependencies for us.
    9.43 -CFLAGS   += -Wp,-MD,.$(@F).d
    9.44 -DEPS     = .*.d
    9.45 -
    9.46 -OBJS     = $(patsubst %.c,%.o,$(SRCS))
    9.47 -IBINS    = parallax $(VDI_TOOLS)
    9.48 -
    9.49 -.PHONY: all
    9.50 -all: $(VDI_TOOLS) parallax blockstored
    9.51 -
    9.52 -.PHONY: install
    9.53 -install: all
    9.54 -	$(INSTALL_PROG) $(IBINS) $(DESTDIR)$(PARALLAX_INSTALL_DIR)
    9.55 -
    9.56 -.PHONY: clean
    9.57 -clean:
    9.58 -	rm -rf *.o *~ $(DEPS) xen TAGS $(VDI_TOOLS) parallax vdi_unittest
    9.59 -
    9.60 -parallax: $(PLX_SRCS)
    9.61 -	$(CC) $(CFLAGS) -o parallax -L.. $(LDFLAGS) $(PLX_SRCS)
    9.62 -
    9.63 -${VDI_TOOLS}: %: %.c $(VDI_SRCS)
    9.64 -	$(CC) $(CFLAGS) -o $@ $@.c $(LDFLAGS) $(VDI_SRCS)
    9.65 -
    9.66 --include $(DEPS)

    10.1 --- a/tools/blktap/parallax/README	Fri Jun 16 18:19:40 2006 +0100
    10.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    10.3 @@ -1,177 +0,0 @@
    10.4 -Parallax Quick Overview
    10.5 -March 3, 2005
    10.6 -
    10.7 -This is intended to provide a quick set of instructions to let you
    10.8 -guys play with the current parallax source.  In it's current form, the
    10.9 -code will let you run an arbitrary number of VMs off of a single disk
   10.10 -image, doing copy-on-write as they make updates.  Each domain is
   10.11 -assigned a virtual disk image (VDI), which may be based on a snapshot
   10.12 -of an existing image.  All of the VDI and snapshot management should
   10.13 -currently work.
   10.14 -
   10.15 -The current implementation uses a single file as a blockstore for
   10.16 -_everything_ this will soon be replaced by the fancier backend code
   10.17 -and the local cache.  As it stands, Parallax will create
   10.18 -"blockstore.dat" in the directory that you run it from, and use
   10.19 -largefile support to make this grow to unfathomable girth.  So, you
   10.20 -probably want to run the daemon off of a local disk, with a lot of
   10.21 -free space.
   10.22 -
   10.23 -Here's how to get going:
   10.24 -
   10.25 -0. Setup:
   10.26 ----------
   10.27 -
   10.28 -Pick a local directory on a disk with lots of room.  You should be
   10.29 -running from a privileged domain (e.g. dom0) with the blocktap
   10.30 -configured in and block backend NOT.
   10.31 -
   10.32 -For convenience (for the moment) copy all of the vdi tools (vdi_*) and
   10.33 -the parallax daemon from tools/blktap into this directory.
   10.34 -
   10.35 -1. Populate the blockstore:
   10.36 ----------------------------
   10.37 -
   10.38 -First you need to put at least one image into the blockstore.  You
   10.39 -will need a disk image, either as a file or local partition.  My
   10.40 -general approach has been to
   10.41 -
   10.42 -(a) make a really big sparse file with 
   10.43 -
   10.44 -        dd if=/dev/zero of=./image bs=4K count=1 seek=[big value]
   10.45 -
   10.46 -(b) put a filesystem into it
   10.47 -
   10.48 -        mkfs.ext3 ./image
   10.49 -
   10.50 -(c) mount it using loopback
   10.51 -
   10.52 -        mkdir ./mnt
   10.53 -        mount -o loop ./image
   10.54 -
   10.55 -(d) cd into it and untar one of the image files from srg-roots.
   10.56 -
   10.57 -        cd mnt
   10.58 -        tar ...
   10.59 -
   10.60 -NOTE: Beware if your system is FC3.  mkfs is not compatible with old
   10.61 -versions of fedora, and so you don't have much choice but to install
   10.62 -further fc3 images if you have used the fc3 version of mkfs.
   10.63 -
   10.64 -(e) unmount the image
   10.65 -
   10.66 -        cd ..
   10.67 -        umount mnt
   10.68 -
   10.69 -(f) now, create a new VDI to hold the image 
   10.70 -
   10.71 -        ./vdi_create "My new FC3 VDI"
   10.72 -
   10.73 -(g) get the id of the new VDI.
   10.74 -
   10.75 -        ./vdi_list
   10.76 -
   10.77 -        |      0                     My new FC3 VDI
   10.78 -
   10.79 -(0 is the VDI id... create a few more if you want.)
   10.80 -
   10.81 -(h) hoover your image into the new VDI.
   10.82 -
   10.83 -        ./vdi_fill 0 ./image
   10.84 -
   10.85 -This will pull the entire image into the blockstore and set up a
   10.86 -mapping tree for it for VDI 0.  Passing a device (i.e. /dev/sda3)
   10.87 -should also work, but vdi_fill has NO notion of sparseness yet, so you
   10.88 -are going to pump a block into the store for each block you read.
   10.89 -
   10.90 -vdi_fill will count up until it is done, and you should be ready to
   10.91 -go.  If you want to be anal, you can use vdi_validate to test the VDI
   10.92 -against the original image.
   10.93 -
   10.94 -2. Create some extra VDIs
   10.95 --------------------------
   10.96 -
   10.97 -VDIs are actually a list of snapshots, and each snapshot is a full
   10.98 -image of mappings.  So, to preserve an immutable copy of a current
   10.99 -VDI, do this:
  10.100 -
  10.101 -(a) Snapshot your new VDI.
  10.102 -
  10.103 -        ./vdi_snap 0
  10.104 -
  10.105 -Snapshotting writes the current radix root to the VDI's snapshot log,
  10.106 -and assigns it a new writable root.
  10.107 -
  10.108 -(b) look at the VDI's snapshot log.
  10.109 -
  10.110 -        ./vdi_snap_list 0
  10.111 -
  10.112 -        | 16   0      Thu Mar  3 19:27:48 2005 565111           31
  10.113 -
  10.114 -The first two columns constitute a snapshot id and represent the
  10.115 -(block, offset) of the snapshot record.  The Date tells you when the
  10.116 -snapshot was made, and 31 is the radix root node of the snapshot.
  10.117 -
  10.118 -(c) Create a new VDI, based on that snapshot, and look at the list.
  10.119 -
  10.120 -        ./vdi_create "FC3 - Copy 1" 16 0
  10.121 -        ./vdi_list
  10.122 -
  10.123 -        |      0                     My new FC3 VDI
  10.124 -        |      1                       FC3 - Copy 1
  10.125 -
  10.126 -NOTE: If you have Graphviz installed on your system, you can use
  10.127 -vdi_tree to generate a postscript of your current set of VDIs and
  10.128 -snapshots.
  10.129 -
  10.130 -
  10.131 -Create as many VDIs as you need for the VMs that you want to run.
  10.132 -
  10.133 -3. Boot some VMs:
  10.134 ------------------
  10.135 -
  10.136 -Parallax currently uses a hack in xend to pass the VDI id, you need to
  10.137 -modify the disk line of the VM config that is going to mount it.
  10.138 -
  10.139 -(a) set up your vm config, by using the following disk line:
  10.140 -
  10.141 -        disk = ['parallax:1,sda1,w,0' ]
  10.142 -
  10.143 -This example uses VDI 1 (from vdi_list above), presents it as sda1
  10.144 -(writable), and uses dom 0 as the backend.  If you were running the
  10.145 -daemon (and tap driver) in some domain other than 0, you would change
  10.146 -this last parameter.
  10.147 -
  10.148 -NOTE: You'll need to have reinstalled xend/tools prior to booting the vm, so that it knows what to do with "parallax:".
  10.149 -
  10.150 -(b) Run parallax in the backend domain.
  10.151 -
  10.152 -        ./parallax
  10.153 -
  10.154 -(c) create your new domain.
  10.155 -
  10.156 -        xm create ...
  10.157 -
  10.158 ----
  10.159 -
  10.160 -That's pretty much all there is to it at the moment.  Hope this is
  10.161 -clear enough to get you going.  Now, a few serious caveats that will
  10.162 -be sorted out in the almost immediate future:
  10.163 -
  10.164 -WARNINGS:
  10.165 ----------
  10.166 -
  10.167 -1. There is NO locking in the VDI tools at the moment, so I'd avoid
  10.168 -running them in parallel, or more importantly, running them while the
  10.169 -daemon is running.
  10.170 -
  10.171 -2. I doubt that xend will be very happy about restarting if you have
  10.172 -parallax-using domains.  So if it dies while there are active parallax
  10.173 -doms, you may need to reboot.
  10.174 -
  10.175 -3. I've turned off write-in-place.  So at the moment, EVERY block
  10.176 -write is a log append on the blockstore.  I've been having some probs
  10.177 -with the radix tree's marking of writable blocks after snapshots and
  10.178 -will sort this out very soon.
  10.179 -
  10.180 -

    11.1 --- a/tools/blktap/parallax/block-async.c	Fri Jun 16 18:19:40 2006 +0100
    11.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    11.3 @@ -1,393 +0,0 @@
    11.4 -/* block-async.c
    11.5 - * 
    11.6 - * Asynchronous block wrappers for parallax.
    11.7 - */
    11.8 - 
    11.9 - 
   11.10 -#include <stdio.h>
   11.11 -#include <stdlib.h>
   11.12 -#include <string.h>
   11.13 -#include <pthread.h>
   11.14 -#include "block-async.h"
   11.15 -#include "blockstore.h"
   11.16 -#include "vdi.h"
   11.17 -
   11.18 -
   11.19 -#if 0
   11.20 -#define DPRINTF(_f, _a...) printf ( _f , ## _a )
   11.21 -#else
   11.22 -#define DPRINTF(_f, _a...) ((void)0)
   11.23 -#endif
   11.24 -
   11.25 -/* We have a queue of outstanding I/O requests implemented as a 
   11.26 - * circular producer-consumer ring with free-running buffers.
   11.27 - * to allow reordering, this ring indirects to indexes in an 
   11.28 - * ring of io_structs.
   11.29 - * 
   11.30 - * the block_* calls may either add an entry to this ring and return, 
   11.31 - * or satisfy the request immediately and call the callback directly.
   11.32 - * None of the io calls in parallax should be nested enough to worry 
   11.33 - * about stack problems with this approach.
   11.34 - */
   11.35 -
   11.36 -struct read_args {
   11.37 -    uint64_t addr;
   11.38 -};
   11.39 -
   11.40 -struct write_args {
   11.41 -    uint64_t   addr;
   11.42 -    char *block;
   11.43 -};
   11.44 -
   11.45 -struct alloc_args {
   11.46 -    char *block;
   11.47 -};
   11.48 - 
   11.49 -struct pending_io_req {
   11.50 -    enum {IO_READ, IO_WRITE, IO_ALLOC, IO_RWAKE, IO_WWAKE} op;
   11.51 -    union {
   11.52 -        struct read_args  r;
   11.53 -        struct write_args w;
   11.54 -        struct alloc_args a;
   11.55 -    } u;
   11.56 -    io_cb_t cb;
   11.57 -    void *param;
   11.58 -};
   11.59 -
   11.60 -void radix_lock_init(struct radix_lock *r)
   11.61 -{
   11.62 -    int i;
   11.63 -    
   11.64 -    pthread_mutex_init(&r->lock, NULL);
   11.65 -    for (i=0; i < 1024; i++) {
   11.66 -        r->lines[i] = 0;
   11.67 -        r->waiters[i] = NULL;
   11.68 -        r->state[i] = ANY;
   11.69 -    }
   11.70 -}
   11.71 -
   11.72 -/* maximum outstanding I/O requests issued asynchronously */
   11.73 -/* must be a power of 2.*/
   11.74 -#define MAX_PENDING_IO 1024
   11.75 -
   11.76 -/* how many threads to concurrently issue I/O to the disk. */
   11.77 -#define IO_POOL_SIZE   10
   11.78 -
   11.79 -static struct pending_io_req pending_io_reqs[MAX_PENDING_IO];
   11.80 -static int pending_io_list[MAX_PENDING_IO];
   11.81 -static unsigned long io_prod = 0, io_cons = 0, io_free = 0;
   11.82 -#define PENDING_IO_MASK(_x) ((_x) & (MAX_PENDING_IO - 1))
   11.83 -#define PENDING_IO_IDX(_x) ((_x) - pending_io_reqs)
   11.84 -#define PENDING_IO_ENT(_x) \
   11.85 -	(&pending_io_reqs[pending_io_list[PENDING_IO_MASK(_x)]])
   11.86 -#define CAN_PRODUCE_PENDING_IO ((io_free + MAX_PENDING_IO) != io_prod)
   11.87 -#define CAN_CONSUME_PENDING_IO (io_cons != io_prod)
   11.88 -static pthread_mutex_t pending_io_lock = PTHREAD_MUTEX_INITIALIZER;
   11.89 -static pthread_cond_t  pending_io_cond = PTHREAD_COND_INITIALIZER;
   11.90 -
   11.91 -static void init_pending_io(void)
   11.92 -{
   11.93 -    int i;
   11.94 -	
   11.95 -    for (i=0; i<MAX_PENDING_IO; i++)
   11.96 -        pending_io_list[i] = i;
   11.97 -		
   11.98 -} 
   11.99 -
  11.100 -void block_read(uint64_t addr, io_cb_t cb, void *param)
  11.101 -{
  11.102 -    struct pending_io_req *req;
  11.103 -    
  11.104 -    pthread_mutex_lock(&pending_io_lock);
  11.105 -    assert(CAN_PRODUCE_PENDING_IO);
  11.106 -    
  11.107 -    req = PENDING_IO_ENT(io_prod++);
  11.108 -    DPRINTF("Produce (R) %lu (%p)\n", io_prod - 1, req);
  11.109 -    req->op = IO_READ;
  11.110 -    req->u.r.addr = addr;
  11.111 -    req->cb = cb;
  11.112 -    req->param = param;
  11.113 -    
  11.114 -    pthread_cond_signal(&pending_io_cond);
  11.115 -    pthread_mutex_unlock(&pending_io_lock);	
  11.116 -}
  11.117 -
  11.118 -
  11.119 -void block_write(uint64_t addr, char *block, io_cb_t cb, void *param)
  11.120 -{
  11.121 -    struct pending_io_req *req;
  11.122 -    
  11.123 -    pthread_mutex_lock(&pending_io_lock);
  11.124 -    assert(CAN_PRODUCE_PENDING_IO);
  11.125 -    
  11.126 -    req = PENDING_IO_ENT(io_prod++);
  11.127 -    DPRINTF("Produce (W) %lu (%p)\n", io_prod - 1, req);
  11.128 -    req->op = IO_WRITE;
  11.129 -    req->u.w.addr  = addr;
  11.130 -    req->u.w.block = block;
  11.131 -    req->cb = cb;
  11.132 -    req->param = param;
  11.133 -    
  11.134 -    pthread_cond_signal(&pending_io_cond);
  11.135 -    pthread_mutex_unlock(&pending_io_lock);	
  11.136 -}
  11.137 -
  11.138 -
  11.139 -void block_alloc(char *block, io_cb_t cb, void *param)
  11.140 -{
  11.141 -    struct pending_io_req *req;
  11.142 -	
  11.143 -    pthread_mutex_lock(&pending_io_lock);
  11.144 -    assert(CAN_PRODUCE_PENDING_IO);
  11.145 -    
  11.146 -    req = PENDING_IO_ENT(io_prod++);
  11.147 -    req->op = IO_ALLOC;
  11.148 -    req->u.a.block = block;
  11.149 -    req->cb = cb;
  11.150 -    req->param = param;
  11.151 -    
  11.152 -    pthread_cond_signal(&pending_io_cond);
  11.153 -    pthread_mutex_unlock(&pending_io_lock);	
  11.154 -}
  11.155 -
  11.156 -void block_rlock(struct radix_lock *r, int row, io_cb_t cb, void *param)
  11.157 -{
  11.158 -    struct io_ret ret;
  11.159 -    pthread_mutex_lock(&r->lock);
  11.160 -    
  11.161 -    if (( r->lines[row] >= 0 ) && (r->state[row] != STOP)) {
  11.162 -        r->lines[row]++;
  11.163 -        r->state[row] = READ;
  11.164 -        DPRINTF("RLOCK  : %3d (row: %d)\n", r->lines[row], row);
  11.165 -        pthread_mutex_unlock(&r->lock);
  11.166 -        ret.type = IO_INT_T;
  11.167 -        ret.u.i = 0;
  11.168 -        cb(ret, param);
  11.169 -    } else {
  11.170 -        struct radix_wait **rwc;
  11.171 -        struct radix_wait *rw = 
  11.172 -            (struct radix_wait *) malloc (sizeof(struct radix_wait));
  11.173 -        DPRINTF("RLOCK  : %3d (row: %d) -- DEFERRED!\n", r->lines[row], row);
  11.174 -        rw->type  = RLOCK;
  11.175 -        rw->param = param;
  11.176 -        rw->cb    = cb;
  11.177 -        rw->next  = NULL;
  11.178 -        /* append to waiters list. */
  11.179 -        rwc = &r->waiters[row];
  11.180 -        while (*rwc != NULL) rwc = &(*rwc)->next;
  11.181 -        *rwc = rw;
  11.182 -        pthread_mutex_unlock(&r->lock);
  11.183 -        return;
  11.184 -    }
  11.185 -}
  11.186 -
  11.187 -
  11.188 -void block_wlock(struct radix_lock *r, int row, io_cb_t cb, void *param)
  11.189 -{
  11.190 -    struct io_ret ret;
  11.191 -    pthread_mutex_lock(&r->lock);
  11.192 -    
  11.193 -    /* the second check here is redundant -- just here for debugging now. */
  11.194 -    if ((r->state[row] == ANY) && ( r->lines[row] == 0 )) {
  11.195 -        r->state[row] = STOP;
  11.196 -        r->lines[row] = -1;
  11.197 -        DPRINTF("WLOCK  : %3d (row: %d)\n", r->lines[row], row);
  11.198 -        pthread_mutex_unlock(&r->lock);
  11.199 -        ret.type = IO_INT_T;
  11.200 -        ret.u.i = 0;
  11.201 -        cb(ret, param);
  11.202 -    } else {
  11.203 -        struct radix_wait **rwc;
  11.204 -        struct radix_wait *rw = 
  11.205 -            (struct radix_wait *) malloc (sizeof(struct radix_wait));
  11.206 -        DPRINTF("WLOCK  : %3d (row: %d) -- DEFERRED!\n", r->lines[row], row);
  11.207 -        rw->type  = WLOCK;
  11.208 -        rw->param = param;
  11.209 -        rw->cb    = cb;
  11.210 -        rw->next  = NULL;
  11.211 -        /* append to waiters list. */
  11.212 -        rwc = &r->waiters[row];
  11.213 -        while (*rwc != NULL) rwc = &(*rwc)->next;
  11.214 -        *rwc = rw;
  11.215 -        pthread_mutex_unlock(&r->lock);
  11.216 -        return;
  11.217 -    }
  11.218 -	
  11.219 -}
  11.220 -
  11.221 -/* called with radix_lock locked and lock count of zero. */
  11.222 -static void wake_waiters(struct radix_lock *r, int row)
  11.223 -{
  11.224 -    struct pending_io_req *req;
  11.225 -    struct radix_wait *rw;
  11.226 -    
  11.227 -    if (r->lines[row] != 0) return;
  11.228 -    if (r->waiters[row] == NULL) return; 
  11.229 -    
  11.230 -    if (r->waiters[row]->type == WLOCK) {
  11.231 -
  11.232 -        rw = r->waiters[row];
  11.233 -        pthread_mutex_lock(&pending_io_lock);
  11.234 -        assert(CAN_PRODUCE_PENDING_IO);
  11.235 -        
  11.236 -        req = PENDING_IO_ENT(io_prod++);
  11.237 -        req->op    = IO_WWAKE;
  11.238 -        req->cb    = rw->cb;
  11.239 -        req->param = rw->param;
  11.240 -        r->lines[row] = -1; /* write lock the row. */
  11.241 -        r->state[row] = STOP;
  11.242 -        r->waiters[row] = rw->next;
  11.243 -        free(rw);
  11.244 -        pthread_mutex_unlock(&pending_io_lock);
  11.245 -    
  11.246 -    } else /* RLOCK */ {
  11.247 -
  11.248 -        while ((r->waiters[row] != NULL) && (r->waiters[row]->type == RLOCK)) {
  11.249 -            rw = r->waiters[row];
  11.250 -            pthread_mutex_lock(&pending_io_lock);
  11.251 -            assert(CAN_PRODUCE_PENDING_IO);
  11.252 -            
  11.253 -            req = PENDING_IO_ENT(io_prod++);
  11.254 -            req->op    = IO_RWAKE;
  11.255 -            req->cb    = rw->cb;
  11.256 -            req->param = rw->param;
  11.257 -            r->lines[row]++; /* read lock the row. */
  11.258 -            r->state[row] = READ; 
  11.259 -            r->waiters[row] = rw->next;
  11.260 -            free(rw);
  11.261 -            pthread_mutex_unlock(&pending_io_lock);
  11.262 -        }
  11.263 -
  11.264 -        if (r->waiters[row] != NULL) /* There is a write queued still */
  11.265 -            r->state[row] = STOP;
  11.266 -    }	
  11.267 -    
  11.268 -    pthread_mutex_lock(&pending_io_lock);
  11.269 -    pthread_cond_signal(&pending_io_cond);
  11.270 -    pthread_mutex_unlock(&pending_io_lock);
  11.271 -}
  11.272 -
  11.273 -void block_runlock(struct radix_lock *r, int row, io_cb_t cb, void *param)
  11.274 -{
  11.275 -    struct io_ret ret;
  11.276 -	
  11.277 -    pthread_mutex_lock(&r->lock);
  11.278 -    assert(r->lines[row] > 0); /* try to catch misuse. */
  11.279 -    r->lines[row]--;
  11.280 -    if (r->lines[row] == 0) {
  11.281 -        r->state[row] = ANY;
  11.282 -        wake_waiters(r, row);
  11.283 -    }
  11.284 -    pthread_mutex_unlock(&r->lock);
  11.285 -    cb(ret, param);
  11.286 -}
  11.287 -
  11.288 -void block_wunlock(struct radix_lock *r, int row, io_cb_t cb, void *param)
  11.289 -{
  11.290 -    struct io_ret ret;
  11.291 -    
  11.292 -    pthread_mutex_lock(&r->lock);
  11.293 -    assert(r->lines[row] == -1); /* try to catch misuse. */
  11.294 -    r->lines[row] = 0;
  11.295 -    r->state[row] = ANY;
  11.296 -    wake_waiters(r, row);
  11.297 -    pthread_mutex_unlock(&r->lock);
  11.298 -    cb(ret, param);
  11.299 -}
  11.300 -
  11.301 -/* consumer calls */
  11.302 -static void do_next_io_req(struct pending_io_req *req)
  11.303 -{
  11.304 -    struct io_ret          ret;
  11.305 -    void  *param;
  11.306 -    
  11.307 -    switch (req->op) {
  11.308 -    case IO_READ:
  11.309 -        ret.type = IO_BLOCK_T;
  11.310 -        ret.u.b  = readblock(req->u.r.addr);
  11.311 -        break;
  11.312 -    case IO_WRITE:
  11.313 -        ret.type = IO_INT_T;
  11.314 -        ret.u.i  = writeblock(req->u.w.addr, req->u.w.block);
  11.315 -        DPRINTF("wrote %d at %Lu\n", *(int *)(req->u.w.block), req->u.w.addr);
  11.316 -        break;
  11.317 -    case IO_ALLOC:
  11.318 -        ret.type = IO_ADDR_T;
  11.319 -        ret.u.a  = allocblock(req->u.a.block);
  11.320 -        break;
  11.321 -    case IO_RWAKE:
  11.322 -        DPRINTF("WAKE DEFERRED RLOCK!\n");
  11.323 -        ret.type = IO_INT_T;
  11.324 -        ret.u.i  = 0;
  11.325 -        break;
  11.326 -    case IO_WWAKE:
  11.327 -        DPRINTF("WAKE DEFERRED WLOCK!\n");
  11.328 -        ret.type = IO_INT_T;
  11.329 -        ret.u.i  = 0;
  11.330 -        break;
  11.331 -    default:
  11.332 -        DPRINTF("Unknown IO operation on pending list!\n");
  11.333 -        return;
  11.334 -    }
  11.335 -    
  11.336 -    param = req->param;
  11.337 -    pthread_mutex_lock(&pending_io_lock);
  11.338 -    pending_io_list[PENDING_IO_MASK(io_free++)] = PENDING_IO_IDX(req);
  11.339 -    pthread_mutex_unlock(&pending_io_lock);
  11.340 -	
  11.341 -    assert(req->cb != NULL);
  11.342 -    req->cb(ret, param);
  11.343 -    
  11.344 -}
  11.345 -
  11.346 -void *io_thread(void *param) 
  11.347 -{
  11.348 -    int tid;
  11.349 -    struct pending_io_req *req;
  11.350 -    
  11.351 -    /* Set this thread's tid. */
  11.352 -    tid = *(int *)param;
  11.353 -    free(param);
  11.354 -    
  11.355 -start:
  11.356 -    pthread_mutex_lock(&pending_io_lock);
  11.357 -    while (io_prod == io_cons) {
  11.358 -        pthread_cond_wait(&pending_io_cond, &pending_io_lock);
  11.359 -    }
  11.360 -    
  11.361 -    if (io_prod == io_cons) {
  11.362 -        /* unnecessary wakeup. */
  11.363 -        pthread_mutex_unlock(&pending_io_lock);
  11.364 -        goto start;
  11.365 -    }
  11.366 -    
  11.367 -    req = PENDING_IO_ENT(io_cons++);
  11.368 -    pthread_mutex_unlock(&pending_io_lock);
  11.369 -	
  11.370 -    do_next_io_req(req);
  11.371 -    
  11.372 -    goto start;
  11.373 -	
  11.374 -}
  11.375 -
  11.376 -static pthread_t io_pool[IO_POOL_SIZE];
  11.377 -void start_io_threads(void)
  11.378 -
  11.379 -{	
  11.380 -    int i, tid=0;
  11.381 -    
  11.382 -    for (i=0; i < IO_POOL_SIZE; i++) {
  11.383 -        int ret, *t;
  11.384 -        t = (int *)malloc(sizeof(int));
  11.385 -        *t = tid++;
  11.386 -        ret = pthread_create(&io_pool[i], NULL, io_thread, t);
  11.387 -        if (ret != 0) printf("Error starting thread %d\n", i);
  11.388 -    }
  11.389 -	
  11.390 -}
  11.391 -
  11.392 -void init_block_async(void)
  11.393 -{
  11.394 -    init_pending_io();
  11.395 -    start_io_threads();
  11.396 -}

    12.1 --- a/tools/blktap/parallax/block-async.h	Fri Jun 16 18:19:40 2006 +0100
    12.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    12.3 @@ -1,69 +0,0 @@
    12.4 -/* block-async.h
    12.5 - * 
    12.6 - * Asynchronous block wrappers for parallax.
    12.7 - */
    12.8 - 
    12.9 -#ifndef _BLOCKASYNC_H_
   12.10 -#define _BLOCKASYNC_H_
   12.11 -
   12.12 -#include <assert.h>
   12.13 -#include <xenctrl.h>
   12.14 -#include "vdi.h"
   12.15 -
   12.16 -struct io_ret
   12.17 -{
   12.18 -    enum {IO_ADDR_T, IO_BLOCK_T, IO_INT_T} type;
   12.19 -    union {
   12.20 -        uint64_t   a;
   12.21 -        char *b;
   12.22 -        int   i;
   12.23 -    } u;
   12.24 -};
   12.25 -
   12.26 -typedef void (*io_cb_t)(struct io_ret r, void *param);
   12.27 -
   12.28 -/* per-vdi lock structures to make sure requests run in a safe order. */
   12.29 -struct radix_wait {
   12.30 -    enum {RLOCK, WLOCK} type;
   12.31 -    io_cb_t  cb;
   12.32 -    void    *param;
   12.33 -    struct radix_wait *next;
   12.34 -};
   12.35 -
   12.36 -struct radix_lock {
   12.37 -    pthread_mutex_t lock;
   12.38 -    int                    lines[1024];
   12.39 -    struct radix_wait     *waiters[1024];
   12.40 -    enum {ANY, READ, STOP} state[1024];
   12.41 -};
   12.42 -void radix_lock_init(struct radix_lock *r);
   12.43 -
   12.44 -void block_read(uint64_t addr, io_cb_t cb, void *param);
   12.45 -void block_write(uint64_t addr, char *block, io_cb_t cb, void *param);
   12.46 -void block_alloc(char *block, io_cb_t cb, void *param);
   12.47 -void block_rlock(struct radix_lock *r, int row, io_cb_t cb, void *param);
   12.48 -void block_wlock(struct radix_lock *r, int row, io_cb_t cb, void *param);
   12.49 -void block_runlock(struct radix_lock *r, int row, io_cb_t cb, void *param);
   12.50 -void block_wunlock(struct radix_lock *r, int row, io_cb_t cb, void *param);
   12.51 -void init_block_async(void);
   12.52 -
   12.53 -static inline uint64_t IO_ADDR(struct io_ret r)
   12.54 -{
   12.55 -    assert(r.type == IO_ADDR_T);
   12.56 -    return r.u.a;
   12.57 -}
   12.58 -
   12.59 -static inline char *IO_BLOCK(struct io_ret r)
   12.60 -{
   12.61 -    assert(r.type == IO_BLOCK_T);
   12.62 -    return r.u.b;
   12.63 -}
   12.64 -
   12.65 -static inline int IO_INT(struct io_ret r)
   12.66 -{
   12.67 -    assert(r.type == IO_INT_T);
   12.68 -    return r.u.i;
   12.69 -}
   12.70 -
   12.71 -
   12.72 -#endif //_BLOCKASYNC_H_

    13.1 --- a/tools/blktap/parallax/blockstore.c	Fri Jun 16 18:19:40 2006 +0100
    13.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    13.3 @@ -1,1348 +0,0 @@
    13.4 -/**************************************************************************
    13.5 - * 
    13.6 - * blockstore.c
    13.7 - *
    13.8 - * Simple block store interface
    13.9 - *
   13.10 - */
   13.11 - 
   13.12 -#include <fcntl.h>
   13.13 -#include <unistd.h>
   13.14 -#include <stdio.h>
   13.15 -#include <stdlib.h>
   13.16 -#include <string.h>
   13.17 -#include <sys/types.h>
   13.18 -#include <sys/stat.h>
   13.19 -#include <sys/time.h>
   13.20 -#include <stdarg.h>
   13.21 -#include "blockstore.h"
   13.22 -#include <pthread.h>
   13.23 -
   13.24 -//#define BLOCKSTORE_REMOTE
   13.25 -//#define BSDEBUG
   13.26 -
   13.27 -#define RETRY_TIMEOUT 1000000 /* microseconds */
   13.28 -
   13.29 -/*****************************************************************************
   13.30 - * Debugging
   13.31 - */
   13.32 -#ifdef BSDEBUG
   13.33 -void DB(char *format, ...)
   13.34 -{
   13.35 -    va_list args;
   13.36 -    fprintf(stderr, "[%05u] ", (int)pthread_getspecific(tid_key));
   13.37 -    va_start(args, format);
   13.38 -    vfprintf(stderr, format, args);
   13.39 -    va_end(args);
   13.40 -}
   13.41 -#else
   13.42 -#define DB(format, ...) (void)0
   13.43 -#endif
   13.44 -
   13.45 -#ifdef BLOCKSTORE_REMOTE
   13.46 -
   13.47 -#include <sys/socket.h>
   13.48 -#include <sys/ioctl.h>
   13.49 -#include <netinet/in.h>
   13.50 -#include <netdb.h>
   13.51 -
   13.52 -/*****************************************************************************
   13.53 - * Network state                                                             *
   13.54 - *****************************************************************************/
   13.55 -
   13.56 -/* The individual disk servers we talks to. These will be referenced by
   13.57 - * an integer index into bsservers[].
   13.58 - */
   13.59 -bsserver_t bsservers[MAX_SERVERS];
   13.60 -
   13.61 -/* The cluster map. This is indexed by an integer cluster number.
   13.62 - */
   13.63 -bscluster_t bsclusters[MAX_CLUSTERS];
   13.64 -
   13.65 -/* Local socket.
   13.66 - */
   13.67 -struct sockaddr_in sin_local;
   13.68 -int bssock = 0;
   13.69 -
   13.70 -/*****************************************************************************
   13.71 - * Notification                                                              *
   13.72 - *****************************************************************************/
   13.73 -
   13.74 -typedef struct pool_thread_t_struct {
   13.75 -    pthread_mutex_t ptmutex;
   13.76 -    pthread_cond_t ptcv;
   13.77 -    int newdata;
   13.78 -} pool_thread_t;
   13.79 -
   13.80 -pool_thread_t pool_thread[READ_POOL_SIZE+1];
   13.81 -
   13.82 -#define RECV_NOTIFY(tid) { \
   13.83 -    pthread_mutex_lock(&(pool_thread[tid].ptmutex)); \
   13.84 -    pool_thread[tid].newdata = 1; \
   13.85 -    DB("CV Waking %u", tid); \
   13.86 -    pthread_cond_signal(&(pool_thread[tid].ptcv)); \
   13.87 -    pthread_mutex_unlock(&(pool_thread[tid].ptmutex)); }
   13.88 -#define RECV_AWAIT(tid) { \
   13.89 -    pthread_mutex_lock(&(pool_thread[tid].ptmutex)); \
   13.90 -    if (pool_thread[tid].newdata) { \
   13.91 -        pool_thread[tid].newdata = 0; \
   13.92 -        DB("CV Woken %u", tid); \
   13.93 -    } \
   13.94 -    else { \
   13.95 -        DB("CV Waiting %u", tid); \
   13.96 -        pthread_cond_wait(&(pool_thread[tid].ptcv), \
   13.97 -                          &(pool_thread[tid].ptmutex)); \
   13.98 -    } \
   13.99 -    pthread_mutex_unlock(&(pool_thread[tid].ptmutex)); }
  13.100 -
  13.101 -/*****************************************************************************
  13.102 - * Message queue management                                                  *
  13.103 - *****************************************************************************/
  13.104 -
  13.105 -/* Protects the queue manipulation critcal regions.
  13.106 - */
  13.107 -pthread_mutex_t ptmutex_queue;
  13.108 -#define ENTER_QUEUE_CR pthread_mutex_lock(&ptmutex_queue)
  13.109 -#define LEAVE_QUEUE_CR pthread_mutex_unlock(&ptmutex_queue)
  13.110 -
  13.111 -pthread_mutex_t ptmutex_recv;
  13.112 -#define ENTER_RECV_CR pthread_mutex_lock(&ptmutex_recv)
  13.113 -#define LEAVE_RECV_CR pthread_mutex_unlock(&ptmutex_recv)
  13.114 -
  13.115 -/* A message queue entry. We allocate one of these for every request we send.
  13.116 - * Asynchronous reply reception also used one of these.
  13.117 - */
  13.118 -typedef struct bsq_t_struct {
  13.119 -    struct bsq_t_struct *prev;
  13.120 -    struct bsq_t_struct *next;
  13.121 -    int status;
  13.122 -    int server;
  13.123 -    int length;
  13.124 -    struct msghdr msghdr;
  13.125 -    struct iovec iov[2];
  13.126 -    int tid;
  13.127 -    struct timeval tv_sent;
  13.128 -    bshdr_t message;
  13.129 -    void *block;
  13.130 -} bsq_t;
  13.131 -
  13.132 -#define BSQ_STATUS_MATCHED 1
  13.133 -
  13.134 -pthread_mutex_t ptmutex_luid;
  13.135 -#define ENTER_LUID_CR pthread_mutex_lock(&ptmutex_luid)
  13.136 -#define LEAVE_LUID_CR pthread_mutex_unlock(&ptmutex_luid)
  13.137 -
  13.138 -static uint64_t luid_cnt = 0x1000ULL;
  13.139 -uint64_t new_luid(void) {
  13.140 -    uint64_t luid;
  13.141 -    ENTER_LUID_CR;
  13.142 -    luid = luid_cnt++;
  13.143 -    LEAVE_LUID_CR;
  13.144 -    return luid;
  13.145 -}
  13.146 -
  13.147 -/* Queue of outstanding requests.
  13.148 - */
  13.149 -bsq_t *bs_head = NULL;
  13.150 -bsq_t *bs_tail = NULL;
  13.151 -int bs_qlen = 0;
  13.152 -
  13.153 -/*
  13.154 - */
  13.155 -void queuedebug(char *msg) {
  13.156 -    bsq_t *q;
  13.157 -    ENTER_QUEUE_CR;
  13.158 -    fprintf(stderr, "Q: %s len=%u\n", msg, bs_qlen);
  13.159 -    for (q = bs_head; q; q = q->next) {
  13.160 -        fprintf(stderr, "  luid=%016llx server=%u\n",
  13.161 -                q->message.luid, q->server);
  13.162 -    }
  13.163 -    LEAVE_QUEUE_CR;
  13.164 -}
  13.165 -
  13.166 -int enqueue(bsq_t *qe) {
  13.167 -    ENTER_QUEUE_CR;
  13.168 -    qe->next = NULL;
  13.169 -    qe->prev = bs_tail;
  13.170 -    if (!bs_head)
  13.171 -        bs_head = qe;
  13.172 -    else
  13.173 -        bs_tail->next = qe;
  13.174 -    bs_tail = qe;
  13.175 -    bs_qlen++;
  13.176 -    LEAVE_QUEUE_CR;
  13.177 -#ifdef BSDEBUG
  13.178 -    queuedebug("enqueue");
  13.179 -#endif
  13.180 -    return 0;
  13.181 -}
  13.182 -
  13.183 -int dequeue(bsq_t *qe) {
  13.184 -    bsq_t *q;
  13.185 -    ENTER_QUEUE_CR;
  13.186 -    for (q = bs_head; q; q = q->next) {
  13.187 -        if (q == qe) {
  13.188 -            if (q->prev)
  13.189 -                q->prev->next = q->next;
  13.190 -            else 
  13.191 -                bs_head = q->next;
  13.192 -            if (q->next)
  13.193 -                q->next->prev = q->prev;
  13.194 -            else
  13.195 -                bs_tail = q->prev;
  13.196 -            bs_qlen--;
  13.197 -            goto found;
  13.198 -        }
  13.199 -    }
  13.200 -
  13.201 -    LEAVE_QUEUE_CR;
  13.202 -#ifdef BSDEBUG
  13.203 -    queuedebug("dequeue not found");
  13.204 -#endif
  13.205 -    return 0;
  13.206 -
  13.207 -    found:
  13.208 -    LEAVE_QUEUE_CR;
  13.209 -#ifdef BSDEBUG
  13.210 -    queuedebug("dequeue not found");
  13.211 -#endif
  13.212 -    return 1;
  13.213 -}
  13.214 -
  13.215 -bsq_t *queuesearch(bsq_t *qe) {
  13.216 -    bsq_t *q;
  13.217 -    ENTER_QUEUE_CR;
  13.218 -    for (q = bs_head; q; q = q->next) {
  13.219 -        if ((qe->server == q->server) &&
  13.220 -            (qe->message.operation == q->message.operation) &&
  13.221 -            (qe->message.luid == q->message.luid)) {
  13.222 -
  13.223 -            if ((q->message.operation == BSOP_READBLOCK) &&
  13.224 -                ((q->message.flags & BSOP_FLAG_ERROR) == 0)) {
  13.225 -                q->block = qe->block;
  13.226 -                qe->block = NULL;
  13.227 -            }
  13.228 -            q->length = qe->length;
  13.229 -            q->message.flags = qe->message.flags;
  13.230 -            q->message.id = qe->message.id;
  13.231 -            q->status |= BSQ_STATUS_MATCHED;
  13.232 -
  13.233 -            if (q->prev)
  13.234 -                q->prev->next = q->next;
  13.235 -            else 
  13.236 -                bs_head = q->next;
  13.237 -            if (q->next)
  13.238 -                q->next->prev = q->prev;
  13.239 -            else
  13.240 -                bs_tail = q->prev;
  13.241 -            q->next = NULL;
  13.242 -            q->prev = NULL;
  13.243 -            bs_qlen--;
  13.244 -            goto found;
  13.245 -        }
  13.246 -    }
  13.247 -
  13.248 -    LEAVE_QUEUE_CR;
  13.249 -#ifdef BSDEBUG
  13.250 -    queuedebug("queuesearch not found");
  13.251 -#endif
  13.252 -    return NULL;
  13.253 -
  13.254 -    found:
  13.255 -    LEAVE_QUEUE_CR;
  13.256 -#ifdef BSDEBUG
  13.257 -    queuedebug("queuesearch found");
  13.258 -#endif
  13.259 -    return q;
  13.260 -}
  13.261 -
  13.262 -/*****************************************************************************
  13.263 - * Network communication                                                     *
  13.264 - *****************************************************************************/
  13.265 -
  13.266 -int send_message(bsq_t *qe) {
  13.267 -    int rc;
  13.268 -
  13.269 -    qe->msghdr.msg_name = (void *)&(bsservers[qe->server].sin);
  13.270 -    qe->msghdr.msg_namelen = sizeof(struct sockaddr_in);
  13.271 -    qe->msghdr.msg_iov = qe->iov;
  13.272 -    if (qe->block)
  13.273 -        qe->msghdr.msg_iovlen = 2;
  13.274 -    else
  13.275 -        qe->msghdr.msg_iovlen = 1;
  13.276 -    qe->msghdr.msg_control = NULL;
  13.277 -    qe->msghdr.msg_controllen = 0;
  13.278 -    qe->msghdr.msg_flags = 0;
  13.279 -
  13.280 -    qe->iov[0].iov_base = (void *)&(qe->message);
  13.281 -    qe->iov[0].iov_len = MSGBUFSIZE_ID;
  13.282 -
  13.283 -    if (qe->block) {
  13.284 -        qe->iov[1].iov_base = qe->block;
  13.285 -        qe->iov[1].iov_len = BLOCK_SIZE;
  13.286 -    }
  13.287 -
  13.288 -    qe->message.luid = new_luid();
  13.289 -
  13.290 -    qe->status = 0;
  13.291 -    qe->tid = (int)pthread_getspecific(tid_key);
  13.292 -    if (enqueue(qe) < 0) {
  13.293 -        fprintf(stderr, "Error enqueuing request.\n");
  13.294 -        return -1;
  13.295 -    }
  13.296 -
  13.297 -    gettimeofday(&(qe->tv_sent), NULL);
  13.298 -    DB("send_message to %d luid=%016llx\n", qe->server, qe->message.luid);
  13.299 -    rc = sendmsg(bssock, &(qe->msghdr), MSG_DONTWAIT);
  13.300 -    //rc = sendto(bssock, (void *)&(qe->message), qe->length, 0,
  13.301 -    //           (struct sockaddr *)&(bsservers[qe->server].sin),
  13.302 -    //           sizeof(struct sockaddr_in));
  13.303 -    if (rc < 0)
  13.304 -        return rc;
  13.305 -
  13.306 -    return rc;
  13.307 -}
  13.308 -
  13.309 -int recv_message(bsq_t *qe) {
  13.310 -    struct sockaddr_in from;
  13.311 -    //int flen = sizeof(from);
  13.312 -    int rc;
  13.313 -
  13.314 -    qe->msghdr.msg_name = &from;
  13.315 -    qe->msghdr.msg_namelen = sizeof(struct sockaddr_in);
  13.316 -    qe->msghdr.msg_iov = qe->iov;
  13.317 -    if (qe->block)
  13.318 -        qe->msghdr.msg_iovlen = 2;
  13.319 -    else
  13.320 -        qe->msghdr.msg_iovlen = 1;
  13.321 -    qe->msghdr.msg_control = NULL;
  13.322 -    qe->msghdr.msg_controllen = 0;
  13.323 -    qe->msghdr.msg_flags = 0;
  13.324 -
  13.325 -    qe->iov[0].iov_base = (void *)&(qe->message);
  13.326 -    qe->iov[0].iov_len = MSGBUFSIZE_ID;
  13.327 -    if (qe->block) {
  13.328 -        qe->iov[1].iov_base = qe->block;
  13.329 -        qe->iov[1].iov_len = BLOCK_SIZE;
  13.330 -    }
  13.331 -
  13.332 -    rc = recvmsg(bssock, &(qe->msghdr), 0);
  13.333 -
  13.334 -    //return recvfrom(bssock, (void *)&(qe->message), sizeof(bsmsg_t), 0,
  13.335 -    //               (struct sockaddr *)&from, &flen);
  13.336 -    return rc;
  13.337 -}
  13.338 -
  13.339 -int get_server_number(struct sockaddr_in *sin) {
  13.340 -    int i;
  13.341 -
  13.342 -#ifdef BSDEBUG2
  13.343 -    fprintf(stderr,
  13.344 -            "get_server_number(%u.%u.%u.%u/%u)\n",
  13.345 -            (unsigned int)sin->sin_addr.s_addr & 0xff,
  13.346 -            ((unsigned int)sin->sin_addr.s_addr >> 8) & 0xff,
  13.347 -            ((unsigned int)sin->sin_addr.s_addr >> 16) & 0xff,
  13.348 -            ((unsigned int)sin->sin_addr.s_addr >> 24) & 0xff,
  13.349 -            (unsigned int)sin->sin_port);
  13.350 -#endif
  13.351 -
  13.352 -    for (i = 0; i < MAX_SERVERS; i++) {
  13.353 -        if (bsservers[i].hostname) {
  13.354 -#ifdef BSDEBUG2
  13.355 -            fprintf(stderr,
  13.356 -                    "get_server_number check %u.%u.%u.%u/%u\n",
  13.357 -                    (unsigned int)bsservers[i].sin.sin_addr.s_addr&0xff,
  13.358 -                    ((unsigned int)bsservers[i].sin.sin_addr.s_addr >> 8)&0xff,
  13.359 -                    ((unsigned int)bsservers[i].sin.sin_addr.s_addr >> 16)&0xff,
  13.360 -                    ((unsigned int)bsservers[i].sin.sin_addr.s_addr >> 24)&0xff,
  13.361 -                    (unsigned int)bsservers[i].sin.sin_port);
  13.362 -#endif
  13.363 -            if ((sin->sin_family == bsservers[i].sin.sin_family) &&
  13.364 -                (sin->sin_port == bsservers[i].sin.sin_port) &&
  13.365 -                (memcmp((void *)&(sin->sin_addr),
  13.366 -                        (void *)&(bsservers[i].sin.sin_addr),
  13.367 -                        sizeof(struct in_addr)) == 0)) {
  13.368 -                return i;
  13.369 -            }
  13.370 -        }        
  13.371 -    }
  13.372 -
  13.373 -    return -1;
  13.374 -}
  13.375 -
  13.376 -void *rx_buffer = NULL;
  13.377 -bsq_t rx_qe;
  13.378 -bsq_t *recv_any(void) {
  13.379 -    struct sockaddr_in from;
  13.380 -    int rc;
  13.381 -    
  13.382 -    DB("ENTER recv_any\n");
  13.383 -
  13.384 -    rx_qe.msghdr.msg_name = &from;
  13.385 -    rx_qe.msghdr.msg_namelen = sizeof(struct sockaddr_in);
  13.386 -    rx_qe.msghdr.msg_iov = rx_qe.iov;
  13.387 -    if (!rx_buffer) {
  13.388 -        rx_buffer = malloc(BLOCK_SIZE);
  13.389 -        if (!rx_buffer) {
  13.390 -            perror("recv_any malloc");
  13.391 -            return NULL;
  13.392 -        }
  13.393 -    }
  13.394 -    rx_qe.block = rx_buffer;
  13.395 -    rx_buffer = NULL;
  13.396 -    rx_qe.msghdr.msg_iovlen = 2;
  13.397 -    rx_qe.msghdr.msg_control = NULL;
  13.398 -    rx_qe.msghdr.msg_controllen = 0;
  13.399 -    rx_qe.msghdr.msg_flags = 0;
  13.400 -    
  13.401 -    rx_qe.iov[0].iov_base = (void *)&(rx_qe.message);
  13.402 -    rx_qe.iov[0].iov_len = MSGBUFSIZE_ID;
  13.403 -    rx_qe.iov[1].iov_base = rx_qe.block;
  13.404 -    rx_qe.iov[1].iov_len = BLOCK_SIZE;
  13.405 -
  13.406 -    rc = recvmsg(bssock, &(rx_qe.msghdr), 0);
  13.407 -    if (rc < 0) {
  13.408 -        perror("recv_any");
  13.409 -        return NULL;
  13.410 -    }
  13.411 -
  13.412 -    rx_qe.length = rc;    
  13.413 -    rx_qe.server = get_server_number(&from);
  13.414 -
  13.415 -    DB("recv_any from %d luid=%016llx len=%u\n",
  13.416 -       rx_qe.server, rx_qe.message.luid, rx_qe.length);
  13.417 -
  13.418 -    return &rx_qe;
  13.419 -}
  13.420 -
  13.421 -void recv_recycle_buffer(bsq_t *q) {
  13.422 -    if (q->block) {
  13.423 -        rx_buffer = q->block;
  13.424 -        q->block = NULL;
  13.425 -    }
  13.426 -}
  13.427 -
  13.428 -// cycle through reading any incoming, searching for a match in the
  13.429 -// queue, until we have all we need.
  13.430 -int wait_recv(bsq_t **reqs, int numreqs) {
  13.431 -    bsq_t *q, *m;
  13.432 -    unsigned int x, i;
  13.433 -    int tid = (int)pthread_getspecific(tid_key);
  13.434 -
  13.435 -    DB("ENTER wait_recv %u\n", numreqs);
  13.436 -
  13.437 -    checkmatch:
  13.438 -    x = 0xffffffff;
  13.439 -    for (i = 0; i < numreqs; i++) {
  13.440 -        x &= reqs[i]->status;
  13.441 -    }
  13.442 -    if ((x & BSQ_STATUS_MATCHED)) {
  13.443 -        DB("LEAVE wait_recv\n");
  13.444 -        return numreqs;
  13.445 -    }
  13.446 -
  13.447 -    RECV_AWAIT(tid);
  13.448 -
  13.449 -    /*
  13.450 -    rxagain:
  13.451 -    ENTER_RECV_CR;
  13.452 -    q = recv_any();
  13.453 -    LEAVE_RECV_CR;
  13.454 -    if (!q)
  13.455 -        return -1;
  13.456 -
  13.457 -    m = queuesearch(q);
  13.458 -    recv_recycle_buffer(q);
  13.459 -    if (!m) {
  13.460 -        fprintf(stderr, "Unmatched RX\n");
  13.461 -        goto rxagain;
  13.462 -    }
  13.463 -    */
  13.464 -
  13.465 -    goto checkmatch;
  13.466 -
  13.467 -}
  13.468 -
  13.469 -/* retry
  13.470 - */
  13.471 -static int retry_count = 0;
  13.472 -int retry(bsq_t *qe)
  13.473 -{
  13.474 -    int rc;
  13.475 -    gettimeofday(&(qe->tv_sent), NULL);
  13.476 -    DB("retry to %d luid=%016llx\n", qe->server, qe->message.luid);
  13.477 -    retry_count++;
  13.478 -    rc = sendmsg(bssock, &(qe->msghdr), MSG_DONTWAIT);
  13.479 -    if (rc < 0)
  13.480 -        return rc;
  13.481 -    return 0;
  13.482 -}
  13.483 -
  13.484 -/* queue runner
  13.485 - */
  13.486 -void *queue_runner(void *arg)
  13.487 -{
  13.488 -    for (;;) {
  13.489 -        struct timeval now;
  13.490 -        long long nowus, sus;
  13.491 -        bsq_t *q;
  13.492 -        int r;
  13.493 -
  13.494 -        sleep(1);
  13.495 -
  13.496 -        gettimeofday(&now, NULL);
  13.497 -        nowus = now.tv_usec + now.tv_sec * 1000000;
  13.498 -        ENTER_QUEUE_CR;
  13.499 -        r = retry_count;
  13.500 -        for (q = bs_head; q; q = q->next) {
  13.501 -            sus = q->tv_sent.tv_usec + q->tv_sent.tv_sec * 1000000;
  13.502 -            if ((nowus - sus) > RETRY_TIMEOUT) {
  13.503 -                if (retry(q) < 0) {
  13.504 -                    fprintf(stderr, "Error on sendmsg retry.\n");
  13.505 -                }
  13.506 -            }
  13.507 -        }
  13.508 -        if (r != retry_count) {
  13.509 -            fprintf(stderr, "RETRIES: %u %u\n", retry_count - r, retry_count);
  13.510 -        }
  13.511 -        LEAVE_QUEUE_CR;
  13.512 -    }
  13.513 -}
  13.514 -
  13.515 -/* receive loop
  13.516 - */
  13.517 -void *receive_loop(void *arg)
  13.518 -{
  13.519 -    bsq_t *q, *m;
  13.520 -
  13.521 -    for(;;) {
  13.522 -        q = recv_any();
  13.523 -        if (!q) {
  13.524 -            fprintf(stderr, "recv_any error\n");
  13.525 -        }
  13.526 -        else {
  13.527 -            m = queuesearch(q);
  13.528 -            recv_recycle_buffer(q);
  13.529 -            if (!m) {
  13.530 -                fprintf(stderr, "Unmatched RX\n");
  13.531 -            }
  13.532 -            else {
  13.533 -                DB("RX MATCH");
  13.534 -                RECV_NOTIFY(m->tid);
  13.535 -            }
  13.536 -        }
  13.537 -    }
  13.538 -}
  13.539 -pthread_t pthread_recv;
  13.540 -
  13.541 -/*****************************************************************************
  13.542 - * Reading                                                                   *
  13.543 - *****************************************************************************/
  13.544 -
  13.545 -void *readblock_indiv(int server, uint64_t id) {
  13.546 -    void *block;
  13.547 -    bsq_t *qe;
  13.548 -    int len, rc;
  13.549 -
  13.550 -    qe = (bsq_t *)malloc(sizeof(bsq_t));
  13.551 -    if (!qe) {
  13.552 -        perror("readblock qe malloc");
  13.553 -        return NULL;
  13.554 -    }
  13.555 -    qe->block = NULL;
  13.556 -    
  13.557 -    /*
  13.558 -    qe->block = malloc(BLOCK_SIZE);
  13.559 -    if (!qe->block) {
  13.560 -        perror("readblock qe malloc");
  13.561 -        free((void *)qe);
  13.562 -        return NULL;
  13.563 -    }
  13.564 -    */
  13.565 -
  13.566 -    qe->server = server;
  13.567 -
  13.568 -    qe->message.operation = BSOP_READBLOCK;
  13.569 -    qe->message.flags = 0;
  13.570 -    qe->message.id = id;
  13.571 -    qe->length = MSGBUFSIZE_ID;
  13.572 -
  13.573 -    if (send_message(qe) < 0) {
  13.574 -        perror("readblock sendto");
  13.575 -        goto err;
  13.576 -    }
  13.577 -    
  13.578 -    /*len = recv_message(qe);
  13.579 -    if (len < 0) {
  13.580 -        perror("readblock recv");
  13.581 -        goto err;
  13.582 -    }*/
  13.583 -
  13.584 -    rc = wait_recv(&qe, 1);
  13.585 -    if (rc < 0) {
  13.586 -        perror("readblock recv");
  13.587 -        goto err;
  13.588 -    }
  13.589 -
  13.590 -    if ((qe->message.flags & BSOP_FLAG_ERROR)) {
  13.591 -        fprintf(stderr, "readblock server error\n");
  13.592 -        goto err;
  13.593 -    }
  13.594 -    if (qe->length < MSGBUFSIZE_BLOCK) {
  13.595 -        fprintf(stderr, "readblock recv short (%u)\n", len);
  13.596 -        goto err;
  13.597 -    }
  13.598 -    /* if ((block = malloc(BLOCK_SIZE)) == NULL) {
  13.599 -        perror("readblock malloc");
  13.600 -        goto err;
  13.601 -    }
  13.602 -    memcpy(block, qe->message.block, BLOCK_SIZE);
  13.603 -    */    
  13.604 -    block = qe->block;
  13.605 -
  13.606 -    free((void *)qe);
  13.607 -    return block;
  13.608 -
  13.609 -    err:
  13.610 -    free(qe->block);
  13.611 -    free((void *)qe);
  13.612 -    return NULL;
  13.613 -}
  13.614 -
  13.615 -/**
  13.616 - * readblock: read a block from disk
  13.617 - *   @id: block id to read
  13.618 - *
  13.619 - *   @return: pointer to block, NULL on error
  13.620 - */
  13.621 -void *readblock(uint64_t id) {
  13.622 -    int map = (int)BSID_MAP(id);
  13.623 -    uint64_t xid;
  13.624 -    static int i = CLUSTER_MAX_REPLICAS - 1;
  13.625 -    void *block = NULL;
  13.626 -
  13.627 -    /* special case for the "superblock" just use the first block on the
  13.628 -     * first replica. (extend to blocks < 6 for vdi bug)
  13.629 -     */
  13.630 -    if (id < 6) {
  13.631 -        block = readblock_indiv(bsclusters[map].servers[0], id);
  13.632 -        goto out;
  13.633 -    }
  13.634 -
  13.635 -    i++;
  13.636 -    if (i >= CLUSTER_MAX_REPLICAS)
  13.637 -        i = 0;
  13.638 -    switch (i) {
  13.639 -    case 0:
  13.640 -        xid = BSID_REPLICA0(id);
  13.641 -        break;
  13.642 -    case 1:
  13.643 -        xid = BSID_REPLICA1(id);
  13.644 -        break;
  13.645 -    case 2:
  13.646 -        xid = BSID_REPLICA2(id);
  13.647 -        break;
  13.648 -    }
  13.649 -    
  13.650 -    block = readblock_indiv(bsclusters[map].servers[i], xid);
  13.651 -
  13.652 -    out:
  13.653 -#ifdef BSDEBUG
  13.654 -    if (block)
  13.655 -        fprintf(stderr, "READ:  %016llx %02x%02x %02x%02x %02x%02x %02x%02x\n",
  13.656 -                id,
  13.657 -                (unsigned int)((unsigned char *)block)[0],
  13.658 -                (unsigned int)((unsigned char *)block)[1],
  13.659 -                (unsigned int)((unsigned char *)block)[2],
  13.660 -                (unsigned int)((unsigned char *)block)[3],
  13.661 -                (unsigned int)((unsigned char *)block)[4],
  13.662 -                (unsigned int)((unsigned char *)block)[5],
  13.663 -                (unsigned int)((unsigned char *)block)[6],
  13.664 -                (unsigned int)((unsigned char *)block)[7]);
  13.665 -    else
  13.666 -        fprintf(stderr, "READ:  %016llx NULL\n", id);
  13.667 -#endif
  13.668 -    return block;
  13.669 -}
  13.670 -
  13.671 -/*****************************************************************************
  13.672 - * Writing                                                                   *
  13.673 - *****************************************************************************/
  13.674 -
  13.675 -bsq_t *writeblock_indiv(int server, uint64_t id, void *block) {
  13.676 -
  13.677 -    bsq_t *qe;
  13.678 -    int len;
  13.679 -
  13.680 -    qe = (bsq_t *)malloc(sizeof(bsq_t));
  13.681 -    if (!qe) {
  13.682 -        perror("writeblock qe malloc");
  13.683 -        goto err;
  13.684 -    }
  13.685 -    qe->server = server;
  13.686 -
  13.687 -    qe->message.operation = BSOP_WRITEBLOCK;
  13.688 -    qe->message.flags = 0;
  13.689 -    qe->message.id = id;
  13.690 -    //memcpy(qe->message.block, block, BLOCK_SIZE);
  13.691 -    qe->block = block;
  13.692 -    qe->length = MSGBUFSIZE_BLOCK;
  13.693 -
  13.694 -    if (send_message(qe) < 0) {
  13.695 -        perror("writeblock sendto");
  13.696 -        goto err;
  13.697 -    }
  13.698 -
  13.699 -    return qe;
  13.700 -
  13.701 -    err:
  13.702 -    free((void *)qe);
  13.703 -    return NULL;
  13.704 -}
  13.705 -    
  13.706 -
  13.707 -/**
  13.708 - * writeblock: write an existing block to disk
  13.709 - *   @id: block id
  13.710 - *   @block: pointer to block
  13.711 - *
  13.712 - *   @return: zero on success, -1 on failure
  13.713 - */
  13.714 -int writeblock(uint64_t id, void *block) {
  13.715 -    
  13.716 -    int map = (int)BSID_MAP(id);
  13.717 -    int rep0 = bsclusters[map].servers[0];
  13.718 -    int rep1 = bsclusters[map].servers[1];
  13.719 -    int rep2 = bsclusters[map].servers[2];
  13.720 -    bsq_t *reqs[3];
  13.721 -    int rc;
  13.722 -
  13.723 -    reqs[0] = reqs[1] = reqs[2] = NULL;
  13.724 -
  13.725 -#ifdef BSDEBUG
  13.726 -    fprintf(stderr,
  13.727 -            "WRITE: %016llx %02x%02x %02x%02x %02x%02x %02x%02x\n",
  13.728 -            id,
  13.729 -            (unsigned int)((unsigned char *)block)[0],
  13.730 -            (unsigned int)((unsigned char *)block)[1],
  13.731 -            (unsigned int)((unsigned char *)block)[2],
  13.732 -            (unsigned int)((unsigned char *)block)[3],
  13.733 -            (unsigned int)((unsigned char *)block)[4],
  13.734 -            (unsigned int)((unsigned char *)block)[5],
  13.735 -            (unsigned int)((unsigned char *)block)[6],
  13.736 -            (unsigned int)((unsigned char *)block)[7]);
  13.737 -#endif
  13.738 -
  13.739 -    /* special case for the "superblock" just use the first block on the
  13.740 -     * first replica. (extend to blocks < 6 for vdi bug)
  13.741 -     */
  13.742 -    if (id < 6) {
  13.743 -        reqs[0] = writeblock_indiv(rep0, id, block);
  13.744 -        if (!reqs[0])
  13.745 -            return -1;
  13.746 -        rc = wait_recv(reqs, 1);
  13.747 -        return rc;
  13.748 -    }
  13.749 -
  13.750 -    reqs[0] = writeblock_indiv(rep0, BSID_REPLICA0(id), block);
  13.751 -    if (!reqs[0])
  13.752 -        goto err;
  13.753 -    reqs[1] = writeblock_indiv(rep1, BSID_REPLICA1(id), block);
  13.754 -    if (!reqs[1])
  13.755 -        goto err;
  13.756 -    reqs[2] = writeblock_indiv(rep2, BSID_REPLICA2(id), block);
  13.757 -    if (!reqs[2])
  13.758 -        goto err;
  13.759 -
  13.760 -    rc = wait_recv(reqs, 3);
  13.761 -    if (rc < 0) {
  13.762 -        perror("writeblock recv");
  13.763 -        goto err;
  13.764 -    }
  13.765 -    if ((reqs[0]->message.flags & BSOP_FLAG_ERROR)) {
  13.766 -        fprintf(stderr, "writeblock server0 error\n");
  13.767 -        goto err;
  13.768 -    }
  13.769 -    if ((reqs[1]->message.flags & BSOP_FLAG_ERROR)) {
  13.770 -        fprintf(stderr, "writeblock server1 error\n");
  13.771 -        goto err;
  13.772 -    }
  13.773 -    if ((reqs[2]->message.flags & BSOP_FLAG_ERROR)) {
  13.774 -        fprintf(stderr, "writeblock server2 error\n");
  13.775 -        goto err;
  13.776 -    }
  13.777 -
  13.778 -
  13.779 -    free((void *)reqs[0]);
  13.780 -    free((void *)reqs[1]);
  13.781 -    free((void *)reqs[2]);
  13.782 -    return 0;
  13.783 -
  13.784 -    err:
  13.785 -    if (reqs[0]) {
  13.786 -        dequeue(reqs[0]);
  13.787 -        free((void *)reqs[0]);
  13.788 -    }
  13.789 -    if (reqs[1]) {
  13.790 -        dequeue(reqs[1]);
  13.791 -        free((void *)reqs[1]);
  13.792 -    }
  13.793 -    if (reqs[2]) {
  13.794 -        dequeue(reqs[2]);
  13.795 -        free((void *)reqs[2]);
  13.796 -    }
  13.797 -    return -1;
  13.798 -}
  13.799 -
  13.800 -/*****************************************************************************
  13.801 - * Allocation                                                                *
  13.802 - *****************************************************************************/
  13.803 -
  13.804 -/**
  13.805 - * allocblock: write a new block to disk
  13.806 - *   @block: pointer to block
  13.807 - *
  13.808 - *   @return: new id of block on disk
  13.809 - */
  13.810 -uint64_t allocblock(void *block) {
  13.811 -    return allocblock_hint(block, 0);
  13.812 -}
  13.813 -
  13.814 -bsq_t *allocblock_hint_indiv(int server, void *block, uint64_t hint) {
  13.815 -    bsq_t *qe;
  13.816 -    int len;
  13.817 -
  13.818 -    qe = (bsq_t *)malloc(sizeof(bsq_t));
  13.819 -    if (!qe) {
  13.820 -        perror("allocblock_hint qe malloc");
  13.821 -        goto err;
  13.822 -    }
  13.823 -    qe->server = server;
  13.824 -
  13.825 -    qe->message.operation = BSOP_ALLOCBLOCK;
  13.826 -    qe->message.flags = 0;
  13.827 -    qe->message.id = hint;
  13.828 -    //memcpy(qe->message.block, block, BLOCK_SIZE);
  13.829 -    qe->block = block;
  13.830 -    qe->length = MSGBUFSIZE_BLOCK;
  13.831 -
  13.832 -    if (send_message(qe) < 0) {
  13.833 -        perror("allocblock_hint sendto");
  13.834 -        goto err;
  13.835 -    }
  13.836 -    
  13.837 -    return qe;
  13.838 -
  13.839 -    err:
  13.840 -    free((void *)qe);
  13.841 -    return NULL;
  13.842 -}
  13.843 -
  13.844 -/**
  13.845 - * allocblock_hint: write a new block to disk
  13.846 - *   @block: pointer to block
  13.847 - *   @hint: allocation hint
  13.848 - *
  13.849 - *   @return: new id of block on disk
  13.850 - */
  13.851 -uint64_t allocblock_hint(void *block, uint64_t hint) {
  13.852 -    int map = (int)hint;
  13.853 -    int rep0 = bsclusters[map].servers[0];
  13.854 -    int rep1 = bsclusters[map].servers[1];
  13.855 -    int rep2 = bsclusters[map].servers[2];
  13.856 -    bsq_t *reqs[3];
  13.857 -    int rc;
  13.858 -    uint64_t id0, id1, id2;
  13.859 -
  13.860 -    reqs[0] = reqs[1] = reqs[2] = NULL;
  13.861 -
  13.862 -    DB("ENTER allocblock\n");
  13.863 -
  13.864 -    reqs[0] = allocblock_hint_indiv(rep0, block, hint);
  13.865 -    if (!reqs[0])
  13.866 -        goto err;
  13.867 -    reqs[1] = allocblock_hint_indiv(rep1, block, hint);
  13.868 -    if (!reqs[1])
  13.869 -        goto err;
  13.870 -    reqs[2] = allocblock_hint_indiv(rep2, block, hint);
  13.871 -    if (!reqs[2])
  13.872 -        goto err;
  13.873 -
  13.874 -    rc = wait_recv(reqs, 3);
  13.875 -    if (rc < 0) {
  13.876 -        perror("allocblock recv");
  13.877 -        goto err;
  13.878 -    }
  13.879 -    if ((reqs[0]->message.flags & BSOP_FLAG_ERROR)) {
  13.880 -        fprintf(stderr, "allocblock server0 error\n");
  13.881 -        goto err;
  13.882 -    }
  13.883 -    if ((reqs[1]->message.flags & BSOP_FLAG_ERROR)) {
  13.884 -        fprintf(stderr, "allocblock server1 error\n");
  13.885 -        goto err;
  13.886 -    }
  13.887 -    if ((reqs[2]->message.flags & BSOP_FLAG_ERROR)) {
  13.888 -        fprintf(stderr, "allocblock server2 error\n");
  13.889 -        goto err;
  13.890 -    }
  13.891 -
  13.892 -    id0 = reqs[0]->message.id;
  13.893 -    id1 = reqs[1]->message.id;
  13.894 -    id2 = reqs[2]->message.id;
  13.895 -
  13.896 -#ifdef BSDEBUG
  13.897 -    fprintf(stderr, "ALLOC: %016llx %02x%02x %02x%02x %02x%02x %02x%02x\n",
  13.898 -            BSID(map, id0, id1, id2),
  13.899 -            (unsigned int)((unsigned char *)block)[0],
  13.900 -            (unsigned int)((unsigned char *)block)[1],
  13.901 -            (unsigned int)((unsigned char *)block)[2],
  13.902 -            (unsigned int)((unsigned char *)block)[3],
  13.903 -            (unsigned int)((unsigned char *)block)[4],
  13.904 -            (unsigned int)((unsigned char *)block)[5],
  13.905 -            (unsigned int)((unsigned char *)block)[6],
  13.906 -            (unsigned int)((unsigned char *)block)[7]);
  13.907 -#endif
  13.908 -    
  13.909 -    free((void *)reqs[0]);
  13.910 -    free((void *)reqs[1]);
  13.911 -    free((void *)reqs[2]);
  13.912 -    return BSID(map, id0, id1, id2);
  13.913 -
  13.914 -    err:
  13.915 -    if (reqs[0]) {
  13.916 -        dequeue(reqs[0]);
  13.917 -        free((void *)reqs[0]);
  13.918 -    }
  13.919 -    if (reqs[1]) {
  13.920 -        dequeue(reqs[1]);
  13.921 -        free((void *)reqs[1]);
  13.922 -    }
  13.923 -    if (reqs[2]) {
  13.924 -        dequeue(reqs[2]);
  13.925 -        free((void *)reqs[2]);
  13.926 -    }
  13.927 -    return 0;
  13.928 -}
  13.929 -
  13.930 -#else /* /BLOCKSTORE_REMOTE */
  13.931 -
  13.932 -/*****************************************************************************
  13.933 - * Local storage version                                                     *
  13.934 - *****************************************************************************/
  13.935 - 
  13.936 -/**
  13.937 - * readblock: read a block from disk
  13.938 - *   @id: block id to read
  13.939 - *
  13.940 - *   @return: pointer to block, NULL on error
  13.941 - */
  13.942 -
  13.943 -void *readblock(uint64_t id) {
  13.944 -    void *block;
  13.945 -    int block_fp;
  13.946 -   
  13.947 -//printf("readblock(%llu)\n", id); 
  13.948 -    block_fp = open("blockstore.dat", O_RDONLY | O_CREAT | O_LARGEFILE, 0644);
  13.949 -
  13.950 -    if (block_fp < 0) {
  13.951 -        perror("open");
  13.952 -        return NULL;
  13.953 -    }
  13.954 -    
  13.955 -    if (lseek64(block_fp, ((off64_t) id - 1LL) * BLOCK_SIZE, SEEK_SET) < 0) {
  13.956 -        printf ("%Ld ", id);
  13.957 -        printf ("%Ld\n", (id - 1) * BLOCK_SIZE);
  13.958 -        perror("readblock lseek");
  13.959 -        goto err;
  13.960 -    }
  13.961 -    if ((block = malloc(BLOCK_SIZE)) == NULL) {
  13.962 -        perror("readblock malloc");
  13.963 -        goto err;
  13.964 -    }
  13.965 -    if (read(block_fp, block, BLOCK_SIZE) != BLOCK_SIZE) {
  13.966 -        perror("readblock read");
  13.967 -        free(block);
  13.968 -        goto err;
  13.969 -    }
  13.970 -    close(block_fp);
  13.971 -    return block;
  13.972 -    
  13.973 -err:
  13.974 -    close(block_fp);
  13.975 -    return NULL;
  13.976 -}
  13.977 -
  13.978 -/**
  13.979 - * writeblock: write an existing block to disk
  13.980 - *   @id: block id
  13.981 - *   @block: pointer to block
  13.982 - *
  13.983 - *   @return: zero on success, -1 on failure
  13.984 - */
  13.985 -int writeblock(uint64_t id, void *block) {
  13.986 -    
  13.987 -    int block_fp;
  13.988 -    
  13.989 -    block_fp = open("blockstore.dat", O_RDWR | O_CREAT | O_LARGEFILE, 0644);
  13.990 -
  13.991 -    if (block_fp < 0) {
  13.992 -        perror("open");
  13.993 -        return -1;
  13.994 -    }
  13.995 -
  13.996 -    if (lseek64(block_fp, ((off64_t) id - 1LL) * BLOCK_SIZE, SEEK_SET) < 0) {
  13.997 -        perror("writeblock lseek");
  13.998 -        goto err;
  13.999 -    }
 13.1000 -    if (write(block_fp, block, BLOCK_SIZE) < 0) {
 13.1001 -        perror("writeblock write");
 13.1002 -        goto err;
 13.1003 -    }
 13.1004 -    close(block_fp);
 13.1005 -    return 0;
 13.1006 -
 13.1007 -err:
 13.1008 -    close(block_fp);
 13.1009 -    return -1;
 13.1010 -}
 13.1011 -
 13.1012 -/**
 13.1013 - * allocblock: write a new block to disk
 13.1014 - *   @block: pointer to block
 13.1015 - *
 13.1016 - *   @return: new id of block on disk
 13.1017 - */
 13.1018 -
 13.1019 -uint64_t allocblock(void *block) {
 13.1020 -    uint64_t lb;
 13.1021 -    off64_t pos;
 13.1022 -    int block_fp;
 13.1023 -    
 13.1024 -    block_fp = open("blockstore.dat", O_RDWR | O_CREAT | O_LARGEFILE, 0644);
 13.1025 -
 13.1026 -    if (block_fp < 0) {
 13.1027 -        perror("open");
 13.1028 -        return 0;
 13.1029 -    }
 13.1030 -
 13.1031 -    pos = lseek64(block_fp, 0, SEEK_END);
 13.1032 -    if (pos == (off64_t)-1) {
 13.1033 -        perror("allocblock lseek");
 13.1034 -        goto err;
 13.1035 -    }
 13.1036 -    if (pos % BLOCK_SIZE != 0) {
 13.1037 -        fprintf(stderr, "file size not multiple of %d\n", BLOCK_SIZE);
 13.1038 -        goto err;
 13.1039 -    }
 13.1040 -    if (write(block_fp, block, BLOCK_SIZE) != BLOCK_SIZE) {
 13.1041 -        perror("allocblock write");
 13.1042 -        goto err;
 13.1043 -    }
 13.1044 -    lb = pos / BLOCK_SIZE + 1;
 13.1045 -//printf("alloc(%Ld)\n", lb);
 13.1046 -    close(block_fp);
 13.1047 -    return lb;
 13.1048 -    
 13.1049 -err:
 13.1050 -    close(block_fp);
 13.1051 -    return 0;
 13.1052 -    
 13.1053 -}
 13.1054 -
 13.1055 -/**
 13.1056 - * allocblock_hint: write a new block to disk
 13.1057 - *   @block: pointer to block
 13.1058 - *   @hint: allocation hint
 13.1059 - *
 13.1060 - *   @return: new id of block on disk
 13.1061 - */
 13.1062 -uint64_t allocblock_hint(void *block, uint64_t hint) {
 13.1063 -    return allocblock(block);
 13.1064 -}
 13.1065 -
 13.1066 -#endif /* BLOCKSTORE_REMOTE */
 13.1067 -
 13.1068 -/*****************************************************************************
 13.1069 - * Memory management                                                         *
 13.1070 - *****************************************************************************/
 13.1071 -
 13.1072 -/**
 13.1073 - * newblock: get a new in-memory block set to zeros
 13.1074 - *
 13.1075 - *   @return: pointer to new block, NULL on error
 13.1076 - */
 13.1077 -void *newblock(void) {
 13.1078 -    void *block = malloc(BLOCK_SIZE);
 13.1079 -    if (block == NULL) {
 13.1080 -        perror("newblock");
 13.1081 -        return NULL;
 13.1082 -    }
 13.1083 -    memset(block, 0, BLOCK_SIZE);
 13.1084 -    return block;
 13.1085 -}
 13.1086 -
 13.1087 -
 13.1088 -/**
 13.1089 - * freeblock: unallocate an in-memory block
 13.1090 - *   @id: block id (zero if this is only in-memory)
 13.1091 - *   @block: block to be freed
 13.1092 - */
 13.1093 -void freeblock(void *block) {
 13.1094 -        free(block);
 13.1095 -}
 13.1096 -
 13.1097 -static freeblock_t *new_freeblock(void)
 13.1098 -{
 13.1099 -    freeblock_t *fb;
 13.1100 -    
 13.1101 -    fb = newblock();
 13.1102 -    
 13.1103 -    if (fb == NULL) return NULL;
 13.1104 -    
 13.1105 -    fb->magic = FREEBLOCK_MAGIC;
 13.1106 -    fb->next  = 0ULL;
 13.1107 -    fb->count = 0ULL;
 13.1108 -    memset(fb->list, 0, sizeof fb->list);
 13.1109 -    
 13.1110 -    return fb;
 13.1111 -}
 13.1112 -
 13.1113 -void releaseblock(uint64_t id)
 13.1114 -{
 13.1115 -    blockstore_super_t *bs_super;
 13.1116 -    freeblock_t *fl_current;
 13.1117 -    
 13.1118 -    /* get superblock */
 13.1119 -    bs_super = (blockstore_super_t *) readblock(BLOCKSTORE_SUPER);
 13.1120 -    
 13.1121 -    /* get freeblock_current */
 13.1122 -    if (bs_super->freelist_current == 0ULL) 
 13.1123 -    {
 13.1124 -        fl_current = new_freeblock();
 13.1125 -        bs_super->freelist_current = allocblock(fl_current);
 13.1126 -        writeblock(BLOCKSTORE_SUPER, bs_super);
 13.1127 -    } else {
 13.1128 -        fl_current = readblock(bs_super->freelist_current);
 13.1129 -    }
 13.1130 -    
 13.1131 -    /* if full, chain to superblock and allocate new current */
 13.1132 -    
 13.1133 -    if (fl_current->count == FREEBLOCK_SIZE) {
 13.1134 -        fl_current->next = bs_super->freelist_full;
 13.1135 -        writeblock(bs_super->freelist_current, fl_current);
 13.1136 -        bs_super->freelist_full = bs_super->freelist_current;
 13.1137 -        freeblock(fl_current);
 13.1138 -        fl_current = new_freeblock();
 13.1139 -        bs_super->freelist_current = allocblock(fl_current);
 13.1140 -        writeblock(BLOCKSTORE_SUPER, bs_super);
 13.1141 -    }
 13.1142 -    
 13.1143 -    /* append id to current */
 13.1144 -    fl_current->list[fl_current->count++] = id;
 13.1145 -    writeblock(bs_super->freelist_current, fl_current);
 13.1146 -    
 13.1147 -    freeblock(fl_current);
 13.1148 -    freeblock(bs_super);
 13.1149 -    
 13.1150 -    
 13.1151 -}
 13.1152 -
 13.1153 -/* freelist debug functions: */
 13.1154 -void freelist_count(int print_each)
 13.1155 -{
 13.1156 -    blockstore_super_t *bs_super;
 13.1157 -    freeblock_t *fb;
 13.1158 -    uint64_t total = 0, next;
 13.1159 -    
 13.1160 -    bs_super = (blockstore_super_t *) readblock(BLOCKSTORE_SUPER);
 13.1161 -    
 13.1162 -    if (bs_super->freelist_current == 0ULL) {
 13.1163 -        printf("freelist is empty!\n");
 13.1164 -        return;
 13.1165 -    }
 13.1166 -    
 13.1167 -    fb = readblock(bs_super->freelist_current);
 13.1168 -    printf("%Ld entires on current.\n", fb->count);
 13.1169 -    total += fb->count;
 13.1170 -    if (print_each == 1)
 13.1171 -    {
 13.1172 -        int i;
 13.1173 -        for (i=0; i< fb->count; i++)
 13.1174 -            printf("  %Ld\n", fb->list[i]);
 13.1175 -    }
 13.1176 -    
 13.1177 -    freeblock(fb);
 13.1178 -    
 13.1179 -    if (bs_super->freelist_full == 0ULL) {
 13.1180 -        printf("freelist_full is empty!\n");
 13.1181 -        return;
 13.1182 -    }
 13.1183 -    
 13.1184 -    next = bs_super->freelist_full;
 13.1185 -    for (;;) {
 13.1186 -        fb = readblock(next);
 13.1187 -        total += fb->count;
 13.1188 -        if (print_each == 1)
 13.1189 -        {
 13.1190 -            int i;
 13.1191 -            for (i=0; i< fb->count; i++)
 13.1192 -                printf("  %Ld\n", fb->list[i]);
 13.1193 -        }
 13.1194 -        next = fb->next;
 13.1195 -        freeblock(fb);
 13.1196 -        if (next == 0ULL) break;
 13.1197 -    }
 13.1198 -    printf("Total of %Ld ids on freelist.\n", total);
 13.1199 -}
 13.1200 -
 13.1201 -/*****************************************************************************
 13.1202 - * Initialisation                                                            *
 13.1203 - *****************************************************************************/
 13.1204 -
 13.1205 -int __init_blockstore(void)
 13.1206 -{
 13.1207 -    int i;
 13.1208 -    blockstore_super_t *bs_super;
 13.1209 -    uint64_t ret;
 13.1210 -    int block_fp;
 13.1211 -    
 13.1212 -#ifdef BLOCKSTORE_REMOTE
 13.1213 -    struct hostent *addr;
 13.1214 -
 13.1215 -    pthread_mutex_init(&ptmutex_queue, NULL);
 13.1216 -    pthread_mutex_init(&ptmutex_luid, NULL);
 13.1217 -    pthread_mutex_init(&ptmutex_recv, NULL);
 13.1218 -    /*pthread_mutex_init(&ptmutex_notify, NULL);*/
 13.1219 -    for (i = 0; i <= READ_POOL_SIZE; i++) {
 13.1220 -        pool_thread[i].newdata = 0;
 13.1221 -        pthread_mutex_init(&(pool_thread[i].ptmutex), NULL);
 13.1222 -        pthread_cond_init(&(pool_thread[i].ptcv), NULL);
 13.1223 -    }
 13.1224 -
 13.1225 -    bsservers[0].hostname = "firebug.cl.cam.ac.uk";
 13.1226 -    bsservers[1].hostname = "planb.cl.cam.ac.uk";
 13.1227 -    bsservers[2].hostname = "simcity.cl.cam.ac.uk";
 13.1228 -    bsservers[3].hostname = NULL/*"gunfighter.cl.cam.ac.uk"*/;
 13.1229 -    bsservers[4].hostname = NULL/*"galaxian.cl.cam.ac.uk"*/;
 13.1230 -    bsservers[5].hostname = NULL/*"firetrack.cl.cam.ac.uk"*/;
 13.1231 -    bsservers[6].hostname = NULL/*"funfair.cl.cam.ac.uk"*/;
 13.1232 -    bsservers[7].hostname = NULL/*"felix.cl.cam.ac.uk"*/;
 13.1233 -    bsservers[8].hostname = NULL;
 13.1234 -    bsservers[9].hostname = NULL;
 13.1235 -    bsservers[10].hostname = NULL;
 13.1236 -    bsservers[11].hostname = NULL;
 13.1237 -    bsservers[12].hostname = NULL;
 13.1238 -    bsservers[13].hostname = NULL;
 13.1239 -    bsservers[14].hostname = NULL;
 13.1240 -    bsservers[15].hostname = NULL;
 13.1241 -
 13.1242 -    for (i = 0; i < MAX_SERVERS; i++) {
 13.1243 -        if (!bsservers[i].hostname)
 13.1244 -            continue;
 13.1245 -        addr = gethostbyname(bsservers[i].hostname);
 13.1246 -        if (!addr) {
 13.1247 -            perror("bad hostname");
 13.1248 -            return -1;
 13.1249 -        }
 13.1250 -        bsservers[i].sin.sin_family = addr->h_addrtype;
 13.1251 -        bsservers[i].sin.sin_port = htons(BLOCKSTORED_PORT);
 13.1252 -        bsservers[i].sin.sin_addr.s_addr = 
 13.1253 -            ((struct in_addr *)(addr->h_addr))->s_addr;
 13.1254 -    }
 13.1255 -
 13.1256 -    /* Cluster map
 13.1257 -     */
 13.1258 -    bsclusters[0].servers[0] = 0;
 13.1259 -    bsclusters[0].servers[1] = 1;
 13.1260 -    bsclusters[0].servers[2] = 2;
 13.1261 -    bsclusters[1].servers[0] = 1;
 13.1262 -    bsclusters[1].servers[1] = 2;
 13.1263 -    bsclusters[1].servers[2] = 3;
 13.1264 -    bsclusters[2].servers[0] = 2;
 13.1265 -    bsclusters[2].servers[1] = 3;
 13.1266 -    bsclusters[2].servers[2] = 4;
 13.1267 -    bsclusters[3].servers[0] = 3;
 13.1268 -    bsclusters[3].servers[1] = 4;
 13.1269 -    bsclusters[3].servers[2] = 5;
 13.1270 -    bsclusters[4].servers[0] = 4;
 13.1271 -    bsclusters[4].servers[1] = 5;
 13.1272 -    bsclusters[4].servers[2] = 6;
 13.1273 -    bsclusters[5].servers[0] = 5;
 13.1274 -    bsclusters[5].servers[1] = 6;
 13.1275 -    bsclusters[5].servers[2] = 7;
 13.1276 -    bsclusters[6].servers[0] = 6;
 13.1277 -    bsclusters[6].servers[1] = 7;
 13.1278 -    bsclusters[6].servers[2] = 0;
 13.1279 -    bsclusters[7].servers[0] = 7;
 13.1280 -    bsclusters[7].servers[1] = 0;
 13.1281 -    bsclusters[7].servers[2] = 1;
 13.1282 -
 13.1283 -    /* Local socket set up
 13.1284 -     */
 13.1285 -    bssock = socket(AF_INET, SOCK_DGRAM, 0);
 13.1286 -    if (bssock < 0) {
 13.1287 -        perror("Bad socket");
 13.1288 -        return -1;
 13.1289 -    }
 13.1290 -    memset(&sin_local, 0, sizeof(sin_local));
 13.1291 -    sin_local.sin_family = AF_INET;
 13.1292 -    sin_local.sin_port = htons(BLOCKSTORED_PORT);
 13.1293 -    sin_local.sin_addr.s_addr = htonl(INADDR_ANY);
 13.1294 -    if (bind(bssock, (struct sockaddr *)&sin_local, sizeof(sin_local)) < 0) {
 13.1295 -        perror("bind");
 13.1296 -        close(bssock);
 13.1297 -        return -1;
 13.1298 -    }
 13.1299 -
 13.1300 -    pthread_create(&pthread_recv, NULL, receive_loop, NULL);
 13.1301 -    pthread_create(&pthread_recv, NULL, queue_runner, NULL);
 13.1302 -
 13.1303 -#else /* /BLOCKSTORE_REMOTE */
 13.1304 -    block_fp = open("blockstore.dat", O_RDWR | O_CREAT | O_LARGEFILE, 0644);
 13.1305 -
 13.1306 -    if (block_fp < 0) {
 13.1307 -        perror("open");
 13.1308 -        return -1;
 13.1309 -        exit(-1);
 13.1310 -    }
 13.1311 -    
 13.1312 -    if (lseek(block_fp, 0, SEEK_END) == 0) {
 13.1313 -        bs_super = newblock();
 13.1314 -        bs_super->magic            = BLOCKSTORE_MAGIC;
 13.1315 -        bs_super->freelist_full    = 0LL;
 13.1316 -        bs_super->freelist_current = 0LL;
 13.1317 -        
 13.1318 -        ret = allocblock(bs_super);
 13.1319 -        
 13.1320 -        freeblock(bs_super);
 13.1321 -    } else {
 13.1322 -        bs_super = (blockstore_super_t *) readblock(BLOCKSTORE_SUPER);
 13.1323 -        if (bs_super->magic != BLOCKSTORE_MAGIC)
 13.1324 -        {
 13.1325 -            printf("BLOCKSTORE IS CORRUPT! (no magic in superblock!)\n");
 13.1326 -            exit(-1);
 13.1327 -        }
 13.1328 -        freeblock(bs_super);
 13.1329 -    }
 13.1330 -        
 13.1331 -    close(block_fp);
 13.1332 -        
 13.1333 -#endif /*  BLOCKSTORE_REMOTE */   
 13.1334 -    return 0;
 13.1335 -}
 13.1336 -
 13.1337 -void __exit_blockstore(void)
 13.1338 -{
 13.1339 -    int i;
 13.1340 -#ifdef BLOCKSTORE_REMOTE
 13.1341 -    pthread_mutex_destroy(&ptmutex_recv);
 13.1342 -    pthread_mutex_destroy(&ptmutex_luid);
 13.1343 -    pthread_mutex_destroy(&ptmutex_queue);
 13.1344 -    /*pthread_mutex_destroy(&ptmutex_notify);
 13.1345 -      pthread_cond_destroy(&ptcv_notify);*/
 13.1346 -    for (i = 0; i <= READ_POOL_SIZE; i++) {
 13.1347 -        pthread_mutex_destroy(&(pool_thread[i].ptmutex));
 13.1348 -        pthread_cond_destroy(&(pool_thread[i].ptcv));
 13.1349 -    }
 13.1350 -#endif
 13.1351 -}

    14.1 --- a/tools/blktap/parallax/blockstore.h	Fri Jun 16 18:19:40 2006 +0100
    14.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    14.3 @@ -1,134 +0,0 @@
    14.4 -/**************************************************************************
    14.5 - * 
    14.6 - * blockstore.h
    14.7 - *
    14.8 - * Simple block store interface
    14.9 - *
   14.10 - */
   14.11 - 
   14.12 -#ifndef __BLOCKSTORE_H__
   14.13 -#define __BLOCKSTORE_H__
   14.14 -
   14.15 -#include <netinet/in.h>
   14.16 -#include <xenctrl.h>
   14.17 -
   14.18 -#define BLOCK_SIZE  4096
   14.19 -#define BLOCK_SHIFT   12
   14.20 -#define BLOCK_MASK  0xfffffffffffff000LL
   14.21 -
   14.22 -/* XXX SMH: where is the below supposed to be defined???? */
   14.23 -#ifndef SECTOR_SHIFT 
   14.24 -#define SECTOR_SHIFT   9 
   14.25 -#endif
   14.26 -
   14.27 -#define FREEBLOCK_SIZE  (BLOCK_SIZE / sizeof(uint64_t)) - (3 * sizeof(uint64_t))
   14.28 -#define FREEBLOCK_MAGIC 0x0fee0fee0fee0feeULL
   14.29 -
   14.30 -typedef struct {
   14.31 -    uint64_t magic;
   14.32 -    uint64_t next;
   14.33 -    uint64_t count;
   14.34 -    uint64_t list[FREEBLOCK_SIZE];
   14.35 -} freeblock_t; 
   14.36 -
   14.37 -#define BLOCKSTORE_MAGIC 0xaaaaaaa00aaaaaaaULL
   14.38 -#define BLOCKSTORE_SUPER 1ULL
   14.39 -
   14.40 -typedef struct {
   14.41 -    uint64_t magic;
   14.42 -    uint64_t freelist_full;
   14.43 -    uint64_t freelist_current;
   14.44 -} blockstore_super_t;
   14.45 -
   14.46 -extern void *newblock();
   14.47 -extern void *readblock(uint64_t id);
   14.48 -extern uint64_t allocblock(void *block);
   14.49 -extern uint64_t allocblock_hint(void *block, uint64_t hint);
   14.50 -extern int writeblock(uint64_t id, void *block);
   14.51 -
   14.52 -/* Add this blockid to a freelist, to be recycled by the allocator. */
   14.53 -extern void releaseblock(uint64_t id);
   14.54 -
   14.55 -/* this is a memory free() operation for block-sized allocations */
   14.56 -extern void freeblock(void *block);
   14.57 -extern int __init_blockstore(void);
   14.58 -
   14.59 -/* debug for freelist. */
   14.60 -void freelist_count(int print_each);
   14.61 -#define ALLOCFAIL (((uint64_t)(-1)))
   14.62 -
   14.63 -/* Distribution
   14.64 - */
   14.65 -#define BLOCKSTORED_PORT 9346
   14.66 -
   14.67 -struct bshdr_t_struct {
   14.68 -    uint32_t            operation;
   14.69 -    uint32_t            flags;
   14.70 -    uint64_t            id;
   14.71 -    uint64_t            luid;
   14.72 -} __attribute__ ((packed));
   14.73 -typedef struct bshdr_t_struct bshdr_t;
   14.74 -
   14.75 -struct bsmsg_t_struct {
   14.76 -    bshdr_t        hdr;
   14.77 -    unsigned char  block[BLOCK_SIZE];
   14.78 -} __attribute__ ((packed));
   14.79 -
   14.80 -typedef struct bsmsg_t_struct bsmsg_t;
   14.81 -
   14.82 -#define MSGBUFSIZE_OP    sizeof(uint32_t)
   14.83 -#define MSGBUFSIZE_FLAGS (sizeof(uint32_t) + sizeof(uint32_t))
   14.84 -#define MSGBUFSIZE_ID    (sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint64_t) + sizeof(uint64_t))
   14.85 -#define MSGBUFSIZE_BLOCK sizeof(bsmsg_t)
   14.86 -
   14.87 -#define BSOP_READBLOCK  0x01
   14.88 -#define BSOP_WRITEBLOCK 0x02
   14.89 -#define BSOP_ALLOCBLOCK 0x03
   14.90 -#define BSOP_FREEBLOCK  0x04
   14.91 -
   14.92 -#define BSOP_FLAG_ERROR 0x01
   14.93 -
   14.94 -#define BS_ALLOC_SKIP 10
   14.95 -#define BS_ALLOC_HACK
   14.96 -
   14.97 -/* Remote hosts and cluster map - XXX need to generalise
   14.98 - */
   14.99 -
  14.100 -/*
  14.101 -
  14.102 -  Interim ID format is
  14.103 -
  14.104 -  63 60 59                40 39                20 19                 0
  14.105 -  +----+--------------------+--------------------+--------------------+
  14.106 -  |map | replica 2          | replica 1          | replica 0          |
  14.107 -  +----+--------------------+--------------------+--------------------+
  14.108 -
  14.109 -  The map is an index into a table detailing which machines form the
  14.110 -  cluster.
  14.111 -
  14.112 - */
  14.113 -
  14.114 -#define BSID_REPLICA0(_id) ((_id)&0xfffffULL)
  14.115 -#define BSID_REPLICA1(_id) (((_id)>>20)&0xfffffULL)
  14.116 -#define BSID_REPLICA2(_id) (((_id)>>40)&0xfffffULL)
  14.117 -#define BSID_MAP(_id)      (((_id)>>60)&0xfULL)
  14.118 -
  14.119 -#define BSID(_map, _rep0, _rep1, _rep2) ((((uint64_t)(_map))<<60) | \
  14.120 -                                         (((uint64_t)(_rep2))<<40) | \
  14.121 -                                         (((uint64_t)(_rep1))<<20) | ((uint64_t)(_rep0)))
  14.122 -
  14.123 -typedef struct bsserver_t_struct {
  14.124 -    char              *hostname;
  14.125 -    struct sockaddr_in sin;
  14.126 -} bsserver_t;
  14.127 -
  14.128 -#define MAX_SERVERS 16
  14.129 -
  14.130 -#define CLUSTER_MAX_REPLICAS 3
  14.131 -typedef struct bscluster_t_struct {
  14.132 -    int servers[CLUSTER_MAX_REPLICAS];
  14.133 -} bscluster_t;
  14.134 -
  14.135 -#define MAX_CLUSTERS 16
  14.136 -
  14.137 -#endif /* __BLOCKSTORE_H__ */

    15.1 --- a/tools/blktap/parallax/blockstored.c	Fri Jun 16 18:19:40 2006 +0100
    15.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    15.3 @@ -1,275 +0,0 @@
    15.4 -/**************************************************************************
    15.5 - * 
    15.6 - * blockstored.c
    15.7 - *
    15.8 - * Block store daemon.
    15.9 - *
   15.10 - */
   15.11 -
   15.12 -#include <fcntl.h>
   15.13 -#include <unistd.h>
   15.14 -#include <stdio.h>
   15.15 -#include <stdlib.h>
   15.16 -#include <string.h>
   15.17 -#include <sys/types.h>
   15.18 -#include <sys/stat.h>
   15.19 -#include <sys/socket.h>
   15.20 -#include <sys/ioctl.h>
   15.21 -#include <netinet/in.h>
   15.22 -#include <errno.h>
   15.23 -#include "blockstore.h"
   15.24 -
   15.25 -//#define BSDEBUG
   15.26 -
   15.27 -int readblock_into(uint64_t id, void *block);
   15.28 -
   15.29 -int open_socket(uint16_t port) {
   15.30 -    
   15.31 -    struct sockaddr_in sn;
   15.32 -    int sock;
   15.33 -
   15.34 -    sock = socket(AF_INET, SOCK_DGRAM, 0);
   15.35 -    if (sock < 0) {
   15.36 -        perror("Bad socket");
   15.37 -        return -1;
   15.38 -    }
   15.39 -    memset(&sn, 0, sizeof(sn));
   15.40 -    sn.sin_family = AF_INET;
   15.41 -    sn.sin_port = htons(port);
   15.42 -    sn.sin_addr.s_addr = htonl(INADDR_ANY);
   15.43 -    if (bind(sock, (struct sockaddr *)&sn, sizeof(sn)) < 0) {
   15.44 -        perror("bind");
   15.45 -        close(sock);
   15.46 -        return -1;
   15.47 -    }
   15.48 -
   15.49 -    return sock;
   15.50 -}
   15.51 -
   15.52 -static int block_fp = -1;
   15.53 -static int bssock = -1;
   15.54 -
   15.55 -int send_reply(struct sockaddr_in *peer, void *buffer, int len) {
   15.56 -
   15.57 -    int rc;
   15.58 -    
   15.59 -#ifdef BSDEBUG
   15.60 -    fprintf(stdout, "TX: %u bytes op=%u id=0x%llx\n",
   15.61 -            len, ((bsmsg_t *)buffer)->hdr.operation, ((bsmsg_t *)buffer)->hdr.id);
   15.62 -#endif
   15.63 -    rc = sendto(bssock, buffer, len, 0, (struct sockaddr *)peer, sizeof(*peer));
   15.64 -    if (rc < 0) {
   15.65 -        perror("send_reply");
   15.66 -        return 1;
   15.67 -    }
   15.68 -
   15.69 -
   15.70 -    return 0;
   15.71 -}
   15.72 -
   15.73 -static bsmsg_t msgbuf;
   15.74 -
   15.75 -void service_loop(void) {
   15.76 -
   15.77 -    for (;;) {
   15.78 -        int rc, len;
   15.79 -        struct sockaddr_in from;
   15.80 -        size_t slen = sizeof(from);
   15.81 -        uint64_t bid;
   15.82 -
   15.83 -        len = recvfrom(bssock, (void *)&msgbuf, sizeof(msgbuf), 0,
   15.84 -                       (struct sockaddr *)&from, &slen);
   15.85 -
   15.86 -        if (len < 0) {
   15.87 -            perror("recvfrom");
   15.88 -            continue;
   15.89 -        }
   15.90 -
   15.91 -        if (len < MSGBUFSIZE_OP) {
   15.92 -            fprintf(stderr, "Short packet.\n");
   15.93 -            continue;
   15.94 -        }
   15.95 -
   15.96 -#ifdef BSDEBUG
   15.97 -        fprintf(stdout, "RX: %u bytes op=%u id=0x%llx\n",
   15.98 -                len, msgbuf.hdr.operation, msgbuf.hdr.id);
   15.99 -#endif
  15.100 -
  15.101 -        switch (msgbuf.hdr.operation) {
  15.102 -        case BSOP_READBLOCK:
  15.103 -            if (len < MSGBUFSIZE_ID) {
  15.104 -                fprintf(stderr, "Short packet (readblock %u).\n", len);
  15.105 -                continue;
  15.106 -            }
  15.107 -            rc = readblock_into(msgbuf.hdr.id, msgbuf.block);
  15.108 -            if (rc < 0) {
  15.109 -                fprintf(stderr, "readblock error\n");
  15.110 -                msgbuf.hdr.flags = BSOP_FLAG_ERROR;
  15.111 -                send_reply(&from, (void *)&msgbuf, MSGBUFSIZE_ID);
  15.112 -                continue;
  15.113 -            }
  15.114 -            msgbuf.hdr.flags = 0;
  15.115 -            send_reply(&from, (void *)&msgbuf, MSGBUFSIZE_BLOCK);
  15.116 -            break;
  15.117 -        case BSOP_WRITEBLOCK:
  15.118 -            if (len < MSGBUFSIZE_BLOCK) {
  15.119 -                fprintf(stderr, "Short packet (writeblock %u).\n", len);
  15.120 -                continue;
  15.121 -            }
  15.122 -            rc = writeblock(msgbuf.hdr.id, msgbuf.block);
  15.123 -            if (rc < 0) {
  15.124 -                fprintf(stderr, "writeblock error\n");
  15.125 -                msgbuf.hdr.flags = BSOP_FLAG_ERROR;
  15.126 -                send_reply(&from, (void *)&msgbuf, MSGBUFSIZE_ID);
  15.127 -                continue;
  15.128 -            }
  15.129 -            msgbuf.hdr.flags = 0;
  15.130 -            send_reply(&from, (void *)&msgbuf, MSGBUFSIZE_ID);
  15.131 -            break;
  15.132 -        case BSOP_ALLOCBLOCK:
  15.133 -            if (len < MSGBUFSIZE_BLOCK) {
  15.134 -                fprintf(stderr, "Short packet (allocblock %u).\n", len);
  15.135 -                continue;
  15.136 -            }
  15.137 -            bid = allocblock(msgbuf.block);
  15.138 -            if (bid == ALLOCFAIL) {
  15.139 -                fprintf(stderr, "allocblock error\n");
  15.140 -                msgbuf.hdr.flags = BSOP_FLAG_ERROR;
  15.141 -                send_reply(&from, (void *)&msgbuf, MSGBUFSIZE_ID);
  15.142 -                continue;
  15.143 -            }
  15.144 -            msgbuf.hdr.id = bid;
  15.145 -            msgbuf.hdr.flags = 0;
  15.146 -            send_reply(&from, (void *)&msgbuf, MSGBUFSIZE_ID);
  15.147 -            break;
  15.148 -        }
  15.149 -
  15.150 -    }
  15.151 -}
  15.152 - 
  15.153 -/**
  15.154 - * readblock: read a block from disk
  15.155 - *   @id: block id to read
  15.156 - *   @block: pointer to buffer to receive block
  15.157 - *
  15.158 - *   @return: 0 if OK, other on error
  15.159 - */
  15.160 -
  15.161 -int readblock_into(uint64_t id, void *block) {
  15.162 -    if (lseek64(block_fp, ((off64_t) id - 1LL) * BLOCK_SIZE, SEEK_SET) < 0) {
  15.163 -        printf ("%Ld\n", (id - 1) * BLOCK_SIZE);
  15.164 -        perror("readblock lseek");
  15.165 -        return -1;
  15.166 -    }
  15.167 -    if (read(block_fp, block, BLOCK_SIZE) != BLOCK_SIZE) {
  15.168 -        perror("readblock read");
  15.169 -        return -1;
  15.170 -    }
  15.171 -    return 0;
  15.172 -}
  15.173 -
  15.174 -/**
  15.175 - * writeblock: write an existing block to disk
  15.176 - *   @id: block id
  15.177 - *   @block: pointer to block
  15.178 - *
  15.179 - *   @return: zero on success, -1 on failure
  15.180 - */
  15.181 -int writeblock(uint64_t id, void *block) {
  15.182 -    if (lseek64(block_fp, ((off64_t) id - 1LL) * BLOCK_SIZE, SEEK_SET) < 0) {
  15.183 -        perror("writeblock lseek");
  15.184 -        return -1;
  15.185 -    }
  15.186 -    if (write(block_fp, block, BLOCK_SIZE) < 0) {
  15.187 -        perror("writeblock write");
  15.188 -        return -1;
  15.189 -    }
  15.190 -    return 0;
  15.191 -}
  15.192 -
  15.193 -/**
  15.194 - * allocblock: write a new block to disk
  15.195 - *   @block: pointer to block
  15.196 - *
  15.197 - *   @return: new id of block on disk
  15.198 - */
  15.199 -static uint64_t lastblock = 0;
  15.200 -
  15.201 -uint64_t allocblock(void *block) {
  15.202 -    uint64_t lb;
  15.203 -    off64_t pos;
  15.204 -
  15.205 -    retry:
  15.206 -    pos = lseek64(block_fp, 0, SEEK_END);
  15.207 -    if (pos == (off64_t)-1) {
  15.208 -        perror("allocblock lseek");
  15.209 -        return ALLOCFAIL;
  15.210 -    }
  15.211 -    if (pos % BLOCK_SIZE != 0) {
  15.212 -        fprintf(stderr, "file size not multiple of %d\n", BLOCK_SIZE);
  15.213 -        return ALLOCFAIL;
  15.214 -    }
  15.215 -    if (write(block_fp, block, BLOCK_SIZE) != BLOCK_SIZE) {
  15.216 -        perror("allocblock write");
  15.217 -        return ALLOCFAIL;
  15.218 -    }
  15.219 -    lb = pos / BLOCK_SIZE + 1;
  15.220 -
  15.221 -#ifdef BS_ALLOC_HACK
  15.222 -    if (lb < BS_ALLOC_SKIP)
  15.223 -        goto retry;
  15.224 -#endif
  15.225 -    
  15.226 -    if (lb <= lastblock)
  15.227 -        printf("[*** %Ld alredy allocated! ***]\n", lb);
  15.228 -    
  15.229 -    lastblock = lb;
  15.230 -    return lb;
  15.231 -}
  15.232 -
  15.233 -/**
  15.234 - * newblock: get a new in-memory block set to zeros
  15.235 - *
  15.236 - *   @return: pointer to new block, NULL on error
  15.237 - */
  15.238 -void *newblock(void) {
  15.239 -    void *block = malloc(BLOCK_SIZE);
  15.240 -    if (block == NULL) {
  15.241 -        perror("newblock");
  15.242 -        return NULL;
  15.243 -    }
  15.244 -    memset(block, 0, BLOCK_SIZE);
  15.245 -    return block;
  15.246 -}
  15.247 -
  15.248 -
  15.249 -/**
  15.250 - * freeblock: unallocate an in-memory block
  15.251 - *   @id: block id (zero if this is only in-memory)
  15.252 - *   @block: block to be freed
  15.253 - */
  15.254 -void freeblock(void *block) {
  15.255 -        free(block);
  15.256 -}
  15.257 -
  15.258 -
  15.259 -int main(int argc, char **argv)
  15.260 -{
  15.261 -    block_fp = open("blockstore.dat", O_RDWR | O_CREAT | O_LARGEFILE, 0644);
  15.262 -
  15.263 -    if (block_fp < 0) {
  15.264 -        perror("open");
  15.265 -        return -1;
  15.266 -    }
  15.267 -
  15.268 -    bssock = open_socket(BLOCKSTORED_PORT);
  15.269 -    if (bssock < 0) {
  15.270 -        return -1;
  15.271 -    }
  15.272 -
  15.273 -    service_loop();
  15.274 -    
  15.275 -    close(bssock);
  15.276 -
  15.277 -    return 0;
  15.278 -}

    16.1 --- a/tools/blktap/parallax/bstest.c	Fri Jun 16 18:19:40 2006 +0100
    16.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    16.3 @@ -1,191 +0,0 @@
    16.4 -/**************************************************************************
    16.5 - * 
    16.6 - * bstest.c
    16.7 - *
    16.8 - * Block store daemon test program.
    16.9 - *
   16.10 - * usage: bstest <host>|X {r|w|a} ID 
   16.11 - *
   16.12 - */
   16.13 -
   16.14 -#include <fcntl.h>
   16.15 -#include <unistd.h>
   16.16 -#include <stdio.h>
   16.17 -#include <stdlib.h>
   16.18 -#include <string.h>
   16.19 -#include <sys/types.h>
   16.20 -#include <sys/stat.h>
   16.21 -#include <sys/socket.h>
   16.22 -#include <sys/ioctl.h>
   16.23 -#include <netinet/in.h>
   16.24 -#include <netdb.h>
   16.25 -#include <errno.h>
   16.26 -#include "blockstore.h"
   16.27 -
   16.28 -int direct(char *host, uint32_t op, uint64_t id, int len) {
   16.29 -    struct sockaddr_in sn, peer;
   16.30 -    int sock;
   16.31 -    bsmsg_t msgbuf;
   16.32 -    int rc, slen;
   16.33 -    struct hostent *addr;
   16.34 -
   16.35 -    addr = gethostbyname(host);
   16.36 -    if (!addr) {
   16.37 -        perror("bad hostname");
   16.38 -        exit(1);
   16.39 -    }
   16.40 -    peer.sin_family = addr->h_addrtype;
   16.41 -    peer.sin_port = htons(BLOCKSTORED_PORT);
   16.42 -    peer.sin_addr.s_addr =  ((struct in_addr *)(addr->h_addr))->s_addr;
   16.43 -    fprintf(stderr, "Sending to: %u.%u.%u.%u\n",
   16.44 -            (unsigned int)(unsigned char)addr->h_addr[0],
   16.45 -            (unsigned int)(unsigned char)addr->h_addr[1],
   16.46 -            (unsigned int)(unsigned char)addr->h_addr[2],
   16.47 -            (unsigned int)(unsigned char)addr->h_addr[3]);
   16.48 -
   16.49 -    sock = socket(AF_INET, SOCK_DGRAM, 0);
   16.50 -    if (sock < 0) {
   16.51 -        perror("Bad socket");
   16.52 -        exit(1);
   16.53 -    }
   16.54 -    memset(&sn, 0, sizeof(sn));
   16.55 -    sn.sin_family = AF_INET;
   16.56 -    sn.sin_port = htons(BLOCKSTORED_PORT);
   16.57 -    sn.sin_addr.s_addr = htonl(INADDR_ANY);
   16.58 -    if (bind(sock, (struct sockaddr *)&sn, sizeof(sn)) < 0) {
   16.59 -        perror("bind");
   16.60 -        close(sock);
   16.61 -        exit(1);
   16.62 -    }
   16.63 -
   16.64 -    memset((void *)&msgbuf, 0, sizeof(msgbuf));
   16.65 -    msgbuf.operation = op;
   16.66 -    msgbuf.id = id;
   16.67 -
   16.68 -    rc = sendto(sock, (void *)&msgbuf, len, 0,
   16.69 -                (struct sockaddr *)&peer, sizeof(peer));
   16.70 -    if (rc < 0) {
   16.71 -        perror("sendto");
   16.72 -        exit(1);
   16.73 -    }
   16.74 -
   16.75 -    slen = sizeof(peer);
   16.76 -    len = recvfrom(sock, (void *)&msgbuf, sizeof(msgbuf), 0,
   16.77 -                   (struct sockaddr *)&peer, &slen);
   16.78 -    if (len < 0) {
   16.79 -        perror("recvfrom");
   16.80 -        exit(1);
   16.81 -    }
   16.82 -
   16.83 -    printf("Reply %u bytes:\n", len);
   16.84 -    if (len >= MSGBUFSIZE_OP)
   16.85 -        printf("  operation: %u\n", msgbuf.operation);
   16.86 -    if (len >= MSGBUFSIZE_FLAGS)
   16.87 -        printf("  flags: 0x%x\n", msgbuf.flags);
   16.88 -    if (len >= MSGBUFSIZE_ID)
   16.89 -        printf("  id: %llu\n", msgbuf.id);
   16.90 -    if (len >= (MSGBUFSIZE_ID + 4))
   16.91 -        printf("  data: %02x %02x %02x %02x...\n",
   16.92 -               (unsigned int)msgbuf.block[0],
   16.93 -               (unsigned int)msgbuf.block[1],
   16.94 -               (unsigned int)msgbuf.block[2],
   16.95 -               (unsigned int)msgbuf.block[3]);
   16.96 -    
   16.97 -    if (sock > 0)
   16.98 -        close(sock);
   16.99 -   
  16.100 -    return 0;
  16.101 -}
  16.102 -
  16.103 -int main (int argc, char **argv) {
  16.104 -
  16.105 -    uint32_t op = 0;
  16.106 -    uint64_t id = 0;
  16.107 -    int len = 0, rc;
  16.108 -    void *block;
  16.109 -
  16.110 -    if (argc < 3) {
  16.111 -        fprintf(stderr, "usage: bstest <host>|X {r|w|a} ID\n");
  16.112 -        return 1;
  16.113 -    }
  16.114 -
  16.115 -    switch (argv[2][0]) {
  16.116 -    case 'r':
  16.117 -    case 'R':
  16.118 -        op = BSOP_READBLOCK;
  16.119 -        len = MSGBUFSIZE_ID;
  16.120 -        break;
  16.121 -    case 'w':
  16.122 -    case 'W':
  16.123 -        op = BSOP_WRITEBLOCK;
  16.124 -        len = MSGBUFSIZE_BLOCK;
  16.125 -        break;
  16.126 -    case 'a':
  16.127 -    case 'A':
  16.128 -        op = BSOP_ALLOCBLOCK;
  16.129 -        len = MSGBUFSIZE_BLOCK;
  16.130 -        break;
  16.131 -    default:
  16.132 -        fprintf(stderr, "Unknown action '%s'.\n", argv[2]);
  16.133 -        return 1;
  16.134 -    }
  16.135 -
  16.136 -    if (argc >= 4)
  16.137 -        id = atoll(argv[3]);
  16.138 -
  16.139 -    if (strcmp(argv[1], "X") == 0) {
  16.140 -        rc = __init_blockstore();
  16.141 -        if (rc < 0) {
  16.142 -            fprintf(stderr, "blockstore init failed.\n");
  16.143 -            return 1;
  16.144 -        }
  16.145 -        switch(op) {
  16.146 -        case BSOP_READBLOCK:
  16.147 -            block = readblock(id);
  16.148 -            if (block) {
  16.149 -                printf("data: %02x %02x %02x %02x...\n",
  16.150 -                       (unsigned int)((unsigned char*)block)[0],
  16.151 -                       (unsigned int)((unsigned char*)block)[1],
  16.152 -                       (unsigned int)((unsigned char*)block)[2],
  16.153 -                       (unsigned int)((unsigned char*)block)[3]);
  16.154 -            }
  16.155 -            break;
  16.156 -        case BSOP_WRITEBLOCK:
  16.157 -            block = malloc(BLOCK_SIZE);
  16.158 -            if (!block) {
  16.159 -                perror("bstest malloc");
  16.160 -                return 1;
  16.161 -            }
  16.162 -            memset(block, 0, BLOCK_SIZE);
  16.163 -            rc = writeblock(id, block);
  16.164 -            if (rc != 0) {
  16.165 -                printf("error\n");
  16.166 -            }
  16.167 -            else {
  16.168 -                printf("OK\n");
  16.169 -            }
  16.170 -            break;
  16.171 -        case BSOP_ALLOCBLOCK:
  16.172 -            block = malloc(BLOCK_SIZE);
  16.173 -            if (!block) {
  16.174 -                perror("bstest malloc");
  16.175 -                return 1;
  16.176 -            }
  16.177 -            memset(block, 0, BLOCK_SIZE);
  16.178 -            id = allocblock_hint(block, id);
  16.179 -            if (id == 0) {
  16.180 -                printf("error\n");
  16.181 -            }
  16.182 -            else {
  16.183 -                printf("ID: %llu\n", id);
  16.184 -            }
  16.185 -            break;
  16.186 -        }
  16.187 -    }
  16.188 -    else {
  16.189 -        direct(argv[1], op, id, len);
  16.190 -    }
  16.191 -
  16.192 -
  16.193 -    return 0;
  16.194 -}

    17.1 --- a/tools/blktap/parallax/parallax.c	Fri Jun 16 18:19:40 2006 +0100
    17.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    17.3 @@ -1,608 +0,0 @@
    17.4 -/**************************************************************************
    17.5 - * 
    17.6 - * parallax.c
    17.7 - *
    17.8 - * The Parallax Storage Server
    17.9 - *
   17.10 - */
   17.11 - 
   17.12 -
   17.13 -#include <stdio.h>
   17.14 -#include <stdlib.h>
   17.15 -#include <string.h>
   17.16 -#include <pthread.h>
   17.17 -#include "blktaplib.h"
   17.18 -#include "blockstore.h"
   17.19 -#include "vdi.h"
   17.20 -#include "block-async.h"
   17.21 -#include "requests-async.h"
   17.22 -
   17.23 -#define PARALLAX_DEV     61440
   17.24 -#define SECTS_PER_NODE   8
   17.25 -
   17.26 -
   17.27 -#if 0
   17.28 -#define DPRINTF(_f, _a...) printf ( _f , ## _a )
   17.29 -#else
   17.30 -#define DPRINTF(_f, _a...) ((void)0)
   17.31 -#endif
   17.32 -
   17.33 -/* ------[ session records ]----------------------------------------------- */
   17.34 -
   17.35 -#define BLKIF_HASHSZ 1024
   17.36 -#define BLKIF_HASH(_d,_h) (((int)(_d)^(int)(_h))&(BLKIF_HASHSZ-1))
   17.37 -
   17.38 -#define VDI_HASHSZ 16
   17.39 -#define VDI_HASH(_vd) ((((_vd)>>8)^(_vd))&(VDI_HASHSZ-1))
   17.40 -
   17.41 -typedef struct blkif {
   17.42 -    domid_t       domid;
   17.43 -    unsigned int  handle;
   17.44 -    enum { DISCONNECTED, DISCONNECTING, CONNECTED } status;
   17.45 -    vdi_t        *vdi_hash[VDI_HASHSZ];
   17.46 -    struct blkif *hash_next;
   17.47 -} blkif_t;
   17.48 -
   17.49 -static blkif_t      *blkif_hash[BLKIF_HASHSZ];
   17.50 -
   17.51 -blkif_t *blkif_find_by_handle(domid_t domid, unsigned int handle)
   17.52 -{
   17.53 -    if ( handle != 0 )
   17.54 -        printf("blktap/parallax don't currently support non-0 dev handles!\n");
   17.55 -    
   17.56 -    blkif_t *blkif = blkif_hash[BLKIF_HASH(domid, handle)];
   17.57 -    while ( (blkif != NULL) && 
   17.58 -            ((blkif->domid != domid) || (blkif->handle != handle)) )
   17.59 -        blkif = blkif->hash_next;
   17.60 -    return blkif;
   17.61 -}
   17.62 -
   17.63 -vdi_t *blkif_get_vdi(blkif_t *blkif, blkif_vdev_t device)
   17.64 -{
   17.65 -    vdi_t *vdi = blkif->vdi_hash[VDI_HASH(device)];
   17.66 -    
   17.67 -    while ((vdi != NULL) && (vdi->vdevice != device))
   17.68 -        vdi = vdi->next;
   17.69 -    
   17.70 -    return vdi;
   17.71 -}
   17.72 -
   17.73 -/* ------[ control message handling ]-------------------------------------- */
   17.74 -
   17.75 -void blkif_create(blkif_be_create_t *create)
   17.76 -{
   17.77 -    domid_t       domid  = create->domid;
   17.78 -    unsigned int  handle = create->blkif_handle;
   17.79 -    blkif_t     **pblkif, *blkif;
   17.80 -
   17.81 -    DPRINTF("parallax (blkif_create): create is %p\n", create); 
   17.82 -    
   17.83 -    if ( (blkif = (blkif_t *)malloc(sizeof(blkif_t))) == NULL )
   17.84 -    {
   17.85 -        DPRINTF("Could not create blkif: out of memory\n");
   17.86 -        create->status = BLKIF_BE_STATUS_OUT_OF_MEMORY;
   17.87 -        return;
   17.88 -    }
   17.89 -
   17.90 -    memset(blkif, 0, sizeof(*blkif));
   17.91 -    blkif->domid  = domid;
   17.92 -    blkif->handle = handle;
   17.93 -    blkif->status = DISCONNECTED;
   17.94 -
   17.95 -    pblkif = &blkif_hash[BLKIF_HASH(domid, handle)];
   17.96 -    while ( *pblkif != NULL )
   17.97 -    {
   17.98 -        if ( ((*pblkif)->domid == domid) && ((*pblkif)->handle == handle) )
   17.99 -        {
  17.100 -            DPRINTF("Could not create blkif: already exists (%d,%d)\n",
  17.101 -                domid, handle);
  17.102 -            create->status = BLKIF_BE_STATUS_INTERFACE_EXISTS;
  17.103 -            free(blkif);
  17.104 -            return;
  17.105 -        }
  17.106 -        pblkif = &(*pblkif)->hash_next;
  17.107 -    }
  17.108 -
  17.109 -    blkif->hash_next = *pblkif;
  17.110 -    *pblkif = blkif;
  17.111 -
  17.112 -    DPRINTF("Successfully created blkif\n");
  17.113 -    create->status = BLKIF_BE_STATUS_OKAY;
  17.114 -}
  17.115 -
  17.116 -void blkif_destroy(blkif_be_destroy_t *destroy)
  17.117 -{
  17.118 -    domid_t       domid  = destroy->domid;
  17.119 -    unsigned int  handle = destroy->blkif_handle;
  17.120 -    blkif_t     **pblkif, *blkif;
  17.121 -
  17.122 -    DPRINTF("parallax (blkif_destroy): destroy is %p\n", destroy); 
  17.123 -    
  17.124 -    pblkif = &blkif_hash[BLKIF_HASH(domid, handle)];
  17.125 -    while ( (blkif = *pblkif) != NULL )
  17.126 -    {
  17.127 -        if ( (blkif->domid == domid) && (blkif->handle == handle) )
  17.128 -        {
  17.129 -            if ( blkif->status != DISCONNECTED )
  17.130 -                goto still_connected;
  17.131 -            goto destroy;
  17.132 -        }
  17.133 -        pblkif = &blkif->hash_next;
  17.134 -    }
  17.135 -
  17.136 -    destroy->status = BLKIF_BE_STATUS_INTERFACE_NOT_FOUND;
  17.137 -    return;
  17.138 -
  17.139 - still_connected:
  17.140 -    destroy->status = BLKIF_BE_STATUS_INTERFACE_CONNECTED;
  17.141 -    return;
  17.142 -
  17.143 - destroy:
  17.144 -    *pblkif = blkif->hash_next;
  17.145 -    free(blkif);
  17.146 -    destroy->status = BLKIF_BE_STATUS_OKAY;
  17.147 -}
  17.148 -
  17.149 -void vbd_create(blkif_be_vbd_create_t *create)
  17.150 -{
  17.151 -    blkif_t            *blkif;
  17.152 -    vdi_t              *vdi, **vdip;
  17.153 -    blkif_vdev_t        vdevice = create->vdevice;
  17.154 -
  17.155 -    DPRINTF("parallax (vbd_create): create=%p\n", create); 
  17.156 -    
  17.157 -    blkif = blkif_find_by_handle(create->domid, create->blkif_handle);
  17.158 -    if ( blkif == NULL )
  17.159 -    {
  17.160 -        DPRINTF("vbd_create attempted for non-existent blkif (%u,%u)\n", 
  17.161 -                create->domid, create->blkif_handle); 
  17.162 -        create->status = BLKIF_BE_STATUS_INTERFACE_NOT_FOUND;
  17.163 -        return;
  17.164 -    }
  17.165 -
  17.166 -    /* VDI identifier is in grow->extent.sector_start */
  17.167 -    DPRINTF("vbd_create: create->dev_handle (id) is %lx\n", 
  17.168 -            (unsigned long)create->dev_handle);
  17.169 -
  17.170 -    vdi = vdi_get(create->dev_handle);
  17.171 -    if (vdi == NULL)
  17.172 -    {
  17.173 -        printf("parallax (vbd_create): VDI %lx not found.\n",
  17.174 -               (unsigned long)create->dev_handle);
  17.175 -        create->status = BLKIF_BE_STATUS_VBD_NOT_FOUND;
  17.176 -        return;
  17.177 -    }
  17.178 -    
  17.179 -    vdi->next = NULL;
  17.180 -    vdi->vdevice = vdevice;
  17.181 -    vdip = &blkif->vdi_hash[VDI_HASH(vdevice)];
  17.182 -    while (*vdip != NULL)
  17.183 -        vdip = &(*vdip)->next;
  17.184 -    *vdip = vdi;
  17.185 -    
  17.186 -    DPRINTF("blkif_create succeeded\n"); 
  17.187 -    create->status = BLKIF_BE_STATUS_OKAY;
  17.188 -}
  17.189 -
  17.190 -void vbd_destroy(blkif_be_vbd_destroy_t *destroy)
  17.191 -{
  17.192 -    blkif_t            *blkif;
  17.193 -    vdi_t              *vdi, **vdip;
  17.194 -    blkif_vdev_t        vdevice = destroy->vdevice;
  17.195 -    
  17.196 -    blkif = blkif_find_by_handle(destroy->domid, destroy->blkif_handle);
  17.197 -    if ( blkif == NULL )
  17.198 -    {
  17.199 -        DPRINTF("vbd_destroy attempted for non-existent blkif (%u,%u)\n", 
  17.200 -                destroy->domid, destroy->blkif_handle); 
  17.201 -        destroy->status = BLKIF_BE_STATUS_INTERFACE_NOT_FOUND;
  17.202 -        return;
  17.203 -    }
  17.204 -
  17.205 -    vdip = &blkif->vdi_hash[VDI_HASH(vdevice)];
  17.206 -    while ((*vdip != NULL) && ((*vdip)->vdevice != vdevice))
  17.207 -        vdip = &(*vdip)->next;
  17.208 -
  17.209 -    if (*vdip != NULL) 
  17.210 -    {
  17.211 -        vdi = *vdip;
  17.212 -        *vdip = vdi->next;
  17.213 -        vdi_put(vdi);
  17.214 -    }
  17.215 -        
  17.216 -}
  17.217 -
  17.218 -int parallax_control(control_msg_t *msg)
  17.219 -{
  17.220 -    domid_t  domid;
  17.221 -    int      ret;
  17.222 -
  17.223 -    DPRINTF("parallax_control: msg is %p\n", msg); 
  17.224 -    
  17.225 -    if (msg->type != CMSG_BLKIF_BE) 
  17.226 -    {
  17.227 -        printf("Unexpected control message (%d)\n", msg->type);
  17.228 -        return 0;
  17.229 -    }
  17.230 -    
  17.231 -    switch(msg->subtype)
  17.232 -    {
  17.233 -    case CMSG_BLKIF_BE_CREATE:
  17.234 -        if ( msg->length != sizeof(blkif_be_create_t) )
  17.235 -            goto parse_error;
  17.236 -        blkif_create((blkif_be_create_t *)msg->msg);
  17.237 -        break;   
  17.238 -        
  17.239 -    case CMSG_BLKIF_BE_DESTROY:
  17.240 -        if ( msg->length != sizeof(blkif_be_destroy_t) )
  17.241 -            goto parse_error;
  17.242 -        blkif_destroy((blkif_be_destroy_t *)msg->msg);
  17.243 -        break;  
  17.244 -        
  17.245 -    case CMSG_BLKIF_BE_VBD_CREATE:
  17.246 -        if ( msg->length != sizeof(blkif_be_vbd_create_t) )
  17.247 -            goto parse_error;
  17.248 -        vbd_create((blkif_be_vbd_create_t *)msg->msg);
  17.249 -        break;
  17.250 -        
  17.251 -    case CMSG_BLKIF_BE_VBD_DESTROY:
  17.252 -        if ( msg->length != sizeof(blkif_be_vbd_destroy_t) )
  17.253 -            goto parse_error;
  17.254 -        vbd_destroy((blkif_be_vbd_destroy_t *)msg->msg);
  17.255 -        break;
  17.256 -
  17.257 -    case CMSG_BLKIF_BE_CONNECT:
  17.258 -    case CMSG_BLKIF_BE_DISCONNECT:
  17.259 -        /* we don't manage the device channel, the tap does. */
  17.260 -        break;
  17.261 -
  17.262 -    default:
  17.263 -        goto parse_error;
  17.264 -    }
  17.265 -    return 0;
  17.266 -parse_error:
  17.267 -    printf("Bad control message!\n");
  17.268 -    return 0;
  17.269 -    
  17.270 -}    
  17.271 -
  17.272 -int parallax_probe(blkif_request_t *req, blkif_t *blkif)
  17.273 -{
  17.274 -    blkif_response_t *rsp;
  17.275 -    vdisk_t *img_info;
  17.276 -    vdi_t *vdi;
  17.277 -    int i, nr_vdis = 0; 
  17.278 -
  17.279 -    DPRINTF("parallax_probe: req=%p, blkif=%p\n", req, blkif); 
  17.280 -
  17.281 -    /* We expect one buffer only. */
  17.282 -    if ( req->nr_segments != 1 )
  17.283 -      goto err;
  17.284 -
  17.285 -    /* Make sure the buffer is page-sized. */
  17.286 -    if ( (req->seg[0].first_sect != 0) || (req->seg[0].last_sect != 7) )
  17.287 -      goto err;
  17.288 -
  17.289 -    /* fill the list of devices */
  17.290 -    for (i=0; i<VDI_HASHSZ; i++) {
  17.291 -        vdi = blkif->vdi_hash[i];
  17.292 -        while (vdi) {
  17.293 -            img_info = (vdisk_t *)MMAP_VADDR(ID_TO_IDX(req->id), 0);
  17.294 -            img_info[nr_vdis].device   = vdi->vdevice;
  17.295 -            img_info[nr_vdis].info     = 0;
  17.296 -            /* The -1 here accounts for the LSB in the radix tree */
  17.297 -            img_info[nr_vdis].capacity = 
  17.298 -                    ((1LL << (VDI_HEIGHT-1)) * SECTS_PER_NODE);
  17.299 -            nr_vdis++;
  17.300 -            vdi = vdi->next;
  17.301 -        }
  17.302 -    }
  17.303 -
  17.304 -    
  17.305 -    rsp = (blkif_response_t *)req;
  17.306 -    rsp->id = req->id;
  17.307 -    rsp->operation = BLKIF_OP_PROBE;
  17.308 -    rsp->status = nr_vdis; /* number of disks */
  17.309 -
  17.310 -    DPRINTF("parallax_probe: send positive response (nr_vdis=%d)\n", nr_vdis);
  17.311 -    return  BLKTAP_RESPOND;
  17.312 -err:
  17.313 -    rsp = (blkif_response_t *)req;
  17.314 -    rsp->id = req->id;
  17.315 -    rsp->operation = BLKIF_OP_PROBE;
  17.316 -    rsp->status = BLKIF_RSP_ERROR;
  17.317 -    
  17.318 -    DPRINTF("parallax_probe: send error response\n"); 
  17.319 -    return BLKTAP_RESPOND;  
  17.320 -}
  17.321 -
  17.322 -typedef struct {
  17.323 -    blkif_request_t *req;
  17.324 -    int              count;
  17.325 -    int              error;
  17.326 -    pthread_mutex_t  mutex;
  17.327 -} pending_t;
  17.328 -
  17.329 -#define MAX_REQUESTS 64
  17.330 -pending_t pending_list[MAX_REQUESTS];
  17.331 -
  17.332 -struct cb_param {
  17.333 -    pending_t *pent;
  17.334 -    int       segment;
  17.335 -    uint64_t       sector; 
  17.336 -    uint64_t       vblock; /* for debug printing -- can be removed. */
  17.337 -};
  17.338 -
  17.339 -static void read_cb(struct io_ret r, void *in_param)
  17.340 -{
  17.341 -    struct cb_param *param = (struct cb_param *)in_param;
  17.342 -    pending_t *p = param->pent;
  17.343 -    int segment = param->segment;
  17.344 -    blkif_request_t *req = p->req;
  17.345 -    unsigned long size, offset, start;
  17.346 -    char *dpage, *spage;
  17.347 -	
  17.348 -    spage  = IO_BLOCK(r);
  17.349 -    if (spage == NULL) { p->error++; goto finish; }
  17.350 -    dpage  = (char *)MMAP_VADDR(ID_TO_IDX(req->id), segment);
  17.351 -    
  17.352 -    /* Calculate read size and offset within the read block. */
  17.353 -
  17.354 -    offset = (param->sector << SECTOR_SHIFT) % BLOCK_SIZE;
  17.355 -    size = (req->seg[segment].last_sect - req->seg[segment].first_sect + 1) <<
  17.356 -        SECTOR_SHIFT;
  17.357 -    start = req->seg[segment].first_sect << SECTOR_SHIFT;
  17.358 -
  17.359 -    DPRINTF("ParallaxRead: sect: %lld (%ld,%ld),  "
  17.360 -            "vblock %llx, "
  17.361 -            "size %lx\n", 
  17.362 -            param->sector,
  17.363 -            p->req->seg[segment].first_sect,
  17.364 -            p->req->seg[segment].last_sect,
  17.365 -            param->vblock, size); 
  17.366 -
  17.367 -    memcpy(dpage + start, spage + offset, size);
  17.368 -    freeblock(spage);
  17.369 -    
  17.370 -    /* Done the read.  Now update the pending record. */
  17.371 - finish:
  17.372 -    pthread_mutex_lock(&p->mutex);
  17.373 -    p->count--;
  17.374 -    
  17.375 -    if (p->count == 0) {
  17.376 -    	blkif_response_t *rsp;
  17.377 -    	
  17.378 -        rsp = (blkif_response_t *)req;
  17.379 -        rsp->id = req->id;
  17.380 -        rsp->operation = BLKIF_OP_READ;
  17.381 -    	if (p->error == 0) {
  17.382 -            rsp->status = BLKIF_RSP_OKAY;
  17.383 -    	} else {
  17.384 -            rsp->status = BLKIF_RSP_ERROR;
  17.385 -    	}
  17.386 -        blktap_inject_response(rsp);       
  17.387 -    }
  17.388 -    
  17.389 -    pthread_mutex_unlock(&p->mutex);
  17.390 -	
  17.391 -    free(param); /* TODO: replace with cached alloc/dealloc */
  17.392 -}	
  17.393 -
  17.394 -int parallax_read(blkif_request_t *req, blkif_t *blkif)
  17.395 -{
  17.396 -    blkif_response_t *rsp;
  17.397 -    uint64_t vblock, gblock;
  17.398 -    vdi_t *vdi;
  17.399 -    uint64_t sector;
  17.400 -    int i;
  17.401 -    char *dpage, *spage;
  17.402 -    pending_t *pent;
  17.403 -
  17.404 -    vdi = blkif_get_vdi(blkif, req->device);
  17.405 -    
  17.406 -    if ( vdi == NULL )
  17.407 -        goto err;
  17.408 -        
  17.409 -    pent = &pending_list[ID_TO_IDX(req->id)];
  17.410 -    pent->count = req->nr_segments;
  17.411 -    pent->req = req;
  17.412 -    pthread_mutex_init(&pent->mutex, NULL);
  17.413 -    
  17.414 -    for (i = 0; i < req->nr_segments; i++) {
  17.415 -        pthread_t tid;
  17.416 -        int ret;
  17.417 -        struct cb_param *p;
  17.418 -        
  17.419 -        /* Round the requested segment to a block address. */
  17.420 -        sector  = req->sector_number + (8*i);
  17.421 -        vblock = (sector << SECTOR_SHIFT) >> BLOCK_SHIFT;
  17.422 -        
  17.423 -        /* TODO: Replace this call to malloc with a cached allocation */
  17.424 -        p = (struct cb_param *)malloc(sizeof(struct cb_param));
  17.425 -        p->pent = pent;
  17.426 -        p->sector = sector; 
  17.427 -        p->segment = i;     
  17.428 -        p->vblock = vblock; /* dbg */
  17.429 -        
  17.430 -        /* Get that block from the store. */
  17.431 -        vdi_read(vdi, vblock, read_cb, (void *)p);    
  17.432 -    }
  17.433 -    
  17.434 -    return BLKTAP_STOLEN;
  17.435 -
  17.436 -err:
  17.437 -    rsp = (blkif_response_t *)req;
  17.438 -    rsp->id = req->id;
  17.439 -    rsp->operation = BLKIF_OP_READ;
  17.440 -    rsp->status = BLKIF_RSP_ERROR;
  17.441 -    
  17.442 -    return BLKTAP_RESPOND;  
  17.443 -}
  17.444 -
  17.445 -static void write_cb(struct io_ret r, void *in_param)
  17.446 -{
  17.447 -    struct cb_param *param = (struct cb_param *)in_param;
  17.448 -    pending_t *p = param->pent;
  17.449 -    blkif_request_t *req = p->req;
  17.450 -    
  17.451 -    /* catch errors from the block code. */
  17.452 -    if (IO_INT(r) < 0) p->error++;
  17.453 -    
  17.454 -    pthread_mutex_lock(&p->mutex);
  17.455 -    p->count--;
  17.456 -    
  17.457 -    if (p->count == 0) {
  17.458 -    	blkif_response_t *rsp;
  17.459 -    	
  17.460 -        rsp = (blkif_response_t *)req;
  17.461 -        rsp->id = req->id;
  17.462 -        rsp->operation = BLKIF_OP_WRITE;
  17.463 -    	if (p->error == 0) {
  17.464 -            rsp->status = BLKIF_RSP_OKAY;
  17.465 -    	} else {
  17.466 -            rsp->status = BLKIF_RSP_ERROR;
  17.467 -    	}
  17.468 -        blktap_inject_response(rsp);       
  17.469 -    }
  17.470 -    
  17.471 -    pthread_mutex_unlock(&p->mutex);
  17.472 -	
  17.473 -    free(param); /* TODO: replace with cached alloc/dealloc */
  17.474 -}
  17.475 -
  17.476 -int parallax_write(blkif_request_t *req, blkif_t *blkif)
  17.477 -{
  17.478 -    blkif_response_t *rsp;
  17.479 -    uint64_t sector;
  17.480 -    int i, writable = 0;
  17.481 -    uint64_t vblock, gblock;
  17.482 -    char *spage;
  17.483 -    unsigned long size, offset, start;
  17.484 -    vdi_t *vdi;
  17.485 -    pending_t *pent;
  17.486 -
  17.487 -    vdi = blkif_get_vdi(blkif, req->device);
  17.488 -    
  17.489 -    if ( vdi == NULL )
  17.490 -        goto err;
  17.491 -        
  17.492 -    pent = &pending_list[ID_TO_IDX(req->id)];
  17.493 -    pent->count = req->nr_segments;
  17.494 -    pent->req = req;
  17.495 -    pthread_mutex_init(&pent->mutex, NULL);
  17.496 -    
  17.497 -    for (i = 0; i < req->nr_segments; i++) {
  17.498 -        struct cb_param *p;
  17.499 -        
  17.500 -        spage  = (char *)MMAP_VADDR(ID_TO_IDX(req->id), i);
  17.501 -        
  17.502 -        /* Round the requested segment to a block address. */
  17.503 -        
  17.504 -        sector  = req->sector_number + (8*i);
  17.505 -        vblock = (sector << SECTOR_SHIFT) >> BLOCK_SHIFT;
  17.506 -        
  17.507 -        /* Calculate read size and offset within the read block. */
  17.508 -        
  17.509 -        offset = (sector << SECTOR_SHIFT) % BLOCK_SIZE;
  17.510 -        size = (req->seg[i].last_sect - req->seg[i].first_sect + 1) <<
  17.511 -            SECTOR_SHIFT;
  17.512 -        start = req->seg[i].first_sect << SECTOR_SHIFT;
  17.513 -
  17.514 -        DPRINTF("ParallaxWrite: sect: %lld (%ld,%ld),  "
  17.515 -                "vblock %llx, gblock %llx, "
  17.516 -                "size %lx\n", 
  17.517 -                sector, 
  17.518 -                req->seg[i].first_sect, req->seg[i].last_sect,
  17.519 -                vblock, gblock, size); 
  17.520 -      
  17.521 -        /* XXX: For now we just freak out if they try to write a   */
  17.522 -        /* non block-sized, block-aligned page.                    */
  17.523 -        
  17.524 -        if ((offset != 0) || (size != BLOCK_SIZE) || (start != 0)) {
  17.525 -            printf("]\n] STRANGE WRITE!\n]\n");
  17.526 -            goto err;
  17.527 -        }
  17.528 -        
  17.529 -        /* TODO: Replace this call to malloc with a cached allocation */
  17.530 -        p = (struct cb_param *)malloc(sizeof(struct cb_param));
  17.531 -        p->pent = pent;
  17.532 -        p->sector = sector; 
  17.533 -        p->segment = i;     
  17.534 -        p->vblock = vblock; /* dbg */
  17.535 -        
  17.536 -        /* Issue the write to the store. */
  17.537 -        vdi_write(vdi, vblock, spage, write_cb, (void *)p);
  17.538 -    }
  17.539 -
  17.540 -    return BLKTAP_STOLEN;
  17.541 -
  17.542 -err:
  17.543 -    rsp = (blkif_response_t *)req;
  17.544 -    rsp->id = req->id;
  17.545 -    rsp->operation = BLKIF_OP_WRITE;
  17.546 -    rsp->status = BLKIF_RSP_ERROR;
  17.547 -    
  17.548 -    return BLKTAP_RESPOND;  
  17.549 -}
  17.550 -
  17.551 -int parallax_request(blkif_request_t *req)
  17.552 -{
  17.553 -    blkif_response_t *rsp;
  17.554 -    domid_t  dom   = ID_TO_DOM(req->id);
  17.555 -    blkif_t *blkif = blkif_find_by_handle(dom, 0);
  17.556 -    
  17.557 -    if (blkif == NULL)
  17.558 -        goto err;
  17.559 -    
  17.560 -    if ( req->operation == BLKIF_OP_PROBE ) {
  17.561 -        
  17.562 -        return parallax_probe(req, blkif);
  17.563 -        
  17.564 -    } else if ( req->operation == BLKIF_OP_READ ) {
  17.565 -        
  17.566 -        return parallax_read(req, blkif);
  17.567 -        
  17.568 -    } else if ( req->operation == BLKIF_OP_WRITE ) {
  17.569 -        
  17.570 -        return parallax_write(req, blkif);
  17.571 -        
  17.572 -    } else {
  17.573 -        printf("Unknown request message type!\n");
  17.574 -        /* Unknown operation */
  17.575 -        goto err;
  17.576 -    }
  17.577 -    
  17.578 -err:
  17.579 -    rsp = (blkif_response_t *)req;
  17.580 -    rsp->operation = req->operation;
  17.581 -    rsp->id = req->id;
  17.582 -    rsp->status = BLKIF_RSP_ERROR;
  17.583 -    return BLKTAP_RESPOND;  
  17.584 -}
  17.585 -
  17.586 -void __init_parallax(void) 
  17.587 -{
  17.588 -    memset(blkif_hash, 0, sizeof(blkif_hash));
  17.589 -}
  17.590 -
  17.591 -
  17.592 -
  17.593 -int main(int argc, char *argv[])
  17.594 -{
  17.595 -    DPRINTF("parallax: starting.\n"); 
  17.596 -    __init_blockstore();
  17.597 -    DPRINTF("parallax: initialized blockstore...\n"); 
  17.598 -    init_block_async();
  17.599 -    DPRINTF("parallax: initialized async blocks...\n"); 
  17.600 -    __init_vdi();
  17.601 -    DPRINTF("parallax: initialized vdi registry etc...\n"); 
  17.602 -    __init_parallax();
  17.603 -    DPRINTF("parallax: initialized local stuff..\n"); 
  17.604 -
  17.605 -    blktap_register_ctrl_hook("parallax_control", parallax_control);
  17.606 -    blktap_register_request_hook("parallax_request", parallax_request);
  17.607 -    DPRINTF("parallax: added ctrl + request hooks, starting listen...\n"); 
  17.608 -    blktap_listen();
  17.609 -    
  17.610 -    return 0;
  17.611 -}