+++ /dev/null
-Most files in this directory are covered by a BSD-3-Clause
-license as stated in the text below, unless explicitly otherwise
-stated.
-
-New contributions to existing files in this directory are
-governed by the license that applies to the relevant specific
-file. New contributions to the files listed in [1] are to be
-taken under a BSD-3-Clause license. We believe that most
-(if not all) of the existing copyright holders intended
-to make their contribution under BSD-3 even for the files
-with no copyright headers. But this has not been verified.
-
-New files are to be taken under BSD-3-Clause, unless otherwise
-explicitly stated in the copyright header.
-
-If you want to deal in this code you may do so under GPLv2,
-at least.
-
-Files without (c) headers
-=========================
-The following source files did not have a (c) notice at the
-time this COPYING notice was added to the source tree:
-
-[1]
-./drivers/aes.h
-./drivers/blk_linux.c
-./drivers/blk_netbsd.c
-./drivers/block-remus.c
-./drivers/bswap.h
-./drivers/check_gcrypt
-./drivers/md5.h
-./drivers/xmsnap
-./include/list.h
-
-QCOW files
-==========
-The following files are dually licensed under an MIT and GPLv2
-license
-
-[2]
-./drivers/img2qcow.c
-./drivers/qcow2raw.c
-./drivers/qcow-create.c
-
-=====================================================================
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-
-1. Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright
- notice, this list of conditions and the following disclaimer in the
- documentation and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder Inc. nor the names of its
- contributors may be used to endorse or promote products derived
- from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+++ /dev/null
-XEN_ROOT = $(CURDIR)/../..
-include $(XEN_ROOT)/tools/Rules.mk
-
-CFLAGS += $(CFLAGS_libxenctrl)
-LDLIBS += $(LDLIBS_libxenctrl)
-
-SUBDIRS-y :=
-SUBDIRS-y += include
-SUBDIRS-y += lvm
-SUBDIRS-y += vhd
-SUBDIRS-$(CONFIG_Linux) += drivers
-SUBDIRS-$(CONFIG_Linux) += control
-
-clean:
- rm -rf *.a *.so *.o *.rpm $(LIB) *~ $(DEPS_RM) TAGS
-
-distclean: clean
-
-.PHONY: all clean install distclean uninstall
-all clean install distclean uninstall: %: subdirs-%
+++ /dev/null
-Blktap2 Userspace Tools + Library
-================================
-
-Dutch Meyer
-4th June 2009
-
-Andrew Warfield and Julian Chesterfield
-16th June 2006
-
-
-The blktap2 userspace toolkit provides a user-level disk I/O
-interface. The blktap2 mechanism involves a kernel driver that acts
-similarly to the existing Xen/Linux blkback driver, and a set of
-associated user-level libraries. Using these tools, blktap2 allows
-virtual block devices presented to VMs to be implemented in userspace
-and to be backed by raw partitions, files, network, etc.
-
-The key benefit of blktap2 is that it makes it easy and fast to write
-arbitrary block backends, and that these user-level backends actually
-perform very well. Specifically:
-
-- Metadata disk formats such as Copy-on-Write, encrypted disks, sparse
- formats and other compression features can be easily implemented.
-
-- Accessing file-based images from userspace avoids problems related
- to flushing dirty pages which are present in the Linux loopback
- driver. (Specifically, doing a large number of writes to an
- NFS-backed image don't result in the OOM killer going berserk.)
-
-- Per-disk handler processes enable easier userspace policing of block
- resources, and process-granularity QoS techniques (disk scheduling
- and related tools) may be trivially applied to block devices.
-
-- It's very easy to take advantage of userspace facilities such as
- networking libraries, compression utilities, peer-to-peer
- file-sharing systems and so on to build more complex block backends.
-
-- Crashes are contained -- incremental development/debugging is very
- fast.
-
-How it works (in one paragraph):
-
-Working in conjunction with the kernel blktap2 driver, all disk I/O
-requests from VMs are passed to the userspace deamon (using a shared
-memory interface) through a character device. Each active disk is
-mapped to an individual device node, allowing per-disk processes to
-implement individual block devices where desired. The userspace
-drivers are implemented using asynchronous (Linux libaio),
-O_DIRECT-based calls to preserve the unbuffered, batched and
-asynchronous request dispatch achieved with the existing blkback
-code. We provide a simple, asynchronous virtual disk interface that
-makes it quite easy to add new disk implementations.
-
-As of June 2009 the current supported disk formats are:
-
- - Raw Images (both on partitions and in image files)
- - Fast sharable RAM disk between VMs (requires some form of
- cluster-based filesystem support e.g. OCFS2 in the guest kernel)
- - VHD, including snapshots and sparse images
- - Qcow, including snapshots and sparse images
-
-
-Build and Installation Instructions
-===================================
-
-Make to configure the blktap2 backend driver in your dom0 kernel. It
-will inter-operate with the existing backend and frontend drivers. It
-will also cohabitate with the original blktap driver. However, some
-formats (currently aio and qcow) will default to their blktap2
-versions when specified in a vm configuration file.
-
-To build the tools separately, "make && make install" in
-tools/blktap2.
-
-
-Using the Tools
-===============
-
-Preparing an image for boot:
-
-The userspace disk agent is configured to start automatically via xend
-
-Customize the VM config file to use the 'tap:tapdisk' handler,
-followed by the driver type. e.g. for a raw image such as a file or
-partition:
-
-disk = ['tap:tapdisk:aio:<FILENAME>,sda1,w']
-
-Alternatively, the vhd-util tool (installed with make install, or in
-/blktap2/vhd) can be used to build sparse copy-on-write vhd images.
-
-For example, to build a sparse image -
- vhd-util create -n MyVHDFile -s 1024
-
-This creates a sparse 1GB file named "MyVHDFile" that can be mounted
-and populated with data.
-
-One can also base the image on a raw file -
- vhd-util snapshot -n MyVHDFile -p SomeRawFile -m
-
-This creates a sparse VHD file named "MyVHDFile" using "SomeRawFile"
-as a parent image. Copy-on-write semantics ensure that writes will be
-stored in "MyVHDFile" while reads will be directed to the most
-recently written version of the data, either in "MyVHDFile" or
-"SomeRawFile" as is appropriate. Other options exist as well, consult
-the vhd-util application for the complete set of VHD tools.
-
-VHD files can be mounted automatically in a guest similarly to the
-above AIO example simply by specifying the vhd driver.
-
-disk = ['tap:tapdisk:vhd:<VHD FILENAME>,sda1,w']
-
-
-Snapshots:
-
-Pausing a guest will also plug the corresponding IO queue for blktap2
-devices and stop blktap2 drivers. This can be used to implement a
-safe live snapshot of qcow and vhd disks. An example script "xmsnap"
-is shown in the tools/blktap2/drivers directory. This script will
-perform a live snapshot of a qcow disk. VHD files can use the
-"vhd-util snapshot" tool discussed above. If this snapshot command is
-applied to a raw file mounted with tap:tapdisk:AIO, include the -m
-flag and the driver will be reloaded as VHD. If applied to an already
-mounted VHD file, omit the -m flag.
-
-
-Mounting images in Dom0 using the blktap2 driver
-===============================================
-Tap (and blkback) disks are also mountable in Dom0 without requiring an
-active VM to attach.
-
-The syntax is -
- tapdisk2 -n <type>:<full path to file>
-
-For example -
- tapdisk2 -n aio:/home/images/rawFile.img
-
-When successful the location of the new device will be provided by
-tapdisk2 to stdout and tapdisk2 will terminate. From that point
-forward control of the device is provided through sysfs in the
-directory-
-
- /sys/class/blktap2/blktap#/
-
-Where # is a blktap2 device number present in the path that tapdisk2
-printed before terminating. The sysfs interface is largely intuitive,
-for example, to remove tap device 0 one would-
-
- echo 1 > /sys/class/blktap2/blktap0/remove
-
-Similarly, a pause control is available, which is can be used to plug
-the request queue of a live running guest.
-
-Previous versions of blktap mounted devices in dom0 by using blkfront
-in dom0 and the xm block-attach command. This approach is still
-available, though slightly more cumbersome.
-
-
-Tapdisk Development
-===============================================
-
-People regularly ask how to develop their own tapdisk drivers, and
-while it has not yet been well documented, the process is relatively
-easy. Here I will provide a brief overview. The best reference, of
-course, comes from the existing drivers. Specifically,
-blktap2/drivers/block-ram.c and blktap2/drivers/block-aio.c provide
-the clearest examples of simple drivers.
-
-
-Setup:
-
-First you need to register your new driver with blktap. This is done
-in disktypes.h. There are five things that you must do. To
-demonstrate, I will create a disk called "mynewdisk", you can name
-yours freely.
-
-1) Forward declare an instance of struct tap_disk.
-
-e.g. -
- extern struct tap_disk tapdisk_mynewdisk;
-
-2) Claim one of the unused disk type numbers, take care to observe the
-MAX_DISK_TYPES macro, increasing the number if necessary.
-
-e.g. -
- #define DISK_TYPE_MYNEWDISK 10
-
-3) Create an instance of disk_info_t. The bulk of this file contains examples of these.
-
-e.g. -
- static disk_info_t mynewdisk_disk = {
- DISK_TYPE_MYNEWDISK,
- "My New Disk (mynewdisk)",
- "mynewdisk",
- 0,
- #ifdef TAPDISK
- &tapdisk_mynewdisk,
- #endif
- };
-
-A few words about what these mean. The first field must be the disk
-type number you claimed in step (2). The second field is a string
-describing your disk, and may contain any relevant info. The third
-field is the name of your disk as will be used by the tapdisk2 utility
-and xend (for example tapdisk2 -n mynewdisk:/path/to/disk.image, or in
-your xm create config file). The forth is binary and determines
-whether you will have one instance of your driver, or many. Here, a 1
-means that your driver is a singleton and will coordinate access to
-any number of tap devices. 0 is more common, meaning that you will
-have one driver for each device that is created. The final field
-should contain a reference to the struct tap_disk you created in step
-(1).
-
-4) Add a reference to your disk info structure (from step (3)) to the
-dtypes array. Take care here - you need to place it in the position
-corresponding to the device type number you claimed in step (2). So
-we would place &mynewdisk_disk in dtypes[10]. Look at the other
-devices in this array and pad with "&null_disk," as necessary.
-
-5) Modify the xend python scripts. You need to add your disk name to
-the list of disks that xend recognizes.
-
-edit:
- tools/python/xen/xend/server/BlktapController.py
-
-And add your disk to the "blktap_disk_types" array near the top of
-your file. Use the same name you specified in the third field of step
-(3). The order of this list is not important.
-
-
-Now your driver is ready to be written. Create a block-mynewdisk.c in
-tools/blktap2/drivers and add it to the Makefile.
-
-
-Development:
-
-Copying block-aio.c and block-ram.c would be a good place to start.
-Read those files as you go through this, I will be assisting by
-commenting on a few useful functions and structures.
-
-struct tap_disk:
-
-Remember the forward declaration in step (1) of the setup phase above?
-Now is the time to make that structure a reality. This structure
-contains a list of function pointers for all the routines that will be
-asked of your driver. Currently the required functions are open,
-close, read, write, get_parent_id, validate_parent, and debug.
-
-e.g. -
- struct tap_disk tapdisk_mynewdisk = {
- .disk_type = "tapdisk_mynewdisk",
- .flags = 0,
- .private_data_size = sizeof(struct tdmynewdisk_state),
- .td_open = tdmynewdisk_open,
- ....
-
-The private_data_size field is used to provide a structure to store
-the state of your device. It is very likely that you will want
-something here, but you are free to design whatever structure you
-want. Blktap will allocate this space for you, you just need to tell
-it how much space you want.
-
-
-tdmynewdisk_open:
-
-This is the open routine. The first argument is a structure
-representing your driver. Two fields in this array are
-interesting.
-
-driver->data will contain a block of memory of the size your requested
-in in the .private_data_size field of your struct tap_disk (above).
-
-driver->info contains a structure that details information about your
-disk. You need to fill this out. By convention this is done with a
-_get_image_info() function. Assign a size (the total number of
-sectors), sector_size (the size of each sector in bytes, and set
-driver->info->info to 0.
-
-The second parameter contains the name that was specified in the
-creation of your device, either through xend, or on the command line
-with tapdisk2. Usually this specifies a file that you will open in
-this routine. The final parameter, flags, contains one of a number of
-flags specified in tapdisk.h that may change the way you treat the
-disk.
-
-
-_queue_read/write:
-
-These are your read and write operations. What you do here will
-depend on your disk, but you should do exactly one of-
-
-1) call td_complete_request with either error or success code.
-
-2) Call td_forward_request, which will forward the request to the next
-driver in the stack.
-
-3) Queue the request for asynchronous processing with
-td_prep_read/write. In doing so, you will also register a callback
-for request completion. When the request completes you must do one of
-options (1) or (2) above. Finally, call td_queue_tiocb to submit the
-request to a wait queue.
-
-The above functions are defined in tapdisk-interface.c. If you don't
-use them as specified you will run into problems as your driver will
-fail to inform blktap of the state of requests that have been
-submitted. Blktap keeps track of all requests and does not like losing track.
-
-
-_close, _get_parent_id, _validate_parent:
-
-These last few tend to be very routine. _close is called when the
-device is closed, and also when it is paused (in this case, open will
-also be called later). The other functions are used in stacking
-drivers. Most often drivers will return TD_NO_PARENT and -EINVAL,
-respectively.
-
-
-
-
-
-
+++ /dev/null
-XEN_ROOT := $(CURDIR)/../../../
-include $(XEN_ROOT)/tools/Rules.mk
-
-MAJOR = 1.0
-MINOR = 0
-LIBNAME = libblktapctl
-LIBSONAME = $(LIBNAME).so.$(MAJOR)
-
-IBIN = tap-ctl
-
-CFLAGS += -Werror
-CFLAGS += -Wno-unused
-CFLAGS += -I../include -I../drivers
-CFLAGS += $(CFLAGS_xeninclude)
-CFLAGS += $(CFLAGS_libxenctrl)
-CFLAGS += -D_GNU_SOURCE
-CFLAGS += -DTAPCTL
-
-CTL_OBJS := tap-ctl-ipc.o
-CTL_OBJS += tap-ctl-list.o
-CTL_OBJS += tap-ctl-allocate.o
-CTL_OBJS += tap-ctl-free.o
-CTL_OBJS += tap-ctl-create.o
-CTL_OBJS += tap-ctl-destroy.o
-CTL_OBJS += tap-ctl-spawn.o
-CTL_OBJS += tap-ctl-attach.o
-CTL_OBJS += tap-ctl-detach.o
-CTL_OBJS += tap-ctl-open.o
-CTL_OBJS += tap-ctl-close.o
-CTL_OBJS += tap-ctl-pause.o
-CTL_OBJS += tap-ctl-unpause.o
-CTL_OBJS += tap-ctl-major.o
-CTL_OBJS += tap-ctl-check.o
-
-CTL_PICS = $(patsubst %.o,%.opic,$(CTL_OBJS))
-
-OBJS = $(CTL_OBJS) tap-ctl.o
-PICS = $(CTL_PICS)
-
-LIB_STATIC = $(LIBNAME).a
-LIB_SHARED = $(LIBSONAME).$(MINOR)
-IBIN = tap-ctl
-
-PKG_CONFIG := xenblktapctl.pc
-PKG_CONFIG_VERSION := $(MAJOR).$(MINOR)
-
-ifneq ($(CONFIG_LIBXC_MINIOS),y)
-PKG_CONFIG_INST := $(PKG_CONFIG)
-$(PKG_CONFIG_INST): PKG_CONFIG_PREFIX = $(prefix)
-$(PKG_CONFIG_INST): PKG_CONFIG_INCDIR = $(includedir)
-$(PKG_CONFIG_INST): PKG_CONFIG_LIBDIR = $(libdir)
-endif
-
-PKG_CONFIG_LOCAL := $(foreach pc,$(PKG_CONFIG),$(PKG_CONFIG_DIR)/$(pc))
-
-$(PKG_CONFIG_LOCAL): PKG_CONFIG_PREFIX = $(XEN_ROOT)
-$(PKG_CONFIG_LOCAL): PKG_CONFIG_INCDIR = $(XEN_BLKTAP2)/include
-$(PKG_CONFIG_LOCAL): PKG_CONFIG_LIBDIR = $(CURDIR)
-$(PKG_CONFIG_LOCAL): PKG_CONFIG_CFLAGS_LOCAL = $(CFLAGS_xeninclude) $(CFLAGS_libxenctrl)
-
-all: build
-
-build: $(IBIN) $(LIB_STATIC) $(LIB_SHARED) $(PKG_CONFIG_INST) $(PKG_CONFIG_LOCAL)
-
-$(LIBNAME).so: $(LIBSONAME)
- ln -sf $< $@
-
-$(LIBSONAME): $(LIB_SHARED)
- ln -sf $< $@
-
-tap-ctl: tap-ctl.o $(LIBNAME).so
- $(CC) $(LDFLAGS) -o $@ $^ $(APPEND_LDFLAGS)
-
-$(LIB_STATIC): $(CTL_OBJS)
- $(AR) r $@ $^
-
-$(LIB_SHARED): $(CTL_PICS)
- $(CC) $(LDFLAGS) -fPIC -Wl,$(SONAME_LDFLAG) -Wl,$(LIBSONAME) $(SHLIB_LDFLAGS) -rdynamic $^ -o $@ $(APPEND_LDFLAGS)
-
-install: build
- $(INSTALL_DIR) -p $(DESTDIR)$(sbindir)
- $(INSTALL_PROG) $(IBIN) $(DESTDIR)$(sbindir)
- $(INSTALL_DATA) $(LIB_STATIC) $(DESTDIR)$(libdir)
- $(INSTALL_PROG) $(LIB_SHARED) $(DESTDIR)$(libdir)
- ln -sf $(LIBSONAME) $(DESTDIR)$(libdir)/$(LIBNAME).so
- ln -sf $(LIB_SHARED) $(DESTDIR)$(libdir)/$(LIBSONAME)
- $(INSTALL_DATA) xenblktapctl.pc $(DESTDIR)$(PKG_INSTALLDIR)
-
-clean:
- rm -f $(OBJS) $(PICS) $(DEPS_RM) $(IBIN) $(LIB_STATIC) $(LIB_SHARED)
- rm -f $(LIBNAME).so $(LIBSONAME)
- rm -f *~
- rm -f xenblktapctl.pc
-
-uninstall:
- rm -f $(DESTDIR)$(PKG_INSTALLDIR)/xenblktapctl.pc
- rm -f $(DESTDIR)$(libdir)/$(LIBSONAME)
- rm -f $(DESTDIR)$(libdir)/$(LIBNAME).so
- rm -f $(addprefix $(DESTDIR)$(libdir)/, $(LIB_SHARED))
- rm -f $(addprefix $(DESTDIR)$(libdir)/, $(LIB_STATIC))
- rm -f $(addprefix $(DESTDIR)$(sbindir)/, $(IBIN))
-
-distclean: clean
-
-.PHONY: all build clean distclean install uninstall
-
--include $(DEPS_INCLUDE)
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include <stdio.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <getopt.h>
-#include <libgen.h>
-#include <sys/sysmacros.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <sys/ioctl.h>
-#include <linux/major.h>
-
-#include "tap-ctl.h"
-#include "blktap2.h"
-
-static int
-tap_ctl_prepare_directory(const char *dir)
-{
- int err;
- char *ptr, *name, *start;
-
- err = access(dir, W_OK | R_OK);
- if (!err)
- return 0;
-
- name = strdup(dir);
- if (!name)
- return ENOMEM;
-
- start = name;
-
- for (;;) {
- ptr = strchr(start + 1, '/');
- if (ptr)
- *ptr = '\0';
-
- err = mkdir(name, 0755);
- if (err && errno != EEXIST) {
- PERROR("mkdir %s", name);
- err = errno;
- break;
- }
-
- if (!ptr)
- break;
- else {
- *ptr = '/';
- start = ptr + 1;
- }
- }
-
- free(name);
- return err;
-}
-
-static int
-tap_ctl_make_device(const char *devname, const int major,
- const int minor, const int perm)
-{
- int err;
- char *copy, *dir;
-
- copy = strdup(devname);
- if (!copy)
- return ENOMEM;
-
- dir = dirname(copy);
-
- err = tap_ctl_prepare_directory(dir);
- free(copy);
-
- if (err)
- return err;
-
- if (!access(devname, F_OK))
- if (unlink(devname)) {
- PERROR("unlink %s", devname);
- return errno;
- }
-
- err = mknod(devname, perm, makedev(major, minor));
- if (err) {
- PERROR("mknod %s", devname);
- return errno;
- }
-
- return 0;
-}
-
-static int
-tap_ctl_check_environment(void)
-{
- FILE *f;
- int err, minor;
- char name[256];
-
- err = tap_ctl_prepare_directory(BLKTAP2_CONTROL_DIR);
- if (err)
- return err;
-
- if (!access(BLKTAP2_CONTROL_DEVICE, R_OK | W_OK))
- return 0;
-
- memset(name, 0, sizeof(name));
-
- f = fopen("/proc/misc", "r");
- if (!f) {
- EPRINTF("failed to open /proc/misc: %d\n", errno);
- return errno;
- }
-
- while (fscanf(f, "%d %256s", &minor, name) == 2)
- if (!strcmp(name, BLKTAP2_CONTROL_NAME)) {
- err = tap_ctl_make_device(BLKTAP2_CONTROL_DEVICE,
- MISC_MAJOR,
- minor, S_IFCHR | 0600);
- goto out;
- }
-
- err = ENOSYS;
- EPRINTF("didn't find %s in /proc/misc\n", BLKTAP2_CONTROL_NAME);
-
-out:
- fclose(f);
- return err;
-}
-
-static int
-tap_ctl_allocate_device(int *minor, char **devname)
-{
- char *name;
- int fd, err;
- struct blktap2_handle handle;
-
- *minor = -1;
- if (!devname)
- return EINVAL;
-
- fd = open(BLKTAP2_CONTROL_DEVICE, O_RDONLY);
- if (fd == -1) {
- EPRINTF("failed to open control device: %d\n", errno);
- return errno;
- }
-
- err = ioctl(fd, BLKTAP2_IOCTL_ALLOC_TAP, &handle);
- close(fd);
- if (err == -1) {
- EPRINTF("failed to allocate new device: %d\n", errno);
- return errno;
- }
-
- err = asprintf(&name, "%s%d", BLKTAP2_RING_DEVICE, handle.minor);
- if (err == -1) {
- err = ENOMEM;
- goto fail;
- }
-
- err = tap_ctl_make_device(name, handle.ring,
- handle.minor, S_IFCHR | 0600);
- free(name);
- if (err) {
- EPRINTF("creating ring device for %d failed: %d\n",
- handle.minor, err);
- goto fail;
- }
-
- if (*devname)
- name = *devname;
- else {
- err = asprintf(&name, "%s%d",
- BLKTAP2_IO_DEVICE, handle.minor);
- if (err == -1) {
- err = ENOMEM;
- goto fail;
- }
- *devname = name;
- }
-
- err = tap_ctl_make_device(name, handle.device,
- handle.minor, S_IFBLK | 0600);
- if (err) {
- EPRINTF("creating IO device for %d failed: %d\n",
- handle.minor, err);
- goto fail;
- }
-
- DBG("new interface: ring: %u, device: %u, minor: %u\n",
- handle.ring, handle.device, handle.minor);
-
- *minor = handle.minor;
- return 0;
-
-fail:
- tap_ctl_free(handle.minor);
- return err;
-}
-
-int
-tap_ctl_allocate(int *minor, char **devname)
-{
- int err;
-
- *minor = -1;
-
- err = tap_ctl_check_environment();
- if (err)
- return err;
-
- err = tap_ctl_allocate_device(minor, devname);
- if (err)
- return err;
-
- return 0;
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include <stdio.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <string.h>
-#include <getopt.h>
-
-#include "tap-ctl.h"
-
-int
-tap_ctl_attach(const int id, const int minor)
-{
- int err;
- tapdisk_message_t message;
-
- memset(&message, 0, sizeof(message));
- message.type = TAPDISK_MESSAGE_ATTACH;
- message.cookie = minor;
-
- err = tap_ctl_connect_send_and_receive(id, &message, 5);
- if (err)
- return err;
-
- if (message.type == TAPDISK_MESSAGE_ATTACH_RSP) {
- err = message.u.response.error;
- if (err)
- EPRINTF("attach failed: %d\n", err);
- } else {
- EPRINTF("got unexpected result '%s' from %d\n",
- tapdisk_message_name(message.type), id);
- err = EINVAL;
- }
-
- return err;
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include <stdio.h>
-#include <errno.h>
-#include <unistd.h>
-#include <string.h>
-
-#include "tap-ctl.h"
-#include "blktap2.h"
-
-int
-tap_ctl_check_blktap(const char **msg)
-{
- FILE *f;
- int err = 0, minor;
- char name[32];
-
- memset(name, 0, sizeof(name));
-
- f = fopen("/proc/misc", "r");
- if (!f) {
- *msg = "failed to open /proc/misc";
- return -errno;
- }
-
- while (fscanf(f, "%d %32s", &minor, name) == 2) {
- if (!strcmp(name, BLKTAP2_CONTROL_NAME))
- goto out;
- }
-
- err = -ENOSYS;
- *msg = "blktap kernel module not installed";
-
-out:
- fclose(f);
- return err;
-}
-
-int
-tap_ctl_check(const char **msg)
-{
- int err;
- uid_t uid;
-
- err = tap_ctl_check_blktap(msg);
- if (err)
- goto out;
-
- err = 0;
- *msg = "ok";
-
-out:
- return err;
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include <stdio.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <getopt.h>
-
-#include "tap-ctl.h"
-
-static int
-__tap_ctl_close(const int id, const int minor, const int force)
-{
- int err;
- tapdisk_message_t message;
-
- memset(&message, 0, sizeof(message));
- message.type = TAPDISK_MESSAGE_CLOSE;
- if (force)
- message.type = TAPDISK_MESSAGE_FORCE_SHUTDOWN;
- message.cookie = minor;
-
- err = tap_ctl_connect_send_and_receive(id, &message, 5);
- if (err)
- return err;
-
- if (message.type == TAPDISK_MESSAGE_CLOSE_RSP) {
- err = message.u.response.error;
- if (err)
- EPRINTF("close failed: %d\n", err);
- } else {
- EPRINTF("got unexpected result '%s' from %d\n",
- tapdisk_message_name(message.type), id);
- err = EINVAL;
- }
-
- return err;
-}
-
-int
-tap_ctl_close(const int id, const int minor, const int force)
-{
- int i, err;
-
- for (i = 0; i < 20; i++) {
- err = __tap_ctl_close(id, minor, force);
- if (!err)
- return 0;
-
- err = (err < 0 ? -err : err);
- if (err != EAGAIN) {
- EPRINTF("close failed: %d\n", err);
- return err;
- }
-
- usleep(1000);
- }
-
- EPRINTF("close timed out\n");
- return EIO;
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include <stdio.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <getopt.h>
-
-#include "tap-ctl.h"
-#include "blktap2.h"
-
-int
-tap_ctl_create(const char *params, char **devname)
-{
- int err, id, minor;
-
- err = tap_ctl_allocate(&minor, devname);
- if (err)
- return err;
-
- id = tap_ctl_spawn();
- if (id < 0) {
- err = id;
- goto destroy;
- }
-
- err = tap_ctl_attach(id, minor);
- if (err)
- goto destroy;
-
- err = tap_ctl_open(id, minor, params);
- if (err)
- goto detach;
-
- return 0;
-
-detach:
- tap_ctl_detach(id, minor);
-destroy:
- tap_ctl_free(minor);
- return err;
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include <stdio.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <getopt.h>
-
-#include "tap-ctl.h"
-#include "blktap2.h"
-
-int
-tap_ctl_destroy(const int id, const int minor)
-{
- int err;
-
- err = tap_ctl_close(id, minor, 0);
- if (err)
- return err;
-
- err = tap_ctl_detach(id, minor);
- if (err)
- return err;
-
- err = tap_ctl_free(minor);
- if (err)
- return err;
-
- return 0;
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include <stdio.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <string.h>
-#include <getopt.h>
-
-#include "tap-ctl.h"
-
-int
-tap_ctl_detach(const int id, const int minor)
-{
- int err;
- tapdisk_message_t message;
-
- memset(&message, 0, sizeof(message));
- message.type = TAPDISK_MESSAGE_DETACH;
- message.cookie = minor;
-
- err = tap_ctl_connect_send_and_receive(id, &message, 5);
- if (err)
- return err;
-
- if (message.type == TAPDISK_MESSAGE_DETACH_RSP) {
- err = message.u.response.error;
- if (err < 0)
- printf("detach failed: %d\n", err);
- } else {
- printf("got unexpected result '%s' from %d\n",
- tapdisk_message_name(message.type), id);
- err = EINVAL;
- }
-
- return err;
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include <stdio.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <getopt.h>
-#include <sys/ioctl.h>
-
-#include "tap-ctl.h"
-#include "blktap2.h"
-
-int
-tap_ctl_free(const int minor)
-{
- int fd, err;
-
- fd = open(BLKTAP2_CONTROL_DEVICE, O_RDONLY);
- if (fd == -1) {
- EPRINTF("failed to open control device: %d\n", errno);
- return errno;
- }
-
- err = ioctl(fd, BLKTAP2_IOCTL_FREE_TAP, minor);
- close(fd);
-
- return err;
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include <stdio.h>
-#include <errno.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/un.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-
-#include "tap-ctl.h"
-#include "blktap2.h"
-
-int tap_ctl_debug = 0;
-
-int
-tap_ctl_read_message(int fd, tapdisk_message_t *message, int timeout)
-{
- fd_set readfds;
- int ret, len, offset;
- struct timeval tv, *t;
-
- t = NULL;
- offset = 0;
- len = sizeof(tapdisk_message_t);
-
- if (timeout) {
- tv.tv_sec = timeout;
- tv.tv_usec = 0;
- t = &tv;
- }
-
- memset(message, 0, sizeof(tapdisk_message_t));
-
- while (offset < len) {
- FD_ZERO(&readfds);
- FD_SET(fd, &readfds);
-
- ret = select(fd + 1, &readfds, NULL, NULL, t);
- if (ret == -1) {
- if (errno == EINTR)
- continue;
- break;
- }
- else if (FD_ISSET(fd, &readfds)) {
- ret = read(fd, message + offset, len - offset);
- if (ret <= 0) {
- if (errno == EINTR)
- continue;
- break;
- }
- offset += ret;
- } else
- break;
- }
-
- if (offset != len) {
- EPRINTF("failure reading message\n");
- return -EIO;
- }
-
- DBG("received '%s' message (uuid = %u)\n",
- tapdisk_message_name(message->type), message->cookie);
-
- return 0;
-}
-
-int
-tap_ctl_write_message(int fd, tapdisk_message_t *message, int timeout)
-{
- fd_set writefds;
- int ret, len, offset;
- struct timeval tv, *t;
-
- t = NULL;
- offset = 0;
- len = sizeof(tapdisk_message_t);
-
- if (timeout) {
- tv.tv_sec = timeout;
- tv.tv_usec = 0;
- t = &tv;
- }
-
- DBG("sending '%s' message (uuid = %u)\n",
- tapdisk_message_name(message->type), message->cookie);
-
- while (offset < len) {
- FD_ZERO(&writefds);
- FD_SET(fd, &writefds);
-
- /* we don't bother reinitializing tv. at worst, it will wait a
- * bit more time than expected. */
-
- ret = select(fd + 1, NULL, &writefds, NULL, t);
- if (ret == -1) {
- if (errno == EINTR)
- continue;
- break;
- }
- else if (FD_ISSET(fd, &writefds)) {
- ret = write(fd, message + offset, len - offset);
- if (ret <= 0) {
- if (errno == EINTR)
- continue;
- break;
- }
- offset += ret;
- } else
- break;
- }
-
- if (offset != len) {
- EPRINTF("failure writing message\n");
- return -EIO;
- }
-
- return 0;
-}
-
-int
-tap_ctl_send_and_receive(int sfd, tapdisk_message_t *message, int timeout)
-{
- int err;
-
- err = tap_ctl_write_message(sfd, message, timeout);
- if (err) {
- EPRINTF("failed to send '%s' message\n",
- tapdisk_message_name(message->type));
- return err;
- }
-
- err = tap_ctl_read_message(sfd, message, timeout);
- if (err) {
- EPRINTF("failed to receive '%s' message\n",
- tapdisk_message_name(message->type));
- return err;
- }
-
- return 0;
-}
-
-char *
-tap_ctl_socket_name(int id)
-{
- char *name;
-
- if (asprintf(&name, "%s/%s%d",
- BLKTAP2_CONTROL_DIR, BLKTAP2_CONTROL_SOCKET, id) == -1)
- return NULL;
-
- return name;
-}
-
-int
-tap_ctl_connect(const char *name, int *sfd)
-{
- int fd, err;
- struct sockaddr_un saddr;
-
- *sfd = -1;
-
- fd = socket(AF_UNIX, SOCK_STREAM, 0);
- if (fd == -1) {
- EPRINTF("couldn't create socket for %s: %d\n", name, errno);
- return -errno;
- }
-
- memset(&saddr, 0, sizeof(saddr));
- saddr.sun_family = AF_UNIX;
- strcpy(saddr.sun_path, name);
-
- err = connect(fd, (const struct sockaddr *)&saddr, sizeof(saddr));
- if (err) {
- EPRINTF("couldn't connect to %s: %d\n", name, errno);
- close(fd);
- return -errno;
- }
-
- *sfd = fd;
- return 0;
-}
-
-int
-tap_ctl_connect_id(int id, int *sfd)
-{
- int err;
- char *name;
-
- *sfd = -1;
-
- if (id < 0) {
- EPRINTF("invalid id %d\n", id);
- return -EINVAL;
- }
-
- name = tap_ctl_socket_name(id);
- if (!name) {
- EPRINTF("couldn't name socket for %d\n", id);
- return -ENOMEM;
- }
-
- err = tap_ctl_connect(name, sfd);
- free(name);
-
- return err;
-}
-
-int
-tap_ctl_connect_send_and_receive(int id, tapdisk_message_t *message, int timeout)
-{
- int err, sfd;
-
- err = tap_ctl_connect_id(id, &sfd);
- if (err)
- return err;
-
- err = tap_ctl_send_and_receive(sfd, message, timeout);
-
- close(sfd);
- return err;
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include <stdio.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <glob.h>
-
-#include "tap-ctl.h"
-#include "blktap2.h"
-#include "list.h"
-
-static void
-free_list(tap_list_t *entry)
-{
- if (entry->type) {
- free(entry->type);
- entry->type = NULL;
- }
-
- if (entry->path) {
- free(entry->path);
- entry->path = NULL;
- }
-
- free(entry);
-}
-
-int
-_parse_params(const char *params, char **type, char **path)
-{
- char *ptr;
- size_t len;
-
- ptr = strchr(params, ':');
- if (!ptr)
- return -EINVAL;
-
- len = ptr - params;
-
- *type = strndup(params, len);
- *path = strdup(params + len + 1);
-
- if (!*type || !*path) {
- free(*type);
- *type = NULL;
-
- free(*path);
- *path = NULL;
-
- return -errno;
- }
-
- return 0;
-}
-
-static int
-init_list(tap_list_t *entry,
- int tap_id, pid_t tap_pid, int vbd_minor, int vbd_state,
- const char *params)
-{
- int err = 0;
-
- entry->id = tap_id;
- entry->pid = tap_pid;
- entry->minor = vbd_minor;
- entry->state = vbd_state;
-
- if (params)
- err = _parse_params(params, &entry->type, &entry->path);
-
- return err;
-}
-
-void
-tap_ctl_free_list(tap_list_t **list)
-{
- tap_list_t **_entry;
-
- for (_entry = list; *_entry != NULL; ++_entry)
- free_list(*_entry);
-
- free(list);
-}
-
-static tap_list_t**
-tap_ctl_alloc_list(int n)
-{
- tap_list_t **list, *entry;
- size_t size;
- int i;
-
- size = sizeof(tap_list_t*) * (n+1);
- list = malloc(size);
- if (!list)
- goto fail;
-
- memset(list, 0, size);
-
- for (i = 0; i < n; ++i) {
- tap_list_t *entry;
-
- entry = malloc(sizeof(tap_list_t));
- if (!entry)
- goto fail;
-
- memset(entry, 0, sizeof(tap_list_t));
-
- list[i] = entry;
- }
-
- return list;
-
-fail:
- if (list)
- tap_ctl_free_list(list);
-
- return NULL;
-}
-
-static int
-tap_ctl_list_length(const tap_list_t **list)
-{
- const tap_list_t **_entry;
- int n;
-
- n = 0;
- for (_entry = list; *_entry != NULL; ++_entry)
- n++;
-
- return n;
-}
-
-static int
-_tap_minor_cmp(const void *a, const void *b)
-{
- return *(int*)a - *(int*)b;
-}
-
-int
-_tap_ctl_find_minors(int **_minorv)
-{
- glob_t glbuf = { 0 };
- const char *pattern, *format;
- int *minorv = NULL, n_minors = 0;
- int err, i;
-
- pattern = BLKTAP2_SYSFS_DIR"/blktap*";
- format = BLKTAP2_SYSFS_DIR"/blktap%d";
-
- n_minors = 0;
- minorv = NULL;
-
- err = glob(pattern, 0, NULL, &glbuf);
- switch (err) {
- case GLOB_NOMATCH:
- goto done;
-
- case GLOB_ABORTED:
- case GLOB_NOSPACE:
- err = -errno;
- EPRINTF("%s: glob failed, err %d", pattern, err);
- goto fail;
- }
-
- minorv = malloc(sizeof(int) * glbuf.gl_pathc);
- if (!minorv) {
- err = -errno;
- goto fail;
- }
-
- for (i = 0; i < glbuf.gl_pathc; ++i) {
- int n;
-
- n = sscanf(glbuf.gl_pathv[i], format, &minorv[n_minors]);
- if (n != 1)
- continue;
-
- n_minors++;
- }
-
- qsort(minorv, n_minors, sizeof(int), _tap_minor_cmp);
-
-done:
- *_minorv = minorv;
- err = 0;
-
-out:
- if (glbuf.gl_pathv)
- globfree(&glbuf);
-
- return err ? : n_minors;
-
-fail:
- if (minorv)
- free(minorv);
-
- goto out;
-}
-
-struct tapdisk {
- int id;
- pid_t pid;
- struct list_head list;
-};
-
-static int
-_tap_tapdisk_cmp(const void *a, const void *b)
-{
- return ((struct tapdisk*)a)->id - ((struct tapdisk*)b)->id;
-}
-
-int
-_tap_ctl_find_tapdisks(struct tapdisk **_tapv)
-{
- glob_t glbuf = { 0 };
- const char *pattern, *format;
- struct tapdisk *tapv = NULL;
- int err, i, n_taps = 0;
-
- pattern = BLKTAP2_CONTROL_DIR"/"BLKTAP2_CONTROL_SOCKET"*";
- format = BLKTAP2_CONTROL_DIR"/"BLKTAP2_CONTROL_SOCKET"%d";
-
- n_taps = 0;
- tapv = NULL;
-
- err = glob(pattern, 0, NULL, &glbuf);
- switch (err) {
- case GLOB_NOMATCH:
- goto done;
-
- case GLOB_ABORTED:
- case GLOB_NOSPACE:
- err = -errno;
- EPRINTF("%s: glob failed, err %d", pattern, err);
- goto fail;
- }
-
- tapv = malloc(sizeof(struct tapdisk) * glbuf.gl_pathc);
- if (!tapv) {
- err = -errno;
- goto fail;
- }
-
- for (i = 0; i < glbuf.gl_pathc; ++i) {
- struct tapdisk *tap;
- int n;
-
- tap = &tapv[n_taps];
-
- err = sscanf(glbuf.gl_pathv[i], format, &tap->id);
- if (err != 1)
- continue;
-
- tap->pid = tap_ctl_get_pid(tap->id);
- if (tap->pid < 0)
- continue;
-
- n_taps++;
- }
-
- qsort(tapv, n_taps, sizeof(struct tapdisk), _tap_tapdisk_cmp);
-
- for (i = 0; i < n_taps; ++i)
- INIT_LIST_HEAD(&tapv[i].list);
-
-done:
- *_tapv = tapv;
- err = 0;
-
-out:
- if (glbuf.gl_pathv)
- globfree(&glbuf);
-
- return err ? : n_taps;
-
-fail:
- if (tapv)
- free(tapv);
-
- goto out;
-}
-
-struct tapdisk_list {
- int minor;
- int state;
- char *params;
- struct list_head entry;
-};
-
-int
-_tap_ctl_list_tapdisk(int id, struct list_head *_list)
-{
- tapdisk_message_t message;
- struct list_head list;
- struct tapdisk_list *tl, *next;
- int err, sfd;
-
- err = tap_ctl_connect_id(id, &sfd);
- if (err)
- return err;
-
- memset(&message, 0, sizeof(message));
- message.type = TAPDISK_MESSAGE_LIST;
- message.cookie = -1;
-
- err = tap_ctl_write_message(sfd, &message, 2);
- if (err)
- return err;
-
- INIT_LIST_HEAD(&list);
- do {
- err = tap_ctl_read_message(sfd, &message, 2);
- if (err) {
- err = -EPROTO;
- break;
- }
-
- if (message.u.list.count == 0)
- break;
-
- tl = malloc(sizeof(struct tapdisk_list));
- if (!tl) {
- err = -ENOMEM;
- break;
- }
-
- tl->minor = message.u.list.minor;
- tl->state = message.u.list.state;
- if (message.u.list.path[0] != 0) {
- tl->params = strndup(message.u.list.path,
- sizeof(message.u.list.path));
- if (!tl->params) {
- err = -errno;
- break;
- }
- } else
- tl->params = NULL;
-
- list_add(&tl->entry, &list);
- } while (1);
-
- if (err)
- list_for_each_entry_safe(tl, next, &list, entry) {
- list_del(&tl->entry);
- free(tl->params);
- free(tl);
- }
-
- close(sfd);
- list_splice(&list, _list);
- return err;
-}
-
-void
-_tap_ctl_free_tapdisks(struct tapdisk *tapv, int n_taps)
-{
- struct tapdisk *tap;
-
- for (tap = tapv; tap < &tapv[n_taps]; ++tap) {
- struct tapdisk_list *tl, *next;
-
- list_for_each_entry_safe(tl, next, &tap->list, entry) {
- free(tl->params);
- free(tl);
- }
- }
-
- free(tapv);
-}
-
-int
-_tap_list_join3(int n_minors, int *minorv, int n_taps, struct tapdisk *tapv,
- tap_list_t ***_list)
-{
- tap_list_t **list, **_entry;
- int i, _m, err;
-
- list = tap_ctl_alloc_list(n_minors + n_taps);
- if (!list) {
- err = -ENOMEM;
- goto fail;
- }
-
- _entry = list;
-
- for (i = 0; i < n_taps; ++i) {
- struct tapdisk *tap = &tapv[i];
- struct tapdisk_list *tl;
-
- /* orphaned tapdisk */
- if (list_empty(&tap->list)) {
- err = init_list(*_entry++, tap->id, tap->pid, -1, -1, NULL);
- if (err)
- goto fail;
- continue;
- }
-
- list_for_each_entry(tl, &tap->list, entry) {
-
- err = init_list(*_entry++,
- tap->id, tap->pid,
- tl->minor, tl->state, tl->params);
- if (err)
- goto fail;
-
- if (tl->minor >= 0) {
- /* clear minor */
- for (_m = 0; _m < n_minors; ++_m) {
- if (minorv[_m] == tl->minor) {
- minorv[_m] = -1;
- break;
- }
- }
- }
- }
- }
-
- /* orphaned minors */
- for (_m = 0; _m < n_minors; ++_m) {
- int minor = minorv[_m];
- if (minor >= 0) {
- err = init_list(*_entry++, -1, -1, minor, -1, NULL);
- if (err)
- goto fail;
- }
- }
-
- /* free extraneous list entries */
- for (; *_entry != NULL; ++_entry) {
- free_list(*_entry);
- *_entry = NULL;
- }
-
- *_list = list;
-
- return 0;
-
-fail:
- if (list)
- tap_ctl_free_list(list);
-
- return err;
-}
-
-int
-tap_ctl_list(tap_list_t ***list)
-{
- int n_taps, n_minors, err, *minorv;
- struct tapdisk *tapv, *tap;
-
- n_taps = -1;
- n_minors = -1;
-
- err = n_minors = _tap_ctl_find_minors(&minorv);
- if (err < 0)
- goto out;
-
- err = n_taps = _tap_ctl_find_tapdisks(&tapv);
- if (err < 0)
- goto out;
-
- for (tap = tapv; tap < &tapv[n_taps]; ++tap) {
- err = _tap_ctl_list_tapdisk(tap->id, &tap->list);
- if (err)
- goto out;
- }
-
- err = _tap_list_join3(n_minors, minorv, n_taps, tapv, list);
-
-out:
- if (n_taps > 0)
- _tap_ctl_free_tapdisks(tapv, n_taps);
-
- if (n_minors > 0)
- free(minorv);
-
- return err;
-}
-
-int
-tap_ctl_find(const char *type, const char *path, tap_list_t *tap)
-{
- tap_list_t **list, **_entry;
- int ret = -ENOENT, err;
-
- err = tap_ctl_list(&list);
- if (err)
- return err;
-
- for (_entry = list; *_entry != NULL; ++_entry) {
- tap_list_t *entry = *_entry;
-
- if (type && (!entry->type || strcmp(entry->type, type)))
- continue;
-
- if (path && (!entry->path || strcmp(entry->path, path)))
- continue;
-
- *tap = *entry;
- tap->type = tap->path = NULL;
- ret = 0;
- break;
- }
-
- tap_ctl_free_list(list);
-
- return ret;
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include <stdio.h>
-#include <errno.h>
-
-#include "tap-ctl.h"
-
-int
-tap_ctl_blk_major(void)
-{
- FILE *devices;
- int rv, major;
-
- devices = fopen("/proc/devices", "r");
- if (!devices) {
- rv = -errno;
- goto out;
- }
-
- do {
- char buf[32], *s;
- int n, offset;
-
- s = fgets(buf, sizeof(buf), devices);
- if (!s)
- break;
-
- major = -ENODEV;
- offset = 0;
-
- n = sscanf(buf, "%d tapdev%n", &major, &offset);
- if (n == 1 && offset)
- break;
- } while (1);
-
- rv = major;
-
-out:
- if (devices)
- fclose(devices);
-
- return rv;
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include <stdio.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <getopt.h>
-
-#include "tap-ctl.h"
-#include "blktaplib.h"
-
-int
-tap_ctl_open(const int id, const int minor, const char *params)
-{
- int err;
- tapdisk_message_t message;
-
- memset(&message, 0, sizeof(message));
- message.type = TAPDISK_MESSAGE_OPEN;
- message.cookie = minor;
- message.u.params.storage = TAPDISK_STORAGE_TYPE_DEFAULT;
- message.u.params.devnum = minor;
-
- err = snprintf(message.u.params.path,
- sizeof(message.u.params.path) - 1, "%s", params);
- if (err >= sizeof(message.u.params.path)) {
- EPRINTF("name too long\n");
- return ENAMETOOLONG;
- }
-
- err = tap_ctl_connect_send_and_receive(id, &message, 5);
- if (err)
- return err;
-
- switch (message.type) {
- case TAPDISK_MESSAGE_OPEN_RSP:
- break;
- case TAPDISK_MESSAGE_ERROR:
- err = -message.u.response.error;
- EPRINTF("open failed, err %d\n", err);
- break;
- default:
- EPRINTF("got unexpected result '%s' from %d\n",
- tapdisk_message_name(message.type), id);
- err = EINVAL;
- }
-
- return err;
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include <stdio.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-
-#include "tap-ctl.h"
-
-int
-tap_ctl_pause(const int id, const int minor)
-{
- int err;
- tapdisk_message_t message;
-
- memset(&message, 0, sizeof(message));
- message.type = TAPDISK_MESSAGE_PAUSE;
- message.cookie = minor;
-
- err = tap_ctl_connect_send_and_receive(id, &message, 5);
- if (err)
- return err;
-
- if (message.type == TAPDISK_MESSAGE_PAUSE_RSP)
- err = message.u.response.error;
- else {
- err = EINVAL;
- EPRINTF("got unexpected result '%s' from %d\n",
- tapdisk_message_name(message.type), id);
- }
-
- return err;
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include <stdio.h>
-#include <errno.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/wait.h>
-
-#include "tap-ctl.h"
-#include "blktap2.h"
-
-static pid_t
-__tap_ctl_spawn(int *readfd)
-{
- int err, child, channel[2];
- char *tapdisk;
-
- if (pipe(channel)) {
- EPRINTF("pipe failed: %d\n", errno);
- return -errno;
- }
-
- if ((child = fork()) == -1) {
- EPRINTF("fork failed: %d\n", errno);
- return -errno;
- }
-
- if (child) {
- close(channel[1]);
- *readfd = channel[0];
- return child;
- }
-
- if (dup2(channel[1], STDOUT_FILENO) == -1) {
- EPRINTF("dup2 failed: %d\n", errno);
- exit(errno);
- }
-
- if (dup2(channel[1], STDERR_FILENO) == -1) {
- EPRINTF("dup2 failed: %d\n", errno);
- exit(errno);
- }
-
- close(channel[0]);
- close(channel[1]);
-
- tapdisk = getenv("TAPDISK2");
- if (!tapdisk)
- tapdisk = "tapdisk2";
-
- execlp(tapdisk, tapdisk, NULL);
-
- EPRINTF("exec failed\n");
- exit(1);
-}
-
-pid_t
-tap_ctl_get_pid(const int id)
-{
- int err;
- tapdisk_message_t message;
-
- memset(&message, 0, sizeof(message));
- message.type = TAPDISK_MESSAGE_PID;
-
- err = tap_ctl_connect_send_and_receive(id, &message, 2);
- if (err)
- return err;
-
- return message.u.tapdisk_pid;
-}
-
-static int
-tap_ctl_wait(pid_t child)
-{
- pid_t pid;
- int status;
-
- pid = waitpid(child, &status, 0);
- if (pid < 0) {
- EPRINTF("wait(%d) failed, err %d\n", child, errno);
- return -errno;
- }
-
- if (WIFEXITED(status)) {
- int code = WEXITSTATUS(status);
- if (code)
- EPRINTF("tapdisk2[%d] failed, status %d\n", child, code);
- return -code;
- }
-
- if (WIFSIGNALED(status)) {
- int signo = WTERMSIG(status);
- EPRINTF("tapdisk2[%d] killed by signal %d\n", child, signo);
- return -EINTR;
- }
-
- EPRINTF("tapdisk2[%d]: unexpected status %#x\n", child, status);
- return -EAGAIN;
-}
-
-static int
-tap_ctl_get_child_id(int readfd)
-{
- int id;
- FILE *f;
-
- f = fdopen(readfd, "r");
- if (!f) {
- EPRINTF("fdopen failed: %d\n", errno);
- return -1;
- }
-
- errno = 0;
- if (fscanf(f, BLKTAP2_CONTROL_DIR"/"
- BLKTAP2_CONTROL_SOCKET"%d", &id) != 1) {
- errno = (errno ? : EINVAL);
- EPRINTF("parsing id failed: %d\n", errno);
- id = -1;
- }
-
- fclose(f);
- return id;
-}
-
-int
-tap_ctl_spawn(void)
-{
- pid_t child;
- int err, id, readfd;
-
- readfd = -1;
-
- child = __tap_ctl_spawn(&readfd);
- if (child < 0)
- return child;
-
- err = tap_ctl_wait(child);
- if (err)
- return err;
-
- id = tap_ctl_get_child_id(readfd);
- if (id < 0)
- EPRINTF("get_id failed, child %d err %d\n", child, errno);
-
- return id;
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include <stdio.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <getopt.h>
-
-#include "tap-ctl.h"
-
-int
-tap_ctl_unpause(const int id, const int minor, const char *params)
-{
- int err;
- tapdisk_message_t message;
-
- memset(&message, 0, sizeof(message));
- message.type = TAPDISK_MESSAGE_RESUME;
- message.cookie = minor;
-
- if (params)
- strncpy(message.u.params.path, params,
- sizeof(message.u.params.path) - 1);
-
- err = tap_ctl_connect_send_and_receive(id, &message, 15);
- if (err)
- return err;
-
- if (message.type == TAPDISK_MESSAGE_RESUME_RSP)
- err = message.u.response.error;
- else {
- err = EINVAL;
- EPRINTF("got unexpected result '%s' from %d\n",
- tapdisk_message_name(message.type), id);
- }
-
- return err;
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <getopt.h>
-
-#include "tap-ctl.h"
-
-typedef int (*tap_ctl_func_t) (int, char **);
-
-struct command {
- char *name;
- tap_ctl_func_t func;
-};
-
-static void
-tap_cli_list_usage(FILE *stream)
-{
- fprintf(stream,
- "usage: list [-h] [-p pid] [-m minor] [-t type] [-f file]\n");
-}
-
-static void
-tap_ctl_list_row(tap_list_t *entry)
-{
- char minor_str[10] = "-";
- char state_str[10] = "-";
- char pid_str[10] = "-";
-
- if (entry->pid != -1)
- sprintf(pid_str, "%d", entry->pid);
-
- if (entry->minor != -1)
- sprintf(minor_str, "%d", entry->minor);
-
- if (entry->state != -1)
- sprintf(state_str, "%x", entry->state);
-
- printf("%8s %2s %4s %10s %s\n",
- pid_str, minor_str, state_str,
- entry->type ? : "-", entry->path ? : "-");
-}
-
-static void
-tap_ctl_list_dict(tap_list_t *entry)
-{
- int d = 0;
-
- if (entry->pid != -1) {
- if (d) putc(' ', stdout);
- d = printf("pid=%d", entry->pid);
- }
-
- if (entry->minor != -1) {
- if (d) putc(' ', stdout);
- d = printf("minor=%d", entry->minor);
- }
-
- if (entry->state != -1) {
- if (d) putc(' ', stdout);
- d = printf("state=%d", entry->state);
- }
-
- if (entry->type && entry->path) {
- if (d) putc(' ', stdout);
- d = printf("args=%s:%s", entry->type, entry->path);
- }
-
- putc('\n', stdout);
-}
-
-int
-tap_cli_list(int argc, char **argv)
-{
- tap_list_t **list, **_entry;
- int c, minor, tty, err;
- const char *type, *file;
- pid_t pid;
-
- err = tap_ctl_list(&list);
- if (err)
- return -err;
-
- pid = -1;
- minor = -1;
- type = NULL;
- file = NULL;
-
- while ((c = getopt(argc, argv, "m:p:t:f:h")) != -1) {
- switch (c) {
- case 'm':
- minor = atoi(optarg);
- break;
- case 'p':
- pid = atoi(optarg);
- break;
- case 't':
- type = optarg;
- break;
- case 'f':
- file = optarg;
- break;
- case '?':
- goto usage;
- case 'h':
- tap_cli_list_usage(stdout);
- return 0;
- }
- }
-
- tty = isatty(STDOUT_FILENO);
-
- for (_entry = list; *_entry != NULL; ++_entry) {
- tap_list_t *entry = *_entry;
-
- if (minor >= 0 && entry->minor != minor)
- continue;
-
- if (pid >= 0 && entry->pid != pid)
- continue;
-
- if (type && (!entry->type || strcmp(entry->type, type)))
- continue;
-
- if (file && (!entry->path || strcmp(entry->path, file)))
- continue;
-
- if (tty)
- tap_ctl_list_row(entry);
- else
- tap_ctl_list_dict(entry);
- }
-
- tap_ctl_free_list(list);
-
- return 0;
-
-usage:
- tap_cli_list_usage(stderr);
- return EINVAL;
-}
-
-static void
-tap_cli_allocate_usage(FILE *stream)
-{
- fprintf(stream, "usage: allocate [-d device name]>\n");
-}
-
-static int
-tap_cli_allocate(int argc, char **argv)
-{
- char *devname;
- int c, minor, err;
-
- devname = NULL;
-
- optind = 0;
- while ((c = getopt(argc, argv, "d:h")) != -1) {
- switch (c) {
- case 'd':
- devname = optarg;
- break;
- case '?':
- goto usage;
- case 'h':
- tap_cli_allocate_usage(stdout);
- return 0;
- }
- }
-
- err = tap_ctl_allocate(&minor, &devname);
- if (!err)
- printf("%s\n", devname);
-
- return err;
-
-usage:
- tap_cli_allocate_usage(stderr);
- return EINVAL;
-}
-
-static void
-tap_cli_free_usage(FILE *stream)
-{
- fprintf(stream, "usage: free <-m minor>\n");
-}
-
-static int
-tap_cli_free(int argc, char **argv)
-{
- int c, minor;
-
- minor = -1;
-
- optind = 0;
- while ((c = getopt(argc, argv, "m:h")) != -1) {
- switch (c) {
- case 'm':
- minor = atoi(optarg);
- break;
- case '?':
- goto usage;
- case 'h':
- tap_cli_free_usage(stdout);
- return 0;
- }
- }
-
- if (minor == -1)
- goto usage;
-
- return tap_ctl_free(minor);
-
-usage:
- tap_cli_free_usage(stderr);
- return EINVAL;
-}
-
-static void
-tap_cli_create_usage(FILE *stream)
-{
- fprintf(stream, "usage: create <-a args> [-d device name]\n");
-}
-
-static int
-tap_cli_create(int argc, char **argv)
-{
- int c, err;
- char *args, *devname;
-
- args = NULL;
- devname = NULL;
-
- optind = 0;
- while ((c = getopt(argc, argv, "a:d:h")) != -1) {
- switch (c) {
- case 'a':
- args = optarg;
- break;
- case 'd':
- devname = optarg;
- break;
- case '?':
- goto usage;
- case 'h':
- tap_cli_create_usage(stdout);
- return 0;
- }
- }
-
- if (!args)
- goto usage;
-
- err = tap_ctl_create(args, &devname);
- if (!err)
- printf("%s\n", devname);
-
- return err;
-
-usage:
- tap_cli_create_usage(stderr);
- return EINVAL;
-}
-
-static void
-tap_cli_destroy_usage(FILE *stream)
-{
- fprintf(stream, "usage: destroy <-p pid> <-m minor>\n");
-}
-
-static int
-tap_cli_destroy(int argc, char **argv)
-{
- int c, pid, minor;
-
- pid = -1;
- minor = -1;
-
- optind = 0;
- while ((c = getopt(argc, argv, "p:m:h")) != -1) {
- switch (c) {
- case 'p':
- pid = atoi(optarg);
- break;
- case 'm':
- minor = atoi(optarg);
- break;
- case '?':
- goto usage;
- case 'h':
- tap_cli_destroy_usage(stdout);
- return 0;
- }
- }
-
- if (pid == -1 || minor == -1)
- goto usage;
-
- return tap_ctl_destroy(pid, minor);
-
-usage:
- tap_cli_destroy_usage(stderr);
- return EINVAL;
-}
-
-static void
-tap_cli_spawn_usage(FILE *stream)
-{
- fprintf(stream, "usage: spawn\n");
-}
-
-static int
-tap_cli_spawn(int argc, char **argv)
-{
- int c;
- pid_t task;
-
- optind = 0;
- while ((c = getopt(argc, argv, "h")) != -1) {
- switch (c) {
- case '?':
- goto usage;
- case 'h':
- tap_cli_spawn_usage(stdout);
- return 0;
- }
- }
-
- task = tap_ctl_spawn();
- if (task < 0) {
- printf("spawn failed: %d\n", errno);
- return task;
- }
-
- printf("tapdisk spawned with pid %d\n", task);
- return 0;
-
-usage:
- tap_cli_spawn_usage(stderr);
- return EINVAL;
-}
-
-static void
-tap_cli_attach_usage(FILE *stream)
-{
- fprintf(stream, "usage: attach <-p pid> <-m minor>\n");
-}
-
-static int
-tap_cli_attach(int argc, char **argv)
-{
- int c, pid, minor;
-
- pid = -1;
- minor = -1;
-
- optind = 0;
- while ((c = getopt(argc, argv, "p:m:h")) != -1) {
- switch (c) {
- case 'p':
- pid = atoi(optarg);
- break;
- case 'm':
- minor = atoi(optarg);
- break;
- case '?':
- goto usage;
- case 'h':
- tap_cli_attach_usage(stderr);
- return 0;
- }
- }
-
- if (pid == -1 || minor == -1)
- goto usage;
-
- return tap_ctl_attach(pid, minor);
-
-usage:
- tap_cli_attach_usage(stderr);
- return EINVAL;
-}
-
-static void
-tap_cli_detach_usage(FILE *stream)
-{
- fprintf(stream, "usage: detach <-p pid> <-m minor>\n");
-}
-
-static int
-tap_cli_detach(int argc, char **argv)
-{
- int c, pid, minor;
-
- pid = -1;
- minor = -1;
-
- optind = 0;
- while ((c = getopt(argc, argv, "p:m:h")) != -1) {
- switch (c) {
- case 'p':
- pid = atoi(optarg);
- break;
- case 'm':
- minor = atoi(optarg);
- break;
- case '?':
- goto usage;
- case 'h':
- tap_cli_detach_usage(stdout);
- return 0;
- }
- }
-
- if (pid == -1 || minor == -1)
- goto usage;
-
- return tap_ctl_detach(pid, minor);
-
-usage:
- tap_cli_detach_usage(stderr);
- return EINVAL;
-}
-
-static void
-tap_cli_close_usage(FILE *stream)
-{
- fprintf(stream, "usage: close <-p pid> <-m minor> [-f force]\n");
-}
-
-static int
-tap_cli_close(int argc, char **argv)
-{
- int c, pid, minor, force;
-
- pid = -1;
- minor = -1;
- force = 0;
-
- optind = 0;
- while ((c = getopt(argc, argv, "p:m:fh")) != -1) {
- switch (c) {
- case 'p':
- pid = atoi(optarg);
- break;
- case 'm':
- minor = atoi(optarg);
- break;
- case 'f':
- force = -1;
- break;
- case '?':
- goto usage;
- case 'h':
- tap_cli_close_usage(stdout);
- return 0;
- }
- }
-
- if (pid == -1 || minor == -1)
- goto usage;
-
- return tap_ctl_close(pid, minor, force);
-
-usage:
- tap_cli_close_usage(stderr);
- return EINVAL;
-}
-
-static void
-tap_cli_pause_usage(FILE *stream)
-{
- fprintf(stream, "usage: pause <-p pid> <-m minor>\n");
-}
-
-static int
-tap_cli_pause(int argc, char **argv)
-{
- int c, pid, minor;
-
- pid = -1;
- minor = -1;
-
- optind = 0;
- while ((c = getopt(argc, argv, "p:m:h")) != -1) {
- switch (c) {
- case 'p':
- pid = atoi(optarg);
- break;
- case 'm':
- minor = atoi(optarg);
- break;
- case '?':
- goto usage;
- case 'h':
- tap_cli_pause_usage(stdout);
- return 0;
- }
- }
-
- if (pid == -1 || minor == -1)
- goto usage;
-
- return tap_ctl_pause(pid, minor);
-
-usage:
- tap_cli_pause_usage(stderr);
- return EINVAL;
-}
-
-static void
-tap_cli_unpause_usage(FILE *stream)
-{
- fprintf(stream, "usage: unpause <-p pid> <-m minor> [-a args]\n");
-}
-
-int
-tap_cli_unpause(int argc, char **argv)
-{
- const char *args;
- int c, pid, minor;
-
- pid = -1;
- minor = -1;
- args = NULL;
-
- optind = 0;
- while ((c = getopt(argc, argv, "p:m:a:h")) != -1) {
- switch (c) {
- case 'p':
- pid = atoi(optarg);
- break;
- case 'm':
- minor = atoi(optarg);
- break;
- case 'a':
- args = optarg;
- break;
- case '?':
- goto usage;
- case 'h':
- tap_cli_unpause_usage(stdout);
- return 0;
- }
- }
-
- if (pid == -1 || minor == -1)
- goto usage;
-
- return tap_ctl_unpause(pid, minor, args);
-
-usage:
- tap_cli_unpause_usage(stderr);
- return EINVAL;
-}
-
-static void
-tap_cli_major_usage(FILE *stream)
-{
- fprintf(stream, "usage: major [-h]\n");
-}
-
-static int
-tap_cli_major(int argc, char **argv)
-{
- int c, chr, major;
-
- chr = 0;
-
- while ((c = getopt(argc, argv, "bch")) != -1) {
- switch (c) {
- case 'b':
- chr = 0;
- break;
- case 'c':
- chr = 1;
- break;
- case '?':
- goto usage;
- case 'h':
- tap_cli_major_usage(stdout);
- return 0;
- default:
- goto usage;
- }
- }
-
- if (chr)
- major = -EINVAL;
- else
- major = tap_ctl_blk_major();
-
- if (major < 0)
- return -major;
-
- printf("%d\n", major);
-
- return 0;
-
-usage:
- tap_cli_major_usage(stderr);
- return EINVAL;
-}
-
-static void
-tap_cli_open_usage(FILE *stream)
-{
- fprintf(stream, "usage: open <-p pid> <-m minor> <-a args>\n");
-}
-
-static int
-tap_cli_open(int argc, char **argv)
-{
- const char *args;
- int c, pid, minor;
-
- pid = -1;
- minor = -1;
- args = NULL;
-
- optind = 0;
- while ((c = getopt(argc, argv, "a:m:p:h")) != -1) {
- switch (c) {
- case 'p':
- pid = atoi(optarg);
- break;
- case 'm':
- minor = atoi(optarg);
- break;
- case 'a':
- args = optarg;
- break;
- case '?':
- goto usage;
- case 'h':
- tap_cli_open_usage(stdout);
- return 0;
- }
- }
-
- if (pid == -1 || minor == -1 || !args)
- goto usage;
-
- return tap_ctl_open(pid, minor, args);
-
-usage:
- tap_cli_open_usage(stderr);
- return EINVAL;
-}
-
-static void
-tap_cli_check_usage(FILE *stream)
-{
- fprintf(stream, "usage: check\n"
- "(checks whether environment is suitable for tapdisk2)\n");
-}
-
-static int
-tap_cli_check(int argc, char **argv)
-{
- int err;
- const char *msg;
-
- if (argc != 1)
- goto usage;
-
- err = tap_ctl_check(&msg);
- printf("%s\n", msg);
-
- return err;
-
-usage:
- tap_cli_check_usage(stderr);
- return EINVAL;
-}
-
-struct command commands[] = {
- { .name = "list", .func = tap_cli_list },
- { .name = "allocate", .func = tap_cli_allocate },
- { .name = "free", .func = tap_cli_free },
- { .name = "create", .func = tap_cli_create },
- { .name = "destroy", .func = tap_cli_destroy },
- { .name = "spawn", .func = tap_cli_spawn },
- { .name = "attach", .func = tap_cli_attach },
- { .name = "detach", .func = tap_cli_detach },
- { .name = "open", .func = tap_cli_open },
- { .name = "close", .func = tap_cli_close },
- { .name = "pause", .func = tap_cli_pause },
- { .name = "unpause", .func = tap_cli_unpause },
- { .name = "major", .func = tap_cli_major },
- { .name = "check", .func = tap_cli_check },
-};
-
-#define print_commands() \
- do { \
- int i, n; \
- n = sizeof(commands) / sizeof(struct command); \
- printf("COMMAND := { "); \
- printf("%s", commands[0].name); \
- for (i = 1; i < n; i++) \
- printf(" | %s", commands[i].name); \
- printf(" }\n"); \
- } while (0)
-
-void
-help(void)
-{
- printf("usage: tap-ctl COMMAND [OPTIONS]\n");
- print_commands();
- exit(0);
-}
-
-struct command *
-get_command(char *command)
-{
- int i, n;
-
- if (strnlen(command, 25) >= 25)
- return NULL;
-
- n = sizeof(commands) / sizeof (struct command);
-
- for (i = 0; i < n; i++)
- if (!strcmp(command, commands[i].name))
- return &commands[i];
-
- return NULL;
-}
-
-int
-main(int argc, char *argv[])
-{
- char **cargv;
- const char *msg;
- struct command *cmd;
- int cargc, i, cnt, ret;
-
-#ifdef CORE_DUMP
- #include <sys/resource.h>
- struct rlimit rlim;
- rlim.rlim_cur = RLIM_INFINITY;
- rlim.rlim_max = RLIM_INFINITY;
- if (setrlimit(RLIMIT_CORE, &rlim) < 0)
- PERROR("setrlimit failed");
-#endif
-
- ret = 0;
-
- if (argc < 2)
- help();
-
- cargc = argc - 1;
- cmd = get_command(argv[1]);
- if (!cmd) {
- EPRINTF("invalid COMMAND %s", argv[1]);
- help();
- }
-
- ret = tap_ctl_check(&msg);
- if (ret) {
- printf("%s\n", msg);
- return ret;
- }
-
- cargv = malloc(sizeof(char *) * cargc);
- if (!cargv)
- exit(ENOMEM);
-
- cnt = 1;
- cargv[0] = cmd->name;
- for (i = 1; i < cargc; i++) {
- char *arg = argv[i + (argc - cargc)];
-
- if (!strcmp(arg, "--debug")) {
- tap_ctl_debug = 1;
- continue;
- }
-
- cargv[cnt++] = arg;
- }
-
- ret = cmd->func(cnt, cargv);
-
- free(cargv);
-
- return (ret >= 0 ? ret : -ret);
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#ifndef __TAP_CTL_H__
-#define __TAP_CTL_H__
-
-#include <syslog.h>
-#include <errno.h>
-#include <tapdisk-message.h>
-
-extern int tap_ctl_debug;
-
-#ifdef TAPCTL
-#define DBG(_f, _a...) \
- do { \
- if (tap_ctl_debug) \
- printf(_f, ##_a); \
- } while (0)
-
-#define DPRINTF(_f, _a...) syslog(LOG_INFO, _f, ##_a)
-#define EPRINTF(_f, _a...) syslog(LOG_ERR, "tap-err:%s: " _f, __func__, ##_a)
-#define PERROR(_f, _a...) syslog(LOG_ERR, "tap-err:%s: " _f ": %s", __func__, ##_a, \
- strerror(errno))
-#endif
-
-void tap_ctl_version(int *major, int *minor);
-int tap_ctl_kernel_version(int *major, int *minor);
-
-int tap_ctl_check_blktap(const char **message);
-int tap_ctl_check_version(const char **message);
-int tap_ctl_check(const char **message);
-
-int tap_ctl_connect(const char *path, int *socket);
-int tap_ctl_connect_id(int id, int *socket);
-int tap_ctl_read_message(int fd, tapdisk_message_t *message, int timeout);
-int tap_ctl_write_message(int fd, tapdisk_message_t *message, int timeout);
-int tap_ctl_send_and_receive(int fd, tapdisk_message_t *message, int timeout);
-int tap_ctl_connect_send_and_receive(int id,
- tapdisk_message_t *message, int timeout);
-char *tap_ctl_socket_name(int id);
-
-typedef struct {
- int id;
- pid_t pid;
- int minor;
- int state;
- char *type;
- char *path;
-} tap_list_t;
-
-int tap_ctl_get_driver_id(const char *handle);
-
-int tap_ctl_list(tap_list_t ***list);
-void tap_ctl_free_list(tap_list_t **list);
-int tap_ctl_find(const char *type, const char *path, tap_list_t *tap);
-
-int tap_ctl_allocate(int *minor, char **devname);
-int tap_ctl_free(const int minor);
-
-int tap_ctl_create(const char *params, char **devname);
-int tap_ctl_destroy(const int id, const int minor);
-
-int tap_ctl_spawn(void);
-pid_t tap_ctl_get_pid(const int id);
-
-int tap_ctl_attach(const int id, const int minor);
-int tap_ctl_detach(const int id, const int minor);
-
-int tap_ctl_open(const int id, const int minor, const char *params);
-int tap_ctl_close(const int id, const int minor, const int force);
-
-int tap_ctl_pause(const int id, const int minor);
-int tap_ctl_unpause(const int id, const int minor, const char *params);
-
-int tap_ctl_blk_major(void);
-
-#endif
+++ /dev/null
-prefix=@@prefix@@
-includedir=@@incdir@@
-libdir=@@libdir@@
-
-Name: Xenblktapctl
-Description: The Xenblktapctl library for Xen hypervisor
-Version: @@version@@
-Cflags: -I${includedir} @@cflagslocal@@
-Libs: @@libsflag@@${libdir} -lxenblktapctl
+++ /dev/null
-XEN_ROOT=$(CURDIR)/../../..
-BLKTAP_ROOT= ..
-include $(XEN_ROOT)/tools/Rules.mk
-
-LIBVHDDIR = $(BLKTAP_ROOT)/vhd/lib
-
-IBIN = tapdisk2 td-util tapdisk-client tapdisk-stream tapdisk-diff
-QCOW_UTIL = img2qcow qcow-create qcow2raw
-LOCK_UTIL = lock-util
-INST_DIR = $(sbindir)
-
-CFLAGS += -Werror
-CFLAGS += -Wno-unused
-CFLAGS += -fno-strict-aliasing
-CFLAGS += -I$(BLKTAP_ROOT)/include -I$(BLKTAP_ROOT)/drivers
-CFLAGS += $(CFLAGS_libxenctrl)
-CFLAGS += -D_GNU_SOURCE
-CFLAGS += -DUSE_NFS_LOCKS
-# drivers/block-log.c incorrectly uses libxc internals
-CFLAGS += -I$(XEN_ROOT)/tools/libxc
-
-ifeq ($(CONFIG_X86_64),y)
-CFLAGS += -fPIC
-endif
-
-VHDLIBS := -L$(LIBVHDDIR) -lvhd
-
-REMUS-OBJS := block-remus.o
-REMUS-OBJS += hashtable.o
-REMUS-OBJS += hashtable_itr.o
-REMUS-OBJS += hashtable_utility.o
-
-tapdisk2 tapdisk-stream tapdisk-diff $(QCOW_UTIL): AIOLIBS := -laio
-
-MEMSHRLIBS :=
-ifeq ($(CONFIG_Linux), __fixme__)
-MEMSHR_DIR = $(XEN_ROOT)/tools/memshr
-CFLAGS += -DMEMSHR
-CFLAGS += -I $(MEMSHR_DIR)
-MEMSHRLIBS += -L$(XEN_ROOT)/tools/libxc -lxenctrl $(MEMSHR_DIR)/libmemshr.a
-endif
-
-ifeq ($(VHD_STATIC),y)
-td-util: CFLAGS += -static
-endif
-
-PORTABLE-OBJS-y :=
-PORTABLE-OBJS-$(CONFIG_Linux) += blk_linux.o
-PORTABLE-OBJS-$(CONFIG_NetBSD) += blk_netbsd.o
-
-TAP-OBJS-y := scheduler.o
-TAP-OBJS-y += tapdisk-vbd.o
-TAP-OBJS-y += tapdisk-control.o
-TAP-OBJS-y += tapdisk-image.o
-TAP-OBJS-y += tapdisk-driver.o
-TAP-OBJS-y += tapdisk-disktype.o
-TAP-OBJS-y += tapdisk-interface.o
-TAP-OBJS-y += tapdisk-server.o
-TAP-OBJS-y += tapdisk-queue.o
-TAP-OBJS-y += tapdisk-filter.o
-TAP-OBJS-y += tapdisk-log.o
-TAP-OBJS-y += tapdisk-utils.o
-TAP-OBJS-y += io-optimize.o
-TAP-OBJS-y += lock.o
-TAP-OBJS-y += $(PORTABLE-OBJS-y)
-
-MISC-OBJS-y := atomicio.o
-
-BLK-OBJS-y := block-aio.o
-BLK-OBJS-y += block-ram.o
-BLK-OBJS-y += block-cache.o
-BLK-OBJS-y += block-vhd.o
-BLK-OBJS-y += block-log.o
-BLK-OBJS-y += block-qcow.o
-BLK-OBJS-y += aes.o
-BLK-OBJS-y += md5.o
-BLK-OBJS-y += $(PORTABLE-OBJS-y)
-BLK-OBJS-y += $(REMUS-OBJS)
-
-all: $(IBIN) lock-util qcow-util
-
-
-tapdisk2: $(TAP-OBJS-y) $(BLK-OBJS-y) $(MISC-OBJS-y) tapdisk2.o
- $(CC) -o $@ $^ $(LDFLAGS) -lrt -lz $(VHDLIBS) $(AIOLIBS) $(MEMSHRLIBS) -lm $(APPEND_LDFLAGS)
-
-tapdisk-client: tapdisk-client.o
- $(CC) -o $@ $^ $(LDFLAGS) -lrt $(APPEND_LDFLAGS)
-
-tapdisk-stream tapdisk-diff: %: %.o $(TAP-OBJS-y) $(BLK-OBJS-y)
- $(CC) -o $@ $^ $(LDFLAGS) -lrt -lz $(VHDLIBS) $(AIOLIBS) $(MEMSHRLIBS) -lm $(APPEND_LDFLAGS)
-
-td-util: td.o tapdisk-utils.o tapdisk-log.o $(PORTABLE-OBJS-y)
- $(CC) -o $@ $^ $(LDFLAGS) $(VHDLIBS) $(APPEND_LDFLAGS)
-
-lock-util: lock.c
- $(CC) $(CFLAGS) -DUTIL -o lock-util lock.c $(LDFLAGS) $(APPEND_LDFLAGS)
-
-.PHONY: qcow-util
-qcow-util: img2qcow qcow2raw qcow-create
-
-img2qcow qcow2raw qcow-create: %: %.o $(TAP-OBJS-y) $(BLK-OBJS-y)
- $(CC) -o $@ $^ $(LDFLAGS) -lrt -lz $(VHDLIBS) $(AIOLIBS) $(MEMSHRLIBS) -lm $(APPEND_LDFLAGS)
-
-install: all
- $(INSTALL_DIR) -p $(DESTDIR)$(INST_DIR)
- $(INSTALL_PROG) $(IBIN) $(LOCK_UTIL) $(QCOW_UTIL) $(DESTDIR)$(INST_DIR)
-
-uninstall:
- rm -f $(addprefix $(DESTDIR)$(INST_DIR)/, $(IBIN) $(LOCK_UTIL) $(QCOW_UTIL))
-
-clean:
- rm -rf .*.d *.o *~ xen TAGS $(IBIN) $(LIB) $(LOCK_UTIL) $(QCOW_UTIL)
-
-distclean: clean
-
-.PHONY: clean install distclean uninstall
+++ /dev/null
-/**\r
- * \r
- * aes.c - integrated in QEMU by Fabrice Bellard from the OpenSSL project.\r
- */\r
-/*\r
- * rijndael-alg-fst.c\r
- *\r
- * @version 3.0 (December 2000)\r
- *\r
- * Optimised ANSI C code for the Rijndael cipher (now AES)\r
- *\r
- * @author Vincent Rijmen <vincent.rijmen@esat.kuleuven.ac.be>\r
- * @author Antoon Bosselaers <antoon.bosselaers@esat.kuleuven.ac.be>\r
- * @author Paulo Barreto <paulo.barreto@terra.com.br>\r
- *\r
- * This code is hereby placed in the public domain.\r
- *\r
- * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ''AS IS'' AND ANY EXPRESS\r
- * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
- * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE\r
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR\r
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,\r
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE\r
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,\r
- * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
- */\r
-//#include "vl.h"\r
-#include <inttypes.h>\r
-#include <string.h>\r
-#include "aes.h"\r
-\r
-//#define NDEBUG\r
-#include <assert.h>\r
-\r
-typedef uint32_t u32;\r
-typedef uint16_t u16;\r
-typedef uint8_t u8;\r
-\r
-#define MAXKC (256/32)\r
-#define MAXKB (256/8)\r
-#define MAXNR 14\r
-\r
-/* This controls loop-unrolling in aes_core.c */\r
-#undef FULL_UNROLL\r
-# define GETU32(pt) (((u32)(pt)[0] << 24) ^ ((u32)(pt)[1] << 16) ^ ((u32)(pt)[2] << 8) ^ ((u32)(pt)[3]))\r
-# define PUTU32(ct, st) { (ct)[0] = (u8)((st) >> 24); (ct)[1] = (u8)((st) >> 16); (ct)[2] = (u8)((st) >> 8); (ct)[3] = (u8)(st); }\r
-\r
-/*\r
-Te0[x] = S [x].[02, 01, 01, 03];\r
-Te1[x] = S [x].[03, 02, 01, 01];\r
-Te2[x] = S [x].[01, 03, 02, 01];\r
-Te3[x] = S [x].[01, 01, 03, 02];\r
-Te4[x] = S [x].[01, 01, 01, 01];\r
-\r
-Td0[x] = Si[x].[0e, 09, 0d, 0b];\r
-Td1[x] = Si[x].[0b, 0e, 09, 0d];\r
-Td2[x] = Si[x].[0d, 0b, 0e, 09];\r
-Td3[x] = Si[x].[09, 0d, 0b, 0e];\r
-Td4[x] = Si[x].[01, 01, 01, 01];\r
-*/\r
-\r
-static const u32 Te0[256] = {\r
- 0xc66363a5U, 0xf87c7c84U, 0xee777799U, 0xf67b7b8dU,\r
- 0xfff2f20dU, 0xd66b6bbdU, 0xde6f6fb1U, 0x91c5c554U,\r
- 0x60303050U, 0x02010103U, 0xce6767a9U, 0x562b2b7dU,\r
- 0xe7fefe19U, 0xb5d7d762U, 0x4dababe6U, 0xec76769aU,\r
- 0x8fcaca45U, 0x1f82829dU, 0x89c9c940U, 0xfa7d7d87U,\r
- 0xeffafa15U, 0xb25959ebU, 0x8e4747c9U, 0xfbf0f00bU,\r
- 0x41adadecU, 0xb3d4d467U, 0x5fa2a2fdU, 0x45afafeaU,\r
- 0x239c9cbfU, 0x53a4a4f7U, 0xe4727296U, 0x9bc0c05bU,\r
- 0x75b7b7c2U, 0xe1fdfd1cU, 0x3d9393aeU, 0x4c26266aU,\r
- 0x6c36365aU, 0x7e3f3f41U, 0xf5f7f702U, 0x83cccc4fU,\r
- 0x6834345cU, 0x51a5a5f4U, 0xd1e5e534U, 0xf9f1f108U,\r
- 0xe2717193U, 0xabd8d873U, 0x62313153U, 0x2a15153fU,\r
- 0x0804040cU, 0x95c7c752U, 0x46232365U, 0x9dc3c35eU,\r
- 0x30181828U, 0x379696a1U, 0x0a05050fU, 0x2f9a9ab5U,\r
- 0x0e070709U, 0x24121236U, 0x1b80809bU, 0xdfe2e23dU,\r
- 0xcdebeb26U, 0x4e272769U, 0x7fb2b2cdU, 0xea75759fU,\r
- 0x1209091bU, 0x1d83839eU, 0x582c2c74U, 0x341a1a2eU,\r
- 0x361b1b2dU, 0xdc6e6eb2U, 0xb45a5aeeU, 0x5ba0a0fbU,\r
- 0xa45252f6U, 0x763b3b4dU, 0xb7d6d661U, 0x7db3b3ceU,\r
- 0x5229297bU, 0xdde3e33eU, 0x5e2f2f71U, 0x13848497U,\r
- 0xa65353f5U, 0xb9d1d168U, 0x00000000U, 0xc1eded2cU,\r
- 0x40202060U, 0xe3fcfc1fU, 0x79b1b1c8U, 0xb65b5bedU,\r
- 0xd46a6abeU, 0x8dcbcb46U, 0x67bebed9U, 0x7239394bU,\r
- 0x944a4adeU, 0x984c4cd4U, 0xb05858e8U, 0x85cfcf4aU,\r
- 0xbbd0d06bU, 0xc5efef2aU, 0x4faaaae5U, 0xedfbfb16U,\r
- 0x864343c5U, 0x9a4d4dd7U, 0x66333355U, 0x11858594U,\r
- 0x8a4545cfU, 0xe9f9f910U, 0x04020206U, 0xfe7f7f81U,\r
- 0xa05050f0U, 0x783c3c44U, 0x259f9fbaU, 0x4ba8a8e3U,\r
- 0xa25151f3U, 0x5da3a3feU, 0x804040c0U, 0x058f8f8aU,\r
- 0x3f9292adU, 0x219d9dbcU, 0x70383848U, 0xf1f5f504U,\r
- 0x63bcbcdfU, 0x77b6b6c1U, 0xafdada75U, 0x42212163U,\r
- 0x20101030U, 0xe5ffff1aU, 0xfdf3f30eU, 0xbfd2d26dU,\r
- 0x81cdcd4cU, 0x180c0c14U, 0x26131335U, 0xc3ecec2fU,\r
- 0xbe5f5fe1U, 0x359797a2U, 0x884444ccU, 0x2e171739U,\r
- 0x93c4c457U, 0x55a7a7f2U, 0xfc7e7e82U, 0x7a3d3d47U,\r
- 0xc86464acU, 0xba5d5de7U, 0x3219192bU, 0xe6737395U,\r
- 0xc06060a0U, 0x19818198U, 0x9e4f4fd1U, 0xa3dcdc7fU,\r
- 0x44222266U, 0x542a2a7eU, 0x3b9090abU, 0x0b888883U,\r
- 0x8c4646caU, 0xc7eeee29U, 0x6bb8b8d3U, 0x2814143cU,\r
- 0xa7dede79U, 0xbc5e5ee2U, 0x160b0b1dU, 0xaddbdb76U,\r
- 0xdbe0e03bU, 0x64323256U, 0x743a3a4eU, 0x140a0a1eU,\r
- 0x924949dbU, 0x0c06060aU, 0x4824246cU, 0xb85c5ce4U,\r
- 0x9fc2c25dU, 0xbdd3d36eU, 0x43acacefU, 0xc46262a6U,\r
- 0x399191a8U, 0x319595a4U, 0xd3e4e437U, 0xf279798bU,\r
- 0xd5e7e732U, 0x8bc8c843U, 0x6e373759U, 0xda6d6db7U,\r
- 0x018d8d8cU, 0xb1d5d564U, 0x9c4e4ed2U, 0x49a9a9e0U,\r
- 0xd86c6cb4U, 0xac5656faU, 0xf3f4f407U, 0xcfeaea25U,\r
- 0xca6565afU, 0xf47a7a8eU, 0x47aeaee9U, 0x10080818U,\r
- 0x6fbabad5U, 0xf0787888U, 0x4a25256fU, 0x5c2e2e72U,\r
- 0x381c1c24U, 0x57a6a6f1U, 0x73b4b4c7U, 0x97c6c651U,\r
- 0xcbe8e823U, 0xa1dddd7cU, 0xe874749cU, 0x3e1f1f21U,\r
- 0x964b4bddU, 0x61bdbddcU, 0x0d8b8b86U, 0x0f8a8a85U,\r
- 0xe0707090U, 0x7c3e3e42U, 0x71b5b5c4U, 0xcc6666aaU,\r
- 0x904848d8U, 0x06030305U, 0xf7f6f601U, 0x1c0e0e12U,\r
- 0xc26161a3U, 0x6a35355fU, 0xae5757f9U, 0x69b9b9d0U,\r
- 0x17868691U, 0x99c1c158U, 0x3a1d1d27U, 0x279e9eb9U,\r
- 0xd9e1e138U, 0xebf8f813U, 0x2b9898b3U, 0x22111133U,\r
- 0xd26969bbU, 0xa9d9d970U, 0x078e8e89U, 0x339494a7U,\r
- 0x2d9b9bb6U, 0x3c1e1e22U, 0x15878792U, 0xc9e9e920U,\r
- 0x87cece49U, 0xaa5555ffU, 0x50282878U, 0xa5dfdf7aU,\r
- 0x038c8c8fU, 0x59a1a1f8U, 0x09898980U, 0x1a0d0d17U,\r
- 0x65bfbfdaU, 0xd7e6e631U, 0x844242c6U, 0xd06868b8U,\r
- 0x824141c3U, 0x299999b0U, 0x5a2d2d77U, 0x1e0f0f11U,\r
- 0x7bb0b0cbU, 0xa85454fcU, 0x6dbbbbd6U, 0x2c16163aU,\r
-};\r
-static const u32 Te1[256] = {\r
- 0xa5c66363U, 0x84f87c7cU, 0x99ee7777U, 0x8df67b7bU,\r
- 0x0dfff2f2U, 0xbdd66b6bU, 0xb1de6f6fU, 0x5491c5c5U,\r
- 0x50603030U, 0x03020101U, 0xa9ce6767U, 0x7d562b2bU,\r
- 0x19e7fefeU, 0x62b5d7d7U, 0xe64dababU, 0x9aec7676U,\r
- 0x458fcacaU, 0x9d1f8282U, 0x4089c9c9U, 0x87fa7d7dU,\r
- 0x15effafaU, 0xebb25959U, 0xc98e4747U, 0x0bfbf0f0U,\r
- 0xec41adadU, 0x67b3d4d4U, 0xfd5fa2a2U, 0xea45afafU,\r
- 0xbf239c9cU, 0xf753a4a4U, 0x96e47272U, 0x5b9bc0c0U,\r
- 0xc275b7b7U, 0x1ce1fdfdU, 0xae3d9393U, 0x6a4c2626U,\r
- 0x5a6c3636U, 0x417e3f3fU, 0x02f5f7f7U, 0x4f83ccccU,\r
- 0x5c683434U, 0xf451a5a5U, 0x34d1e5e5U, 0x08f9f1f1U,\r
- 0x93e27171U, 0x73abd8d8U, 0x53623131U, 0x3f2a1515U,\r
- 0x0c080404U, 0x5295c7c7U, 0x65462323U, 0x5e9dc3c3U,\r
- 0x28301818U, 0xa1379696U, 0x0f0a0505U, 0xb52f9a9aU,\r
- 0x090e0707U, 0x36241212U, 0x9b1b8080U, 0x3ddfe2e2U,\r
- 0x26cdebebU, 0x694e2727U, 0xcd7fb2b2U, 0x9fea7575U,\r
- 0x1b120909U, 0x9e1d8383U, 0x74582c2cU, 0x2e341a1aU,\r
- 0x2d361b1bU, 0xb2dc6e6eU, 0xeeb45a5aU, 0xfb5ba0a0U,\r
- 0xf6a45252U, 0x4d763b3bU, 0x61b7d6d6U, 0xce7db3b3U,\r
- 0x7b522929U, 0x3edde3e3U, 0x715e2f2fU, 0x97138484U,\r
- 0xf5a65353U, 0x68b9d1d1U, 0x00000000U, 0x2cc1ededU,\r
- 0x60402020U, 0x1fe3fcfcU, 0xc879b1b1U, 0xedb65b5bU,\r
- 0xbed46a6aU, 0x468dcbcbU, 0xd967bebeU, 0x4b723939U,\r
- 0xde944a4aU, 0xd4984c4cU, 0xe8b05858U, 0x4a85cfcfU,\r
- 0x6bbbd0d0U, 0x2ac5efefU, 0xe54faaaaU, 0x16edfbfbU,\r
- 0xc5864343U, 0xd79a4d4dU, 0x55663333U, 0x94118585U,\r
- 0xcf8a4545U, 0x10e9f9f9U, 0x06040202U, 0x81fe7f7fU,\r
- 0xf0a05050U, 0x44783c3cU, 0xba259f9fU, 0xe34ba8a8U,\r
- 0xf3a25151U, 0xfe5da3a3U, 0xc0804040U, 0x8a058f8fU,\r
- 0xad3f9292U, 0xbc219d9dU, 0x48703838U, 0x04f1f5f5U,\r
- 0xdf63bcbcU, 0xc177b6b6U, 0x75afdadaU, 0x63422121U,\r
- 0x30201010U, 0x1ae5ffffU, 0x0efdf3f3U, 0x6dbfd2d2U,\r
- 0x4c81cdcdU, 0x14180c0cU, 0x35261313U, 0x2fc3ececU,\r
- 0xe1be5f5fU, 0xa2359797U, 0xcc884444U, 0x392e1717U,\r
- 0x5793c4c4U, 0xf255a7a7U, 0x82fc7e7eU, 0x477a3d3dU,\r
- 0xacc86464U, 0xe7ba5d5dU, 0x2b321919U, 0x95e67373U,\r
- 0xa0c06060U, 0x98198181U, 0xd19e4f4fU, 0x7fa3dcdcU,\r
- 0x66442222U, 0x7e542a2aU, 0xab3b9090U, 0x830b8888U,\r
- 0xca8c4646U, 0x29c7eeeeU, 0xd36bb8b8U, 0x3c281414U,\r
- 0x79a7dedeU, 0xe2bc5e5eU, 0x1d160b0bU, 0x76addbdbU,\r
- 0x3bdbe0e0U, 0x56643232U, 0x4e743a3aU, 0x1e140a0aU,\r
- 0xdb924949U, 0x0a0c0606U, 0x6c482424U, 0xe4b85c5cU,\r
- 0x5d9fc2c2U, 0x6ebdd3d3U, 0xef43acacU, 0xa6c46262U,\r
- 0xa8399191U, 0xa4319595U, 0x37d3e4e4U, 0x8bf27979U,\r
- 0x32d5e7e7U, 0x438bc8c8U, 0x596e3737U, 0xb7da6d6dU,\r
- 0x8c018d8dU, 0x64b1d5d5U, 0xd29c4e4eU, 0xe049a9a9U,\r
- 0xb4d86c6cU, 0xfaac5656U, 0x07f3f4f4U, 0x25cfeaeaU,\r
- 0xafca6565U, 0x8ef47a7aU, 0xe947aeaeU, 0x18100808U,\r
- 0xd56fbabaU, 0x88f07878U, 0x6f4a2525U, 0x725c2e2eU,\r
- 0x24381c1cU, 0xf157a6a6U, 0xc773b4b4U, 0x5197c6c6U,\r
- 0x23cbe8e8U, 0x7ca1ddddU, 0x9ce87474U, 0x213e1f1fU,\r
- 0xdd964b4bU, 0xdc61bdbdU, 0x860d8b8bU, 0x850f8a8aU,\r
- 0x90e07070U, 0x427c3e3eU, 0xc471b5b5U, 0xaacc6666U,\r
- 0xd8904848U, 0x05060303U, 0x01f7f6f6U, 0x121c0e0eU,\r
- 0xa3c26161U, 0x5f6a3535U, 0xf9ae5757U, 0xd069b9b9U,\r
- 0x91178686U, 0x5899c1c1U, 0x273a1d1dU, 0xb9279e9eU,\r
- 0x38d9e1e1U, 0x13ebf8f8U, 0xb32b9898U, 0x33221111U,\r
- 0xbbd26969U, 0x70a9d9d9U, 0x89078e8eU, 0xa7339494U,\r
- 0xb62d9b9bU, 0x223c1e1eU, 0x92158787U, 0x20c9e9e9U,\r
- 0x4987ceceU, 0xffaa5555U, 0x78502828U, 0x7aa5dfdfU,\r
- 0x8f038c8cU, 0xf859a1a1U, 0x80098989U, 0x171a0d0dU,\r
- 0xda65bfbfU, 0x31d7e6e6U, 0xc6844242U, 0xb8d06868U,\r
- 0xc3824141U, 0xb0299999U, 0x775a2d2dU, 0x111e0f0fU,\r
- 0xcb7bb0b0U, 0xfca85454U, 0xd66dbbbbU, 0x3a2c1616U,\r
-};\r
-static const u32 Te2[256] = {\r
- 0x63a5c663U, 0x7c84f87cU, 0x7799ee77U, 0x7b8df67bU,\r
- 0xf20dfff2U, 0x6bbdd66bU, 0x6fb1de6fU, 0xc55491c5U,\r
- 0x30506030U, 0x01030201U, 0x67a9ce67U, 0x2b7d562bU,\r
- 0xfe19e7feU, 0xd762b5d7U, 0xabe64dabU, 0x769aec76U,\r
- 0xca458fcaU, 0x829d1f82U, 0xc94089c9U, 0x7d87fa7dU,\r
- 0xfa15effaU, 0x59ebb259U, 0x47c98e47U, 0xf00bfbf0U,\r
- 0xadec41adU, 0xd467b3d4U, 0xa2fd5fa2U, 0xafea45afU,\r
- 0x9cbf239cU, 0xa4f753a4U, 0x7296e472U, 0xc05b9bc0U,\r
- 0xb7c275b7U, 0xfd1ce1fdU, 0x93ae3d93U, 0x266a4c26U,\r
- 0x365a6c36U, 0x3f417e3fU, 0xf702f5f7U, 0xcc4f83ccU,\r
- 0x345c6834U, 0xa5f451a5U, 0xe534d1e5U, 0xf108f9f1U,\r
- 0x7193e271U, 0xd873abd8U, 0x31536231U, 0x153f2a15U,\r
- 0x040c0804U, 0xc75295c7U, 0x23654623U, 0xc35e9dc3U,\r
- 0x18283018U, 0x96a13796U, 0x050f0a05U, 0x9ab52f9aU,\r
- 0x07090e07U, 0x12362412U, 0x809b1b80U, 0xe23ddfe2U,\r
- 0xeb26cdebU, 0x27694e27U, 0xb2cd7fb2U, 0x759fea75U,\r
- 0x091b1209U, 0x839e1d83U, 0x2c74582cU, 0x1a2e341aU,\r
- 0x1b2d361bU, 0x6eb2dc6eU, 0x5aeeb45aU, 0xa0fb5ba0U,\r
- 0x52f6a452U, 0x3b4d763bU, 0xd661b7d6U, 0xb3ce7db3U,\r
- 0x297b5229U, 0xe33edde3U, 0x2f715e2fU, 0x84971384U,\r
- 0x53f5a653U, 0xd168b9d1U, 0x00000000U, 0xed2cc1edU,\r
- 0x20604020U, 0xfc1fe3fcU, 0xb1c879b1U, 0x5bedb65bU,\r
- 0x6abed46aU, 0xcb468dcbU, 0xbed967beU, 0x394b7239U,\r
- 0x4ade944aU, 0x4cd4984cU, 0x58e8b058U, 0xcf4a85cfU,\r
- 0xd06bbbd0U, 0xef2ac5efU, 0xaae54faaU, 0xfb16edfbU,\r
- 0x43c58643U, 0x4dd79a4dU, 0x33556633U, 0x85941185U,\r
- 0x45cf8a45U, 0xf910e9f9U, 0x02060402U, 0x7f81fe7fU,\r
- 0x50f0a050U, 0x3c44783cU, 0x9fba259fU, 0xa8e34ba8U,\r
- 0x51f3a251U, 0xa3fe5da3U, 0x40c08040U, 0x8f8a058fU,\r
- 0x92ad3f92U, 0x9dbc219dU, 0x38487038U, 0xf504f1f5U,\r
- 0xbcdf63bcU, 0xb6c177b6U, 0xda75afdaU, 0x21634221U,\r
- 0x10302010U, 0xff1ae5ffU, 0xf30efdf3U, 0xd26dbfd2U,\r
- 0xcd4c81cdU, 0x0c14180cU, 0x13352613U, 0xec2fc3ecU,\r
- 0x5fe1be5fU, 0x97a23597U, 0x44cc8844U, 0x17392e17U,\r
- 0xc45793c4U, 0xa7f255a7U, 0x7e82fc7eU, 0x3d477a3dU,\r
- 0x64acc864U, 0x5de7ba5dU, 0x192b3219U, 0x7395e673U,\r
- 0x60a0c060U, 0x81981981U, 0x4fd19e4fU, 0xdc7fa3dcU,\r
- 0x22664422U, 0x2a7e542aU, 0x90ab3b90U, 0x88830b88U,\r
- 0x46ca8c46U, 0xee29c7eeU, 0xb8d36bb8U, 0x143c2814U,\r
- 0xde79a7deU, 0x5ee2bc5eU, 0x0b1d160bU, 0xdb76addbU,\r
- 0xe03bdbe0U, 0x32566432U, 0x3a4e743aU, 0x0a1e140aU,\r
- 0x49db9249U, 0x060a0c06U, 0x246c4824U, 0x5ce4b85cU,\r
- 0xc25d9fc2U, 0xd36ebdd3U, 0xacef43acU, 0x62a6c462U,\r
- 0x91a83991U, 0x95a43195U, 0xe437d3e4U, 0x798bf279U,\r
- 0xe732d5e7U, 0xc8438bc8U, 0x37596e37U, 0x6db7da6dU,\r
- 0x8d8c018dU, 0xd564b1d5U, 0x4ed29c4eU, 0xa9e049a9U,\r
- 0x6cb4d86cU, 0x56faac56U, 0xf407f3f4U, 0xea25cfeaU,\r
- 0x65afca65U, 0x7a8ef47aU, 0xaee947aeU, 0x08181008U,\r
- 0xbad56fbaU, 0x7888f078U, 0x256f4a25U, 0x2e725c2eU,\r
- 0x1c24381cU, 0xa6f157a6U, 0xb4c773b4U, 0xc65197c6U,\r
- 0xe823cbe8U, 0xdd7ca1ddU, 0x749ce874U, 0x1f213e1fU,\r
- 0x4bdd964bU, 0xbddc61bdU, 0x8b860d8bU, 0x8a850f8aU,\r
- 0x7090e070U, 0x3e427c3eU, 0xb5c471b5U, 0x66aacc66U,\r
- 0x48d89048U, 0x03050603U, 0xf601f7f6U, 0x0e121c0eU,\r
- 0x61a3c261U, 0x355f6a35U, 0x57f9ae57U, 0xb9d069b9U,\r
- 0x86911786U, 0xc15899c1U, 0x1d273a1dU, 0x9eb9279eU,\r
- 0xe138d9e1U, 0xf813ebf8U, 0x98b32b98U, 0x11332211U,\r
- 0x69bbd269U, 0xd970a9d9U, 0x8e89078eU, 0x94a73394U,\r
- 0x9bb62d9bU, 0x1e223c1eU, 0x87921587U, 0xe920c9e9U,\r
- 0xce4987ceU, 0x55ffaa55U, 0x28785028U, 0xdf7aa5dfU,\r
- 0x8c8f038cU, 0xa1f859a1U, 0x89800989U, 0x0d171a0dU,\r
- 0xbfda65bfU, 0xe631d7e6U, 0x42c68442U, 0x68b8d068U,\r
- 0x41c38241U, 0x99b02999U, 0x2d775a2dU, 0x0f111e0fU,\r
- 0xb0cb7bb0U, 0x54fca854U, 0xbbd66dbbU, 0x163a2c16U,\r
-};\r
-static const u32 Te3[256] = {\r
-\r
- 0x6363a5c6U, 0x7c7c84f8U, 0x777799eeU, 0x7b7b8df6U,\r
- 0xf2f20dffU, 0x6b6bbdd6U, 0x6f6fb1deU, 0xc5c55491U,\r
- 0x30305060U, 0x01010302U, 0x6767a9ceU, 0x2b2b7d56U,\r
- 0xfefe19e7U, 0xd7d762b5U, 0xababe64dU, 0x76769aecU,\r
- 0xcaca458fU, 0x82829d1fU, 0xc9c94089U, 0x7d7d87faU,\r
- 0xfafa15efU, 0x5959ebb2U, 0x4747c98eU, 0xf0f00bfbU,\r
- 0xadadec41U, 0xd4d467b3U, 0xa2a2fd5fU, 0xafafea45U,\r
- 0x9c9cbf23U, 0xa4a4f753U, 0x727296e4U, 0xc0c05b9bU,\r
- 0xb7b7c275U, 0xfdfd1ce1U, 0x9393ae3dU, 0x26266a4cU,\r
- 0x36365a6cU, 0x3f3f417eU, 0xf7f702f5U, 0xcccc4f83U,\r
- 0x34345c68U, 0xa5a5f451U, 0xe5e534d1U, 0xf1f108f9U,\r
- 0x717193e2U, 0xd8d873abU, 0x31315362U, 0x15153f2aU,\r
- 0x04040c08U, 0xc7c75295U, 0x23236546U, 0xc3c35e9dU,\r
- 0x18182830U, 0x9696a137U, 0x05050f0aU, 0x9a9ab52fU,\r
- 0x0707090eU, 0x12123624U, 0x80809b1bU, 0xe2e23ddfU,\r
- 0xebeb26cdU, 0x2727694eU, 0xb2b2cd7fU, 0x75759feaU,\r
- 0x09091b12U, 0x83839e1dU, 0x2c2c7458U, 0x1a1a2e34U,\r
- 0x1b1b2d36U, 0x6e6eb2dcU, 0x5a5aeeb4U, 0xa0a0fb5bU,\r
- 0x5252f6a4U, 0x3b3b4d76U, 0xd6d661b7U, 0xb3b3ce7dU,\r
- 0x29297b52U, 0xe3e33eddU, 0x2f2f715eU, 0x84849713U,\r
- 0x5353f5a6U, 0xd1d168b9U, 0x00000000U, 0xeded2cc1U,\r
- 0x20206040U, 0xfcfc1fe3U, 0xb1b1c879U, 0x5b5bedb6U,\r
- 0x6a6abed4U, 0xcbcb468dU, 0xbebed967U, 0x39394b72U,\r
- 0x4a4ade94U, 0x4c4cd498U, 0x5858e8b0U, 0xcfcf4a85U,\r
- 0xd0d06bbbU, 0xefef2ac5U, 0xaaaae54fU, 0xfbfb16edU,\r
- 0x4343c586U, 0x4d4dd79aU, 0x33335566U, 0x85859411U,\r
- 0x4545cf8aU, 0xf9f910e9U, 0x02020604U, 0x7f7f81feU,\r
- 0x5050f0a0U, 0x3c3c4478U, 0x9f9fba25U, 0xa8a8e34bU,\r
- 0x5151f3a2U, 0xa3a3fe5dU, 0x4040c080U, 0x8f8f8a05U,\r
- 0x9292ad3fU, 0x9d9dbc21U, 0x38384870U, 0xf5f504f1U,\r
- 0xbcbcdf63U, 0xb6b6c177U, 0xdada75afU, 0x21216342U,\r
- 0x10103020U, 0xffff1ae5U, 0xf3f30efdU, 0xd2d26dbfU,\r
- 0xcdcd4c81U, 0x0c0c1418U, 0x13133526U, 0xecec2fc3U,\r
- 0x5f5fe1beU, 0x9797a235U, 0x4444cc88U, 0x1717392eU,\r
- 0xc4c45793U, 0xa7a7f255U, 0x7e7e82fcU, 0x3d3d477aU,\r
- 0x6464acc8U, 0x5d5de7baU, 0x19192b32U, 0x737395e6U,\r
- 0x6060a0c0U, 0x81819819U, 0x4f4fd19eU, 0xdcdc7fa3U,\r
- 0x22226644U, 0x2a2a7e54U, 0x9090ab3bU, 0x8888830bU,\r
- 0x4646ca8cU, 0xeeee29c7U, 0xb8b8d36bU, 0x14143c28U,\r
- 0xdede79a7U, 0x5e5ee2bcU, 0x0b0b1d16U, 0xdbdb76adU,\r
- 0xe0e03bdbU, 0x32325664U, 0x3a3a4e74U, 0x0a0a1e14U,\r
- 0x4949db92U, 0x06060a0cU, 0x24246c48U, 0x5c5ce4b8U,\r
- 0xc2c25d9fU, 0xd3d36ebdU, 0xacacef43U, 0x6262a6c4U,\r
- 0x9191a839U, 0x9595a431U, 0xe4e437d3U, 0x79798bf2U,\r
- 0xe7e732d5U, 0xc8c8438bU, 0x3737596eU, 0x6d6db7daU,\r
- 0x8d8d8c01U, 0xd5d564b1U, 0x4e4ed29cU, 0xa9a9e049U,\r
- 0x6c6cb4d8U, 0x5656faacU, 0xf4f407f3U, 0xeaea25cfU,\r
- 0x6565afcaU, 0x7a7a8ef4U, 0xaeaee947U, 0x08081810U,\r
- 0xbabad56fU, 0x787888f0U, 0x25256f4aU, 0x2e2e725cU,\r
- 0x1c1c2438U, 0xa6a6f157U, 0xb4b4c773U, 0xc6c65197U,\r
- 0xe8e823cbU, 0xdddd7ca1U, 0x74749ce8U, 0x1f1f213eU,\r
- 0x4b4bdd96U, 0xbdbddc61U, 0x8b8b860dU, 0x8a8a850fU,\r
- 0x707090e0U, 0x3e3e427cU, 0xb5b5c471U, 0x6666aaccU,\r
- 0x4848d890U, 0x03030506U, 0xf6f601f7U, 0x0e0e121cU,\r
- 0x6161a3c2U, 0x35355f6aU, 0x5757f9aeU, 0xb9b9d069U,\r
- 0x86869117U, 0xc1c15899U, 0x1d1d273aU, 0x9e9eb927U,\r
- 0xe1e138d9U, 0xf8f813ebU, 0x9898b32bU, 0x11113322U,\r
- 0x6969bbd2U, 0xd9d970a9U, 0x8e8e8907U, 0x9494a733U,\r
- 0x9b9bb62dU, 0x1e1e223cU, 0x87879215U, 0xe9e920c9U,\r
- 0xcece4987U, 0x5555ffaaU, 0x28287850U, 0xdfdf7aa5U,\r
- 0x8c8c8f03U, 0xa1a1f859U, 0x89898009U, 0x0d0d171aU,\r
- 0xbfbfda65U, 0xe6e631d7U, 0x4242c684U, 0x6868b8d0U,\r
- 0x4141c382U, 0x9999b029U, 0x2d2d775aU, 0x0f0f111eU,\r
- 0xb0b0cb7bU, 0x5454fca8U, 0xbbbbd66dU, 0x16163a2cU,\r
-};\r
-static const u32 Te4[256] = {\r
- 0x63636363U, 0x7c7c7c7cU, 0x77777777U, 0x7b7b7b7bU,\r
- 0xf2f2f2f2U, 0x6b6b6b6bU, 0x6f6f6f6fU, 0xc5c5c5c5U,\r
- 0x30303030U, 0x01010101U, 0x67676767U, 0x2b2b2b2bU,\r
- 0xfefefefeU, 0xd7d7d7d7U, 0xababababU, 0x76767676U,\r
- 0xcacacacaU, 0x82828282U, 0xc9c9c9c9U, 0x7d7d7d7dU,\r
- 0xfafafafaU, 0x59595959U, 0x47474747U, 0xf0f0f0f0U,\r
- 0xadadadadU, 0xd4d4d4d4U, 0xa2a2a2a2U, 0xafafafafU,\r
- 0x9c9c9c9cU, 0xa4a4a4a4U, 0x72727272U, 0xc0c0c0c0U,\r
- 0xb7b7b7b7U, 0xfdfdfdfdU, 0x93939393U, 0x26262626U,\r
- 0x36363636U, 0x3f3f3f3fU, 0xf7f7f7f7U, 0xccccccccU,\r
- 0x34343434U, 0xa5a5a5a5U, 0xe5e5e5e5U, 0xf1f1f1f1U,\r
- 0x71717171U, 0xd8d8d8d8U, 0x31313131U, 0x15151515U,\r
- 0x04040404U, 0xc7c7c7c7U, 0x23232323U, 0xc3c3c3c3U,\r
- 0x18181818U, 0x96969696U, 0x05050505U, 0x9a9a9a9aU,\r
- 0x07070707U, 0x12121212U, 0x80808080U, 0xe2e2e2e2U,\r
- 0xebebebebU, 0x27272727U, 0xb2b2b2b2U, 0x75757575U,\r
- 0x09090909U, 0x83838383U, 0x2c2c2c2cU, 0x1a1a1a1aU,\r
- 0x1b1b1b1bU, 0x6e6e6e6eU, 0x5a5a5a5aU, 0xa0a0a0a0U,\r
- 0x52525252U, 0x3b3b3b3bU, 0xd6d6d6d6U, 0xb3b3b3b3U,\r
- 0x29292929U, 0xe3e3e3e3U, 0x2f2f2f2fU, 0x84848484U,\r
- 0x53535353U, 0xd1d1d1d1U, 0x00000000U, 0xededededU,\r
- 0x20202020U, 0xfcfcfcfcU, 0xb1b1b1b1U, 0x5b5b5b5bU,\r
- 0x6a6a6a6aU, 0xcbcbcbcbU, 0xbebebebeU, 0x39393939U,\r
- 0x4a4a4a4aU, 0x4c4c4c4cU, 0x58585858U, 0xcfcfcfcfU,\r
- 0xd0d0d0d0U, 0xefefefefU, 0xaaaaaaaaU, 0xfbfbfbfbU,\r
- 0x43434343U, 0x4d4d4d4dU, 0x33333333U, 0x85858585U,\r
- 0x45454545U, 0xf9f9f9f9U, 0x02020202U, 0x7f7f7f7fU,\r
- 0x50505050U, 0x3c3c3c3cU, 0x9f9f9f9fU, 0xa8a8a8a8U,\r
- 0x51515151U, 0xa3a3a3a3U, 0x40404040U, 0x8f8f8f8fU,\r
- 0x92929292U, 0x9d9d9d9dU, 0x38383838U, 0xf5f5f5f5U,\r
- 0xbcbcbcbcU, 0xb6b6b6b6U, 0xdadadadaU, 0x21212121U,\r
- 0x10101010U, 0xffffffffU, 0xf3f3f3f3U, 0xd2d2d2d2U,\r
- 0xcdcdcdcdU, 0x0c0c0c0cU, 0x13131313U, 0xececececU,\r
- 0x5f5f5f5fU, 0x97979797U, 0x44444444U, 0x17171717U,\r
- 0xc4c4c4c4U, 0xa7a7a7a7U, 0x7e7e7e7eU, 0x3d3d3d3dU,\r
- 0x64646464U, 0x5d5d5d5dU, 0x19191919U, 0x73737373U,\r
- 0x60606060U, 0x81818181U, 0x4f4f4f4fU, 0xdcdcdcdcU,\r
- 0x22222222U, 0x2a2a2a2aU, 0x90909090U, 0x88888888U,\r
- 0x46464646U, 0xeeeeeeeeU, 0xb8b8b8b8U, 0x14141414U,\r
- 0xdedededeU, 0x5e5e5e5eU, 0x0b0b0b0bU, 0xdbdbdbdbU,\r
- 0xe0e0e0e0U, 0x32323232U, 0x3a3a3a3aU, 0x0a0a0a0aU,\r
- 0x49494949U, 0x06060606U, 0x24242424U, 0x5c5c5c5cU,\r
- 0xc2c2c2c2U, 0xd3d3d3d3U, 0xacacacacU, 0x62626262U,\r
- 0x91919191U, 0x95959595U, 0xe4e4e4e4U, 0x79797979U,\r
- 0xe7e7e7e7U, 0xc8c8c8c8U, 0x37373737U, 0x6d6d6d6dU,\r
- 0x8d8d8d8dU, 0xd5d5d5d5U, 0x4e4e4e4eU, 0xa9a9a9a9U,\r
- 0x6c6c6c6cU, 0x56565656U, 0xf4f4f4f4U, 0xeaeaeaeaU,\r
- 0x65656565U, 0x7a7a7a7aU, 0xaeaeaeaeU, 0x08080808U,\r
- 0xbabababaU, 0x78787878U, 0x25252525U, 0x2e2e2e2eU,\r
- 0x1c1c1c1cU, 0xa6a6a6a6U, 0xb4b4b4b4U, 0xc6c6c6c6U,\r
- 0xe8e8e8e8U, 0xddddddddU, 0x74747474U, 0x1f1f1f1fU,\r
- 0x4b4b4b4bU, 0xbdbdbdbdU, 0x8b8b8b8bU, 0x8a8a8a8aU,\r
- 0x70707070U, 0x3e3e3e3eU, 0xb5b5b5b5U, 0x66666666U,\r
- 0x48484848U, 0x03030303U, 0xf6f6f6f6U, 0x0e0e0e0eU,\r
- 0x61616161U, 0x35353535U, 0x57575757U, 0xb9b9b9b9U,\r
- 0x86868686U, 0xc1c1c1c1U, 0x1d1d1d1dU, 0x9e9e9e9eU,\r
- 0xe1e1e1e1U, 0xf8f8f8f8U, 0x98989898U, 0x11111111U,\r
- 0x69696969U, 0xd9d9d9d9U, 0x8e8e8e8eU, 0x94949494U,\r
- 0x9b9b9b9bU, 0x1e1e1e1eU, 0x87878787U, 0xe9e9e9e9U,\r
- 0xcecececeU, 0x55555555U, 0x28282828U, 0xdfdfdfdfU,\r
- 0x8c8c8c8cU, 0xa1a1a1a1U, 0x89898989U, 0x0d0d0d0dU,\r
- 0xbfbfbfbfU, 0xe6e6e6e6U, 0x42424242U, 0x68686868U,\r
- 0x41414141U, 0x99999999U, 0x2d2d2d2dU, 0x0f0f0f0fU,\r
- 0xb0b0b0b0U, 0x54545454U, 0xbbbbbbbbU, 0x16161616U,\r
-};\r
-static const u32 Td0[256] = {\r
- 0x51f4a750U, 0x7e416553U, 0x1a17a4c3U, 0x3a275e96U,\r
- 0x3bab6bcbU, 0x1f9d45f1U, 0xacfa58abU, 0x4be30393U,\r
- 0x2030fa55U, 0xad766df6U, 0x88cc7691U, 0xf5024c25U,\r
- 0x4fe5d7fcU, 0xc52acbd7U, 0x26354480U, 0xb562a38fU,\r
- 0xdeb15a49U, 0x25ba1b67U, 0x45ea0e98U, 0x5dfec0e1U,\r
- 0xc32f7502U, 0x814cf012U, 0x8d4697a3U, 0x6bd3f9c6U,\r
- 0x038f5fe7U, 0x15929c95U, 0xbf6d7aebU, 0x955259daU,\r
- 0xd4be832dU, 0x587421d3U, 0x49e06929U, 0x8ec9c844U,\r
- 0x75c2896aU, 0xf48e7978U, 0x99583e6bU, 0x27b971ddU,\r
- 0xbee14fb6U, 0xf088ad17U, 0xc920ac66U, 0x7dce3ab4U,\r
- 0x63df4a18U, 0xe51a3182U, 0x97513360U, 0x62537f45U,\r
- 0xb16477e0U, 0xbb6bae84U, 0xfe81a01cU, 0xf9082b94U,\r
- 0x70486858U, 0x8f45fd19U, 0x94de6c87U, 0x527bf8b7U,\r
- 0xab73d323U, 0x724b02e2U, 0xe31f8f57U, 0x6655ab2aU,\r
- 0xb2eb2807U, 0x2fb5c203U, 0x86c57b9aU, 0xd33708a5U,\r
- 0x302887f2U, 0x23bfa5b2U, 0x02036abaU, 0xed16825cU,\r
- 0x8acf1c2bU, 0xa779b492U, 0xf307f2f0U, 0x4e69e2a1U,\r
- 0x65daf4cdU, 0x0605bed5U, 0xd134621fU, 0xc4a6fe8aU,\r
- 0x342e539dU, 0xa2f355a0U, 0x058ae132U, 0xa4f6eb75U,\r
- 0x0b83ec39U, 0x4060efaaU, 0x5e719f06U, 0xbd6e1051U,\r
- 0x3e218af9U, 0x96dd063dU, 0xdd3e05aeU, 0x4de6bd46U,\r
- 0x91548db5U, 0x71c45d05U, 0x0406d46fU, 0x605015ffU,\r
- 0x1998fb24U, 0xd6bde997U, 0x894043ccU, 0x67d99e77U,\r
- 0xb0e842bdU, 0x07898b88U, 0xe7195b38U, 0x79c8eedbU,\r
- 0xa17c0a47U, 0x7c420fe9U, 0xf8841ec9U, 0x00000000U,\r
- 0x09808683U, 0x322bed48U, 0x1e1170acU, 0x6c5a724eU,\r
- 0xfd0efffbU, 0x0f853856U, 0x3daed51eU, 0x362d3927U,\r
- 0x0a0fd964U, 0x685ca621U, 0x9b5b54d1U, 0x24362e3aU,\r
- 0x0c0a67b1U, 0x9357e70fU, 0xb4ee96d2U, 0x1b9b919eU,\r
- 0x80c0c54fU, 0x61dc20a2U, 0x5a774b69U, 0x1c121a16U,\r
- 0xe293ba0aU, 0xc0a02ae5U, 0x3c22e043U, 0x121b171dU,\r
- 0x0e090d0bU, 0xf28bc7adU, 0x2db6a8b9U, 0x141ea9c8U,\r
- 0x57f11985U, 0xaf75074cU, 0xee99ddbbU, 0xa37f60fdU,\r
- 0xf701269fU, 0x5c72f5bcU, 0x44663bc5U, 0x5bfb7e34U,\r
- 0x8b432976U, 0xcb23c6dcU, 0xb6edfc68U, 0xb8e4f163U,\r
- 0xd731dccaU, 0x42638510U, 0x13972240U, 0x84c61120U,\r
- 0x854a247dU, 0xd2bb3df8U, 0xaef93211U, 0xc729a16dU,\r
- 0x1d9e2f4bU, 0xdcb230f3U, 0x0d8652ecU, 0x77c1e3d0U,\r
- 0x2bb3166cU, 0xa970b999U, 0x119448faU, 0x47e96422U,\r
- 0xa8fc8cc4U, 0xa0f03f1aU, 0x567d2cd8U, 0x223390efU,\r
- 0x87494ec7U, 0xd938d1c1U, 0x8ccaa2feU, 0x98d40b36U,\r
- 0xa6f581cfU, 0xa57ade28U, 0xdab78e26U, 0x3fadbfa4U,\r
- 0x2c3a9de4U, 0x5078920dU, 0x6a5fcc9bU, 0x547e4662U,\r
- 0xf68d13c2U, 0x90d8b8e8U, 0x2e39f75eU, 0x82c3aff5U,\r
- 0x9f5d80beU, 0x69d0937cU, 0x6fd52da9U, 0xcf2512b3U,\r
- 0xc8ac993bU, 0x10187da7U, 0xe89c636eU, 0xdb3bbb7bU,\r
- 0xcd267809U, 0x6e5918f4U, 0xec9ab701U, 0x834f9aa8U,\r
- 0xe6956e65U, 0xaaffe67eU, 0x21bccf08U, 0xef15e8e6U,\r
- 0xbae79bd9U, 0x4a6f36ceU, 0xea9f09d4U, 0x29b07cd6U,\r
- 0x31a4b2afU, 0x2a3f2331U, 0xc6a59430U, 0x35a266c0U,\r
- 0x744ebc37U, 0xfc82caa6U, 0xe090d0b0U, 0x33a7d815U,\r
- 0xf104984aU, 0x41ecdaf7U, 0x7fcd500eU, 0x1791f62fU,\r
- 0x764dd68dU, 0x43efb04dU, 0xccaa4d54U, 0xe49604dfU,\r
- 0x9ed1b5e3U, 0x4c6a881bU, 0xc12c1fb8U, 0x4665517fU,\r
- 0x9d5eea04U, 0x018c355dU, 0xfa877473U, 0xfb0b412eU,\r
- 0xb3671d5aU, 0x92dbd252U, 0xe9105633U, 0x6dd64713U,\r
- 0x9ad7618cU, 0x37a10c7aU, 0x59f8148eU, 0xeb133c89U,\r
- 0xcea927eeU, 0xb761c935U, 0xe11ce5edU, 0x7a47b13cU,\r
- 0x9cd2df59U, 0x55f2733fU, 0x1814ce79U, 0x73c737bfU,\r
- 0x53f7cdeaU, 0x5ffdaa5bU, 0xdf3d6f14U, 0x7844db86U,\r
- 0xcaaff381U, 0xb968c43eU, 0x3824342cU, 0xc2a3405fU,\r
- 0x161dc372U, 0xbce2250cU, 0x283c498bU, 0xff0d9541U,\r
- 0x39a80171U, 0x080cb3deU, 0xd8b4e49cU, 0x6456c190U,\r
- 0x7bcb8461U, 0xd532b670U, 0x486c5c74U, 0xd0b85742U,\r
-};\r
-static const u32 Td1[256] = {\r
- 0x5051f4a7U, 0x537e4165U, 0xc31a17a4U, 0x963a275eU,\r
- 0xcb3bab6bU, 0xf11f9d45U, 0xabacfa58U, 0x934be303U,\r
- 0x552030faU, 0xf6ad766dU, 0x9188cc76U, 0x25f5024cU,\r
- 0xfc4fe5d7U, 0xd7c52acbU, 0x80263544U, 0x8fb562a3U,\r
- 0x49deb15aU, 0x6725ba1bU, 0x9845ea0eU, 0xe15dfec0U,\r
- 0x02c32f75U, 0x12814cf0U, 0xa38d4697U, 0xc66bd3f9U,\r
- 0xe7038f5fU, 0x9515929cU, 0xebbf6d7aU, 0xda955259U,\r
- 0x2dd4be83U, 0xd3587421U, 0x2949e069U, 0x448ec9c8U,\r
- 0x6a75c289U, 0x78f48e79U, 0x6b99583eU, 0xdd27b971U,\r
- 0xb6bee14fU, 0x17f088adU, 0x66c920acU, 0xb47dce3aU,\r
- 0x1863df4aU, 0x82e51a31U, 0x60975133U, 0x4562537fU,\r
- 0xe0b16477U, 0x84bb6baeU, 0x1cfe81a0U, 0x94f9082bU,\r
- 0x58704868U, 0x198f45fdU, 0x8794de6cU, 0xb7527bf8U,\r
- 0x23ab73d3U, 0xe2724b02U, 0x57e31f8fU, 0x2a6655abU,\r
- 0x07b2eb28U, 0x032fb5c2U, 0x9a86c57bU, 0xa5d33708U,\r
- 0xf2302887U, 0xb223bfa5U, 0xba02036aU, 0x5ced1682U,\r
- 0x2b8acf1cU, 0x92a779b4U, 0xf0f307f2U, 0xa14e69e2U,\r
- 0xcd65daf4U, 0xd50605beU, 0x1fd13462U, 0x8ac4a6feU,\r
- 0x9d342e53U, 0xa0a2f355U, 0x32058ae1U, 0x75a4f6ebU,\r
- 0x390b83ecU, 0xaa4060efU, 0x065e719fU, 0x51bd6e10U,\r
- 0xf93e218aU, 0x3d96dd06U, 0xaedd3e05U, 0x464de6bdU,\r
- 0xb591548dU, 0x0571c45dU, 0x6f0406d4U, 0xff605015U,\r
- 0x241998fbU, 0x97d6bde9U, 0xcc894043U, 0x7767d99eU,\r
- 0xbdb0e842U, 0x8807898bU, 0x38e7195bU, 0xdb79c8eeU,\r
- 0x47a17c0aU, 0xe97c420fU, 0xc9f8841eU, 0x00000000U,\r
- 0x83098086U, 0x48322bedU, 0xac1e1170U, 0x4e6c5a72U,\r
- 0xfbfd0effU, 0x560f8538U, 0x1e3daed5U, 0x27362d39U,\r
- 0x640a0fd9U, 0x21685ca6U, 0xd19b5b54U, 0x3a24362eU,\r
- 0xb10c0a67U, 0x0f9357e7U, 0xd2b4ee96U, 0x9e1b9b91U,\r
- 0x4f80c0c5U, 0xa261dc20U, 0x695a774bU, 0x161c121aU,\r
- 0x0ae293baU, 0xe5c0a02aU, 0x433c22e0U, 0x1d121b17U,\r
- 0x0b0e090dU, 0xadf28bc7U, 0xb92db6a8U, 0xc8141ea9U,\r
- 0x8557f119U, 0x4caf7507U, 0xbbee99ddU, 0xfda37f60U,\r
- 0x9ff70126U, 0xbc5c72f5U, 0xc544663bU, 0x345bfb7eU,\r
- 0x768b4329U, 0xdccb23c6U, 0x68b6edfcU, 0x63b8e4f1U,\r
- 0xcad731dcU, 0x10426385U, 0x40139722U, 0x2084c611U,\r
- 0x7d854a24U, 0xf8d2bb3dU, 0x11aef932U, 0x6dc729a1U,\r
- 0x4b1d9e2fU, 0xf3dcb230U, 0xec0d8652U, 0xd077c1e3U,\r
- 0x6c2bb316U, 0x99a970b9U, 0xfa119448U, 0x2247e964U,\r
- 0xc4a8fc8cU, 0x1aa0f03fU, 0xd8567d2cU, 0xef223390U,\r
- 0xc787494eU, 0xc1d938d1U, 0xfe8ccaa2U, 0x3698d40bU,\r
- 0xcfa6f581U, 0x28a57adeU, 0x26dab78eU, 0xa43fadbfU,\r
- 0xe42c3a9dU, 0x0d507892U, 0x9b6a5fccU, 0x62547e46U,\r
- 0xc2f68d13U, 0xe890d8b8U, 0x5e2e39f7U, 0xf582c3afU,\r
- 0xbe9f5d80U, 0x7c69d093U, 0xa96fd52dU, 0xb3cf2512U,\r
- 0x3bc8ac99U, 0xa710187dU, 0x6ee89c63U, 0x7bdb3bbbU,\r
- 0x09cd2678U, 0xf46e5918U, 0x01ec9ab7U, 0xa8834f9aU,\r
- 0x65e6956eU, 0x7eaaffe6U, 0x0821bccfU, 0xe6ef15e8U,\r
- 0xd9bae79bU, 0xce4a6f36U, 0xd4ea9f09U, 0xd629b07cU,\r
- 0xaf31a4b2U, 0x312a3f23U, 0x30c6a594U, 0xc035a266U,\r
- 0x37744ebcU, 0xa6fc82caU, 0xb0e090d0U, 0x1533a7d8U,\r
- 0x4af10498U, 0xf741ecdaU, 0x0e7fcd50U, 0x2f1791f6U,\r
- 0x8d764dd6U, 0x4d43efb0U, 0x54ccaa4dU, 0xdfe49604U,\r
- 0xe39ed1b5U, 0x1b4c6a88U, 0xb8c12c1fU, 0x7f466551U,\r
- 0x049d5eeaU, 0x5d018c35U, 0x73fa8774U, 0x2efb0b41U,\r
- 0x5ab3671dU, 0x5292dbd2U, 0x33e91056U, 0x136dd647U,\r
- 0x8c9ad761U, 0x7a37a10cU, 0x8e59f814U, 0x89eb133cU,\r
- 0xeecea927U, 0x35b761c9U, 0xede11ce5U, 0x3c7a47b1U,\r
- 0x599cd2dfU, 0x3f55f273U, 0x791814ceU, 0xbf73c737U,\r
- 0xea53f7cdU, 0x5b5ffdaaU, 0x14df3d6fU, 0x867844dbU,\r
- 0x81caaff3U, 0x3eb968c4U, 0x2c382434U, 0x5fc2a340U,\r
- 0x72161dc3U, 0x0cbce225U, 0x8b283c49U, 0x41ff0d95U,\r
- 0x7139a801U, 0xde080cb3U, 0x9cd8b4e4U, 0x906456c1U,\r
- 0x617bcb84U, 0x70d532b6U, 0x74486c5cU, 0x42d0b857U,\r
-};\r
-static const u32 Td2[256] = {\r
- 0xa75051f4U, 0x65537e41U, 0xa4c31a17U, 0x5e963a27U,\r
- 0x6bcb3babU, 0x45f11f9dU, 0x58abacfaU, 0x03934be3U,\r
- 0xfa552030U, 0x6df6ad76U, 0x769188ccU, 0x4c25f502U,\r
- 0xd7fc4fe5U, 0xcbd7c52aU, 0x44802635U, 0xa38fb562U,\r
- 0x5a49deb1U, 0x1b6725baU, 0x0e9845eaU, 0xc0e15dfeU,\r
- 0x7502c32fU, 0xf012814cU, 0x97a38d46U, 0xf9c66bd3U,\r
- 0x5fe7038fU, 0x9c951592U, 0x7aebbf6dU, 0x59da9552U,\r
- 0x832dd4beU, 0x21d35874U, 0x692949e0U, 0xc8448ec9U,\r
- 0x896a75c2U, 0x7978f48eU, 0x3e6b9958U, 0x71dd27b9U,\r
- 0x4fb6bee1U, 0xad17f088U, 0xac66c920U, 0x3ab47dceU,\r
- 0x4a1863dfU, 0x3182e51aU, 0x33609751U, 0x7f456253U,\r
- 0x77e0b164U, 0xae84bb6bU, 0xa01cfe81U, 0x2b94f908U,\r
- 0x68587048U, 0xfd198f45U, 0x6c8794deU, 0xf8b7527bU,\r
- 0xd323ab73U, 0x02e2724bU, 0x8f57e31fU, 0xab2a6655U,\r
- 0x2807b2ebU, 0xc2032fb5U, 0x7b9a86c5U, 0x08a5d337U,\r
- 0x87f23028U, 0xa5b223bfU, 0x6aba0203U, 0x825ced16U,\r
- 0x1c2b8acfU, 0xb492a779U, 0xf2f0f307U, 0xe2a14e69U,\r
- 0xf4cd65daU, 0xbed50605U, 0x621fd134U, 0xfe8ac4a6U,\r
- 0x539d342eU, 0x55a0a2f3U, 0xe132058aU, 0xeb75a4f6U,\r
- 0xec390b83U, 0xefaa4060U, 0x9f065e71U, 0x1051bd6eU,\r
-\r
- 0x8af93e21U, 0x063d96ddU, 0x05aedd3eU, 0xbd464de6U,\r
- 0x8db59154U, 0x5d0571c4U, 0xd46f0406U, 0x15ff6050U,\r
- 0xfb241998U, 0xe997d6bdU, 0x43cc8940U, 0x9e7767d9U,\r
- 0x42bdb0e8U, 0x8b880789U, 0x5b38e719U, 0xeedb79c8U,\r
- 0x0a47a17cU, 0x0fe97c42U, 0x1ec9f884U, 0x00000000U,\r
- 0x86830980U, 0xed48322bU, 0x70ac1e11U, 0x724e6c5aU,\r
- 0xfffbfd0eU, 0x38560f85U, 0xd51e3daeU, 0x3927362dU,\r
- 0xd9640a0fU, 0xa621685cU, 0x54d19b5bU, 0x2e3a2436U,\r
- 0x67b10c0aU, 0xe70f9357U, 0x96d2b4eeU, 0x919e1b9bU,\r
- 0xc54f80c0U, 0x20a261dcU, 0x4b695a77U, 0x1a161c12U,\r
- 0xba0ae293U, 0x2ae5c0a0U, 0xe0433c22U, 0x171d121bU,\r
- 0x0d0b0e09U, 0xc7adf28bU, 0xa8b92db6U, 0xa9c8141eU,\r
- 0x198557f1U, 0x074caf75U, 0xddbbee99U, 0x60fda37fU,\r
- 0x269ff701U, 0xf5bc5c72U, 0x3bc54466U, 0x7e345bfbU,\r
- 0x29768b43U, 0xc6dccb23U, 0xfc68b6edU, 0xf163b8e4U,\r
- 0xdccad731U, 0x85104263U, 0x22401397U, 0x112084c6U,\r
- 0x247d854aU, 0x3df8d2bbU, 0x3211aef9U, 0xa16dc729U,\r
- 0x2f4b1d9eU, 0x30f3dcb2U, 0x52ec0d86U, 0xe3d077c1U,\r
- 0x166c2bb3U, 0xb999a970U, 0x48fa1194U, 0x642247e9U,\r
- 0x8cc4a8fcU, 0x3f1aa0f0U, 0x2cd8567dU, 0x90ef2233U,\r
- 0x4ec78749U, 0xd1c1d938U, 0xa2fe8ccaU, 0x0b3698d4U,\r
- 0x81cfa6f5U, 0xde28a57aU, 0x8e26dab7U, 0xbfa43fadU,\r
- 0x9de42c3aU, 0x920d5078U, 0xcc9b6a5fU, 0x4662547eU,\r
- 0x13c2f68dU, 0xb8e890d8U, 0xf75e2e39U, 0xaff582c3U,\r
- 0x80be9f5dU, 0x937c69d0U, 0x2da96fd5U, 0x12b3cf25U,\r
- 0x993bc8acU, 0x7da71018U, 0x636ee89cU, 0xbb7bdb3bU,\r
- 0x7809cd26U, 0x18f46e59U, 0xb701ec9aU, 0x9aa8834fU,\r
- 0x6e65e695U, 0xe67eaaffU, 0xcf0821bcU, 0xe8e6ef15U,\r
- 0x9bd9bae7U, 0x36ce4a6fU, 0x09d4ea9fU, 0x7cd629b0U,\r
- 0xb2af31a4U, 0x23312a3fU, 0x9430c6a5U, 0x66c035a2U,\r
- 0xbc37744eU, 0xcaa6fc82U, 0xd0b0e090U, 0xd81533a7U,\r
- 0x984af104U, 0xdaf741ecU, 0x500e7fcdU, 0xf62f1791U,\r
- 0xd68d764dU, 0xb04d43efU, 0x4d54ccaaU, 0x04dfe496U,\r
- 0xb5e39ed1U, 0x881b4c6aU, 0x1fb8c12cU, 0x517f4665U,\r
- 0xea049d5eU, 0x355d018cU, 0x7473fa87U, 0x412efb0bU,\r
- 0x1d5ab367U, 0xd25292dbU, 0x5633e910U, 0x47136dd6U,\r
- 0x618c9ad7U, 0x0c7a37a1U, 0x148e59f8U, 0x3c89eb13U,\r
- 0x27eecea9U, 0xc935b761U, 0xe5ede11cU, 0xb13c7a47U,\r
- 0xdf599cd2U, 0x733f55f2U, 0xce791814U, 0x37bf73c7U,\r
- 0xcdea53f7U, 0xaa5b5ffdU, 0x6f14df3dU, 0xdb867844U,\r
- 0xf381caafU, 0xc43eb968U, 0x342c3824U, 0x405fc2a3U,\r
- 0xc372161dU, 0x250cbce2U, 0x498b283cU, 0x9541ff0dU,\r
- 0x017139a8U, 0xb3de080cU, 0xe49cd8b4U, 0xc1906456U,\r
- 0x84617bcbU, 0xb670d532U, 0x5c74486cU, 0x5742d0b8U,\r
-};\r
-static const u32 Td3[256] = {\r
- 0xf4a75051U, 0x4165537eU, 0x17a4c31aU, 0x275e963aU,\r
- 0xab6bcb3bU, 0x9d45f11fU, 0xfa58abacU, 0xe303934bU,\r
- 0x30fa5520U, 0x766df6adU, 0xcc769188U, 0x024c25f5U,\r
- 0xe5d7fc4fU, 0x2acbd7c5U, 0x35448026U, 0x62a38fb5U,\r
- 0xb15a49deU, 0xba1b6725U, 0xea0e9845U, 0xfec0e15dU,\r
- 0x2f7502c3U, 0x4cf01281U, 0x4697a38dU, 0xd3f9c66bU,\r
- 0x8f5fe703U, 0x929c9515U, 0x6d7aebbfU, 0x5259da95U,\r
- 0xbe832dd4U, 0x7421d358U, 0xe0692949U, 0xc9c8448eU,\r
- 0xc2896a75U, 0x8e7978f4U, 0x583e6b99U, 0xb971dd27U,\r
- 0xe14fb6beU, 0x88ad17f0U, 0x20ac66c9U, 0xce3ab47dU,\r
- 0xdf4a1863U, 0x1a3182e5U, 0x51336097U, 0x537f4562U,\r
- 0x6477e0b1U, 0x6bae84bbU, 0x81a01cfeU, 0x082b94f9U,\r
- 0x48685870U, 0x45fd198fU, 0xde6c8794U, 0x7bf8b752U,\r
- 0x73d323abU, 0x4b02e272U, 0x1f8f57e3U, 0x55ab2a66U,\r
- 0xeb2807b2U, 0xb5c2032fU, 0xc57b9a86U, 0x3708a5d3U,\r
- 0x2887f230U, 0xbfa5b223U, 0x036aba02U, 0x16825cedU,\r
- 0xcf1c2b8aU, 0x79b492a7U, 0x07f2f0f3U, 0x69e2a14eU,\r
- 0xdaf4cd65U, 0x05bed506U, 0x34621fd1U, 0xa6fe8ac4U,\r
- 0x2e539d34U, 0xf355a0a2U, 0x8ae13205U, 0xf6eb75a4U,\r
- 0x83ec390bU, 0x60efaa40U, 0x719f065eU, 0x6e1051bdU,\r
- 0x218af93eU, 0xdd063d96U, 0x3e05aeddU, 0xe6bd464dU,\r
- 0x548db591U, 0xc45d0571U, 0x06d46f04U, 0x5015ff60U,\r
- 0x98fb2419U, 0xbde997d6U, 0x4043cc89U, 0xd99e7767U,\r
- 0xe842bdb0U, 0x898b8807U, 0x195b38e7U, 0xc8eedb79U,\r
- 0x7c0a47a1U, 0x420fe97cU, 0x841ec9f8U, 0x00000000U,\r
- 0x80868309U, 0x2bed4832U, 0x1170ac1eU, 0x5a724e6cU,\r
- 0x0efffbfdU, 0x8538560fU, 0xaed51e3dU, 0x2d392736U,\r
- 0x0fd9640aU, 0x5ca62168U, 0x5b54d19bU, 0x362e3a24U,\r
- 0x0a67b10cU, 0x57e70f93U, 0xee96d2b4U, 0x9b919e1bU,\r
- 0xc0c54f80U, 0xdc20a261U, 0x774b695aU, 0x121a161cU,\r
- 0x93ba0ae2U, 0xa02ae5c0U, 0x22e0433cU, 0x1b171d12U,\r
- 0x090d0b0eU, 0x8bc7adf2U, 0xb6a8b92dU, 0x1ea9c814U,\r
- 0xf1198557U, 0x75074cafU, 0x99ddbbeeU, 0x7f60fda3U,\r
- 0x01269ff7U, 0x72f5bc5cU, 0x663bc544U, 0xfb7e345bU,\r
- 0x4329768bU, 0x23c6dccbU, 0xedfc68b6U, 0xe4f163b8U,\r
- 0x31dccad7U, 0x63851042U, 0x97224013U, 0xc6112084U,\r
- 0x4a247d85U, 0xbb3df8d2U, 0xf93211aeU, 0x29a16dc7U,\r
- 0x9e2f4b1dU, 0xb230f3dcU, 0x8652ec0dU, 0xc1e3d077U,\r
- 0xb3166c2bU, 0x70b999a9U, 0x9448fa11U, 0xe9642247U,\r
- 0xfc8cc4a8U, 0xf03f1aa0U, 0x7d2cd856U, 0x3390ef22U,\r
- 0x494ec787U, 0x38d1c1d9U, 0xcaa2fe8cU, 0xd40b3698U,\r
- 0xf581cfa6U, 0x7ade28a5U, 0xb78e26daU, 0xadbfa43fU,\r
- 0x3a9de42cU, 0x78920d50U, 0x5fcc9b6aU, 0x7e466254U,\r
- 0x8d13c2f6U, 0xd8b8e890U, 0x39f75e2eU, 0xc3aff582U,\r
- 0x5d80be9fU, 0xd0937c69U, 0xd52da96fU, 0x2512b3cfU,\r
- 0xac993bc8U, 0x187da710U, 0x9c636ee8U, 0x3bbb7bdbU,\r
- 0x267809cdU, 0x5918f46eU, 0x9ab701ecU, 0x4f9aa883U,\r
- 0x956e65e6U, 0xffe67eaaU, 0xbccf0821U, 0x15e8e6efU,\r
- 0xe79bd9baU, 0x6f36ce4aU, 0x9f09d4eaU, 0xb07cd629U,\r
- 0xa4b2af31U, 0x3f23312aU, 0xa59430c6U, 0xa266c035U,\r
- 0x4ebc3774U, 0x82caa6fcU, 0x90d0b0e0U, 0xa7d81533U,\r
- 0x04984af1U, 0xecdaf741U, 0xcd500e7fU, 0x91f62f17U,\r
- 0x4dd68d76U, 0xefb04d43U, 0xaa4d54ccU, 0x9604dfe4U,\r
- 0xd1b5e39eU, 0x6a881b4cU, 0x2c1fb8c1U, 0x65517f46U,\r
- 0x5eea049dU, 0x8c355d01U, 0x877473faU, 0x0b412efbU,\r
- 0x671d5ab3U, 0xdbd25292U, 0x105633e9U, 0xd647136dU,\r
- 0xd7618c9aU, 0xa10c7a37U, 0xf8148e59U, 0x133c89ebU,\r
- 0xa927eeceU, 0x61c935b7U, 0x1ce5ede1U, 0x47b13c7aU,\r
- 0xd2df599cU, 0xf2733f55U, 0x14ce7918U, 0xc737bf73U,\r
- 0xf7cdea53U, 0xfdaa5b5fU, 0x3d6f14dfU, 0x44db8678U,\r
- 0xaff381caU, 0x68c43eb9U, 0x24342c38U, 0xa3405fc2U,\r
- 0x1dc37216U, 0xe2250cbcU, 0x3c498b28U, 0x0d9541ffU,\r
- 0xa8017139U, 0x0cb3de08U, 0xb4e49cd8U, 0x56c19064U,\r
- 0xcb84617bU, 0x32b670d5U, 0x6c5c7448U, 0xb85742d0U,\r
-};\r
-static const u32 Td4[256] = {\r
- 0x52525252U, 0x09090909U, 0x6a6a6a6aU, 0xd5d5d5d5U,\r
- 0x30303030U, 0x36363636U, 0xa5a5a5a5U, 0x38383838U,\r
- 0xbfbfbfbfU, 0x40404040U, 0xa3a3a3a3U, 0x9e9e9e9eU,\r
- 0x81818181U, 0xf3f3f3f3U, 0xd7d7d7d7U, 0xfbfbfbfbU,\r
- 0x7c7c7c7cU, 0xe3e3e3e3U, 0x39393939U, 0x82828282U,\r
- 0x9b9b9b9bU, 0x2f2f2f2fU, 0xffffffffU, 0x87878787U,\r
- 0x34343434U, 0x8e8e8e8eU, 0x43434343U, 0x44444444U,\r
- 0xc4c4c4c4U, 0xdedededeU, 0xe9e9e9e9U, 0xcbcbcbcbU,\r
- 0x54545454U, 0x7b7b7b7bU, 0x94949494U, 0x32323232U,\r
- 0xa6a6a6a6U, 0xc2c2c2c2U, 0x23232323U, 0x3d3d3d3dU,\r
- 0xeeeeeeeeU, 0x4c4c4c4cU, 0x95959595U, 0x0b0b0b0bU,\r
- 0x42424242U, 0xfafafafaU, 0xc3c3c3c3U, 0x4e4e4e4eU,\r
- 0x08080808U, 0x2e2e2e2eU, 0xa1a1a1a1U, 0x66666666U,\r
- 0x28282828U, 0xd9d9d9d9U, 0x24242424U, 0xb2b2b2b2U,\r
- 0x76767676U, 0x5b5b5b5bU, 0xa2a2a2a2U, 0x49494949U,\r
- 0x6d6d6d6dU, 0x8b8b8b8bU, 0xd1d1d1d1U, 0x25252525U,\r
- 0x72727272U, 0xf8f8f8f8U, 0xf6f6f6f6U, 0x64646464U,\r
- 0x86868686U, 0x68686868U, 0x98989898U, 0x16161616U,\r
- 0xd4d4d4d4U, 0xa4a4a4a4U, 0x5c5c5c5cU, 0xccccccccU,\r
- 0x5d5d5d5dU, 0x65656565U, 0xb6b6b6b6U, 0x92929292U,\r
- 0x6c6c6c6cU, 0x70707070U, 0x48484848U, 0x50505050U,\r
- 0xfdfdfdfdU, 0xededededU, 0xb9b9b9b9U, 0xdadadadaU,\r
- 0x5e5e5e5eU, 0x15151515U, 0x46464646U, 0x57575757U,\r
- 0xa7a7a7a7U, 0x8d8d8d8dU, 0x9d9d9d9dU, 0x84848484U,\r
- 0x90909090U, 0xd8d8d8d8U, 0xababababU, 0x00000000U,\r
- 0x8c8c8c8cU, 0xbcbcbcbcU, 0xd3d3d3d3U, 0x0a0a0a0aU,\r
- 0xf7f7f7f7U, 0xe4e4e4e4U, 0x58585858U, 0x05050505U,\r
- 0xb8b8b8b8U, 0xb3b3b3b3U, 0x45454545U, 0x06060606U,\r
- 0xd0d0d0d0U, 0x2c2c2c2cU, 0x1e1e1e1eU, 0x8f8f8f8fU,\r
- 0xcacacacaU, 0x3f3f3f3fU, 0x0f0f0f0fU, 0x02020202U,\r
- 0xc1c1c1c1U, 0xafafafafU, 0xbdbdbdbdU, 0x03030303U,\r
- 0x01010101U, 0x13131313U, 0x8a8a8a8aU, 0x6b6b6b6bU,\r
- 0x3a3a3a3aU, 0x91919191U, 0x11111111U, 0x41414141U,\r
- 0x4f4f4f4fU, 0x67676767U, 0xdcdcdcdcU, 0xeaeaeaeaU,\r
- 0x97979797U, 0xf2f2f2f2U, 0xcfcfcfcfU, 0xcecececeU,\r
- 0xf0f0f0f0U, 0xb4b4b4b4U, 0xe6e6e6e6U, 0x73737373U,\r
- 0x96969696U, 0xacacacacU, 0x74747474U, 0x22222222U,\r
- 0xe7e7e7e7U, 0xadadadadU, 0x35353535U, 0x85858585U,\r
- 0xe2e2e2e2U, 0xf9f9f9f9U, 0x37373737U, 0xe8e8e8e8U,\r
- 0x1c1c1c1cU, 0x75757575U, 0xdfdfdfdfU, 0x6e6e6e6eU,\r
- 0x47474747U, 0xf1f1f1f1U, 0x1a1a1a1aU, 0x71717171U,\r
- 0x1d1d1d1dU, 0x29292929U, 0xc5c5c5c5U, 0x89898989U,\r
- 0x6f6f6f6fU, 0xb7b7b7b7U, 0x62626262U, 0x0e0e0e0eU,\r
- 0xaaaaaaaaU, 0x18181818U, 0xbebebebeU, 0x1b1b1b1bU,\r
- 0xfcfcfcfcU, 0x56565656U, 0x3e3e3e3eU, 0x4b4b4b4bU,\r
- 0xc6c6c6c6U, 0xd2d2d2d2U, 0x79797979U, 0x20202020U,\r
- 0x9a9a9a9aU, 0xdbdbdbdbU, 0xc0c0c0c0U, 0xfefefefeU,\r
- 0x78787878U, 0xcdcdcdcdU, 0x5a5a5a5aU, 0xf4f4f4f4U,\r
- 0x1f1f1f1fU, 0xddddddddU, 0xa8a8a8a8U, 0x33333333U,\r
- 0x88888888U, 0x07070707U, 0xc7c7c7c7U, 0x31313131U,\r
- 0xb1b1b1b1U, 0x12121212U, 0x10101010U, 0x59595959U,\r
- 0x27272727U, 0x80808080U, 0xececececU, 0x5f5f5f5fU,\r
- 0x60606060U, 0x51515151U, 0x7f7f7f7fU, 0xa9a9a9a9U,\r
- 0x19191919U, 0xb5b5b5b5U, 0x4a4a4a4aU, 0x0d0d0d0dU,\r
- 0x2d2d2d2dU, 0xe5e5e5e5U, 0x7a7a7a7aU, 0x9f9f9f9fU,\r
- 0x93939393U, 0xc9c9c9c9U, 0x9c9c9c9cU, 0xefefefefU,\r
- 0xa0a0a0a0U, 0xe0e0e0e0U, 0x3b3b3b3bU, 0x4d4d4d4dU,\r
- 0xaeaeaeaeU, 0x2a2a2a2aU, 0xf5f5f5f5U, 0xb0b0b0b0U,\r
- 0xc8c8c8c8U, 0xebebebebU, 0xbbbbbbbbU, 0x3c3c3c3cU,\r
- 0x83838383U, 0x53535353U, 0x99999999U, 0x61616161U,\r
- 0x17171717U, 0x2b2b2b2bU, 0x04040404U, 0x7e7e7e7eU,\r
- 0xbabababaU, 0x77777777U, 0xd6d6d6d6U, 0x26262626U,\r
- 0xe1e1e1e1U, 0x69696969U, 0x14141414U, 0x63636363U,\r
- 0x55555555U, 0x21212121U, 0x0c0c0c0cU, 0x7d7d7d7dU,\r
-};\r
-static const u32 rcon[] = {\r
- 0x01000000, 0x02000000, 0x04000000, 0x08000000,\r
- 0x10000000, 0x20000000, 0x40000000, 0x80000000,\r
- 0x1B000000, 0x36000000, /* for 128-bit blocks, Rijndael never uses more than 10 rcon values */\r
-};\r
-\r
-/**\r
- * Expand the cipher key into the encryption key schedule.\r
- */\r
-int AES_set_encrypt_key(const unsigned char *userKey, const int bits,\r
- AES_KEY *key) {\r
-\r
- u32 *rk;\r
- int i = 0;\r
- u32 temp;\r
-\r
- if (!userKey || !key)\r
- return -1;\r
- if (bits != 128 && bits != 192 && bits != 256)\r
- return -2;\r
-\r
- rk = key->rd_key;\r
-\r
- if (bits==128)\r
- key->rounds = 10;\r
- else if (bits==192)\r
- key->rounds = 12;\r
- else\r
- key->rounds = 14;\r
-\r
- rk[0] = GETU32(userKey );\r
- rk[1] = GETU32(userKey + 4);\r
- rk[2] = GETU32(userKey + 8);\r
- rk[3] = GETU32(userKey + 12);\r
- if (bits == 128) {\r
- while (1) {\r
- temp = rk[3];\r
- rk[4] = rk[0] ^\r
- (Te4[(temp >> 16) & 0xff] & 0xff000000) ^\r
- (Te4[(temp >> 8) & 0xff] & 0x00ff0000) ^\r
- (Te4[(temp ) & 0xff] & 0x0000ff00) ^\r
- (Te4[(temp >> 24) ] & 0x000000ff) ^\r
- rcon[i];\r
- rk[5] = rk[1] ^ rk[4];\r
- rk[6] = rk[2] ^ rk[5];\r
- rk[7] = rk[3] ^ rk[6];\r
- if (++i == 10) {\r
- return 0;\r
- }\r
- rk += 4;\r
- }\r
- }\r
- rk[4] = GETU32(userKey + 16);\r
- rk[5] = GETU32(userKey + 20);\r
- if (bits == 192) {\r
- while (1) {\r
- temp = rk[ 5];\r
- rk[ 6] = rk[ 0] ^\r
- (Te4[(temp >> 16) & 0xff] & 0xff000000) ^\r
- (Te4[(temp >> 8) & 0xff] & 0x00ff0000) ^\r
- (Te4[(temp ) & 0xff] & 0x0000ff00) ^\r
- (Te4[(temp >> 24) ] & 0x000000ff) ^\r
- rcon[i];\r
- rk[ 7] = rk[ 1] ^ rk[ 6];\r
- rk[ 8] = rk[ 2] ^ rk[ 7];\r
- rk[ 9] = rk[ 3] ^ rk[ 8];\r
- if (++i == 8) {\r
- return 0;\r
- }\r
- rk[10] = rk[ 4] ^ rk[ 9];\r
- rk[11] = rk[ 5] ^ rk[10];\r
- rk += 6;\r
- }\r
- }\r
- rk[6] = GETU32(userKey + 24);\r
- rk[7] = GETU32(userKey + 28);\r
- if (bits == 256) {\r
- while (1) {\r
- temp = rk[ 7];\r
- rk[ 8] = rk[ 0] ^\r
- (Te4[(temp >> 16) & 0xff] & 0xff000000) ^\r
- (Te4[(temp >> 8) & 0xff] & 0x00ff0000) ^\r
- (Te4[(temp ) & 0xff] & 0x0000ff00) ^\r
- (Te4[(temp >> 24) ] & 0x000000ff) ^\r
- rcon[i];\r
- rk[ 9] = rk[ 1] ^ rk[ 8];\r
- rk[10] = rk[ 2] ^ rk[ 9];\r
- rk[11] = rk[ 3] ^ rk[10];\r
- if (++i == 7) {\r
- return 0;\r
- }\r
- temp = rk[11];\r
- rk[12] = rk[ 4] ^\r
- (Te4[(temp >> 24) ] & 0xff000000) ^\r
- (Te4[(temp >> 16) & 0xff] & 0x00ff0000) ^\r
- (Te4[(temp >> 8) & 0xff] & 0x0000ff00) ^\r
- (Te4[(temp ) & 0xff] & 0x000000ff);\r
- rk[13] = rk[ 5] ^ rk[12];\r
- rk[14] = rk[ 6] ^ rk[13];\r
- rk[15] = rk[ 7] ^ rk[14];\r
-\r
- rk += 8;\r
- }\r
- }\r
- return 0;\r
-}\r
-\r
-/**\r
- * Expand the cipher key into the decryption key schedule.\r
- */\r
-int AES_set_decrypt_key(const unsigned char *userKey, const int bits,\r
- AES_KEY *key) {\r
-\r
- u32 *rk;\r
- int i, j, status;\r
- u32 temp;\r
-\r
- /* first, start with an encryption schedule */\r
- status = AES_set_encrypt_key(userKey, bits, key);\r
- if (status < 0)\r
- return status;\r
-\r
- rk = key->rd_key;\r
-\r
- /* invert the order of the round keys: */\r
- for (i = 0, j = 4*(key->rounds); i < j; i += 4, j -= 4) {\r
- temp = rk[i ]; rk[i ] = rk[j ]; rk[j ] = temp;\r
- temp = rk[i + 1]; rk[i + 1] = rk[j + 1]; rk[j + 1] = temp;\r
- temp = rk[i + 2]; rk[i + 2] = rk[j + 2]; rk[j + 2] = temp;\r
- temp = rk[i + 3]; rk[i + 3] = rk[j + 3]; rk[j + 3] = temp;\r
- }\r
- /* apply the inverse MixColumn transform to all round keys but the first and the last: */\r
- for (i = 1; i < (key->rounds); i++) {\r
- rk += 4;\r
- rk[0] =\r
- Td0[Te4[(rk[0] >> 24) ] & 0xff] ^\r
- Td1[Te4[(rk[0] >> 16) & 0xff] & 0xff] ^\r
- Td2[Te4[(rk[0] >> 8) & 0xff] & 0xff] ^\r
- Td3[Te4[(rk[0] ) & 0xff] & 0xff];\r
- rk[1] =\r
- Td0[Te4[(rk[1] >> 24) ] & 0xff] ^\r
- Td1[Te4[(rk[1] >> 16) & 0xff] & 0xff] ^\r
- Td2[Te4[(rk[1] >> 8) & 0xff] & 0xff] ^\r
- Td3[Te4[(rk[1] ) & 0xff] & 0xff];\r
- rk[2] =\r
- Td0[Te4[(rk[2] >> 24) ] & 0xff] ^\r
- Td1[Te4[(rk[2] >> 16) & 0xff] & 0xff] ^\r
- Td2[Te4[(rk[2] >> 8) & 0xff] & 0xff] ^\r
- Td3[Te4[(rk[2] ) & 0xff] & 0xff];\r
- rk[3] =\r
- Td0[Te4[(rk[3] >> 24) ] & 0xff] ^\r
- Td1[Te4[(rk[3] >> 16) & 0xff] & 0xff] ^\r
- Td2[Te4[(rk[3] >> 8) & 0xff] & 0xff] ^\r
- Td3[Te4[(rk[3] ) & 0xff] & 0xff];\r
- }\r
- return 0;\r
-}\r
-\r
-#ifndef AES_ASM\r
-/*\r
- * Encrypt a single block\r
- * in and out can overlap\r
- */\r
-void AES_encrypt(const unsigned char *in, unsigned char *out,\r
- const AES_KEY *key) {\r
-\r
- const u32 *rk;\r
- u32 s0, s1, s2, s3, t0, t1, t2, t3;\r
-#ifndef FULL_UNROLL\r
- int r;\r
-#endif /* ?FULL_UNROLL */\r
-\r
- assert(in && out && key);\r
- rk = key->rd_key;\r
-\r
- /*\r
- * map byte array block to cipher state\r
- * and add initial round key:\r
- */\r
- s0 = GETU32(in ) ^ rk[0];\r
- s1 = GETU32(in + 4) ^ rk[1];\r
- s2 = GETU32(in + 8) ^ rk[2];\r
- s3 = GETU32(in + 12) ^ rk[3];\r
-#ifdef FULL_UNROLL\r
- /* round 1: */\r
- t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >> 8) & 0xff] ^ Te3[s3 & 0xff] ^ rk[ 4];\r
- t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >> 8) & 0xff] ^ Te3[s0 & 0xff] ^ rk[ 5];\r
- t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >> 8) & 0xff] ^ Te3[s1 & 0xff] ^ rk[ 6];\r
- t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >> 8) & 0xff] ^ Te3[s2 & 0xff] ^ rk[ 7];\r
- /* round 2: */\r
- s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >> 8) & 0xff] ^ Te3[t3 & 0xff] ^ rk[ 8];\r
- s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >> 8) & 0xff] ^ Te3[t0 & 0xff] ^ rk[ 9];\r
- s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >> 8) & 0xff] ^ Te3[t1 & 0xff] ^ rk[10];\r
- s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >> 8) & 0xff] ^ Te3[t2 & 0xff] ^ rk[11];\r
- /* round 3: */\r
- t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >> 8) & 0xff] ^ Te3[s3 & 0xff] ^ rk[12];\r
- t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >> 8) & 0xff] ^ Te3[s0 & 0xff] ^ rk[13];\r
- t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >> 8) & 0xff] ^ Te3[s1 & 0xff] ^ rk[14];\r
- t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >> 8) & 0xff] ^ Te3[s2 & 0xff] ^ rk[15];\r
- /* round 4: */\r
- s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >> 8) & 0xff] ^ Te3[t3 & 0xff] ^ rk[16];\r
- s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >> 8) & 0xff] ^ Te3[t0 & 0xff] ^ rk[17];\r
- s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >> 8) & 0xff] ^ Te3[t1 & 0xff] ^ rk[18];\r
- s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >> 8) & 0xff] ^ Te3[t2 & 0xff] ^ rk[19];\r
- /* round 5: */\r
- t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >> 8) & 0xff] ^ Te3[s3 & 0xff] ^ rk[20];\r
- t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >> 8) & 0xff] ^ Te3[s0 & 0xff] ^ rk[21];\r
- t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >> 8) & 0xff] ^ Te3[s1 & 0xff] ^ rk[22];\r
- t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >> 8) & 0xff] ^ Te3[s2 & 0xff] ^ rk[23];\r
- /* round 6: */\r
- s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >> 8) & 0xff] ^ Te3[t3 & 0xff] ^ rk[24];\r
- s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >> 8) & 0xff] ^ Te3[t0 & 0xff] ^ rk[25];\r
- s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >> 8) & 0xff] ^ Te3[t1 & 0xff] ^ rk[26];\r
- s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >> 8) & 0xff] ^ Te3[t2 & 0xff] ^ rk[27];\r
- /* round 7: */\r
- t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >> 8) & 0xff] ^ Te3[s3 & 0xff] ^ rk[28];\r
- t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >> 8) & 0xff] ^ Te3[s0 & 0xff] ^ rk[29];\r
- t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >> 8) & 0xff] ^ Te3[s1 & 0xff] ^ rk[30];\r
- t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >> 8) & 0xff] ^ Te3[s2 & 0xff] ^ rk[31];\r
- /* round 8: */\r
- s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >> 8) & 0xff] ^ Te3[t3 & 0xff] ^ rk[32];\r
- s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >> 8) & 0xff] ^ Te3[t0 & 0xff] ^ rk[33];\r
- s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >> 8) & 0xff] ^ Te3[t1 & 0xff] ^ rk[34];\r
- s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >> 8) & 0xff] ^ Te3[t2 & 0xff] ^ rk[35];\r
- /* round 9: */\r
- t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >> 8) & 0xff] ^ Te3[s3 & 0xff] ^ rk[36];\r
- t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >> 8) & 0xff] ^ Te3[s0 & 0xff] ^ rk[37];\r
- t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >> 8) & 0xff] ^ Te3[s1 & 0xff] ^ rk[38];\r
- t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >> 8) & 0xff] ^ Te3[s2 & 0xff] ^ rk[39];\r
- if (key->rounds > 10) {\r
- /* round 10: */\r
- s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >> 8) & 0xff] ^ Te3[t3 & 0xff] ^ rk[40];\r
- s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >> 8) & 0xff] ^ Te3[t0 & 0xff] ^ rk[41];\r
- s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >> 8) & 0xff] ^ Te3[t1 & 0xff] ^ rk[42];\r
- s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >> 8) & 0xff] ^ Te3[t2 & 0xff] ^ rk[43];\r
- /* round 11: */\r
- t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >> 8) & 0xff] ^ Te3[s3 & 0xff] ^ rk[44];\r
- t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >> 8) & 0xff] ^ Te3[s0 & 0xff] ^ rk[45];\r
- t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >> 8) & 0xff] ^ Te3[s1 & 0xff] ^ rk[46];\r
- t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >> 8) & 0xff] ^ Te3[s2 & 0xff] ^ rk[47];\r
- if (key->rounds > 12) {\r
- /* round 12: */\r
- s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >> 8) & 0xff] ^ Te3[t3 & 0xff] ^ rk[48];\r
- s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >> 8) & 0xff] ^ Te3[t0 & 0xff] ^ rk[49];\r
- s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >> 8) & 0xff] ^ Te3[t1 & 0xff] ^ rk[50];\r
- s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >> 8) & 0xff] ^ Te3[t2 & 0xff] ^ rk[51];\r
- /* round 13: */\r
- t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >> 8) & 0xff] ^ Te3[s3 & 0xff] ^ rk[52];\r
- t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >> 8) & 0xff] ^ Te3[s0 & 0xff] ^ rk[53];\r
- t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >> 8) & 0xff] ^ Te3[s1 & 0xff] ^ rk[54];\r
- t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >> 8) & 0xff] ^ Te3[s2 & 0xff] ^ rk[55];\r
- }\r
- }\r
- rk += key->rounds << 2;\r
-#else /* !FULL_UNROLL */\r
- /*\r
- * Nr - 1 full rounds:\r
- */\r
- r = key->rounds >> 1;\r
- for (;;) {\r
- t0 =\r
- Te0[(s0 >> 24) ] ^\r
- Te1[(s1 >> 16) & 0xff] ^\r
- Te2[(s2 >> 8) & 0xff] ^\r
- Te3[(s3 ) & 0xff] ^\r
- rk[4];\r
- t1 =\r
- Te0[(s1 >> 24) ] ^\r
- Te1[(s2 >> 16) & 0xff] ^\r
- Te2[(s3 >> 8) & 0xff] ^\r
- Te3[(s0 ) & 0xff] ^\r
- rk[5];\r
- t2 =\r
- Te0[(s2 >> 24) ] ^\r
- Te1[(s3 >> 16) & 0xff] ^\r
- Te2[(s0 >> 8) & 0xff] ^\r
- Te3[(s1 ) & 0xff] ^\r
- rk[6];\r
- t3 =\r
- Te0[(s3 >> 24) ] ^\r
- Te1[(s0 >> 16) & 0xff] ^\r
- Te2[(s1 >> 8) & 0xff] ^\r
- Te3[(s2 ) & 0xff] ^\r
- rk[7];\r
-\r
- rk += 8;\r
- if (--r == 0) {\r
- break;\r
- }\r
-\r
- s0 =\r
- Te0[(t0 >> 24) ] ^\r
- Te1[(t1 >> 16) & 0xff] ^\r
- Te2[(t2 >> 8) & 0xff] ^\r
- Te3[(t3 ) & 0xff] ^\r
- rk[0];\r
- s1 =\r
- Te0[(t1 >> 24) ] ^\r
- Te1[(t2 >> 16) & 0xff] ^\r
- Te2[(t3 >> 8) & 0xff] ^\r
- Te3[(t0 ) & 0xff] ^\r
- rk[1];\r
- s2 =\r
- Te0[(t2 >> 24) ] ^\r
- Te1[(t3 >> 16) & 0xff] ^\r
- Te2[(t0 >> 8) & 0xff] ^\r
- Te3[(t1 ) & 0xff] ^\r
- rk[2];\r
- s3 =\r
- Te0[(t3 >> 24) ] ^\r
- Te1[(t0 >> 16) & 0xff] ^\r
- Te2[(t1 >> 8) & 0xff] ^\r
- Te3[(t2 ) & 0xff] ^\r
- rk[3];\r
- }\r
-#endif /* ?FULL_UNROLL */\r
- /*\r
- * apply last round and\r
- * map cipher state to byte array block:\r
- */\r
- s0 =\r
- (Te4[(t0 >> 24) ] & 0xff000000) ^\r
- (Te4[(t1 >> 16) & 0xff] & 0x00ff0000) ^\r
- (Te4[(t2 >> 8) & 0xff] & 0x0000ff00) ^\r
- (Te4[(t3 ) & 0xff] & 0x000000ff) ^\r
- rk[0];\r
- PUTU32(out , s0);\r
- s1 =\r
- (Te4[(t1 >> 24) ] & 0xff000000) ^\r
- (Te4[(t2 >> 16) & 0xff] & 0x00ff0000) ^\r
- (Te4[(t3 >> 8) & 0xff] & 0x0000ff00) ^\r
- (Te4[(t0 ) & 0xff] & 0x000000ff) ^\r
- rk[1];\r
- PUTU32(out + 4, s1);\r
- s2 =\r
- (Te4[(t2 >> 24) ] & 0xff000000) ^\r
- (Te4[(t3 >> 16) & 0xff] & 0x00ff0000) ^\r
- (Te4[(t0 >> 8) & 0xff] & 0x0000ff00) ^\r
- (Te4[(t1 ) & 0xff] & 0x000000ff) ^\r
- rk[2];\r
- PUTU32(out + 8, s2);\r
- s3 =\r
- (Te4[(t3 >> 24) ] & 0xff000000) ^\r
- (Te4[(t0 >> 16) & 0xff] & 0x00ff0000) ^\r
- (Te4[(t1 >> 8) & 0xff] & 0x0000ff00) ^\r
- (Te4[(t2 ) & 0xff] & 0x000000ff) ^\r
- rk[3];\r
- PUTU32(out + 12, s3);\r
-}\r
-\r
-/*\r
- * Decrypt a single block\r
- * in and out can overlap\r
- */\r
-void AES_decrypt(const unsigned char *in, unsigned char *out,\r
- const AES_KEY *key) {\r
-\r
- const u32 *rk;\r
- u32 s0, s1, s2, s3, t0, t1, t2, t3;\r
-#ifndef FULL_UNROLL\r
- int r;\r
-#endif /* ?FULL_UNROLL */\r
-\r
- assert(in && out && key);\r
- rk = key->rd_key;\r
-\r
- /*\r
- * map byte array block to cipher state\r
- * and add initial round key:\r
- */\r
- s0 = GETU32(in ) ^ rk[0];\r
- s1 = GETU32(in + 4) ^ rk[1];\r
- s2 = GETU32(in + 8) ^ rk[2];\r
- s3 = GETU32(in + 12) ^ rk[3];\r
-#ifdef FULL_UNROLL\r
- /* round 1: */\r
- t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >> 8) & 0xff] ^ Td3[s1 & 0xff] ^ rk[ 4];\r
- t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >> 8) & 0xff] ^ Td3[s2 & 0xff] ^ rk[ 5];\r
- t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >> 8) & 0xff] ^ Td3[s3 & 0xff] ^ rk[ 6];\r
- t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >> 8) & 0xff] ^ Td3[s0 & 0xff] ^ rk[ 7];\r
- /* round 2: */\r
- s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >> 8) & 0xff] ^ Td3[t1 & 0xff] ^ rk[ 8];\r
- s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >> 8) & 0xff] ^ Td3[t2 & 0xff] ^ rk[ 9];\r
- s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >> 8) & 0xff] ^ Td3[t3 & 0xff] ^ rk[10];\r
- s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >> 8) & 0xff] ^ Td3[t0 & 0xff] ^ rk[11];\r
- /* round 3: */\r
- t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >> 8) & 0xff] ^ Td3[s1 & 0xff] ^ rk[12];\r
- t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >> 8) & 0xff] ^ Td3[s2 & 0xff] ^ rk[13];\r
- t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >> 8) & 0xff] ^ Td3[s3 & 0xff] ^ rk[14];\r
- t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >> 8) & 0xff] ^ Td3[s0 & 0xff] ^ rk[15];\r
- /* round 4: */\r
- s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >> 8) & 0xff] ^ Td3[t1 & 0xff] ^ rk[16];\r
- s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >> 8) & 0xff] ^ Td3[t2 & 0xff] ^ rk[17];\r
- s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >> 8) & 0xff] ^ Td3[t3 & 0xff] ^ rk[18];\r
- s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >> 8) & 0xff] ^ Td3[t0 & 0xff] ^ rk[19];\r
- /* round 5: */\r
- t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >> 8) & 0xff] ^ Td3[s1 & 0xff] ^ rk[20];\r
- t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >> 8) & 0xff] ^ Td3[s2 & 0xff] ^ rk[21];\r
- t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >> 8) & 0xff] ^ Td3[s3 & 0xff] ^ rk[22];\r
- t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >> 8) & 0xff] ^ Td3[s0 & 0xff] ^ rk[23];\r
- /* round 6: */\r
- s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >> 8) & 0xff] ^ Td3[t1 & 0xff] ^ rk[24];\r
- s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >> 8) & 0xff] ^ Td3[t2 & 0xff] ^ rk[25];\r
- s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >> 8) & 0xff] ^ Td3[t3 & 0xff] ^ rk[26];\r
- s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >> 8) & 0xff] ^ Td3[t0 & 0xff] ^ rk[27];\r
- /* round 7: */\r
- t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >> 8) & 0xff] ^ Td3[s1 & 0xff] ^ rk[28];\r
- t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >> 8) & 0xff] ^ Td3[s2 & 0xff] ^ rk[29];\r
- t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >> 8) & 0xff] ^ Td3[s3 & 0xff] ^ rk[30];\r
- t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >> 8) & 0xff] ^ Td3[s0 & 0xff] ^ rk[31];\r
- /* round 8: */\r
- s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >> 8) & 0xff] ^ Td3[t1 & 0xff] ^ rk[32];\r
- s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >> 8) & 0xff] ^ Td3[t2 & 0xff] ^ rk[33];\r
- s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >> 8) & 0xff] ^ Td3[t3 & 0xff] ^ rk[34];\r
- s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >> 8) & 0xff] ^ Td3[t0 & 0xff] ^ rk[35];\r
- /* round 9: */\r
- t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >> 8) & 0xff] ^ Td3[s1 & 0xff] ^ rk[36];\r
- t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >> 8) & 0xff] ^ Td3[s2 & 0xff] ^ rk[37];\r
- t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >> 8) & 0xff] ^ Td3[s3 & 0xff] ^ rk[38];\r
- t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >> 8) & 0xff] ^ Td3[s0 & 0xff] ^ rk[39];\r
- if (key->rounds > 10) {\r
- /* round 10: */\r
- s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >> 8) & 0xff] ^ Td3[t1 & 0xff] ^ rk[40];\r
- s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >> 8) & 0xff] ^ Td3[t2 & 0xff] ^ rk[41];\r
- s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >> 8) & 0xff] ^ Td3[t3 & 0xff] ^ rk[42];\r
- s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >> 8) & 0xff] ^ Td3[t0 & 0xff] ^ rk[43];\r
- /* round 11: */\r
- t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >> 8) & 0xff] ^ Td3[s1 & 0xff] ^ rk[44];\r
- t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >> 8) & 0xff] ^ Td3[s2 & 0xff] ^ rk[45];\r
- t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >> 8) & 0xff] ^ Td3[s3 & 0xff] ^ rk[46];\r
- t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >> 8) & 0xff] ^ Td3[s0 & 0xff] ^ rk[47];\r
- if (key->rounds > 12) {\r
- /* round 12: */\r
- s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >> 8) & 0xff] ^ Td3[t1 & 0xff] ^ rk[48];\r
- s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >> 8) & 0xff] ^ Td3[t2 & 0xff] ^ rk[49];\r
- s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >> 8) & 0xff] ^ Td3[t3 & 0xff] ^ rk[50];\r
- s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >> 8) & 0xff] ^ Td3[t0 & 0xff] ^ rk[51];\r
- /* round 13: */\r
- t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >> 8) & 0xff] ^ Td3[s1 & 0xff] ^ rk[52];\r
- t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >> 8) & 0xff] ^ Td3[s2 & 0xff] ^ rk[53];\r
- t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >> 8) & 0xff] ^ Td3[s3 & 0xff] ^ rk[54];\r
- t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >> 8) & 0xff] ^ Td3[s0 & 0xff] ^ rk[55];\r
- }\r
- }\r
- rk += key->rounds << 2;\r
-#else /* !FULL_UNROLL */\r
- /*\r
- * Nr - 1 full rounds:\r
- */\r
- r = key->rounds >> 1;\r
- for (;;) {\r
- t0 =\r
- Td0[(s0 >> 24) ] ^\r
- Td1[(s3 >> 16) & 0xff] ^\r
- Td2[(s2 >> 8) & 0xff] ^\r
- Td3[(s1 ) & 0xff] ^\r
- rk[4];\r
- t1 =\r
- Td0[(s1 >> 24) ] ^\r
- Td1[(s0 >> 16) & 0xff] ^\r
- Td2[(s3 >> 8) & 0xff] ^\r
- Td3[(s2 ) & 0xff] ^\r
- rk[5];\r
- t2 =\r
- Td0[(s2 >> 24) ] ^\r
- Td1[(s1 >> 16) & 0xff] ^\r
- Td2[(s0 >> 8) & 0xff] ^\r
- Td3[(s3 ) & 0xff] ^\r
- rk[6];\r
- t3 =\r
- Td0[(s3 >> 24) ] ^\r
- Td1[(s2 >> 16) & 0xff] ^\r
- Td2[(s1 >> 8) & 0xff] ^\r
- Td3[(s0 ) & 0xff] ^\r
- rk[7];\r
-\r
- rk += 8;\r
- if (--r == 0) {\r
- break;\r
- }\r
-\r
- s0 =\r
- Td0[(t0 >> 24) ] ^\r
- Td1[(t3 >> 16) & 0xff] ^\r
- Td2[(t2 >> 8) & 0xff] ^\r
- Td3[(t1 ) & 0xff] ^\r
- rk[0];\r
- s1 =\r
- Td0[(t1 >> 24) ] ^\r
- Td1[(t0 >> 16) & 0xff] ^\r
- Td2[(t3 >> 8) & 0xff] ^\r
- Td3[(t2 ) & 0xff] ^\r
- rk[1];\r
- s2 =\r
- Td0[(t2 >> 24) ] ^\r
- Td1[(t1 >> 16) & 0xff] ^\r
- Td2[(t0 >> 8) & 0xff] ^\r
- Td3[(t3 ) & 0xff] ^\r
- rk[2];\r
- s3 =\r
- Td0[(t3 >> 24) ] ^\r
- Td1[(t2 >> 16) & 0xff] ^\r
- Td2[(t1 >> 8) & 0xff] ^\r
- Td3[(t0 ) & 0xff] ^\r
- rk[3];\r
- }\r
-#endif /* ?FULL_UNROLL */\r
- /*\r
- * apply last round and\r
- * map cipher state to byte array block:\r
- */\r
- s0 =\r
- (Td4[(t0 >> 24) ] & 0xff000000) ^\r
- (Td4[(t3 >> 16) & 0xff] & 0x00ff0000) ^\r
- (Td4[(t2 >> 8) & 0xff] & 0x0000ff00) ^\r
- (Td4[(t1 ) & 0xff] & 0x000000ff) ^\r
- rk[0];\r
- PUTU32(out , s0);\r
- s1 =\r
- (Td4[(t1 >> 24) ] & 0xff000000) ^\r
- (Td4[(t0 >> 16) & 0xff] & 0x00ff0000) ^\r
- (Td4[(t3 >> 8) & 0xff] & 0x0000ff00) ^\r
- (Td4[(t2 ) & 0xff] & 0x000000ff) ^\r
- rk[1];\r
- PUTU32(out + 4, s1);\r
- s2 =\r
- (Td4[(t2 >> 24) ] & 0xff000000) ^\r
- (Td4[(t1 >> 16) & 0xff] & 0x00ff0000) ^\r
- (Td4[(t0 >> 8) & 0xff] & 0x0000ff00) ^\r
- (Td4[(t3 ) & 0xff] & 0x000000ff) ^\r
- rk[2];\r
- PUTU32(out + 8, s2);\r
- s3 =\r
- (Td4[(t3 >> 24) ] & 0xff000000) ^\r
- (Td4[(t2 >> 16) & 0xff] & 0x00ff0000) ^\r
- (Td4[(t1 >> 8) & 0xff] & 0x0000ff00) ^\r
- (Td4[(t0 ) & 0xff] & 0x000000ff) ^\r
- rk[3];\r
- PUTU32(out + 12, s3);\r
-}\r
-\r
-#endif /* AES_ASM */\r
-\r
-void AES_cbc_encrypt(const unsigned char *in, unsigned char *out,\r
- const unsigned long length, const AES_KEY *key,\r
- unsigned char *ivec, const int enc) \r
-{\r
-\r
- unsigned long n;\r
- unsigned long len = length;\r
- unsigned char tmp[AES_BLOCK_SIZE];\r
-\r
- assert(in && out && key && ivec);\r
-\r
- if (enc) {\r
- while (len >= AES_BLOCK_SIZE) {\r
- for(n=0; n < AES_BLOCK_SIZE; ++n)\r
- tmp[n] = in[n] ^ ivec[n];\r
- AES_encrypt(tmp, out, key);\r
- memcpy(ivec, out, AES_BLOCK_SIZE);\r
- len -= AES_BLOCK_SIZE;\r
- in += AES_BLOCK_SIZE;\r
- out += AES_BLOCK_SIZE;\r
- }\r
- if (len) {\r
- for(n=0; n < len; ++n)\r
- tmp[n] = in[n] ^ ivec[n];\r
- for(n=len; n < AES_BLOCK_SIZE; ++n)\r
- tmp[n] = ivec[n];\r
- AES_encrypt(tmp, tmp, key);\r
- memcpy(out, tmp, AES_BLOCK_SIZE);\r
- memcpy(ivec, tmp, AES_BLOCK_SIZE);\r
- } \r
- } else {\r
- while (len >= AES_BLOCK_SIZE) {\r
- memcpy(tmp, in, AES_BLOCK_SIZE);\r
- AES_decrypt(in, out, key);\r
- for(n=0; n < AES_BLOCK_SIZE; ++n)\r
- out[n] ^= ivec[n];\r
- memcpy(ivec, tmp, AES_BLOCK_SIZE);\r
- len -= AES_BLOCK_SIZE;\r
- in += AES_BLOCK_SIZE;\r
- out += AES_BLOCK_SIZE;\r
- }\r
- if (len) {\r
- memcpy(tmp, in, AES_BLOCK_SIZE);\r
- AES_decrypt(tmp, tmp, key);\r
- for(n=0; n < len; ++n)\r
- out[n] = tmp[n] ^ ivec[n];\r
- memcpy(ivec, tmp, AES_BLOCK_SIZE);\r
- } \r
- }\r
-}\r
+++ /dev/null
-#ifndef QEMU_AES_H
-#define QEMU_AES_H
-
-#include <stdint.h>
-
-#define AES_MAXNR 14
-#define AES_BLOCK_SIZE 16
-
-struct aes_key_st {
- uint32_t rd_key[4 *(AES_MAXNR + 1)];
- int rounds;
-};
-typedef struct aes_key_st AES_KEY;
-
-int AES_set_encrypt_key(const unsigned char *userKey, const int bits,
- AES_KEY *key);
-int AES_set_decrypt_key(const unsigned char *userKey, const int bits,
- AES_KEY *key);
-
-void AES_encrypt(const unsigned char *in, unsigned char *out,
- const AES_KEY *key);
-void AES_decrypt(const unsigned char *in, unsigned char *out,
- const AES_KEY *key);
-void AES_cbc_encrypt(const unsigned char *in, unsigned char *out,
- const unsigned long length, const AES_KEY *key,
- unsigned char *ivec, const int enc);
-
-#endif
+++ /dev/null
-/*
- * Copyright (c) 2005 Anil Madhavapeddy. All rights reserved.
- * Copyright (c) 1995,1999 Theo de Raadt. All rights reserved.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include <stdlib.h>
-#include <errno.h>
-#include "atomicio.h"
-
-/*
- * ensure all of data on socket comes through. f==read || f==vwrite
- */
-size_t
-atomicio(f, fd, _s, n)
- ssize_t (*f) (int, void *, size_t);
- int fd;
- void *_s;
- size_t n;
-{
- char *s = _s;
- size_t pos = 0;
- ssize_t res;
-
- while (n > pos) {
- res = (f) (fd, s + pos, n - pos);
- switch (res) {
- case -1:
- if (errno == EINTR || errno == EAGAIN)
- continue;
- return 0;
- case 0:
- errno = EPIPE;
- return pos;
- default:
- pos += (size_t)res;
- }
- }
- return (pos);
-}
-
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#include <inttypes.h>
-
-int blk_getimagesize(int fd, uint64_t *size);
-int blk_getsectorsize(int fd, uint64_t *sector_size);
-
-#ifndef O_LARGEFILE
-#define O_LARGEFILE 0
-#endif
+++ /dev/null
-#include <inttypes.h>
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/mount.h>
-#include "tapdisk.h"
-#include "blk.h"
-
-int blk_getimagesize(int fd, uint64_t *size)
-{
- int rc;
-
- *size = 0;
- rc = ioctl(fd, BLKGETSIZE, size);
- if (rc) {
- DPRINTF("ERR: BLKGETSIZE failed, couldn't stat image");
- return -EINVAL;
- }
-
- return 0;
-}
-
-int blk_getsectorsize(int fd, uint64_t *sector_size)
-{
-#if defined(BLKSSZGET)
- int rc;
-
- *sector_size = DEFAULT_SECTOR_SIZE;
- rc = ioctl(fd, BLKSSZGET, sector_size);
- if (rc) {
- DPRINTF("ERR: BLKSSZGET failed. Falling back to use default sector size");
- *sector_size = DEFAULT_SECTOR_SIZE;
- }
-
- if (*sector_size != DEFAULT_SECTOR_SIZE)
- DPRINTF("Note: sector size is %"PRIu64" (not %u)\n",
- *sector_size, DEFAULT_SECTOR_SIZE);
-#else
- *sector_size = DEFAULT_SECTOR_SIZE;
-#endif
-
- return 0;
-}
-
+++ /dev/null
-#include <sys/param.h>
-#include <sys/ioctl.h>
-#include <sys/disklabel.h>
-#include <errno.h>
-#include <inttypes.h>
-#include "tapdisk.h"
-#include "blk.h"
-
-int blk_getimagesize(int fd, uint64_t *size)
-{
- int rc;
- struct disklabel dl;
-
- *size = 0;
- rc = ioctl(fd, DIOCGDINFO, &dl);
- if (rc) {
- DPRINTF("ERR: DIOCGDINFO failed, couldn't stat image");
- return -EINVAL;
- }
-
- *size = dl.d_secsize * dl.d_secpercyl;
-
- return 0;
-}
-
-int blk_getsectorsize(int fd, uint64_t *sector_size)
-{
- int rc;
- struct disklabel dl;
-
- *sector_size = DEV_BSIZE;
- rc = ioctl(fd, DIOCGDINFO, &dl);
- if (rc) {
- DPRINTF("ERR: DIOCGDINFO failed, couldn't stat image");
- return 0; /* fallback to DEV_BSIZE */
- }
-
- *sector_size = dl.d_secsize;
- return 0;
-}
-
+++ /dev/null
-/*
- * Copyright (c) 2007, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-
-#include <errno.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <sys/statvfs.h>
-#include <sys/stat.h>
-#include <sys/ioctl.h>
-
-#include "blk.h"
-#include "tapdisk.h"
-#include "tapdisk-driver.h"
-#include "tapdisk-interface.h"
-
-#define MAX_AIO_REQS TAPDISK_DATA_REQUESTS
-
-struct tdaio_state;
-
-struct aio_request {
- td_request_t treq;
- struct tiocb tiocb;
- struct tdaio_state *state;
-};
-
-struct tdaio_state {
- int fd;
- td_driver_t *driver;
-
- int aio_free_count;
- struct aio_request aio_requests[MAX_AIO_REQS];
- struct aio_request *aio_free_list[MAX_AIO_REQS];
-};
-
-/*Get Image size, secsize*/
-static int tdaio_get_image_info(int fd, td_disk_info_t *info)
-{
- int ret;
- long size;
- unsigned long total_size;
- struct statvfs statBuf;
- struct stat stat;
-
- ret = fstat(fd, &stat);
- if (ret != 0) {
- DPRINTF("ERROR: fstat failed, Couldn't stat image");
- return -EINVAL;
- }
-
- if (S_ISBLK(stat.st_mode)) {
- /*Accessing block device directly*/
- info->size = 0;
- if (blk_getimagesize(fd, &info->size) != 0)
- return -EINVAL;
-
- DPRINTF("Image size: \n\tpre sector_shift [%llu]\n\tpost "
- "sector_shift [%llu]\n",
- (long long unsigned)(info->size << SECTOR_SHIFT),
- (long long unsigned)info->size);
-
- /*Get the sector size*/
- if (blk_getsectorsize(fd, &info->sector_size) != 0)
- info->sector_size = DEFAULT_SECTOR_SIZE;
-
- } else {
- /*Local file? try fstat instead*/
- info->size = (stat.st_size >> SECTOR_SHIFT);
- info->sector_size = DEFAULT_SECTOR_SIZE;
- DPRINTF("Image size: \n\tpre sector_shift [%llu]\n\tpost "
- "sector_shift [%llu]\n",
- (long long unsigned)(info->size << SECTOR_SHIFT),
- (long long unsigned)info->size);
- }
-
- if (info->size == 0) {
- info->size =((uint64_t) 16836057);
- info->sector_size = DEFAULT_SECTOR_SIZE;
- }
- info->info = 0;
-
- return 0;
-}
-
-/* Open the disk file and initialize aio state. */
-int tdaio_open(td_driver_t *driver, const char *name, td_flag_t flags)
-{
- int i, fd, ret, o_flags;
- struct tdaio_state *prv;
-
- ret = 0;
- prv = (struct tdaio_state *)driver->data;
-
- DPRINTF("block-aio open('%s')", name);
-
- memset(prv, 0, sizeof(struct tdaio_state));
-
- prv->aio_free_count = MAX_AIO_REQS;
- for (i = 0; i < MAX_AIO_REQS; i++)
- prv->aio_free_list[i] = &prv->aio_requests[i];
-
- /* Open the file */
- o_flags = O_DIRECT | O_LARGEFILE |
- ((flags & TD_OPEN_RDONLY) ? O_RDONLY : O_RDWR);
- fd = open(name, o_flags);
-
- if ( (fd == -1) && (errno == EINVAL) ) {
-
- /* Maybe O_DIRECT isn't supported. */
- o_flags &= ~O_DIRECT;
- fd = open(name, o_flags);
- if (fd != -1) DPRINTF("WARNING: Accessing image without"
- "O_DIRECT! (%s)\n", name);
-
- } else if (fd != -1) DPRINTF("open(%s) with O_DIRECT\n", name);
-
- if (fd == -1) {
- DPRINTF("Unable to open [%s] (%d)!\n", name, 0 - errno);
- ret = 0 - errno;
- goto done;
- }
-
- ret = tdaio_get_image_info(fd, &driver->info);
- if (ret) {
- close(fd);
- goto done;
- }
-
- prv->fd = fd;
-
-done:
- return ret;
-}
-
-void tdaio_complete(void *arg, struct tiocb *tiocb, int err)
-{
- struct aio_request *aio = (struct aio_request *)arg;
- struct tdaio_state *prv = aio->state;
-
- td_complete_request(aio->treq, err);
- prv->aio_free_list[prv->aio_free_count++] = aio;
-}
-
-void tdaio_queue_read(td_driver_t *driver, td_request_t treq)
-{
- int size;
- uint64_t offset;
- struct aio_request *aio;
- struct tdaio_state *prv;
-
- prv = (struct tdaio_state *)driver->data;
- size = treq.secs * driver->info.sector_size;
- offset = treq.sec * (uint64_t)driver->info.sector_size;
-
- if (prv->aio_free_count == 0)
- goto fail;
-
- aio = prv->aio_free_list[--prv->aio_free_count];
- aio->treq = treq;
- aio->state = prv;
-
- td_prep_read(&aio->tiocb, prv->fd, treq.buf,
- size, offset, tdaio_complete, aio);
- td_queue_tiocb(driver, &aio->tiocb);
-
- return;
-
-fail:
- td_complete_request(treq, -EBUSY);
-}
-
-void tdaio_queue_write(td_driver_t *driver, td_request_t treq)
-{
- int size;
- uint64_t offset;
- struct aio_request *aio;
- struct tdaio_state *prv;
-
- prv = (struct tdaio_state *)driver->data;
- size = treq.secs * driver->info.sector_size;
- offset = treq.sec * (uint64_t)driver->info.sector_size;
-
- if (prv->aio_free_count == 0)
- goto fail;
-
- aio = prv->aio_free_list[--prv->aio_free_count];
- aio->treq = treq;
- aio->state = prv;
-
- td_prep_write(&aio->tiocb, prv->fd, treq.buf,
- size, offset, tdaio_complete, aio);
- td_queue_tiocb(driver, &aio->tiocb);
-
- return;
-
-fail:
- td_complete_request(treq, -EBUSY);
-}
-
-int tdaio_close(td_driver_t *driver)
-{
- struct tdaio_state *prv = (struct tdaio_state *)driver->data;
-
- close(prv->fd);
-
- return 0;
-}
-
-int tdaio_get_parent_id(td_driver_t *driver, td_disk_id_t *id)
-{
- return TD_NO_PARENT;
-}
-
-int tdaio_validate_parent(td_driver_t *driver,
- td_driver_t *pdriver, td_flag_t flags)
-{
- return -EINVAL;
-}
-
-struct tap_disk tapdisk_aio = {
- .disk_type = "tapdisk_aio",
- .flags = 0,
- .private_data_size = sizeof(struct tdaio_state),
- .td_open = tdaio_open,
- .td_close = tdaio_close,
- .td_queue_read = tdaio_queue_read,
- .td_queue_write = tdaio_queue_write,
- .td_get_parent_id = tdaio_get_parent_id,
- .td_validate_parent = tdaio_validate_parent,
- .td_debug = NULL,
-};
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include <errno.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <sys/mman.h>
-
-#include "tapdisk.h"
-#include "tapdisk-utils.h"
-#include "tapdisk-driver.h"
-#include "tapdisk-server.h"
-#include "tapdisk-interface.h"
-
-#ifdef DEBUG
-#define DBG(_f, _a...) tlog_write(TLOG_DBG, _f, ##_a)
-#else
-#define DBG(_f, _a...) ((void)0)
-#endif
-
-#define WARN(_f, _a...) tlog_write(TLOG_WARN, _f, ##_a)
-
-#define RADIX_TREE_PAGE_SHIFT 12 /* 4K pages */
-#define RADIX_TREE_PAGE_SIZE (1 << RADIX_TREE_PAGE_SHIFT)
-
-#define RADIX_TREE_NODE_SHIFT 9 /* 512B nodes */
-#define RADIX_TREE_NODE_SIZE (1 << RADIX_TREE_NODE_SHIFT)
-#define RADIX_TREE_NODE_MASK (RADIX_TREE_NODE_SIZE - 1)
-
-#define BLOCK_CACHE_NODES_PER_PAGE (1 << (RADIX_TREE_PAGE_SHIFT - RADIX_TREE_NODE_SHIFT))
-
-#define BLOCK_CACHE_MAX_SIZE (10 << 20) /* 100MB cache */
-#define BLOCK_CACHE_REQUESTS (TAPDISK_DATA_REQUESTS << 3)
-#define BLOCK_CACHE_PAGE_IDLETIME 60
-
-typedef struct radix_tree radix_tree_t;
-typedef struct radix_tree_node radix_tree_node_t;
-typedef struct radix_tree_link radix_tree_link_t;
-typedef struct radix_tree_leaf radix_tree_leaf_t;
-typedef struct radix_tree_page radix_tree_page_t;
-
-typedef struct block_cache block_cache_t;
-typedef struct block_cache_request block_cache_request_t;
-typedef struct block_cache_stats block_cache_stats_t;
-
-struct radix_tree_page {
- char *buf;
- size_t size;
- uint64_t sec;
- radix_tree_link_t *owners[BLOCK_CACHE_NODES_PER_PAGE];
-};
-
-struct radix_tree_leaf {
- radix_tree_page_t *page;
- char *buf;
-};
-
-struct radix_tree_link {
- uint32_t time;
- union {
- radix_tree_node_t *next;
- radix_tree_leaf_t leaf;
- } u;
-};
-
-struct radix_tree_node {
- int height;
- radix_tree_link_t links[RADIX_TREE_NODE_SIZE];
-};
-
-struct radix_tree {
- int height;
- uint64_t size;
- uint32_t nodes;
- radix_tree_node_t *root;
-
- block_cache_t *cache;
-};
-
-struct block_cache_request {
- int err;
- char *buf;
- uint64_t secs;
- td_request_t treq;
- block_cache_t *cache;
-};
-
-struct block_cache_stats {
- uint64_t reads;
- uint64_t hits;
- uint64_t misses;
- uint64_t prunes;
-};
-
-struct block_cache {
- int ptype;
- char *name;
-
- uint64_t sectors;
-
- block_cache_request_t requests[BLOCK_CACHE_REQUESTS];
- block_cache_request_t *request_free_list[BLOCK_CACHE_REQUESTS];
- int requests_free;
-
- event_id_t timeout_id;
-
- radix_tree_t tree;
-
- block_cache_stats_t stats;
-};
-
-static inline uint64_t
-radix_tree_calculate_size(int height)
-{
- return (uint64_t)RADIX_TREE_NODE_SIZE <<
- (height * RADIX_TREE_NODE_SHIFT);
-}
-
-static inline int
-radix_tree_calculate_height(uint64_t sectors)
-{
- int height;
- uint64_t tree_size;
-
- height = 1; /* always allocate root node */
- tree_size = radix_tree_calculate_size(height);
- while (sectors > tree_size)
- tree_size = radix_tree_calculate_size(++height);
-
- return height;
-}
-
-static inline int
-radix_tree_index(radix_tree_node_t *node, uint64_t sector)
-{
- return ((sector >> (node->height * RADIX_TREE_NODE_SHIFT)) &
- RADIX_TREE_NODE_MASK);
-}
-
-static inline int
-radix_tree_node_contains_leaves(radix_tree_t *tree, radix_tree_node_t *node)
-{
- return (node->height == 0);
-}
-
-static inline int
-radix_tree_node_is_root(radix_tree_t *tree, radix_tree_node_t *node)
-{
- return (node->height == tree->height);
-}
-
-static inline uint64_t
-radix_tree_size(radix_tree_t *tree)
-{
- return tree->size + tree->nodes * sizeof(radix_tree_node_t);
-}
-
-static inline void
-radix_tree_clear_link(radix_tree_link_t *link)
-{
- if (link)
- memset(link, 0, sizeof(radix_tree_link_t));
-}
-
-static inline radix_tree_node_t *
-radix_tree_allocate_node(radix_tree_t *tree, int height)
-{
- radix_tree_node_t *node;
-
- node = calloc(1, sizeof(radix_tree_node_t));
- if (!node)
- return NULL;
-
- node->height = height;
- tree->nodes++;
-
- return node;
-}
-
-static inline radix_tree_node_t *
-radix_tree_allocate_child_node(radix_tree_t *tree, radix_tree_node_t *parent)
-{
- return radix_tree_allocate_node(tree, parent->height - 1);
-}
-
-void
-radix_tree_free_node(radix_tree_t *tree, radix_tree_node_t *node)
-{
- if (!node)
- return;
-
- free(node);
- tree->nodes--;
-}
-
-static inline radix_tree_page_t *
-radix_tree_allocate_page(radix_tree_t *tree,
- char *buf, uint64_t sec, size_t size)
-{
- radix_tree_page_t *page;
-
- page = calloc(1, sizeof(radix_tree_page_t));
- if (!page)
- return NULL;
-
- page->buf = buf;
- page->sec = sec;
- page->size = size;
- tree->size += size;
-
- return page;
-}
-
-static inline void
-radix_tree_free_page(radix_tree_t *tree, radix_tree_page_t *page)
-{
- int i;
-
- for (i = 0; i < page->size >> RADIX_TREE_NODE_SHIFT; i++)
- DBG("%s: ejecting sector 0x%llx\n",
- tree->cache->name, page->sec + i);
-
- tree->cache->stats.prunes += (page->size >> RADIX_TREE_NODE_SHIFT);
- tree->size -= page->size;
- free(page->buf);
- free(page);
-}
-
-/*
- * remove a leaf and the shared radix_tree_page_t containing its buffer.
- * leaves are deleted, nodes are not; gc will reap the nodes later.
- */
-static void
-radix_tree_remove_page(radix_tree_t *tree, radix_tree_page_t *page)
-{
- int i;
-
- if (!page)
- return;
-
- for (i = 0; i < BLOCK_CACHE_NODES_PER_PAGE; i++)
- radix_tree_clear_link(page->owners[i]);
-
- radix_tree_free_page(tree, page);
-}
-
-static void
-radix_tree_insert_leaf(radix_tree_t *tree, radix_tree_link_t *link,
- radix_tree_page_t *page, off_t off)
-{
- int i;
-
- if (off + RADIX_TREE_NODE_SIZE > page->size)
- return;
-
- for (i = 0; i < BLOCK_CACHE_NODES_PER_PAGE; i++) {
- if (page->owners[i])
- continue;
-
- page->owners[i] = link;
- link->u.leaf.page = page;
- link->u.leaf.buf = page->buf + off;
-
- break;
- }
-}
-
-static char *
-radix_tree_find_leaf(radix_tree_t *tree, uint64_t sector)
-{
- int idx;
- struct timeval now;
- radix_tree_link_t *link;
- radix_tree_node_t *node;
-
- node = tree->root;
- gettimeofday(&now, NULL);
-
- do {
- idx = radix_tree_index(node, sector);
- link = node->links + idx;
- link->time = now.tv_sec;
-
- if (radix_tree_node_contains_leaves(tree, node))
- return link->u.leaf.buf;
-
- if (!link->u.next)
- return NULL;
-
- node = link->u.next;
- } while (1);
-}
-
-static char *
-radix_tree_add_leaf(radix_tree_t *tree, uint64_t sector,
- radix_tree_page_t *page, off_t off)
-{
- int idx;
- struct timeval now;
- radix_tree_link_t *link;
- radix_tree_node_t *node;
-
- node = tree->root;
- gettimeofday(&now, NULL);
-
- do {
- idx = radix_tree_index(node, sector);
- link = node->links + idx;
- link->time = now.tv_sec;
-
- if (radix_tree_node_contains_leaves(tree, node)) {
- radix_tree_remove_page(tree, link->u.leaf.page);
- radix_tree_insert_leaf(tree, link, page, off);
- return link->u.leaf.buf;
- }
-
- if (!link->u.next) {
- link->u.next = radix_tree_allocate_child_node(tree,
- node);
- if (!link->u.next)
- return NULL;
- }
-
- node = link->u.next;
- } while (1);
-}
-
-static int
-radix_tree_add_leaves(radix_tree_t *tree, char *buf,
- uint64_t sector, uint64_t sectors)
-{
- int i;
- radix_tree_page_t *page;
-
- page = radix_tree_allocate_page(tree, buf, sector,
- sectors << RADIX_TREE_NODE_SHIFT);
- if (!page)
- return -ENOMEM;
-
- for (i = 0; i < sectors; i++)
- if (!radix_tree_add_leaf(tree, sector + i,
- page, (i << RADIX_TREE_NODE_SHIFT)))
- goto fail;
-
- return 0;
-
-fail:
- page->buf = NULL;
- radix_tree_remove_page(tree, page);
- return -ENOMEM;
-}
-
-static void
-radix_tree_delete_branch(radix_tree_t *tree, radix_tree_node_t *node)
-{
- int i;
- radix_tree_link_t *link;
-
- if (!node)
- return;
-
- for (i = 0; i < RADIX_TREE_NODE_SIZE; i++) {
- link = node->links + i;
-
- if (radix_tree_node_contains_leaves(tree, node))
- radix_tree_remove_page(tree, link->u.leaf.page);
- else
- radix_tree_delete_branch(tree, link->u.next);
-
- radix_tree_clear_link(link);
- }
-
- radix_tree_free_node(tree, node);
-}
-
-static inline void
-radix_tree_destroy(radix_tree_t *tree)
-{
- radix_tree_delete_branch(tree, tree->root);
- tree->root = NULL;
-}
-
-/*
- * returns 1 if @node is empty after pruning, 0 otherwise
- */
-static int
-radix_tree_prune_branch(radix_tree_t *tree,
- radix_tree_node_t *node, uint32_t now)
-{
- int i, empty;
- radix_tree_link_t *link;
-
- empty = 1;
- if (!node)
- return empty;
-
- for (i = 0; i < RADIX_TREE_NODE_SIZE; i++) {
- link = node->links + i;
-
- if (now - link->time < BLOCK_CACHE_PAGE_IDLETIME) {
- if (radix_tree_node_contains_leaves(tree, node)) {
- empty = 0;
- continue;
- }
-
- if (radix_tree_prune_branch(tree, link->u.next, now))
- radix_tree_clear_link(link);
- else
- empty = 0;
-
- continue;
- }
-
- if (radix_tree_node_contains_leaves(tree, node))
- radix_tree_remove_page(tree, link->u.leaf.page);
- else
- radix_tree_delete_branch(tree, link->u.next);
-
- radix_tree_clear_link(link);
- }
-
- if (empty && !radix_tree_node_is_root(tree, node))
- radix_tree_free_node(tree, node);
-
- return empty;
-}
-
-/*
- * walk tree and free any node that has been idle for too long
- */
-static void
-radix_tree_prune(radix_tree_t *tree)
-{
- struct timeval now;
-
- if (!tree->root)
- return;
-
- DPRINTF("tree %s has %"PRIu64" bytes\n",
- tree->cache->name, tree->size);
-
- gettimeofday(&now, NULL);
- radix_tree_prune_branch(tree, tree->root, now.tv_sec);
-
- DPRINTF("tree %s now has %"PRIu64" bytes\n",
- tree->cache->name, tree->size);
-}
-
-static inline int
-radix_tree_initialize(radix_tree_t *tree, uint64_t sectors)
-{
- tree->height = radix_tree_calculate_height(sectors);
- tree->root = radix_tree_allocate_node(tree, tree->height);
- if (!tree->root)
- return -ENOMEM;
-
- return 0;
-}
-
-static inline void
-radix_tree_free(radix_tree_t *tree)
-{
- radix_tree_destroy(tree);
-}
-
-static void
-block_cache_prune_event(event_id_t id, char mode, void *private)
-{
- radix_tree_t *tree;
- block_cache_t *cache;
-
- cache = (block_cache_t *)private;
- tree = &cache->tree;
-
- radix_tree_prune(tree);
-}
-
-static inline block_cache_request_t *
-block_cache_get_request(block_cache_t *cache)
-{
- if (!cache->requests_free)
- return NULL;
-
- return cache->request_free_list[--cache->requests_free];
-}
-
-static inline void
-block_cache_put_request(block_cache_t *cache, block_cache_request_t *breq)
-{
- memset(breq, 0, sizeof(block_cache_request_t));
- cache->request_free_list[cache->requests_free++] = breq;
-}
-
-static int
-block_cache_open(td_driver_t *driver, const char *name, td_flag_t flags)
-{
- int i, err;
- radix_tree_t *tree;
- block_cache_t *cache;
-
- if (!td_flag_test(flags, TD_OPEN_RDONLY))
- return -EINVAL;
-
- if (driver->info.sector_size != RADIX_TREE_NODE_SIZE)
- return -EINVAL;
-
- cache = (block_cache_t *)driver->data;
- err = tapdisk_namedup(&cache->name, (char *)name);
- if (err)
- return -ENOMEM;
-
- cache->sectors = driver->info.size;
-
- tree = &cache->tree;
- err = radix_tree_initialize(tree, cache->sectors);
- if (err)
- goto fail;
-
- tree->cache = cache;
- cache->requests_free = BLOCK_CACHE_REQUESTS;
- for (i = 0; i < BLOCK_CACHE_REQUESTS; i++)
- cache->request_free_list[i] = cache->requests + i;
-
- cache->timeout_id = tapdisk_server_register_event(SCHEDULER_POLL_TIMEOUT,
- -1, /* dummy fd */
- BLOCK_CACHE_PAGE_IDLETIME << 1,
- block_cache_prune_event,
- cache);
- if (cache->timeout_id < 0)
- goto fail;
-
- DPRINTF("opening cache for %s, sectors: %"PRIu64", "
- "tree: %p, height: %d\n",
- cache->name, cache->sectors, tree, tree->height);
-
- if (mlockall(MCL_CURRENT | MCL_FUTURE))
- DPRINTF("mlockall failed: %d\n", -errno);
-
- return 0;
-
-fail:
- free(cache->name);
- radix_tree_free(&cache->tree);
- return err;
-}
-
-static int
-block_cache_close(td_driver_t *driver)
-{
- radix_tree_t *tree;
- block_cache_t *cache;
-
- cache = (block_cache_t *)driver->data;
- tree = &cache->tree;
-
- DPRINTF("closing cache for %s\n", cache->name);
-
- tapdisk_server_unregister_event(cache->timeout_id);
- radix_tree_free(tree);
- free(cache->name);
-
- return 0;
-}
-
-static inline uint64_t
-block_cache_hash(block_cache_t *cache, char *buf)
-{
- int i, n;
- uint64_t cksm, *data;
-
- return 0;
-
- cksm = 0;
- data = (uint64_t *)buf;
- n = RADIX_TREE_NODE_SIZE / sizeof(uint64_t);
-
- for (i = 0; i < n; i++)
- cksm += data[i];
-
- return ~cksm;
-}
-
-static void
-block_cache_hit(block_cache_t *cache, td_request_t treq, char *iov[])
-{
- int i;
- off_t off;
-
- cache->stats.hits += treq.secs;
-
- for (i = 0; i < treq.secs; i++) {
- DBG("%s: block cache hit: sec 0x%08llx, hash: 0x%08llx\n",
- cache->name, treq.sec + i, block_cache_hash(cache, iov[i]));
-
- off = i << RADIX_TREE_NODE_SHIFT;
- memcpy(treq.buf + off, iov[i], RADIX_TREE_NODE_SIZE);
- }
-
- td_complete_request(treq, 0);
-}
-
-static void
-block_cache_populate_cache(td_request_t clone, int err)
-{
- int i;
- radix_tree_t *tree;
- block_cache_t *cache;
- block_cache_request_t *breq;
-
- breq = (block_cache_request_t *)clone.cb_data;
- cache = breq->cache;
- tree = &cache->tree;
- breq->secs -= clone.secs;
- breq->err = (breq->err ? breq->err : err);
-
- if (breq->secs)
- return;
-
- if (breq->err) {
- free(breq->buf);
- goto out;
- }
-
- for (i = 0; i < breq->treq.secs; i++) {
- off_t off = i << RADIX_TREE_NODE_SHIFT;
- DBG("%s: populating sec 0x%08llx\n",
- cache->name, breq->treq.sec + i);
- memcpy(breq->treq.buf + off,
- breq->buf + off, RADIX_TREE_NODE_SIZE);
- }
-
- if (radix_tree_add_leaves(tree, breq->buf,
- breq->treq.sec, breq->treq.secs))
- free(breq->buf);
-
-out:
- td_complete_request(breq->treq, breq->err);
- block_cache_put_request(cache, breq);
-}
-
-static void
-block_cache_miss(block_cache_t *cache, td_request_t treq)
-{
- char *buf;
- size_t size;
- td_request_t clone;
- radix_tree_t *tree;
- block_cache_request_t *breq;
-
- DBG("%s: block cache miss: sec 0x%08llx\n", cache->name, treq.sec);
-
- clone = treq;
- tree = &cache->tree;
- size = treq.secs << RADIX_TREE_NODE_SHIFT;
-
- cache->stats.misses += treq.secs;
-
- if (radix_tree_size(tree) + size >= BLOCK_CACHE_MAX_SIZE)
- goto out;
-
- breq = block_cache_get_request(cache);
- if (!breq)
- goto out;
-
- if (posix_memalign((void **)&buf, RADIX_TREE_NODE_SIZE, size)) {
- block_cache_put_request(cache, breq);
- goto out;
- }
-
- breq->treq = treq;
- breq->secs = treq.secs;
- breq->err = 0;
- breq->buf = buf;
- breq->cache = cache;
-
- clone.buf = buf;
- clone.cb = block_cache_populate_cache;
- clone.cb_data = breq;
-
-out:
- td_forward_request(clone);
-}
-
-static void
-block_cache_queue_read(td_driver_t *driver, td_request_t treq)
-{
- int i;
- radix_tree_t *tree;
- block_cache_t *cache;
- char *iov[BLOCK_CACHE_NODES_PER_PAGE];
-
- cache = (block_cache_t *)driver->data;
- tree = &cache->tree;
-
- cache->stats.reads += treq.secs;
-
- if (treq.secs > BLOCK_CACHE_NODES_PER_PAGE)
- return td_forward_request(treq);
-
- for (i = 0; i < treq.secs; i++) {
- iov[i] = radix_tree_find_leaf(tree, treq.sec + i);
- if (!iov[i])
- return block_cache_miss(cache, treq);
- }
-
- return block_cache_hit(cache, treq, iov);
-}
-
-static void
-block_cache_queue_write(td_driver_t *driver, td_request_t treq)
-{
- td_complete_request(treq, -EPERM);
-}
-
-static int
-block_cache_get_parent_id(td_driver_t *driver, td_disk_id_t *id)
-{
- return -EINVAL;
-}
-
-static int
-block_cache_validate_parent(td_driver_t *driver,
- td_driver_t *pdriver, td_flag_t flags)
-{
- block_cache_t *cache;
-
- if (!td_flag_test(pdriver->state, TD_DRIVER_RDONLY))
- return -EINVAL;
-
- cache = (block_cache_t *)driver->data;
- if (strcmp(driver->name, pdriver->name))
- return -EINVAL;
-
- return 0;
-}
-
-static void
-block_cache_debug(td_driver_t *driver)
-{
- block_cache_t *cache;
- block_cache_stats_t *stats;
-
- cache = (block_cache_t *)driver->data;
- stats = &cache->stats;
-
- WARN("BLOCK CACHE %s\n", cache->name);
- WARN("reads: %"PRIu64", hits: %"PRIu64", misses: %"PRIu64", prunes: %"PRIu64"\n",
- stats->reads, stats->hits, stats->misses, stats->prunes);
-}
-
-struct tap_disk tapdisk_block_cache = {
- .disk_type = "tapdisk_block_cache",
- .flags = 0,
- .private_data_size = sizeof(block_cache_t),
- .td_open = block_cache_open,
- .td_close = block_cache_close,
- .td_queue_read = block_cache_queue_read,
- .td_queue_write = block_cache_queue_write,
- .td_get_parent_id = block_cache_get_parent_id,
- .td_validate_parent = block_cache_validate_parent,
- .td_debug = block_cache_debug,
-};
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/* Driver to sit on top of another disk and log writes, in order
- * to synchronize two distinct disks
- *
- * On receipt of a control request it can export a list of dirty
- * sectors in the following format:
- * struct writerange {
- * u64 sector;
- * u32 count;
- * }
- * terminated by { 0, 0 }
- */
-
-#include <errno.h>
-#include <stdio.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <sys/mman.h>
-#include <sys/socket.h>
-#include <sys/un.h>
-
-#include "xc_bitops.h"
-#include "log.h"
-#include "tapdisk.h"
-#include "tapdisk-server.h"
-#include "tapdisk-driver.h"
-#include "tapdisk-interface.h"
-
-#define MAX_CONNECTIONS 1
-
-typedef struct poll_fd {
- int fd;
- event_id_t id;
-} poll_fd_t;
-
-struct tdlog_state {
- uint64_t size;
-
- void* writelog;
-
- char* ctlpath;
- poll_fd_t ctl;
-
- int connected;
- poll_fd_t connections[MAX_CONNECTIONS];
-
- char* shmpath;
- void* shm;
-
- log_sring_t* sring;
- log_back_ring_t bring;
-};
-
-#define BDPRINTF(_f, _a...) syslog (LOG_DEBUG, "log: " _f "\n", ## _a)
-
-#define BWPRINTF(_f, _a...) syslog (LOG_WARNING, "log: " _f "\n", ## _a)
-
-static void ctl_accept(event_id_t, char, void *);
-static void ctl_request(event_id_t, char, void *);
-
-/* -- write log -- */
-
-/* large flat bitmaps don't scale particularly well either in size or scan
- * time, but they'll do for now */
-
-static int writelog_create(struct tdlog_state *s)
-{
- uint64_t bmsize;
-
- bmsize = bitmap_size(s->size);
-
- BDPRINTF("allocating %"PRIu64" bytes for dirty bitmap", bmsize);
-
- s->writelog = bitmap_alloc(s->size);
- if (!s->writelog) {
- BWPRINTF("could not allocate dirty bitmap of size %"PRIu64, bmsize);
- return -1;
- }
-
- return 0;
-}
-
-static int writelog_free(struct tdlog_state *s)
-{
- if (s->writelog)
- free(s->writelog);
-
- return 0;
-}
-
-static int writelog_set(struct tdlog_state* s, uint64_t sector, int count)
-{
- int i;
-
- for (i = 0; i < count; i++)
- set_bit(sector + i, s->writelog);
-
- return 0;
-}
-
-/* if end is 0, clear to end of disk */
-int writelog_clear(struct tdlog_state* s, uint64_t start, uint64_t end)
-{
- if (!end)
- end = s->size;
-
- /* clear to word boundaries */
- while (BITMAP_SHIFT(start))
- clear_bit(start++, s->writelog);
- while (BITMAP_SHIFT(end))
- clear_bit(end--, s->writelog);
-
- memset(s->writelog + start / BITS_PER_LONG, 0, (end - start) >> 3);
-
- return 0;
-}
-
-/* returns last block exported (may not be end of disk if shm region
- * overflows) */
-static uint64_t writelog_export(struct tdlog_state* s)
-{
- struct disk_range* range = s->shm;
- uint64_t i = 0;
-
- BDPRINTF("sector count: %"PRIu64, s->size);
-
- for (i = 0; i < s->size; i++) {
- if (test_bit(i, s->writelog)) {
- /* range start */
- range->sector = i;
- range->count = 1;
- /* find end */
- for (i++; i < s->size && test_bit(i, s->writelog); i++)
- range->count++;
-
- BDPRINTF("export: dirty extent %"PRIu64":%u",
- range->sector, range->count);
- range++;
-
- /* out of space in shared memory region */
- if ((void*)range >= bmend(s->shm)) {
- BDPRINTF("out of space in shm region at sector %"PRIu64, i);
- return i;
- }
-
- /* undo forloop increment */
- i--;
- }
- }
-
- /* NULL-terminate range list */
- range->sector = 0;
- range->count = 0;
-
- return i;
-}
-
-/* -- communication channel -- */
-
-/* remove FS special characters in up to len bytes of path */
-static inline void path_escape(char* path, size_t len) {
- int i;
-
- for (i = 0; i < len && path[i]; i++)
- if (strchr(":/", path[i]))
- path[i] = '_';
-}
-
-static char* ctl_makepath(const char* name, const char* ext)
-{
- char* res;
- char *file;
-
- file = strrchr(name, '/');
- if (!file) {
- BWPRINTF("invalid name %s\n", name);
- return NULL;
- }
-
- if (asprintf(&res, BLKTAP_CTRL_DIR "/log_%s.%s", file, ext) < 0) {
- BWPRINTF("could not allocate path");
- return NULL;
- }
-
- path_escape(res + strlen(BLKTAP_CTRL_DIR) + 5, strlen(file));
-
- return res;
-}
-
-static int shmem_open(struct tdlog_state* s, const char* name)
-{
- int i, l, fd;
-
- /* device name -> path */
- if (asprintf(&s->shmpath, "/log_%s.wlog", name) < 0) {
- BWPRINTF("could not allocate shm path");
- return -1;
- }
-
- path_escape(s->shmpath + 5, strlen(name));
-
- if ((fd = shm_open(s->shmpath, O_CREAT|O_RDWR, 0750)) < 0) {
- BWPRINTF("could not open shared memory file %s: %s", s->shmpath,
- strerror(errno));
- goto err;
- }
- if (ftruncate(fd, SHMSIZE) < 0) {
- BWPRINTF("error truncating shmem to size %u", SHMSIZE);
- close(fd);
- goto err;
- }
-
- s->shm = mmap(NULL, SHMSIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
- close(fd);
- if (s->shm == MAP_FAILED) {
- BWPRINTF("could not mmap write log shm: %s", strerror(errno));
- goto err;
- }
- return 0;
-
- err:
- s->shm = NULL;
- free(s->shmpath);
- s->shmpath = NULL;
- return -1;
-}
-
-static int shmem_close(struct tdlog_state* s)
-{
- if (s->shm) {
- munmap(s->shm, SHMSIZE);
- s->shm = NULL;
- }
-
- if (s->shmpath) {
- shm_unlink(s->shmpath);
- s->shmpath = NULL;
- }
-
- return 0;
-}
-
-/* control socket */
-
-static int ctl_open(struct tdlog_state* s, const char* name)
-{
- struct sockaddr_un saddr;
-
- if (!(s->ctlpath = ctl_makepath(name, "ctl")))
- return -1;
-
- if ((s->ctl.fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
- BWPRINTF("error opening control socket: %s", strerror(errno));
- goto err;
- }
-
- memset(&saddr, 0, sizeof(saddr));
- saddr.sun_family = AF_UNIX;
- memcpy(saddr.sun_path, s->ctlpath, strlen(s->ctlpath));
- if (unlink(s->ctlpath) && errno != ENOENT) {
- BWPRINTF("error unlinking old socket path %s: %s", s->ctlpath,
- strerror(errno));
- goto err_sock;
- }
-
- if (bind(s->ctl.fd, (const struct sockaddr *)&saddr, sizeof(saddr)) < 0) {
- BWPRINTF("error binding control socket to %s: %s", s->ctlpath,
- strerror(errno));
- goto err_sock;
- }
-
- if (listen(s->ctl.fd, 1) < 0) {
- BWPRINTF("error listening on control socket: %s", strerror(errno));
- goto err_sock;
- }
-
- s->ctl.id = tapdisk_server_register_event(SCHEDULER_POLL_READ_FD,
- s->ctl.fd, 0, ctl_accept, s);
- if (s->ctl.id < 0) {
- BWPRINTF("error register event handler: %s", strerror(s->ctl.id));
- goto err_sock;
- }
-
- return 0;
-
- err_sock:
- close(s->ctl.fd);
- s->ctl.fd = -1;
- err:
- free(s->ctlpath);
- s->ctlpath = NULL;
-
- return -1;
-}
-
-static int ctl_close(struct tdlog_state* s)
-{
- while (s->connected) {
- s->connected--;
- tapdisk_server_unregister_event(s->connections[s->connected].id);
- close(s->connections[s->connected].fd);
- s->connections[s->connected].fd = -1;
- s->connections[s->connected].id = 0;
- }
-
- if (s->ctl.fd >= 0) {
- tapdisk_server_unregister_event(s->ctl.id);
- close(s->ctl.fd);
- s->ctl.fd = -1;
- s->ctl.id = 0;
- }
-
- if (s->ctlpath) {
- unlink(s->ctlpath);
- free(s->ctlpath);
- s->ctlpath = NULL;
- }
-
- /* XXX this must be fixed once requests are actually in flight */
- /* could just drain the existing ring here first */
- if (s->sring) {
- SHARED_RING_INIT(s->sring);
- BACK_RING_INIT(&s->bring, s->sring, SRINGSIZE);
- }
-
- return 0;
-}
-
-/* walk list of open sockets, close matching fd */
-static int ctl_close_sock(struct tdlog_state* s, int fd)
-{
- int i;
-
- for (i = 0; i < s->connected; i++) {
- if (s->connections[i].fd == fd) {
- tapdisk_server_unregister_event(s->connections[i].id);
- close(s->connections[i].fd);
- s->connections[i].fd = -1;
- s->connections[i].id = 0;
- s->connected--;
- return 0;
- }
- }
-
- BWPRINTF("requested to close unknown socket %d", fd);
- return -1;
-}
-
-static void ctl_accept(event_id_t id, char mode, void *private)
-{
- struct tdlog_state* s = (struct tdlog_state *)private;
- int fd;
- event_id_t cid;
-
- if ((fd = accept(s->ctl.fd, NULL, NULL)) < 0) {
- BWPRINTF("error accepting control connection: %s", strerror(errno));
- return;
- }
-
- if (s->connected) {
- BWPRINTF("control session in progress, closing new connection");
- close(fd);
- return;
- }
-
- cid = tapdisk_server_register_event(SCHEDULER_POLL_READ_FD,
- fd, 0, ctl_request, s);
- if (cid < 0) {
- BWPRINTF("error registering connection event handler: %s", strerror(cid));
- close(fd);
- return;
- }
-
- s->connections[s->connected].fd = fd;
- s->connections[s->connected].id = cid;
- s->connected++;
-}
-
-/* response format: 4 bytes shmsize, 0-terminated path */
-static int ctl_get_shmpath(struct tdlog_state* s, int fd)
-{
- char msg[CTLRSPLEN_SHMP + 1];
- uint32_t sz;
- int rc;
-
- BDPRINTF("ctl: sending shared memory parameters (size: %u, path: %s)",
- SHMSIZE, s->shmpath);
-
- /* TMP: sanity-check shm */
- sz = 0xdeadbeef;
- memcpy(s->shm, &sz, sizeof(sz));
-
- sz = SHMSIZE;
- memcpy(msg, &sz, sizeof(sz));
- snprintf(msg + sizeof(sz), sizeof(msg) - sizeof(sz), "%s", s->shmpath);
- if ((rc = write(fd, msg, CTLRSPLEN_SHMP)) < 0) {
- BWPRINTF("error writing shmpath: %s", strerror(errno));
- return -1;
- }
-
- return 0;
-}
-
-static int ctl_peek_writes(struct tdlog_state* s, int fd)
-{
- int rc;
-
- BDPRINTF("ctl: peeking bitmap");
-
- writelog_export(s);
-
- if ((rc = write(fd, "done", CTLRSPLEN_PEEK)) < 0) {
- BWPRINTF("error writing peek ack: %s", strerror(errno));
- return -1;
- }
-
- return 0;
-}
-
-static int ctl_clear_writes(struct tdlog_state* s, int fd)
-{
- int rc;
-
- BDPRINTF("ctl: clearing bitmap");
-
- writelog_clear(s, 0, 0);
-
- if ((rc = write(fd, "done", CTLRSPLEN_CLEAR)) < 0) {
- BWPRINTF("error writing clear ack: %s", strerror(errno));
- return -1;
- }
-
- return 0;
-}
-
-/* get dirty bitmap and clear it atomically */
-static int ctl_get_writes(struct tdlog_state* s, int fd)
-{
- int rc;
-
- BDPRINTF("ctl: getting bitmap");
-
- writelog_export(s);
- writelog_clear(s, 0, 0);
-
- if ((rc = write(fd, "done", CTLRSPLEN_GET)) < 0) {
- BWPRINTF("error writing get ack: %s", strerror(errno));
- return -1;
- }
-
- return 0;
-}
-
-/* get requests from ring */
-static int ctl_kick(struct tdlog_state* s, int fd)
-{
- RING_IDX reqstart, reqend;
- log_request_t req;
-
- /* XXX testing */
- RING_IDX rspstart, rspend;
- log_response_t rsp;
- struct log_ctlmsg msg;
- int rc;
-
- reqstart = s->bring.req_cons;
- reqend = s->sring->req_prod;
-
- BDPRINTF("ctl: ring kicked (start = %u, end = %u)", reqstart, reqend);
-
- while (reqstart != reqend) {
- /* XXX actually submit these! */
- memcpy(&req, RING_GET_REQUEST(&s->bring, reqstart), sizeof(req));
- BDPRINTF("ctl: read request %"PRIu64":%u", req.sector, req.count);
- s->bring.req_cons = ++reqstart;
-
- rsp.sector = req.sector;
- rsp.count = req.count;
- memcpy(RING_GET_RESPONSE(&s->bring, s->bring.rsp_prod_pvt), &rsp,
- sizeof(rsp));
- s->bring.rsp_prod_pvt++;
- }
-
- RING_PUSH_RESPONSES(&s->bring);
- memset(&msg, 0, sizeof(msg));
- memcpy(msg.msg, LOGCMD_KICK, 4);
- if ((rc = write(fd, &msg, sizeof(msg))) < 0) {
- BWPRINTF("error sending notify: %s", strerror(errno));
- return -1;
- } else if (rc < sizeof(msg)) {
- BWPRINTF("short notify write (%d/%zd)", rc, sizeof(msg));
- return -1;
- }
-
- return 0;
-}
-
-static int ctl_do_request(struct tdlog_state* s, int fd, struct log_ctlmsg* msg)
-{
- if (!strncmp(msg->msg, LOGCMD_SHMP, 4)) {
- return ctl_get_shmpath(s, fd);
- } else if (!strncmp(msg->msg, LOGCMD_PEEK, 4)) {
- return ctl_peek_writes(s, fd);
- } else if (!strncmp(msg->msg, LOGCMD_CLEAR, 4)) {
- return ctl_clear_writes(s, fd);
- } else if (!strncmp(msg->msg, LOGCMD_GET, 4)) {
- return ctl_get_writes(s, fd);
- } else if (!strncmp(msg->msg, LOGCMD_KICK, 4)) {
- return ctl_kick(s, fd);
- }
-
- BWPRINTF("unknown control request %.4s", msg->msg);
- return -1;
-}
-
-static inline int ctl_find_connection(struct tdlog_state *s, event_id_t id)
-{
- int i;
-
- for (i = 0; i < s->connected; i++)
- if (s->connections[i].id == id)
- return s->connections[i].fd;
-
- BWPRINTF("unrecognized event callback id %d", id);
- return -1;
-}
-
-static void ctl_request(event_id_t id, char mode, void *private)
-{
- struct tdlog_state* s = (struct tdlog_state*)private;
- struct log_ctlmsg msg;
- int rc, i, fd = -1;
-
- fd = ctl_find_connection(s, id);
- if (fd == -1)
- return;
-
- if ((rc = read(fd, &msg, sizeof(msg))) < 0) {
- BWPRINTF("error reading from ctl socket %d, closing: %s", fd,
- strerror(errno));
- ctl_close_sock(s, fd);
- return;
- } else if (rc == 0) {
- BDPRINTF("ctl_request: EOF, closing socket");
- ctl_close_sock(s, fd);
- return;
- } else if (rc < sizeof(msg)) {
- BWPRINTF("short request received (%d/%zd bytes), ignoring", rc,
- sizeof(msg));
- return;
- }
-
- ctl_do_request(s, fd, &msg);
-}
-
-/* -- interface -- */
-
-static int tdlog_close(td_driver_t*);
-
-static int tdlog_open(td_driver_t* driver, const char* name, td_flag_t flags)
-{
- struct tdlog_state* s = (struct tdlog_state*)driver->data;
- int rc;
-
- memset(s, 0, sizeof(*s));
-
- s->size = driver->info.size;
-
- if ((rc = writelog_create(s))) {
- tdlog_close(driver);
- return rc;
- }
- if ((rc = shmem_open(s, name))) {
- tdlog_close(driver);
- return rc;
- }
- if ((rc = ctl_open(s, name))) {
- tdlog_close(driver);
- return rc;
- }
-
- s->sring = (log_sring_t*)sringstart(s->shm);
- SHARED_RING_INIT(s->sring);
- BACK_RING_INIT(&s->bring, s->sring, SRINGSIZE);
-
- BDPRINTF("opened ctl socket");
-
- return 0;
-}
-
-static int tdlog_close(td_driver_t* driver)
-{
- struct tdlog_state* s = (struct tdlog_state*)driver->data;
-
- ctl_close(s);
- shmem_close(s);
- writelog_free(s);
-
- return 0;
-}
-
-static void tdlog_queue_read(td_driver_t* driver, td_request_t treq)
-{
- td_forward_request(treq);
-}
-
-static void tdlog_queue_write(td_driver_t* driver, td_request_t treq)
-{
- struct tdlog_state* s = (struct tdlog_state*)driver->data;
- int rc;
-
- writelog_set(s, treq.sec, treq.secs);
- td_forward_request(treq);
-}
-
-static int tdlog_get_parent_id(td_driver_t* driver, td_disk_id_t* id)
-{
- return -EINVAL;
-}
-
-static int tdlog_validate_parent(td_driver_t *driver,
- td_driver_t *parent, td_flag_t flags)
-{
- return 0;
-}
-
-struct tap_disk tapdisk_log = {
- .disk_type = "tapdisk_log",
- .private_data_size = sizeof(struct tdlog_state),
- .flags = 0,
- .td_open = tdlog_open,
- .td_close = tdlog_close,
- .td_queue_read = tdlog_queue_read,
- .td_queue_write = tdlog_queue_write,
- .td_get_parent_id = tdlog_get_parent_id,
- .td_validate_parent = tdlog_validate_parent,
-};
+++ /dev/null
-/* block-qcow.c
- *
- * Asynchronous Qemu copy-on-write disk implementation.
- * Code based on the Qemu implementation
- * (see copyright notice below)
- *
- * (c) 2006 Andrew Warfield and Julian Chesterfield
- *
- */
-
-/*
- * Block driver for the QCOW format
- *
- * Copyright (c) 2004 Fabrice Bellard
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files(the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- */
-
-#include <errno.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <sys/statvfs.h>
-#include <sys/stat.h>
-#include <sys/ioctl.h>
-#include <string.h>
-#include <zlib.h>
-#include <inttypes.h>
-#include <libaio.h>
-#include <limits.h>
-#include "bswap.h"
-#include "aes.h"
-#include "md5.h"
-
-#include "tapdisk.h"
-#include "tapdisk-driver.h"
-#include "tapdisk-interface.h"
-#include "tapdisk-disktype.h"
-#include "qcow.h"
-#include "blk.h"
-#include "atomicio.h"
-
-/* *BSD has no O_LARGEFILE */
-#ifndef O_LARGEFILE
-#define O_LARGEFILE 0
-#endif
-
-#if 1
-#define ASSERT(_p) \
- if ( !(_p) ) { DPRINTF("Assertion '%s' failed, line %d, file %s", #_p , \
- __LINE__, __FILE__); *(int*)0=0; }
-#else
-#define ASSERT(_p) ((void)0)
-#endif
-
-struct pending_aio {
- td_callback_t cb;
- int id;
- void *private;
- int nb_sectors;
- char *buf;
- uint64_t sector;
-};
-
-#undef IOCB_IDX
-#define IOCB_IDX(_s, _io) ((_io) - (_s)->iocb_list)
-
-#define ZERO_TEST(_b) (_b | 0x00)
-
-struct qcow_request {
- td_request_t treq;
- struct tiocb tiocb;
- struct tdqcow_state *state;
-};
-
-static int decompress_cluster(struct tdqcow_state *s, uint64_t cluster_offset);
-
-uint32_t gen_cksum(char *ptr, int len)
-{
- int i;
- uint32_t md[4];
-
- /* Generate checksum */
- md5_sum((const uint8_t*)ptr, len, (uint8_t*)md);
-
- return md[0];
-}
-
-static void free_aio_state(struct tdqcow_state* s)
-{
- free(s->aio_requests);
- free(s->aio_free_list);
-}
-
-static int init_aio_state(td_driver_t *driver)
-{
- int i, ret;
- td_disk_info_t *bs = &(driver->info);
- struct tdqcow_state *s = (struct tdqcow_state *)driver->data;
-
- // A segment (i.e. a page) can span multiple clusters
- s->max_aio_reqs = ((getpagesize() / s->cluster_size) + 1) *
- MAX_SEGMENTS_PER_REQ * MAX_REQUESTS;
-
- s->aio_free_count = s->max_aio_reqs;
-
- if (!(s->aio_requests = calloc(s->max_aio_reqs, sizeof(struct qcow_request))) ||
- !(s->aio_free_list = calloc(s->max_aio_reqs, sizeof(struct qcow_request)))) {
- DPRINTF("Failed to allocate AIO structs (max_aio_reqs = %d)\n",
- s->max_aio_reqs);
- goto fail;
- }
-
- for (i = 0; i < s->max_aio_reqs; i++)
- s->aio_free_list[i] = &s->aio_requests[i];
-
- DPRINTF("AIO state initialised\n");
-
- return 0;
- fail:
- return -1;
-}
-
-int get_filesize(char *filename, uint64_t *size, struct stat *st)
-{
- int fd;
- QCowHeader header;
-
- /*Set to the backing file size*/
- fd = open(filename, O_RDONLY);
- if (fd < 0)
- return -1;
- if (read(fd, &header, sizeof(header)) < sizeof(header)) {
- close(fd);
- return -1;
- }
- close(fd);
-
- be32_to_cpus(&header.magic);
- be64_to_cpus(&header.size);
- if (header.magic == QCOW_MAGIC) {
- *size = header.size >> SECTOR_SHIFT;
- return 0;
- }
-
- if(S_ISBLK(st->st_mode)) {
- fd = open(filename, O_RDONLY);
- if (fd < 0)
- return -1;
- if (blk_getimagesize(fd, size) != 0) {
- printf("Unable to get Block device size\n");
- close(fd);
- return -1;
- }
- close(fd);
- } else *size = (st->st_size >> SECTOR_SHIFT);
- return 0;
-}
-
-static int qcow_set_key(struct tdqcow_state *s, const char *key)
-{
- uint8_t keybuf[16];
- int len, i;
-
- memset(keybuf, 0, 16);
- len = strlen(key);
- if (len > 16)
- len = 16;
- /* XXX: we could compress the chars to 7 bits to increase
- entropy */
- for (i = 0; i < len; i++) {
- keybuf[i] = key[i];
- }
- s->crypt_method = s->crypt_method_header;
-
- if (AES_set_encrypt_key(keybuf, 128, &s->aes_encrypt_key) != 0)
- return -1;
- if (AES_set_decrypt_key(keybuf, 128, &s->aes_decrypt_key) != 0)
- return -1;
-#if 0
- /* test */
- {
- uint8_t in[16];
- uint8_t out[16];
- uint8_t tmp[16];
- for (i=0; i<16; i++)
- in[i] = i;
- AES_encrypt(in, tmp, &s->aes_encrypt_key);
- AES_decrypt(tmp, out, &s->aes_decrypt_key);
- for (i = 0; i < 16; i++)
- DPRINTF(" %02x", tmp[i]);
- DPRINTF("\n");
- for (i = 0; i < 16; i++)
- DPRINTF(" %02x", out[i]);
- DPRINTF("\n");
- }
-#endif
- return 0;
-}
-
-void tdqcow_complete(void *arg, struct tiocb *tiocb, int err)
-{
- struct qcow_request *aio = (struct qcow_request *)arg;
- struct tdqcow_state *s = aio->state;
-
- td_complete_request(aio->treq, err);
-
- s->aio_free_list[s->aio_free_count++] = aio;
-}
-
-static void async_read(td_driver_t *driver, td_request_t treq)
-{
- int size;
- uint64_t offset;
- struct qcow_request *aio;
- struct tdqcow_state *prv;
-
- prv = (struct tdqcow_state *)driver->data;
- size = treq.secs * driver->info.sector_size;
- offset = treq.sec * (uint64_t)driver->info.sector_size;
-
- if (prv->aio_free_count == 0)
- goto fail;
-
- aio = prv->aio_free_list[--prv->aio_free_count];
- aio->treq = treq;
- aio->state = prv;
-
- td_prep_read(&aio->tiocb, prv->fd, treq.buf,
- size, offset, tdqcow_complete, aio);
- td_queue_tiocb(driver, &aio->tiocb);
-
- return;
-
-fail:
- td_complete_request(treq, -EBUSY);
-}
-
-static void async_write(td_driver_t *driver, td_request_t treq)
-{
- int size;
- uint64_t offset;
- struct qcow_request *aio;
- struct tdqcow_state *prv;
-
- prv = (struct tdqcow_state *)driver->data;
- size = treq.secs * driver->info.sector_size;
- offset = treq.sec * (uint64_t)driver->info.sector_size;
-
- if (prv->aio_free_count == 0)
- goto fail;
-
- aio = prv->aio_free_list[--prv->aio_free_count];
- aio->treq = treq;
- aio->state = prv;
-
- td_prep_write(&aio->tiocb, prv->fd, treq.buf,
- size, offset, tdqcow_complete, aio);
- td_queue_tiocb(driver, &aio->tiocb);
-
- return;
-
-fail:
- td_complete_request(treq, -EBUSY);
-}
-
-/*
- * The crypt function is compatible with the linux cryptoloop
- * algorithm for < 4 GB images. NOTE: out_buf == in_buf is
- * supported .
- */
-static void encrypt_sectors(struct tdqcow_state *s, int64_t sector_num,
- uint8_t *out_buf, const uint8_t *in_buf,
- int nb_sectors, int enc,
- const AES_KEY *key)
-{
- union {
- uint64_t ll[2];
- uint8_t b[16];
- } ivec;
- int i;
-
- for (i = 0; i < nb_sectors; i++) {
- ivec.ll[0] = cpu_to_le64(sector_num);
- ivec.ll[1] = 0;
- AES_cbc_encrypt(in_buf, out_buf, 512, key,
- ivec.b, enc);
- sector_num++;
- in_buf += 512;
- out_buf += 512;
- }
-}
-
-int qtruncate(int fd, off_t length, int sparse)
-{
- int ret, i;
- int current = 0, rem = 0;
- uint64_t sectors;
- struct stat st;
- char *buf;
-
- /* If length is greater than the current file len
- * we synchronously write zeroes to the end of the
- * file, otherwise we truncate the length down
- */
- ret = fstat(fd, &st);
- if (ret == -1)
- return -1;
- if (S_ISBLK(st.st_mode))
- return 0;
-
- sectors = (length + DEFAULT_SECTOR_SIZE - 1)/DEFAULT_SECTOR_SIZE;
- current = (st.st_size + DEFAULT_SECTOR_SIZE - 1)/DEFAULT_SECTOR_SIZE;
- rem = st.st_size % DEFAULT_SECTOR_SIZE;
-
- /* If we are extending this file, we write zeros to the end --
- * this tries to ensure that the extents allocated wind up being
- * contiguous on disk.
- */
- if(st.st_size < sectors * DEFAULT_SECTOR_SIZE) {
- /*We are extending the file*/
- if ((ret = posix_memalign((void **)&buf,
- 512, DEFAULT_SECTOR_SIZE))) {
- DPRINTF("posix_memalign failed: %d\n", ret);
- return -1;
- }
- memset(buf, 0x00, DEFAULT_SECTOR_SIZE);
- if (lseek(fd, 0, SEEK_END)==-1) {
- DPRINTF("Lseek EOF failed (%d), internal error\n",
- errno);
- free(buf);
- return -1;
- }
- if (rem) {
- ret = write(fd, buf, rem);
- if (ret != rem) {
- DPRINTF("write failed: ret = %d, err = %s\n",
- ret, strerror(errno));
- free(buf);
- return -1;
- }
- }
- for (i = current; i < sectors; i++ ) {
- ret = write(fd, buf, DEFAULT_SECTOR_SIZE);
- if (ret != DEFAULT_SECTOR_SIZE) {
- DPRINTF("write failed: ret = %d, err = %s\n",
- ret, strerror(errno));
- free(buf);
- return -1;
- }
- }
- free(buf);
- } else if(sparse && (st.st_size > sectors * DEFAULT_SECTOR_SIZE))
- if (ftruncate(fd, (off_t)sectors * DEFAULT_SECTOR_SIZE)==-1) {
- DPRINTF("Ftruncate failed (%s)\n", strerror(errno));
- return -1;
- }
- return 0;
-}
-
-/* 'allocate' is:
- *
- * 0 to not allocate.
- *
- * 1 to allocate a normal cluster (for sector indexes 'n_start' to
- * 'n_end')
- *
- * 2 to allocate a compressed cluster of size
- * 'compressed_size'. 'compressed_size' must be > 0 and <
- * cluster_size
- *
- * return 0 if not allocated.
- */
-static uint64_t get_cluster_offset(struct tdqcow_state *s,
- uint64_t offset, int allocate,
- int compressed_size,
- int n_start, int n_end)
-{
- int min_index, i, j, l1_index, l2_index, l2_sector, l1_sector;
- char *tmp_ptr2, *l2_ptr, *l1_ptr;
- uint64_t *tmp_ptr;
- uint64_t l2_offset, *l2_table, cluster_offset, tmp;
- uint32_t min_count;
- int new_l2_table;
-
- /*Check L1 table for the extent offset*/
- l1_index = offset >> (s->l2_bits + s->cluster_bits);
- l2_offset = s->l1_table[l1_index];
- new_l2_table = 0;
- if (!l2_offset) {
- if (!allocate)
- return 0;
- /*
- * allocating a new l2 entry + extent
- * at the end of the file, we must also
- * update the L1 entry safely.
- */
- l2_offset = s->fd_end;
-
- /* round to cluster size */
- l2_offset = (l2_offset + s->cluster_size - 1)
- & ~(s->cluster_size - 1);
-
- /* update the L1 entry */
- s->l1_table[l1_index] = l2_offset;
-
- /*Truncate file for L2 table
- *(initialised to zero in case we crash)*/
- if (qtruncate(s->fd,
- l2_offset + (s->l2_size * sizeof(uint64_t)),
- s->sparse) != 0) {
- DPRINTF("ERROR truncating file\n");
- return 0;
- }
- s->fd_end = l2_offset + (s->l2_size * sizeof(uint64_t));
-
- /*Update the L1 table entry on disk
- * (for O_DIRECT we write 4KByte blocks)*/
- l1_sector = (l1_index * sizeof(uint64_t)) >> 12;
- l1_ptr = (char *)s->l1_table + (l1_sector << 12);
-
- if (posix_memalign((void **)&tmp_ptr, 4096, 4096) != 0) {
- DPRINTF("ERROR allocating memory for L1 table\n");
- return 0;
- }
- memcpy(tmp_ptr, l1_ptr, 4096);
-
- /* Convert block to write to big endian */
- for(i = 0; i < 4096 / sizeof(uint64_t); i++) {
- cpu_to_be64s(&tmp_ptr[i]);
- }
-
- /*
- * Issue non-asynchronous L1 write.
- * For safety, we must ensure that
- * entry is written before blocks.
- */
- lseek(s->fd, s->l1_table_offset + (l1_sector << 12), SEEK_SET);
- if (write(s->fd, tmp_ptr, 4096) != 4096) {
- free(tmp_ptr);
- return 0;
- }
- free(tmp_ptr);
-
- new_l2_table = 1;
- goto cache_miss;
- } else if (s->min_cluster_alloc == s->l2_size) {
- /*Fast-track the request*/
- cluster_offset = l2_offset + (s->l2_size * sizeof(uint64_t));
- l2_index = (offset >> s->cluster_bits) & (s->l2_size - 1);
- return cluster_offset + (l2_index * s->cluster_size);
- }
-
- /*Check to see if L2 entry is already cached*/
- for (i = 0; i < L2_CACHE_SIZE; i++) {
- if (l2_offset == s->l2_cache_offsets[i]) {
- /* increment the hit count */
- if (++s->l2_cache_counts[i] == 0xffffffff) {
- for (j = 0; j < L2_CACHE_SIZE; j++) {
- s->l2_cache_counts[j] >>= 1;
- }
- }
- l2_table = s->l2_cache + (i << s->l2_bits);
- goto found;
- }
- }
-
-cache_miss:
- /* not found: load a new entry in the least used one */
- min_index = 0;
- min_count = 0xffffffff;
- for (i = 0; i < L2_CACHE_SIZE; i++) {
- if (s->l2_cache_counts[i] < min_count) {
- min_count = s->l2_cache_counts[i];
- min_index = i;
- }
- }
- l2_table = s->l2_cache + (min_index << s->l2_bits);
-
- /*If extent pre-allocated, read table from disk,
- *otherwise write new table to disk*/
- if (new_l2_table) {
- /*Should we allocate the whole extent? Adjustable parameter.*/
- if (s->cluster_alloc == s->l2_size) {
- cluster_offset = l2_offset +
- (s->l2_size * sizeof(uint64_t));
- cluster_offset = (cluster_offset + s->cluster_size - 1)
- & ~(s->cluster_size - 1);
- if (qtruncate(s->fd, cluster_offset +
- (s->cluster_size * s->l2_size),
- s->sparse) != 0) {
- DPRINTF("ERROR truncating file\n");
- return 0;
- }
- s->fd_end = cluster_offset +
- (s->cluster_size * s->l2_size);
- for (i = 0; i < s->l2_size; i++) {
- l2_table[i] = cpu_to_be64(cluster_offset +
- (i*s->cluster_size));
- }
- } else memset(l2_table, 0, s->l2_size * sizeof(uint64_t));
-
- lseek(s->fd, l2_offset, SEEK_SET);
- if (write(s->fd, l2_table, s->l2_size * sizeof(uint64_t)) !=
- s->l2_size * sizeof(uint64_t))
- return 0;
- } else {
- lseek(s->fd, l2_offset, SEEK_SET);
- if (read(s->fd, l2_table, s->l2_size * sizeof(uint64_t)) !=
- s->l2_size * sizeof(uint64_t))
- return 0;
- }
-
- /*Update the cache entries*/
- s->l2_cache_offsets[min_index] = l2_offset;
- s->l2_cache_counts[min_index] = 1;
-
-found:
- /*The extent is split into 's->l2_size' blocks of
- *size 's->cluster_size'*/
- l2_index = (offset >> s->cluster_bits) & (s->l2_size - 1);
- cluster_offset = be64_to_cpu(l2_table[l2_index]);
-
- if (!cluster_offset ||
- ((cluster_offset & QCOW_OFLAG_COMPRESSED) && allocate == 1) ) {
- if (!allocate)
- return 0;
-
- if ((cluster_offset & QCOW_OFLAG_COMPRESSED) &&
- (n_end - n_start) < s->cluster_sectors) {
- /* cluster is already allocated but compressed, we must
- decompress it in the case it is not completely
- overwritten */
- if (decompress_cluster(s, cluster_offset) < 0)
- return 0;
- cluster_offset = lseek(s->fd, s->fd_end, SEEK_SET);
- cluster_offset = (cluster_offset + s->cluster_size - 1)
- & ~(s->cluster_size - 1);
- /* write the cluster content - not asynchronous */
- lseek(s->fd, cluster_offset, SEEK_SET);
- if (write(s->fd, s->cluster_cache, s->cluster_size) !=
- s->cluster_size)
- return -1;
- } else {
- /* allocate a new cluster */
- cluster_offset = lseek(s->fd, s->fd_end, SEEK_SET);
- if (allocate == 1) {
- /* round to cluster size */
- cluster_offset =
- (cluster_offset + s->cluster_size - 1)
- & ~(s->cluster_size - 1);
- if (qtruncate(s->fd, cluster_offset +
- s->cluster_size, s->sparse)!=0) {
- DPRINTF("ERROR truncating file\n");
- return 0;
- }
- s->fd_end = (cluster_offset + s->cluster_size);
- /* if encrypted, we must initialize the cluster
- content which won't be written */
- if (s->crypt_method &&
- (n_end - n_start) < s->cluster_sectors) {
- uint64_t start_sect;
- start_sect = (offset &
- ~(s->cluster_size - 1))
- >> 9;
- memset(s->cluster_data + 512,
- 0xaa, 512);
- for (i = 0; i < s->cluster_sectors;i++)
- {
- if (i < n_start || i >= n_end)
- {
- encrypt_sectors(s, start_sect + i,
- s->cluster_data,
- s->cluster_data + 512, 1, 1,
- &s->aes_encrypt_key);
- lseek(s->fd, cluster_offset + i * 512, SEEK_SET);
- if (write(s->fd, s->cluster_data, 512) != 512)
- return -1;
- }
- }
- }
- } else {
- cluster_offset |= QCOW_OFLAG_COMPRESSED |
- (uint64_t)compressed_size
- << (63 - s->cluster_bits);
- }
- }
- /* update L2 table */
- tmp = cpu_to_be64(cluster_offset);
- l2_table[l2_index] = tmp;
-
- /*For IO_DIRECT we write 4KByte blocks*/
- l2_sector = (l2_index * sizeof(uint64_t)) >> 12;
- l2_ptr = (char *)l2_table + (l2_sector << 12);
-
- if (posix_memalign((void **)&tmp_ptr2, 4096, 4096) != 0) {
- DPRINTF("ERROR allocating memory for L1 table\n");
- return 0;
- }
- memcpy(tmp_ptr2, l2_ptr, 4096);
- lseek(s->fd, l2_offset + (l2_sector << 12), SEEK_SET);
- if (write(s->fd, tmp_ptr2, 4096) != 4096) {
- free(tmp_ptr2);
- return -1;
- }
- free(tmp_ptr2);
- }
- return cluster_offset;
-}
-
-static int qcow_is_allocated(struct tdqcow_state *s, int64_t sector_num,
- int nb_sectors, int *pnum)
-{
- int index_in_cluster, n;
- uint64_t cluster_offset;
-
- cluster_offset = get_cluster_offset(s, sector_num << 9, 0, 0, 0, 0);
- index_in_cluster = sector_num & (s->cluster_sectors - 1);
- n = s->cluster_sectors - index_in_cluster;
- if (n > nb_sectors)
- n = nb_sectors;
- *pnum = n;
- return (cluster_offset != 0);
-}
-
-static int decompress_buffer(uint8_t *out_buf, int out_buf_size,
- const uint8_t *buf, int buf_size)
-{
- z_stream strm1, *strm = &strm1;
- int ret, out_len;
-
- memset(strm, 0, sizeof(*strm));
-
- strm->next_in = (uint8_t *)buf;
- strm->avail_in = buf_size;
- strm->next_out = out_buf;
- strm->avail_out = out_buf_size;
-
- ret = inflateInit2(strm, -12);
- if (ret != Z_OK)
- return -1;
- ret = inflate(strm, Z_FINISH);
- out_len = strm->next_out - out_buf;
- if ( (ret != Z_STREAM_END && ret != Z_BUF_ERROR) ||
- (out_len != out_buf_size) ) {
- inflateEnd(strm);
- return -1;
- }
- inflateEnd(strm);
- return 0;
-}
-
-static int decompress_cluster(struct tdqcow_state *s, uint64_t cluster_offset)
-{
- int ret, csize;
- uint64_t coffset;
-
- coffset = cluster_offset & s->cluster_offset_mask;
- if (s->cluster_cache_offset != coffset) {
- csize = cluster_offset >> (63 - s->cluster_bits);
- csize &= (s->cluster_size - 1);
- lseek(s->fd, coffset, SEEK_SET);
- ret = read(s->fd, s->cluster_data, csize);
- if (ret != csize)
- return -1;
- if (decompress_buffer(s->cluster_cache, s->cluster_size,
- s->cluster_data, csize) < 0) {
- return -1;
- }
- s->cluster_cache_offset = coffset;
- }
- return 0;
-}
-
-static int
-tdqcow_read_header(int fd, QCowHeader *header)
-{
- int err;
- char *buf;
- struct stat st;
- size_t size, expected;
-
- memset(header, 0, sizeof(*header));
-
- err = fstat(fd, &st);
- if (err)
- return -errno;
-
- err = lseek(fd, 0, SEEK_SET);
- if (err == (off_t)-1)
- return -errno;
-
- size = (sizeof(*header) + 511) & ~511;
- err = posix_memalign((void **)&buf, 512, size);
- if (err)
- return err;
-
- expected = size;
- if (st.st_size < size)
- expected = st.st_size;
-
- errno = 0;
- err = read(fd, buf, size);
- if (err != expected) {
- err = (errno ? -errno : -EIO);
- goto out;
- }
-
- memcpy(header, buf, sizeof(*header));
- be32_to_cpus(&header->magic);
- be32_to_cpus(&header->version);
- be64_to_cpus(&header->backing_file_offset);
- be32_to_cpus(&header->backing_file_size);
- be32_to_cpus(&header->mtime);
- be64_to_cpus(&header->size);
- be32_to_cpus(&header->crypt_method);
- be64_to_cpus(&header->l1_table_offset);
-
- err = 0;
-
-out:
- free(buf);
- return err;
-}
-
-static int
-tdqcow_load_l1_table(struct tdqcow_state *s, QCowHeader *header)
-{
- char *buf;
- struct stat st;
- size_t expected;
- int i, err, shift;
- QCowHeader_ext *exthdr;
- uint32_t l1_table_bytes, l1_table_block, l1_table_size;
-
- buf = NULL;
- s->l1_table = NULL;
-
- shift = s->cluster_bits + s->l2_bits;
-
- s->l1_size = (header->size + (1LL << shift) - 1) >> shift;
- s->l1_table_offset = header->l1_table_offset;
-
- s->min_cluster_alloc = 1; /* default */
-
- l1_table_bytes = s->l1_size * sizeof(uint64_t);
- l1_table_size = (l1_table_bytes + 4095) & ~4095;
- l1_table_block = (l1_table_bytes + s->l1_table_offset + 4095) & ~4095;
-
- DPRINTF("L1 Table offset detected: %"PRIu64", size %d (%d)\n",
- (uint64_t)s->l1_table_offset,
- (int) (s->l1_size * sizeof(uint64_t)),
- l1_table_size);
-
- err = fstat(s->fd, &st);
- if (err) {
- err = -errno;
- goto out;
- }
-
- err = lseek(s->fd, 0, SEEK_SET);
- if (err == (off_t)-1) {
- err = -errno;
- goto out;
- }
-
- err = posix_memalign((void **)&buf, 512, l1_table_block);
- if (err) {
- buf = NULL;
- goto out;
- }
-
- err = posix_memalign((void **)&s->l1_table, 4096, l1_table_size);
- if (err) {
- s->l1_table = NULL;
- goto out;
- }
-
- memset(buf, 0, l1_table_block);
- memset(s->l1_table, 0, l1_table_size);
-
- expected = l1_table_block;
- if (st.st_size < l1_table_block)
- expected = st.st_size;
-
- errno = 0;
- err = read(s->fd, buf, l1_table_block);
- if (err != expected) {
- err = (errno ? -errno : -EIO);
- goto out;
- }
-
- memcpy(s->l1_table, buf + s->l1_table_offset, l1_table_size);
- exthdr = (QCowHeader_ext *)(buf + sizeof(QCowHeader));
-
- /* check for xen extended header */
- if (s->l1_table_offset % 4096 == 0 &&
- be32_to_cpu(exthdr->xmagic) == XEN_MAGIC) {
- uint32_t flags = be32_to_cpu(exthdr->flags);
- uint32_t cksum = be32_to_cpu(exthdr->cksum);
-
- /*
- * Try to detect old tapdisk images. They have to be fixed
- * because they use big endian rather than native endian for
- * the L1 table. After this block, the l1 table will
- * definitely be in BIG endian.
- */
- if (!(flags & EXTHDR_L1_BIG_ENDIAN)) {
- DPRINTF("qcow: converting to big endian L1 table\n");
-
- /* convert to big endian */
- for (i = 0; i < s->l1_size; i++)
- cpu_to_be64s(&s->l1_table[i]);
-
- flags |= EXTHDR_L1_BIG_ENDIAN;
- exthdr->flags = cpu_to_be32(flags);
-
- memcpy(buf + s->l1_table_offset,
- s->l1_table, l1_table_size);
-
- err = lseek(s->fd, 0, SEEK_SET);
- if (err == (off_t)-1) {
- err = -errno;
- goto out;
- }
-
- err = atomicio(vwrite, s->fd, buf, l1_table_block);
- if (err != l1_table_block) {
- err = -errno;
- goto out;
- }
- }
-
- /* check the L1 table checksum */
- if (cksum != gen_cksum((char *)s->l1_table,
- s->l1_size * sizeof(uint64_t)))
- DPRINTF("qcow: bad L1 checksum\n");
- else {
- s->extended = 1;
- s->sparse = (be32_to_cpu(exthdr->flags) & SPARSE_FILE);
- s->min_cluster_alloc =
- be32_to_cpu(exthdr->min_cluster_alloc);
- }
- }
-
- /* convert L1 table to native endian for operation */
- for (i = 0; i < s->l1_size; i++)
- be64_to_cpus(&s->l1_table[i]);
-
- err = 0;
-
-out:
- if (err) {
- free(buf);
- free(s->l1_table);
- s->l1_table = NULL;
- }
- return err;
-}
-
-/* Open the disk file and initialize qcow state. */
-int tdqcow_open (td_driver_t *driver, const char *name, td_flag_t flags)
-{
- int fd, len, i, ret, size, o_flags;
- td_disk_info_t *bs = &(driver->info);
- struct tdqcow_state *s = (struct tdqcow_state *)driver->data;
- QCowHeader header;
- uint64_t final_cluster = 0;
-
- DPRINTF("QCOW: Opening %s\n", name);
-
- o_flags = O_DIRECT | O_LARGEFILE |
- ((flags == TD_OPEN_RDONLY) ? O_RDONLY : O_RDWR);
- fd = open(name, o_flags);
- if (fd < 0) {
- DPRINTF("Unable to open %s (%d)\n", name, -errno);
- return -1;
- }
-
- s->fd = fd;
- s->name = strdup(name);
- if (!s->name)
- goto fail;
-
- if (tdqcow_read_header(fd, &header))
- goto fail;
-
- if (header.magic != QCOW_MAGIC)
- goto fail;
-
- switch (header.version) {
- case QCOW_VERSION:
- break;
- case 2:
- //TODO: Port qcow2 to new blktap framework.
- // close(fd);
- // dd->drv = &tapdisk_qcow2;
- // return dd->drv->td_open(dd, name, flags);
- goto fail;
- default:
- goto fail;
- }
-
- if (header.size <= 1 || header.cluster_bits < 9)
- goto fail;
- if (header.crypt_method > QCOW_CRYPT_AES)
- goto fail;
- s->crypt_method_header = header.crypt_method;
- if (s->crypt_method_header)
- s->encrypted = 1;
- s->cluster_bits = header.cluster_bits;
- s->cluster_size = 1 << s->cluster_bits;
- s->cluster_sectors = 1 << (s->cluster_bits - 9);
- s->l2_bits = header.l2_bits;
- s->l2_size = 1 << s->l2_bits;
- s->cluster_alloc = s->l2_size;
- bs->size = header.size / 512;
- s->cluster_offset_mask = (1LL << (63 - s->cluster_bits)) - 1;
- s->backing_file_offset = header.backing_file_offset;
- s->backing_file_size = header.backing_file_size;
-
- /* allocate and load l1 table */
- if (tdqcow_load_l1_table(s, &header))
- goto fail;
-
- /* alloc L2 cache */
- size = s->l2_size * L2_CACHE_SIZE * sizeof(uint64_t);
- ret = posix_memalign((void **)&s->l2_cache, 4096, size);
- if(ret != 0) goto fail;
-
- size = s->cluster_size;
- ret = posix_memalign((void **)&s->cluster_cache, 4096, size);
- if(ret != 0) goto fail;
-
- ret = posix_memalign((void **)&s->cluster_data, 4096, size);
- if(ret != 0) goto fail;
- s->cluster_cache_offset = -1;
-
- if (s->backing_file_offset != 0)
- s->cluster_alloc = 1; /*Cannot use pre-alloc*/
-
- bs->sector_size = 512;
- bs->info = 0;
-
- for(i = 0; i < s->l1_size; i++)
- if (s->l1_table[i] > final_cluster)
- final_cluster = s->l1_table[i];
-
- if (init_aio_state(driver)!=0) {
- DPRINTF("Unable to initialise AIO state\n");
- free_aio_state(s);
- goto fail;
- }
-
- if (!final_cluster)
- s->fd_end = s->l1_table_offset +
- ((s->l1_size * sizeof(uint64_t) + 4095) & ~4095);
- else {
- s->fd_end = lseek(fd, 0, SEEK_END);
- if (s->fd_end == (off_t)-1)
- goto fail;
- }
-
- return 0;
-
-fail:
- DPRINTF("QCOW Open failed\n");
-
- free_aio_state(s);
- free(s->l1_table);
- free(s->l2_cache);
- free(s->cluster_cache);
- free(s->cluster_data);
- close(fd);
- return -1;
-}
-
-void tdqcow_queue_read(td_driver_t *driver, td_request_t treq)
-{
- struct tdqcow_state *s = (struct tdqcow_state *)driver->data;
- int ret = 0, index_in_cluster, n, i;
- uint64_t cluster_offset, sector, nb_sectors;
- struct qcow_prv* prv;
- td_request_t clone = treq;
- char* buf = treq.buf;
-
- sector = treq.sec;
- nb_sectors = treq.secs;
-
- /*We store a local record of the request*/
- while (nb_sectors > 0) {
- cluster_offset =
- get_cluster_offset(s, sector << 9, 0, 0, 0, 0);
- index_in_cluster = sector & (s->cluster_sectors - 1);
- n = s->cluster_sectors - index_in_cluster;
- if (n > nb_sectors)
- n = nb_sectors;
-
- if (s->aio_free_count == 0) {
- td_complete_request(treq, -EBUSY);
- return;
- }
-
- if(!cluster_offset) {
- int i;
- /* Forward entire request if possible. */
- for(i=0; i<nb_sectors; i++)
- if(get_cluster_offset(s, (sector+i) << 9, 0, 0, 0, 0))
- goto coalesce_failed;
- treq.buf = buf;
- treq.sec = sector;
- treq.secs = nb_sectors;
- td_forward_request(treq);
- return;
-coalesce_failed:
- treq.buf = buf;
- treq.sec = sector;
- treq.secs = n;
- td_forward_request(treq);
-
- } else if (cluster_offset & QCOW_OFLAG_COMPRESSED) {
- if (decompress_cluster(s, cluster_offset) < 0) {
- td_complete_request(treq, -EIO);
- goto done;
- }
- memcpy(buf, s->cluster_cache + index_in_cluster * 512,
- 512 * n);
-
- treq.buf = buf;
- treq.sec = sector;
- treq.secs = n;
- td_complete_request(treq, 0);
- } else {
- clone.buf = buf;
- clone.sec = (cluster_offset>>9)+index_in_cluster;
- clone.secs = n;
- async_read(driver, clone);
- }
- nb_sectors -= n;
- sector += n;
- buf += n * 512;
- }
-done:
- return;
-}
-
-void tdqcow_queue_write(td_driver_t *driver, td_request_t treq)
-{
- struct tdqcow_state *s = (struct tdqcow_state *)driver->data;
- int ret = 0, index_in_cluster, n, i;
- uint64_t cluster_offset, sector, nb_sectors;
- td_callback_t cb;
- struct qcow_prv* prv;
- char* buf = treq.buf;
- td_request_t clone=treq;
-
- sector = treq.sec;
- nb_sectors = treq.secs;
-
- /*We store a local record of the request*/
- while (nb_sectors > 0) {
- index_in_cluster = sector & (s->cluster_sectors - 1);
- n = s->cluster_sectors - index_in_cluster;
- if (n > nb_sectors)
- n = nb_sectors;
-
- if (s->aio_free_count == 0) {
- td_complete_request(treq, -EBUSY);
- return;
- }
-
- cluster_offset = get_cluster_offset(s, sector << 9, 1, 0,
- index_in_cluster,
- index_in_cluster+n);
- if (!cluster_offset) {
- DPRINTF("Ooops, no write cluster offset!\n");
- td_complete_request(treq, -EIO);
- return;
- }
-
- if (s->crypt_method) {
- encrypt_sectors(s, sector, s->cluster_data,
- (unsigned char *)buf, n, 1,
- &s->aes_encrypt_key);
-
- clone.buf = buf;
- clone.sec = (cluster_offset>>9) + index_in_cluster;
- clone.secs = n;
- async_write(driver, clone);
- } else {
- clone.buf = buf;
- clone.sec = (cluster_offset>>9) + index_in_cluster;
- clone.secs = n;
-
- async_write(driver, clone);
- }
-
- nb_sectors -= n;
- sector += n;
- buf += n * 512;
- }
- s->cluster_cache_offset = -1; /* disable compressed cache */
-
- return;
-}
-
-static int
-tdqcow_update_checksum(struct tdqcow_state *s)
-{
- int i, fd, err;
- uint32_t offset, cksum, out;
-
- if (!s->extended)
- return 0;
-
- fd = open(s->name, O_WRONLY | O_LARGEFILE); /* open without O_DIRECT */
- if (fd == -1) {
- err = errno;
- goto out;
- }
-
- offset = sizeof(QCowHeader) + offsetof(QCowHeader_ext, cksum);
- if (lseek(fd, offset, SEEK_SET) == (off_t)-1) {
- err = errno;
- goto out;
- }
-
- /* convert to big endian for checksum */
- for (i = 0; i < s->l1_size; i++)
- cpu_to_be64s(&s->l1_table[i]);
-
- cksum = gen_cksum((char *)s->l1_table, s->l1_size * sizeof(uint64_t));
-
- /* and back again... */
- for (i = 0; i < s->l1_size; i++)
- be64_to_cpus(&s->l1_table[i]);
-
- DPRINTF("Writing cksum: %d", cksum);
-
- out = cpu_to_be32(cksum);
- if (write(fd, &out, sizeof(out)) != sizeof(out)) {
- err = errno;
- goto out;
- }
-
- err = 0;
-
-out:
- if (err)
- DPRINTF("failed to update checksum: %d\n", err);
- if (fd != -1)
- close(fd);
- return err;
-}
-
-int tdqcow_close(td_driver_t *driver)
-{
- struct tdqcow_state *s = (struct tdqcow_state *)driver->data;
-
- /*Update the hdr cksum*/
- tdqcow_update_checksum(s);
-
- free_aio_state(s);
- free(s->name);
- free(s->l1_table);
- free(s->l2_cache);
- free(s->cluster_cache);
- free(s->cluster_data);
- close(s->fd);
- return 0;
-}
-
-int qcow_create(const char *filename, uint64_t total_size,
- const char *backing_file, int sparse)
-{
- int fd, header_size, backing_filename_len, l1_size, i;
- int shift, length, adjust, flags = 0, ret = 0;
- QCowHeader header;
- QCowHeader_ext exthdr;
- char backing_filename[PATH_MAX], *ptr;
- uint64_t tmp, size, total_length;
- struct stat st;
-
- DPRINTF("Qcow_create: size %"PRIu64"\n",total_size);
-
- fd = open(filename,
- O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_LARGEFILE,
- 0644);
- if (fd < 0)
- return -1;
-
- memset(&header, 0, sizeof(header));
- header.magic = cpu_to_be32(QCOW_MAGIC);
- header.version = cpu_to_be32(QCOW_VERSION);
-
- /*Create extended header fields*/
- exthdr.xmagic = cpu_to_be32(XEN_MAGIC);
-
- header_size = sizeof(header) + sizeof(QCowHeader_ext);
- backing_filename_len = 0;
- size = (total_size >> SECTOR_SHIFT);
- if (backing_file) {
- if (strcmp(backing_file, "fat:")) {
- const char *p;
- /* XXX: this is a hack: we do not attempt to
- *check for URL like syntax */
- p = strchr(backing_file, ':');
- if (p && (p - backing_file) >= 2) {
- /* URL like but exclude "c:" like filenames */
- strncpy(backing_filename, backing_file,
- sizeof(backing_filename) - 1);
- backing_filename[sizeof(backing_filename) - 1] = '\0';
- } else {
- if (realpath(backing_file, backing_filename) == NULL ||
- stat(backing_filename, &st) != 0) {
- return -1;
- }
- }
- header.backing_file_offset = cpu_to_be64(header_size);
- backing_filename_len = strlen(backing_filename);
- header.backing_file_size = cpu_to_be32(
- backing_filename_len);
- header_size += backing_filename_len;
-
- /*Set to the backing file size*/
- if(get_filesize(backing_filename, &size, &st)) {
- return -1;
- }
- DPRINTF("Backing file size detected: %"PRId64" sectors"
- "(total %"PRId64" [%"PRId64" MB])\n",
- size,
- (uint64_t)(size << SECTOR_SHIFT),
- (uint64_t)(size >> 11));
- } else {
- backing_file = NULL;
- DPRINTF("Setting file size: %"PRId64" (total %"PRId64")\n",
- total_size,
- (uint64_t) (total_size << SECTOR_SHIFT));
- }
- header.mtime = cpu_to_be32(st.st_mtime);
- header.cluster_bits = 9; /* 512 byte cluster to avoid copying
- unmodifyed sectors */
- header.l2_bits = 12; /* 32 KB L2 tables */
- exthdr.min_cluster_alloc = cpu_to_be32(1);
- } else {
- DPRINTF("Setting file size: %"PRId64" sectors"
- "(total %"PRId64" [%"PRId64" MB])\n",
- size,
- (uint64_t) (size << SECTOR_SHIFT),
- (uint64_t) (size >> 11));
- header.cluster_bits = 12; /* 4 KB clusters */
- header.l2_bits = 9; /* 4 KB L2 tables */
- exthdr.min_cluster_alloc = cpu_to_be32(1 << 9);
- }
- /*Set the header size value*/
- header.size = cpu_to_be64(size * 512);
-
- header_size = (header_size + 7) & ~7;
- if (header_size % 4096 > 0) {
- header_size = ((header_size >> 12) + 1) << 12;
- }
-
- shift = header.cluster_bits + header.l2_bits;
- l1_size = ((size * 512) + (1LL << shift) - 1) >> shift;
-
- header.l1_table_offset = cpu_to_be64(header_size);
- DPRINTF("L1 Table offset: %d, size %d\n",
- header_size,
- (int)(l1_size * sizeof(uint64_t)));
- header.crypt_method = cpu_to_be32(QCOW_CRYPT_NONE);
-
- ptr = calloc(1, l1_size * sizeof(uint64_t));
- exthdr.cksum = cpu_to_be32(gen_cksum(ptr, l1_size * sizeof(uint64_t)));
- printf("Created cksum: %d\n",exthdr.cksum);
- free(ptr);
-
- /*adjust file length to system page size boundary*/
- length = ROUNDUP(header_size + (l1_size * sizeof(uint64_t)),
- getpagesize());
- if (qtruncate(fd, length, 0)!=0) {
- DPRINTF("ERROR truncating file\n");
- return -1;
- }
-
- if (sparse == 0) {
- /*Filesize is length+l1_size*(1 << s->l2_bits)+(size*512)*/
- total_length = length + (l1_size * (1 << 9)) + (size * 512);
- if (qtruncate(fd, total_length, 0)!=0) {
- DPRINTF("ERROR truncating file\n");
- return -1;
- }
- printf("File truncated to length %"PRIu64"\n",total_length);
- } else
- flags = SPARSE_FILE;
-
- flags |= EXTHDR_L1_BIG_ENDIAN;
- exthdr.flags = cpu_to_be32(flags);
-
- /* write all the data */
- lseek(fd, 0, SEEK_SET);
- ret += write(fd, &header, sizeof(header));
- ret += write(fd, &exthdr, sizeof(exthdr));
- if (backing_file)
- ret += write(fd, backing_filename, backing_filename_len);
-
- lseek(fd, header_size, SEEK_SET);
- tmp = 0;
- for (i = 0;i < l1_size; i++) {
- ret += write(fd, &tmp, sizeof(tmp));
- }
-
- close(fd);
-
- return 0;
-}
-
-static int qcow_make_empty(struct tdqcow_state *s)
-{
- uint32_t l1_length = s->l1_size * sizeof(uint64_t);
-
- memset(s->l1_table, 0, l1_length);
- lseek(s->fd, s->l1_table_offset, SEEK_SET);
- if (write(s->fd, s->l1_table, l1_length) < 0)
- return -1;
- if (qtruncate(s->fd, s->l1_table_offset + l1_length, s->sparse)!=0) {
- DPRINTF("ERROR truncating file\n");
- return -1;
- }
-
- memset(s->l2_cache, 0, s->l2_size * L2_CACHE_SIZE * sizeof(uint64_t));
- memset(s->l2_cache_offsets, 0, L2_CACHE_SIZE * sizeof(uint64_t));
- memset(s->l2_cache_counts, 0, L2_CACHE_SIZE * sizeof(uint32_t));
-
- return 0;
-}
-
-static int qcow_get_cluster_size(struct tdqcow_state *s)
-{
- return s->cluster_size;
-}
-
-/* XXX: put compressed sectors first, then all the cluster aligned
- tables to avoid losing bytes in alignment */
-static int qcow_compress_cluster(struct tdqcow_state *s, int64_t sector_num,
- const uint8_t *buf)
-{
- z_stream strm;
- int ret, out_len;
- uint8_t *out_buf;
- uint64_t cluster_offset;
-
- out_buf = malloc(s->cluster_size + (s->cluster_size / 1000) + 128);
- if (!out_buf)
- return -1;
-
- /* best compression, small window, no zlib header */
- memset(&strm, 0, sizeof(strm));
- ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION,
- Z_DEFLATED, -12,
- 9, Z_DEFAULT_STRATEGY);
- if (ret != 0) {
- free(out_buf);
- return -1;
- }
-
- strm.avail_in = s->cluster_size;
- strm.next_in = (uint8_t *)buf;
- strm.avail_out = s->cluster_size;
- strm.next_out = out_buf;
-
- ret = deflate(&strm, Z_FINISH);
- if (ret != Z_STREAM_END && ret != Z_OK) {
- free(out_buf);
- deflateEnd(&strm);
- return -1;
- }
- out_len = strm.next_out - out_buf;
-
- deflateEnd(&strm);
-
- if (ret != Z_STREAM_END || out_len >= s->cluster_size) {
- /* could not compress: write normal cluster */
- //tdqcow_queue_write(bs, sector_num, buf, s->cluster_sectors);
- } else {
- cluster_offset = get_cluster_offset(s, sector_num << 9, 2,
- out_len, 0, 0);
- cluster_offset &= s->cluster_offset_mask;
- lseek(s->fd, cluster_offset, SEEK_SET);
- if (write(s->fd, out_buf, out_len) != out_len) {
- free(out_buf);
- return -1;
- }
- }
-
- free(out_buf);
- return 0;
-}
-
-static int
-tdqcow_get_image_type(const char *file, int *type)
-{
- int fd;
- size_t size;
- QCowHeader header;
-
- fd = open(file, O_RDONLY);
- if (fd == -1)
- return -errno;
-
- size = read(fd, &header, sizeof(header));
- close(fd);
- if (size != sizeof(header))
- return (errno ? -errno : -EIO);
-
- be32_to_cpus(&header.magic);
- if (header.magic == QCOW_MAGIC)
- *type = DISK_TYPE_QCOW;
- else
- *type = DISK_TYPE_AIO;
-
- return 0;
-}
-
-int tdqcow_get_parent_id(td_driver_t *driver, td_disk_id_t *id)
-{
- off_t off;
- char *buf, *filename;
- int len, secs, type = 0, err = -EINVAL;
- struct tdqcow_state *child = (struct tdqcow_state *)driver->data;
-
- if (!child->backing_file_offset)
- return TD_NO_PARENT;
-
- /* read the backing file name */
- len = child->backing_file_size;
- off = child->backing_file_offset - (child->backing_file_offset % 512);
- secs = (len + (child->backing_file_offset - off) + 511) >> 9;
-
- if (posix_memalign((void **)&buf, 512, secs << 9))
- return -1;
-
- if (lseek(child->fd, off, SEEK_SET) == (off_t)-1)
- goto out;
-
- if (read(child->fd, buf, secs << 9) != secs << 9)
- goto out;
- filename = buf + (child->backing_file_offset - off);
- filename[len] = '\0';
-
- if (tdqcow_get_image_type(filename, &type))
- goto out;
-
- id->name = strdup(filename);
- id->drivertype = type;
- err = 0;
- out:
- free(buf);
- return err;
-}
-
-int tdqcow_validate_parent(td_driver_t *driver,
- td_driver_t *pdriver, td_flag_t flags)
-{
- struct stat stats;
- uint64_t psize, csize;
- struct tdqcow_state *c = (struct tdqcow_state *)driver->data;
- struct tdqcow_state *p = (struct tdqcow_state *)pdriver->data;
-
- if (stat(p->name, &stats))
- return -EINVAL;
- if (get_filesize(p->name, &psize, &stats))
- return -EINVAL;
-
- if (stat(c->name, &stats))
- return -EINVAL;
- if (get_filesize(c->name, &csize, &stats))
- return -EINVAL;
-
- if (csize != psize)
- return -EINVAL;
-
- return 0;
-}
-
-struct tap_disk tapdisk_qcow = {
- .disk_type = "tapdisk_qcow",
- .flags = 0,
- .private_data_size = sizeof(struct tdqcow_state),
- .td_open = tdqcow_open,
- .td_close = tdqcow_close,
- .td_queue_read = tdqcow_queue_read,
- .td_queue_write = tdqcow_queue_write,
- .td_get_parent_id = tdqcow_get_parent_id,
- .td_validate_parent = tdqcow_validate_parent,
- .td_debug = NULL,
-};
+++ /dev/null
-/*
- * Copyright (c) 2007, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include <errno.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <sys/statvfs.h>
-#include <sys/stat.h>
-#include <sys/ioctl.h>
-#include <string.h>
-
-#include "blk.h"
-#include "tapdisk.h"
-#include "tapdisk-driver.h"
-#include "tapdisk-interface.h"
-
-char *img;
-long int disksector_size;
-long int disksize;
-long int diskinfo;
-static int connections = 0;
-
-struct tdram_state {
- int fd;
-};
-
-/*Get Image size, secsize*/
-static int get_image_info(int fd, td_disk_info_t *info)
-{
- int ret;
- long size;
- unsigned long total_size;
- struct statvfs statBuf;
- struct stat stat;
-
- ret = fstat(fd, &stat);
- if (ret != 0) {
- DPRINTF("ERROR: fstat failed, Couldn't stat image");
- return -EINVAL;
- }
-
- if (S_ISBLK(stat.st_mode)) {
- /*Accessing block device directly*/
- info->size = 0;
- if (blk_getimagesize(fd, &info->size) != 0)
- return -EINVAL;
-
- DPRINTF("Image size: \n\tpre sector_shift [%llu]\n\tpost "
- "sector_shift [%llu]\n",
- (long long unsigned)(info->size << SECTOR_SHIFT),
- (long long unsigned)info->size);
-
- /*Get the sector size*/
- if (blk_getsectorsize(fd, &info->sector_size) != 0)
- info->sector_size = DEFAULT_SECTOR_SIZE;
-
- } else {
- /*Local file? try fstat instead*/
- info->size = (stat.st_size >> SECTOR_SHIFT);
- info->sector_size = DEFAULT_SECTOR_SIZE;
- DPRINTF("Image size: \n\tpre sector_shift [%llu]\n\tpost "
- "sector_shift [%llu]\n",
- (long long unsigned)(info->size << SECTOR_SHIFT),
- (long long unsigned)info->size);
- }
-
- if (info->size == 0) {
- info->size =((uint64_t) MAX_RAMDISK_SIZE);
- info->sector_size = DEFAULT_SECTOR_SIZE;
- }
- info->info = 0;
-
- /*Store variables locally*/
- disksector_size = info->sector_size;
- disksize = info->size;
- diskinfo = info->info;
- DPRINTF("Image sector_size: \n\t[%"PRIu64"]\n",
- info->sector_size);
-
- return 0;
-}
-
-/* Open the disk file and initialize ram state. */
-int tdram_open (td_driver_t *driver, const char *name, td_flag_t flags)
-{
- char *p;
- uint64_t size;
- int i, fd, ret = 0, count = 0, o_flags;
- struct tdram_state *prv = (struct tdram_state *)driver->data;
-
- connections++;
-
- if (connections > 1) {
- driver->info.sector_size = disksector_size;
- driver->info.size = disksize;
- driver->info.info = diskinfo;
- DPRINTF("Image already open, returning parameters:\n");
- DPRINTF("Image size: \n\tpre sector_shift [%llu]\n\tpost "
- "sector_shift [%llu]\n",
- (long long unsigned)(driver->info.size << SECTOR_SHIFT),
- (long long unsigned)driver->info.size);
- DPRINTF("Image sector_size: \n\t[%"PRIu64"]\n",
- driver->info.sector_size);
-
- prv->fd = -1;
- goto done;
- }
-
- /* Open the file */
- o_flags = O_DIRECT | O_LARGEFILE |
- ((flags == TD_OPEN_RDONLY) ? O_RDONLY : O_RDWR);
- fd = open(name, o_flags);
-
- if ((fd == -1) && (errno == EINVAL)) {
-
- /* Maybe O_DIRECT isn't supported. */
- o_flags &= ~O_DIRECT;
- fd = open(name, o_flags);
- if (fd != -1) DPRINTF("WARNING: Accessing image without"
- "O_DIRECT! (%s)\n", name);
-
- } else if (fd != -1) DPRINTF("open(%s) with O_DIRECT\n", name);
-
- if (fd == -1) {
- DPRINTF("Unable to open [%s]!\n",name);
- ret = 0 - errno;
- goto done;
- }
-
- prv->fd = fd;
-
- ret = get_image_info(fd, &driver->info);
- size = MAX_RAMDISK_SIZE;
-
- if (driver->info.size > size) {
- DPRINTF("Disk exceeds limit, must be less than [%d]MB",
- (MAX_RAMDISK_SIZE<<SECTOR_SHIFT)>>20);
- return -ENOMEM;
- }
-
- /*Read the image into memory*/
- if (posix_memalign((void **)&img,
- DEFAULT_SECTOR_SIZE,
- driver->info.size << SECTOR_SHIFT)) {
- DPRINTF("Mem malloc failed\n");
- return -errno;
- }
- p = img;
- DPRINTF("Reading %llu bytes.......",
- (long long unsigned)driver->info.size << SECTOR_SHIFT);
-
- for (i = 0; i < driver->info.size; i++) {
- ret = read(prv->fd, p, driver->info.sector_size);
- if (ret != driver->info.sector_size) {
- DPRINTF("ret = %d, errno = %d\n", ret, errno);
- ret = 0 - errno;
- break;
- } else {
- count += ret;
- p = img + count;
- }
- }
- DPRINTF("[%d]\n",count);
- if (count != driver->info.size << SECTOR_SHIFT) {
- ret = -1;
- } else {
- ret = 0;
- }
-
-done:
- return ret;
-}
-
-void tdram_queue_read(td_driver_t *driver, td_request_t treq)
-{
- struct tdram_state *prv = (struct tdram_state *)driver->data;
- int size = treq.secs * driver->info.sector_size;
- uint64_t offset = treq.sec * (uint64_t)driver->info.sector_size;
-
- memcpy(treq.buf, img + offset, size);
-
- td_complete_request(treq, 0);
-}
-
-void tdram_queue_write(td_driver_t *driver, td_request_t treq)
-{
- struct tdram_state *prv = (struct tdram_state *)driver->data;
- int size = treq.secs * driver->info.sector_size;
- uint64_t offset = treq.sec * (uint64_t)driver->info.sector_size;
-
- /* We assume that write access is controlled
- * at a higher level for multiple disks */
- memcpy(img + offset, treq.buf, size);
-
- td_complete_request(treq, 0);
-}
-
-int tdram_close(td_driver_t *driver)
-{
- struct tdram_state *prv = (struct tdram_state *)driver->data;
-
- connections--;
-
- return 0;
-}
-
-int tdram_get_parent_id(td_driver_t *driver, td_disk_id_t *id)
-{
- return TD_NO_PARENT;
-}
-
-int tdram_validate_parent(td_driver_t *driver,
- td_driver_t *pdriver, td_flag_t flags)
-{
- return -EINVAL;
-}
-
-struct tap_disk tapdisk_ram = {
- .disk_type = "tapdisk_ram",
- .flags = 0,
- .private_data_size = sizeof(struct tdram_state),
- .td_open = tdram_open,
- .td_close = tdram_close,
- .td_queue_read = tdram_queue_read,
- .td_queue_write = tdram_queue_write,
- .td_get_parent_id = tdram_get_parent_id,
- .td_validate_parent = tdram_validate_parent,
- .td_debug = NULL,
-};
+++ /dev/null
-/* block-remus.c
- *
- * This disk sends all writes to a backup via a network interface before
- * passing them to an underlying device.
- * The backup is a bit more complicated:
- * 1. It applies all incoming writes to a ramdisk.
- * 2. When a checkpoint request arrives, it moves the ramdisk to
- * a committing state and uses a new ramdisk for subsequent writes.
- * It also acknowledges the request, to let the sender know it can
- * release output.
- * 3. The ramdisk flushes its contents to the underlying driver.
- * 4. At failover, the backup waits for the in-flight ramdisk (if any) to
- * drain before letting the domain be activated.
- *
- * The driver determines whether it is the client or server by attempting
- * to bind to the replication address. If the address is not local,
- * the driver acts as client.
- *
- * The following messages are defined for the replication stream:
- * 1. write request
- * "wreq" 4
- * num_sectors 4
- * sector 8
- * buffer (num_sectors * sector_size)
- * 2. submit request (may be used as a barrier
- * "sreq" 4
- * 3. commit request
- * "creq" 4
- * After a commit request, the client must wait for a competion message:
- * 4. completion
- * "done" 4
- */
-
-/* due to architectural choices in tapdisk, block-buffer is forced to
- * reimplement some code which is meant to be private */
-#include "tapdisk.h"
-#include "tapdisk-server.h"
-#include "tapdisk-driver.h"
-#include "tapdisk-interface.h"
-#include "hashtable.h"
-#include "hashtable_itr.h"
-#include "hashtable_utility.h"
-
-#include <errno.h>
-#include <inttypes.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netdb.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#include <sys/param.h>
-#include <unistd.h>
-#include <sys/stat.h>
-
-/* timeout for reads and writes in ms */
-#define HEARTBEAT_MS 1000
-#define RAMDISK_HASHSIZE 128
-
-/* connect retry timeout (seconds) */
-#define REMUS_CONNRETRY_TIMEOUT 10
-
-#define RPRINTF(_f, _a...) syslog (LOG_DEBUG, "remus: " _f, ## _a)
-
-enum tdremus_mode {
- mode_invalid = 0,
- mode_unprotected,
- mode_primary,
- mode_backup
-};
-
-struct tdremus_req {
- uint64_t sector;
- int nb_sectors;
- char buf[4096];
-};
-
-struct req_ring {
- /* waste one slot to distinguish between empty and full */
- struct tdremus_req requests[MAX_REQUESTS * 2 + 1];
- unsigned int head;
- unsigned int tail;
-};
-
-/* TODO: This isn't very pretty, but to properly generate our own treqs (needed
- * by the backup) we need to know our td_vbt_t and td_image_t (blktap2
- * internals). As a proper fix, we should consider extending the tapdisk
- * interface with a td_create_request() function, or something similar.
- *
- * For now, we just grab the vbd in the td_open() command, and the td_image_t
- * from the first read request.
- */
-td_vbd_t *device_vbd = NULL;
-td_image_t *remus_image = NULL;
-struct tap_disk tapdisk_remus;
-
-struct ramdisk {
- size_t sector_size;
- struct hashtable* h;
- /* when a ramdisk is flushed, h is given a new empty hash for writes
- * while the old ramdisk (prev) is drained asynchronously.
- */
- struct hashtable* prev;
- /* count of outstanding requests to the base driver */
- size_t inflight;
- /* prev holds the requests to be flushed, while inprogress holds
- * requests being flushed. When requests complete, they are removed
- * from inprogress.
- * Whenever a new flush is merged with ongoing flush (i.e, prev),
- * we have to make sure that none of the new requests overlap with
- * ones in "inprogress". If it does, keep it back in prev and dont issue
- * IO until the current one finishes. If we allow this IO to proceed,
- * we might end up with two "overlapping" requests in the disk's queue and
- * the disk may not offer any guarantee on which one is written first.
- * IOW, make sure we dont create a write-after-write time ordering constraint.
- *
- */
- struct hashtable* inprogress;
-};
-
-/* the ramdisk intercepts the original callback for reads and writes.
- * This holds the original data. */
-/* Might be worth making this a static array in struct ramdisk to avoid
- * a malloc per request */
-
-struct tdremus_state;
-
-struct ramdisk_cbdata {
- td_callback_t cb;
- void* private;
- char* buf;
- struct tdremus_state* state;
-};
-
-struct ramdisk_write_cbdata {
- struct tdremus_state* state;
- char* buf;
-};
-
-typedef void (*queue_rw_t) (td_driver_t *driver, td_request_t treq);
-
-/* poll_fd type for blktap2 fd system. taken from block_log.c */
-typedef struct poll_fd {
- int fd;
- event_id_t id;
-} poll_fd_t;
-
-struct tdremus_state {
-// struct tap_disk* driver;
- void* driver_data;
-
- /* XXX: this is needed so that the server can perform operations on
- * the driver from the stream_fd event handler. fix this. */
- td_driver_t *tdremus_driver;
-
- /* TODO: we may wish to replace these two FIFOs with a unix socket */
- char* ctl_path; /* receive flush instruction here */
- poll_fd_t ctl_fd; /* io_fd slot for control FIFO */
- char* msg_path; /* output completion message here */
- poll_fd_t msg_fd;
-
- /* replication host */
- struct sockaddr_in sa;
- poll_fd_t server_fd; /* server listen port */
- poll_fd_t stream_fd; /* replication channel */
-
- /* queue write requests, batch-replicate at submit */
- struct req_ring write_ring;
-
- /* ramdisk data*/
- struct ramdisk ramdisk;
-
- /* mode methods */
- enum tdremus_mode mode;
- int (*queue_flush)(td_driver_t *driver);
-};
-
-typedef struct tdremus_wire {
- uint32_t op;
- uint64_t id;
- uint64_t sec;
- uint32_t secs;
-} tdremus_wire_t;
-
-#define TDREMUS_READ "rreq"
-#define TDREMUS_WRITE "wreq"
-#define TDREMUS_SUBMIT "sreq"
-#define TDREMUS_COMMIT "creq"
-#define TDREMUS_DONE "done"
-#define TDREMUS_FAIL "fail"
-
-/* primary read/write functions */
-static void primary_queue_read(td_driver_t *driver, td_request_t treq);
-static void primary_queue_write(td_driver_t *driver, td_request_t treq);
-
-/* backup read/write functions */
-static void backup_queue_read(td_driver_t *driver, td_request_t treq);
-static void backup_queue_write(td_driver_t *driver, td_request_t treq);
-
-/* unpritected read/write functions */
-static void unprotected_queue_read(td_driver_t *driver, td_request_t treq);
-static void unprotected_queue_write(td_driver_t *driver, td_request_t treq);
-
-static int tdremus_close(td_driver_t *driver);
-
-static int switch_mode(td_driver_t *driver, enum tdremus_mode mode);
-static int ctl_respond(struct tdremus_state *s, const char *response);
-
-/* ring functions */
-static inline unsigned int ring_next(struct req_ring* ring, unsigned int pos)
-{
- if (++pos >= MAX_REQUESTS * 2 + 1)
- return 0;
-
- return pos;
-}
-
-static inline int ring_isempty(struct req_ring* ring)
-{
- return ring->head == ring->tail;
-}
-
-static inline int ring_isfull(struct req_ring* ring)
-{
- return ring_next(ring, ring->tail) == ring->head;
-}
-/* Prototype declarations */
-static int ramdisk_flush(td_driver_t *driver, struct tdremus_state* s);
-
-/* functions to create and sumbit treq's */
-
-static void
-replicated_write_callback(td_request_t treq, int err)
-{
- struct tdremus_state *s = (struct tdremus_state *) treq.cb_data;
- td_vbd_request_t *vreq;
- int i;
- uint64_t start;
- vreq = (td_vbd_request_t *) treq.private;
-
- /* the write failed for now, lets panic. this is very bad */
- if (err) {
- RPRINTF("ramdisk write failed, disk image is not consistent\n");
- exit(-1);
- }
-
- /* The write succeeded. let's pull the vreq off whatever request list
- * it is on and free() it */
- list_del(&vreq->next);
- free(vreq);
-
- s->ramdisk.inflight--;
- start = treq.sec;
- for (i = 0; i < treq.secs; i++) {
- hashtable_remove(s->ramdisk.inprogress, &start);
- start++;
- }
- free(treq.buf);
-
- if (!s->ramdisk.inflight && !s->ramdisk.prev) {
- /* TODO: the ramdisk has been flushed */
- }
-}
-
-static inline int
-create_write_request(struct tdremus_state *state, td_sector_t sec, int secs, char *buf)
-{
- td_request_t treq;
- td_vbd_request_t *vreq;
-
- treq.op = TD_OP_WRITE;
- treq.buf = buf;
- treq.sec = sec;
- treq.secs = secs;
- treq.image = remus_image;
- treq.cb = replicated_write_callback;
- treq.cb_data = state;
- treq.id = 0;
- treq.sidx = 0;
-
- vreq = calloc(1, sizeof(td_vbd_request_t));
- treq.private = vreq;
-
- if(!vreq)
- return -1;
-
- vreq->submitting = 1;
- INIT_LIST_HEAD(&vreq->next);
- tapdisk_vbd_move_request(treq.private, &device_vbd->pending_requests);
-
- /* TODO:
- * we should probably leave it up to the caller to forward the request */
- td_forward_request(treq);
-
- vreq->submitting--;
-
- return 0;
-}
-
-
-/* http://www.concentric.net/~Ttwang/tech/inthash.htm */
-static unsigned int uint64_hash(void* k)
-{
- uint64_t key = *(uint64_t*)k;
-
- key = (~key) + (key << 18);
- key = key ^ (key >> 31);
- key = key * 21;
- key = key ^ (key >> 11);
- key = key + (key << 6);
- key = key ^ (key >> 22);
-
- return (unsigned int)key;
-}
-
-static int rd_hash_equal(void* k1, void* k2)
-{
- uint64_t key1, key2;
-
- key1 = *(uint64_t*)k1;
- key2 = *(uint64_t*)k2;
-
- return key1 == key2;
-}
-
-static int ramdisk_read(struct ramdisk* ramdisk, uint64_t sector,
- int nb_sectors, char* buf)
-{
- int i;
- char* v;
- uint64_t key;
-
- for (i = 0; i < nb_sectors; i++) {
- key = sector + i;
- /* check whether it is queued in a previous flush request */
- if (!(ramdisk->prev && (v = hashtable_search(ramdisk->prev, &key)))) {
- /* check whether it is an ongoing flush */
- if (!(ramdisk->inprogress && (v = hashtable_search(ramdisk->inprogress, &key))))
- return -1;
- }
- memcpy(buf + i * ramdisk->sector_size, v, ramdisk->sector_size);
- }
-
- return 0;
-}
-
-static int ramdisk_write_hash(struct hashtable* h, uint64_t sector, char* buf,
- size_t len)
-{
- char* v;
- uint64_t* key;
-
- if ((v = hashtable_search(h, §or))) {
- memcpy(v, buf, len);
- return 0;
- }
-
- if (!(v = malloc(len))) {
- DPRINTF("ramdisk_write_hash: malloc failed\n");
- return -1;
- }
- memcpy(v, buf, len);
- if (!(key = malloc(sizeof(*key)))) {
- DPRINTF("ramdisk_write_hash: error allocating key\n");
- free(v);
- return -1;
- }
- *key = sector;
- if (!hashtable_insert(h, key, v)) {
- DPRINTF("ramdisk_write_hash failed on sector %" PRIu64 "\n", sector);
- free(key);
- free(v);
- return -1;
- }
-
- return 0;
-}
-
-static inline int ramdisk_write(struct ramdisk* ramdisk, uint64_t sector,
- int nb_sectors, char* buf)
-{
- int i, rc;
-
- for (i = 0; i < nb_sectors; i++) {
- rc = ramdisk_write_hash(ramdisk->h, sector + i,
- buf + i * ramdisk->sector_size,
- ramdisk->sector_size);
- if (rc)
- return rc;
- }
-
- return 0;
-}
-
-static int uint64_compare(const void* k1, const void* k2)
-{
- uint64_t u1 = *(uint64_t*)k1;
- uint64_t u2 = *(uint64_t*)k2;
-
- /* u1 - u2 is unsigned */
- return u1 < u2 ? -1 : u1 > u2 ? 1 : 0;
-}
-
-/* set psectors to an array of the sector numbers in the hash, returning
- * the number of entries (or -1 on error) */
-static int ramdisk_get_sectors(struct hashtable* h, uint64_t** psectors)
-{
- struct hashtable_itr* itr;
- uint64_t* sectors;
- int count;
-
- if (!(count = hashtable_count(h)))
- return 0;
-
- if (!(*psectors = malloc(count * sizeof(uint64_t)))) {
- DPRINTF("ramdisk_get_sectors: error allocating sector map\n");
- return -1;
- }
- sectors = *psectors;
-
- itr = hashtable_iterator(h);
- count = 0;
- do {
- sectors[count++] = *(uint64_t*)hashtable_iterator_key(itr);
- } while (hashtable_iterator_advance(itr));
- free(itr);
-
- return count;
-}
-
-/*
- return -1 for OOM
- return -2 for merge lookup failure
- return -3 for WAW race
- return 0 on success.
-*/
-static int merge_requests(struct ramdisk* ramdisk, uint64_t start,
- size_t count, char **mergedbuf)
-{
- char* buf;
- char* sector;
- int i;
- uint64_t *key;
- int rc = 0;
-
- if (!(buf = valloc(count * ramdisk->sector_size))) {
- DPRINTF("merge_request: allocation failed\n");
- return -1;
- }
-
- for (i = 0; i < count; i++) {
- if (!(sector = hashtable_search(ramdisk->prev, &start))) {
- DPRINTF("merge_request: lookup failed on %"PRIu64"\n", start);
- free(buf);
- rc = -2;
- goto fail;
- }
-
- /* Check inprogress requests to avoid waw non-determinism */
- if (hashtable_search(ramdisk->inprogress, &start)) {
- DPRINTF("merge_request: WAR RACE on %"PRIu64"\n", start);
- free(buf);
- rc = -3;
- goto fail;
- }
- /* Insert req into inprogress (brief period of duplication of hash entries until
- * they are removed from prev. Read tracking would not be reading wrong entries)
- */
- if (!(key = malloc(sizeof(*key)))) {
- DPRINTF("%s: error allocating key\n", __FUNCTION__);
- free(buf);
- rc = -1;
- goto fail;
- }
- *key = start;
- if (!hashtable_insert(ramdisk->inprogress, key, NULL)) {
- DPRINTF("%s failed to insert sector %" PRIu64 " into inprogress hash\n",
- __FUNCTION__, start);
- free(key);
- free(buf);
- rc = -1;
- goto fail;
- }
- memcpy(buf + i * ramdisk->sector_size, sector, ramdisk->sector_size);
- start++;
- }
-
- *mergedbuf = buf;
- return 0;
-fail:
- for (start--; i >0; i--, start--)
- hashtable_remove(ramdisk->inprogress, &start);
- return rc;
-}
-
-/* The underlying driver may not handle having the whole ramdisk queued at
- * once. We queue what we can and let the callbacks attempt to queue more. */
-/* NOTE: may be called from callback, while dd->private still belongs to
- * the underlying driver */
-static int ramdisk_flush(td_driver_t *driver, struct tdremus_state* s)
-{
- uint64_t* sectors;
- char* buf = NULL;
- uint64_t base, batchlen;
- int i, j, count = 0;
-
- // RPRINTF("ramdisk flush\n");
-
- if ((count = ramdisk_get_sectors(s->ramdisk.prev, §ors)) <= 0)
- return count;
-
- /* Create the inprogress table if empty */
- if (!s->ramdisk.inprogress)
- s->ramdisk.inprogress = create_hashtable(RAMDISK_HASHSIZE,
- uint64_hash,
- rd_hash_equal);
-
- /*
- RPRINTF("ramdisk: flushing %d sectors\n", count);
- */
-
- /* sort and merge sectors to improve disk performance */
- qsort(sectors, count, sizeof(*sectors), uint64_compare);
-
- for (i = 0; i < count;) {
- base = sectors[i++];
- while (i < count && sectors[i] == sectors[i-1] + 1)
- i++;
- batchlen = sectors[i-1] - base + 1;
-
- j = merge_requests(&s->ramdisk, base, batchlen, &buf);
-
- if (j) {
- RPRINTF("ramdisk_flush: merge_requests failed:%s\n",
- j == -1? "OOM": (j==-2? "missing sector" : "WAW race"));
- if (j == -3) continue;
- free(sectors);
- return -1;
- }
-
- /* NOTE: create_write_request() creates a treq AND forwards it down
- * the driver chain */
- // RPRINTF("forwarding write request at %" PRIu64 ", length: %" PRIu64 "\n", base, batchlen);
- create_write_request(s, base, batchlen, buf);
- //RPRINTF("write request at %" PRIu64 ", length: %" PRIu64 " forwarded\n", base, batchlen);
-
- s->ramdisk.inflight++;
-
- for (j = 0; j < batchlen; j++) {
- buf = hashtable_search(s->ramdisk.prev, &base);
- free(buf);
- hashtable_remove(s->ramdisk.prev, &base);
- base++;
- }
- }
-
- if (!hashtable_count(s->ramdisk.prev)) {
- /* everything is in flight */
- hashtable_destroy(s->ramdisk.prev, 0);
- s->ramdisk.prev = NULL;
- }
-
- free(sectors);
-
- // RPRINTF("ramdisk flush done\n");
- return 0;
-}
-
-/* flush ramdisk contents to disk */
-static int ramdisk_start_flush(td_driver_t *driver)
-{
- struct tdremus_state *s = (struct tdremus_state *)driver->data;
- uint64_t* key;
- char* buf;
- int rc = 0;
- int i, j, count, batchlen;
- uint64_t* sectors;
-
- if (!hashtable_count(s->ramdisk.h)) {
- /*
- RPRINTF("Nothing to flush\n");
- */
- return 0;
- }
-
- if (s->ramdisk.prev) {
- /* a flush request issued while a previous flush is still in progress
- * will merge with the previous request. If you want the previous
- * request to be consistent, wait for it to complete. */
- if ((count = ramdisk_get_sectors(s->ramdisk.h, §ors)) < 0)
- return count;
-
- for (i = 0; i < count; i++) {
- buf = hashtable_search(s->ramdisk.h, sectors + i);
- ramdisk_write_hash(s->ramdisk.prev, sectors[i], buf,
- s->ramdisk.sector_size);
- }
- free(sectors);
-
- hashtable_destroy (s->ramdisk.h, 0);
- } else
- s->ramdisk.prev = s->ramdisk.h;
-
- /* We create a new hashtable so that new writes can be performed before
- * the old hashtable is completely drained. */
- s->ramdisk.h = create_hashtable(RAMDISK_HASHSIZE, uint64_hash,
- rd_hash_equal);
-
- return ramdisk_flush(driver, s);
-}
-
-
-static int ramdisk_start(td_driver_t *driver)
-{
- struct tdremus_state *s = (struct tdremus_state *)driver->data;
-
- if (s->ramdisk.h) {
- RPRINTF("ramdisk already allocated\n");
- return 0;
- }
-
- s->ramdisk.sector_size = driver->info.sector_size;
- s->ramdisk.h = create_hashtable(RAMDISK_HASHSIZE, uint64_hash,
- rd_hash_equal);
-
- DPRINTF("Ramdisk started, %zu bytes/sector\n", s->ramdisk.sector_size);
-
- return 0;
-}
-
-/* common client/server functions */
-/* mayberead: Time out after a certain interval. */
-static int mread(int fd, void* buf, size_t len)
-{
- fd_set rfds;
- int rc;
- size_t cur = 0;
- struct timeval tv = {
- .tv_sec = HEARTBEAT_MS / 1000,
- .tv_usec = (HEARTBEAT_MS % 1000) * 1000
- };
-
- if (!len)
- return 0;
-
- /* read first. Only select if read is incomplete. */
- rc = read(fd, buf, len);
- while (rc < 0 || cur + rc < len) {
- if (!rc) {
- RPRINTF("end-of-file");
- return -1;
- }
- if (rc < 0 && errno != EAGAIN) {
- RPRINTF("error during read: %s\n", strerror(errno));
- return -1;
- }
- if (rc > 0)
- cur += rc;
-
- FD_ZERO(&rfds);
- FD_SET(fd, &rfds);
- if (!(rc = select(fd + 1, &rfds, NULL, NULL, &tv))) {
- RPRINTF("time out during read\n");
- return -1;
- } else if (rc < 0) {
- RPRINTF("error during select: %d\n", errno);
- return -1;
- }
- rc = read(fd, buf + cur, len - cur);
- }
- /*
- RPRINTF("read %d bytes\n", cur + rc);
- */
-
- return 0;
-}
-
-static int mwrite(int fd, void* buf, size_t len)
-{
- fd_set wfds;
- size_t cur = 0;
- int rc;
- struct timeval tv = {
- .tv_sec = HEARTBEAT_MS / 1000,
- .tv_usec = (HEARTBEAT_MS % 1000) * 1000
- };
-
- if (!len)
- return 0;
-
- /* read first. Only select if read is incomplete. */
- rc = write(fd, buf, len);
- while (rc < 0 || cur + rc < len) {
- if (!rc) {
- RPRINTF("end-of-file");
- return -1;
- }
- if (rc < 0 && errno != EAGAIN) {
- RPRINTF("error during write: %s\n", strerror(errno));
- return -1;
- }
- if (rc > 0)
- cur += rc;
-
- FD_ZERO(&wfds);
- FD_SET(fd, &wfds);
- if (!(rc = select(fd + 1, NULL, &wfds, NULL, &tv))) {
- RPRINTF("time out during write\n");
- return -1;
- } else if (rc < 0) {
- RPRINTF("error during select: %d\n", errno);
- return -1;
- }
- rc = write(fd, buf + cur, len - cur);
- }
- /*
- RPRINTF("wrote %d bytes\n", cur + rc);
- */
-
- return 0;
- FD_ZERO(&wfds);
- FD_SET(fd, &wfds);
- select(fd + 1, NULL, &wfds, NULL, &tv);
-}
-
-
-static void inline close_stream_fd(struct tdremus_state *s)
-{
- /* XXX: -2 is magic. replace with macro perhaps? */
- tapdisk_server_unregister_event(s->stream_fd.id);
- close(s->stream_fd.fd);
- s->stream_fd.fd = -2;
-}
-
-/* primary functions */
-static void remus_client_event(event_id_t, char mode, void *private);
-static void remus_connect_event(event_id_t id, char mode, void *private);
-static void remus_retry_connect_event(event_id_t id, char mode, void *private);
-
-static int primary_do_connect(struct tdremus_state *state)
-{
- event_id_t id;
- int fd;
- int rc;
- int flags;
-
- RPRINTF("client connecting to %s:%d...\n", inet_ntoa(state->sa.sin_addr), ntohs(state->sa.sin_port));
-
- if ((fd = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
- RPRINTF("could not create client socket: %d\n", errno);
- return -1;
- }
-
- /* make socket nonblocking */
- if ((flags = fcntl(fd, F_GETFL, 0)) == -1)
- flags = 0;
- if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
- return -1;
-
- /* once we have created the socket and populated the address, we can now start
- * our non-blocking connect. rather than duplicating code we trigger a timeout
- * on the socket fd, which calls out nonblocking connect code
- */
- if((id = tapdisk_server_register_event(SCHEDULER_POLL_TIMEOUT, fd, 0, remus_retry_connect_event, state)) < 0) {
- RPRINTF("error registering timeout client connection event handler: %s\n", strerror(id));
- /* TODO: we leak a fd here */
- return -1;
- }
- state->stream_fd.fd = fd;
- state->stream_fd.id = id;
- return 0;
-}
-
-static int primary_blocking_connect(struct tdremus_state *state)
-{
- int fd;
- int id;
- int rc;
- int flags;
-
- RPRINTF("client connecting to %s:%d...\n", inet_ntoa(state->sa.sin_addr), ntohs(state->sa.sin_port));
-
- if ((fd = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
- RPRINTF("could not create client socket: %d\n", errno);
- return -1;
- }
-
- do {
- if ((rc = connect(fd, (struct sockaddr *)&state->sa,
- sizeof(state->sa))) < 0)
- {
- if (errno == ECONNREFUSED) {
- RPRINTF("connection refused -- retrying in 1 second\n");
- sleep(1);
- } else {
- RPRINTF("connection failed: %d\n", errno);
- close(fd);
- return -1;
- }
- }
- } while (rc < 0);
-
- RPRINTF("client connected\n");
-
- /* make socket nonblocking */
- if ((flags = fcntl(fd, F_GETFL, 0)) == -1)
- flags = 0;
- if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
- {
- RPRINTF("error making socket nonblocking\n");
- close(fd);
- return -1;
- }
-
- if((id = tapdisk_server_register_event(SCHEDULER_POLL_READ_FD, fd, 0, remus_client_event, state)) < 0) {
- RPRINTF("error registering client event handler: %s\n", strerror(id));
- close(fd);
- return -1;
- }
-
- state->stream_fd.fd = fd;
- state->stream_fd.id = id;
- return 0;
-}
-
-/* on read, just pass request through */
-static void primary_queue_read(td_driver_t *driver, td_request_t treq)
-{
- /* just pass read through */
- td_forward_request(treq);
-}
-
-/* TODO:
- * The primary uses mwrite() to write the contents of a write request to the
- * backup. This effectively blocks until all data has been copied into a system
- * buffer or a timeout has occured. We may wish to instead use tapdisk's
- * nonblocking i/o interface, tapdisk_server_register_event(), to set timeouts
- * and write data in an asynchronous fashion.
- */
-static void primary_queue_write(td_driver_t *driver, td_request_t treq)
-{
- struct tdremus_state *s = (struct tdremus_state *)driver->data;
-
- char header[sizeof(uint32_t) + sizeof(uint64_t)];
- uint32_t *sectors = (uint32_t *)header;
- uint64_t *sector = (uint64_t *)(header + sizeof(uint32_t));
-
- // RPRINTF("write: stream_fd.fd: %d\n", s->stream_fd.fd);
-
- /* -1 means we haven't connected yet, -2 means the connection was lost */
- if(s->stream_fd.fd == -1) {
- RPRINTF("connecting to backup...\n");
- primary_blocking_connect(s);
- }
-
- *sectors = treq.secs;
- *sector = treq.sec;
-
- if (mwrite(s->stream_fd.fd, TDREMUS_WRITE, strlen(TDREMUS_WRITE)) < 0)
- goto fail;
- if (mwrite(s->stream_fd.fd, header, sizeof(header)) < 0)
- goto fail;
-
- if (mwrite(s->stream_fd.fd, treq.buf, treq.secs * driver->info.sector_size) < 0)
- goto fail;
-
- td_forward_request(treq);
-
- return;
-
- fail:
- /* switch to unprotected mode and tell tapdisk to retry */
- RPRINTF("write request replication failed, switching to unprotected mode");
- switch_mode(s->tdremus_driver, mode_unprotected);
- td_complete_request(treq, -EBUSY);
-}
-
-
-static int client_flush(td_driver_t *driver)
-{
- struct tdremus_state *s = (struct tdremus_state *)driver->data;
-
- // RPRINTF("committing output\n");
-
- if (s->stream_fd.fd == -1)
- /* connection not yet established, nothing to flush */
- return 0;
-
- if (mwrite(s->stream_fd.fd, TDREMUS_COMMIT, strlen(TDREMUS_COMMIT)) < 0) {
- RPRINTF("error flushing output");
- close_stream_fd(s);
- return -1;
- }
-
- return 0;
-}
-
-static int server_flush(td_driver_t *driver)
-{
- struct tdremus_state *s = (struct tdremus_state *)driver->data;
- /*
- * Nothing to flush in beginning.
- */
- if (!s->ramdisk.prev)
- return 0;
- /* Try to flush any remaining requests */
- return ramdisk_flush(driver, s);
-}
-
-static int primary_start(td_driver_t *driver)
-{
- struct tdremus_state *s = (struct tdremus_state *)driver->data;
-
- RPRINTF("activating client mode\n");
-
- tapdisk_remus.td_queue_read = primary_queue_read;
- tapdisk_remus.td_queue_write = primary_queue_write;
- s->queue_flush = client_flush;
-
- s->stream_fd.fd = -1;
- s->stream_fd.id = -1;
-
- return 0;
-}
-
-/* timeout callback */
-static void remus_retry_connect_event(event_id_t id, char mode, void *private)
-{
- struct tdremus_state *s = (struct tdremus_state *)private;
-
- /* do a non-blocking connect */
- if (connect(s->stream_fd.fd, (struct sockaddr *)&s->sa, sizeof(s->sa))
- && errno != EINPROGRESS)
- {
- if(errno == ECONNREFUSED || errno == ENETUNREACH || errno == EAGAIN || errno == ECONNABORTED)
- {
- /* try again in a second */
- tapdisk_server_unregister_event(s->stream_fd.id);
- if((id = tapdisk_server_register_event(SCHEDULER_POLL_TIMEOUT, s->stream_fd.fd, REMUS_CONNRETRY_TIMEOUT, remus_retry_connect_event, s)) < 0) {
- RPRINTF("error registering timeout client connection event handler: %s\n", strerror(id));
- return;
- }
- s->stream_fd.id = id;
- }
- else
- {
- /* not recoverable */
- RPRINTF("error connection to server %s\n", strerror(errno));
- return;
- }
- }
- else
- {
- /* the connect returned EINPROGRESS (nonblocking connect) we must wait for the fd to be writeable to determine if the connect worked */
-
- tapdisk_server_unregister_event(s->stream_fd.id);
- if((id = tapdisk_server_register_event(SCHEDULER_POLL_WRITE_FD, s->stream_fd.fd, 0, remus_connect_event, s)) < 0) {
- RPRINTF("error registering client connection event handler: %s\n", strerror(id));
- return;
- }
- s->stream_fd.id = id;
- }
-}
-
-/* callback when nonblocking connect() is finished */
-/* called only by primary in unprotected state */
-static void remus_connect_event(event_id_t id, char mode, void *private)
-{
- int socket_errno;
- socklen_t socket_errno_size;
- struct tdremus_state *s = (struct tdremus_state *)private;
-
- /* check to se if the connect succeeded */
- socket_errno_size = sizeof(socket_errno);
- if (getsockopt(s->stream_fd.fd, SOL_SOCKET, SO_ERROR, &socket_errno, &socket_errno_size)) {
- RPRINTF("error getting socket errno\n");
- return;
- }
-
- RPRINTF("socket connect returned %d\n", socket_errno);
-
- if(socket_errno)
- {
- /* the connect did not succeed */
-
- if(socket_errno == ECONNREFUSED || socket_errno == ENETUNREACH || socket_errno == ETIMEDOUT
- || socket_errno == ECONNABORTED || socket_errno == EAGAIN)
- {
- /* we can probably assume that the backup is down. just try again later */
- tapdisk_server_unregister_event(s->stream_fd.id);
- if((id = tapdisk_server_register_event(SCHEDULER_POLL_TIMEOUT, s->stream_fd.fd, REMUS_CONNRETRY_TIMEOUT, remus_retry_connect_event, s)) < 0) {
- RPRINTF("error registering timeout client connection event handler: %s\n", strerror(id));
- return;
- }
- s->stream_fd.id = id;
- }
- else
- {
- RPRINTF("socket connect returned %d, giving up\n", socket_errno);
- }
- }
- else
- {
- /* the connect succeeded */
-
- /* unregister this function and register a new event handler */
- tapdisk_server_unregister_event(s->stream_fd.id);
- if((id = tapdisk_server_register_event(SCHEDULER_POLL_READ_FD, s->stream_fd.fd, 0, remus_client_event, s)) < 0) {
- RPRINTF("error registering client event handler: %s\n", strerror(id));
- return;
- }
- s->stream_fd.id = id;
-
- /* switch from unprotected to protected client */
- switch_mode(s->tdremus_driver, mode_primary);
- }
-}
-
-
-/* we install this event handler on the primary once we have connected to the backup */
-/* wait for "done" message to commit checkpoint */
-static void remus_client_event(event_id_t id, char mode, void *private)
-{
- struct tdremus_state *s = (struct tdremus_state *)private;
- char req[5];
- int rc;
-
- if (mread(s->stream_fd.fd, req, sizeof(req) - 1) < 0) {
- /* replication stream closed or otherwise broken (timeout, reset, &c) */
- RPRINTF("error reading from backup\n");
- close_stream_fd(s);
- return;
- }
-
- req[4] = '\0';
-
- if (!strcmp(req, TDREMUS_DONE))
- /* checkpoint committed, inform msg_fd */
- ctl_respond(s, TDREMUS_DONE);
- else {
- RPRINTF("received unknown message: %s\n", req);
- close_stream_fd(s);
- }
-
- return;
-}
-
-/* backup functions */
-static void remus_server_event(event_id_t id, char mode, void *private);
-
-/* returns the socket that receives write requests */
-static void remus_server_accept(event_id_t id, char mode, void* private)
-{
- struct tdremus_state* s = (struct tdremus_state *) private;
-
- int stream_fd;
- event_id_t cid;
-
- /* XXX: add address-based black/white list */
- if ((stream_fd = accept(s->server_fd.fd, NULL, NULL)) < 0) {
- RPRINTF("error accepting connection: %d\n", errno);
- return;
- }
-
- /* TODO: check to see if we are already replicating. if so just close the
- * connection (or do something smarter) */
- RPRINTF("server accepted connection\n");
-
- /* add tapdisk event for replication stream */
- cid = tapdisk_server_register_event(SCHEDULER_POLL_READ_FD, stream_fd, 0,
- remus_server_event, s);
-
- if(cid < 0) {
- RPRINTF("error registering connection event handler: %s\n", strerror(errno));
- close(stream_fd);
- return;
- }
-
- /* store replication file descriptor */
- s->stream_fd.fd = stream_fd;
- s->stream_fd.id = cid;
-}
-
-/* returns -2 if EADDRNOTAVAIL */
-static int remus_bind(struct tdremus_state* s)
-{
-// struct sockaddr_in sa;
- int opt;
- int rc = -1;
-
- if ((s->server_fd.fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
- RPRINTF("could not create server socket: %d\n", errno);
- return rc;
- }
- opt = 1;
- if (setsockopt(s->server_fd.fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0)
- RPRINTF("Error setting REUSEADDR on %d: %d\n", s->server_fd.fd, errno);
-
- if (bind(s->server_fd.fd, (struct sockaddr *)&s->sa, sizeof(s->sa)) < 0) {
- RPRINTF("could not bind server socket %d to %s:%d: %d %s\n", s->server_fd.fd,
- inet_ntoa(s->sa.sin_addr), ntohs(s->sa.sin_port), errno, strerror(errno));
- if (errno != EADDRINUSE)
- rc = -2;
- goto err_sfd;
- }
- if (listen(s->server_fd.fd, 10)) {
- RPRINTF("could not listen on socket: %d\n", errno);
- goto err_sfd;
- }
-
- /* The socket s now bound to the address and listening so we may now register
- * the fd with tapdisk */
-
- if((s->server_fd.id = tapdisk_server_register_event(SCHEDULER_POLL_READ_FD,
- s->server_fd.fd, 0,
- remus_server_accept, s)) < 0) {
- RPRINTF("error registering server connection event handler: %s",
- strerror(s->server_fd.id));
- goto err_sfd;
- }
-
- return 0;
-
- err_sfd:
- close(s->server_fd.fd);
- s->server_fd.fd = -1;
-
- return rc;
-}
-
-/* wait for latest checkpoint to be applied */
-static inline int server_writes_inflight(td_driver_t *driver)
-{
- struct tdremus_state *s = (struct tdremus_state *)driver->data;
-
- if (!s->ramdisk.inflight && !s->ramdisk.prev)
- return 0;
-
- return 1;
-}
-
-/* Due to block device prefetching this code may be called on the server side
- * during normal replication. In this case we must return EBUSY, otherwise the
- * domain may be started with stale data.
- */
-void backup_queue_read(td_driver_t *driver, td_request_t treq)
-{
- struct tdremus_state *s = (struct tdremus_state *)driver->data;
- int i;
- if(!remus_image)
- remus_image = treq.image;
-
- /* check if this read is queued in any currently ongoing flush */
- if (ramdisk_read(&s->ramdisk, treq.sec, treq.secs, treq.buf)) {
- /* TODO: Add to pending read hash */
- td_forward_request(treq);
- } else {
- /* complete the request */
- td_complete_request(treq, 0);
- }
-}
-
-/* see above */
-void backup_queue_write(td_driver_t *driver, td_request_t treq)
-{
- struct tdremus_state *s = (struct tdremus_state *)driver->data;
-
- /* on a server write, we know the domain has failed over. we must change our
- * state to unprotected and then have the unprotected queue_write function
- * handle the write
- */
-
- switch_mode(driver, mode_unprotected);
- /* TODO: call the appropriate write function rather than return EBUSY */
- td_complete_request(treq, -EBUSY);
-}
-
-static int backup_start(td_driver_t *driver)
-{
- struct tdremus_state *s = (struct tdremus_state *)driver->data;
- int fd;
-
- if (ramdisk_start(driver) < 0)
- return -1;
-
- tapdisk_remus.td_queue_read = backup_queue_read;
- tapdisk_remus.td_queue_write = backup_queue_write;
- s->queue_flush = server_flush;
- /* TODO set flush function */
- return 0;
-}
-
-static int server_do_wreq(td_driver_t *driver)
-{
- struct tdremus_state *s = (struct tdremus_state *)driver->data;
- static tdremus_wire_t twreq;
- char buf[4096];
- int len, rc;
-
- char header[sizeof(uint32_t) + sizeof(uint64_t)];
- uint32_t *sectors = (uint32_t *) header;
- uint64_t *sector = (uint64_t *) &header[sizeof(uint32_t)];
-
- // RPRINTF("received write request\n");
-
- if (mread(s->stream_fd.fd, header, sizeof(header)) < 0)
- goto err;
-
- len = *sectors * driver->info.sector_size;
-
- //RPRINTF("writing %d sectors (%d bytes) starting at %" PRIu64 "\n", *sectors, len,
- // *sector);
-
- if (len > sizeof(buf)) {
- /* freak out! */
- RPRINTF("write request too large: %d/%u\n", len, (unsigned)sizeof(buf));
- return -1;
- }
-
- if (mread(s->stream_fd.fd, buf, len) < 0)
- goto err;
-
- if (ramdisk_write(&s->ramdisk, *sector, *sectors, buf) < 0)
- goto err;
-
- return 0;
-
- err:
- /* should start failover */
- RPRINTF("backup write request error\n");
- close_stream_fd(s);
-
- return -1;
-}
-
-static int server_do_sreq(td_driver_t *driver)
-{
- /*
- RPRINTF("submit request received\n");
- */
-
- return 0;
-}
-
-/* at this point, the server can start applying the most recent
- * ramdisk. */
-static int server_do_creq(td_driver_t *driver)
-{
- struct tdremus_state *s = (struct tdremus_state *)driver->data;
-
- // RPRINTF("committing buffer\n");
-
- ramdisk_start_flush(driver);
-
- /* XXX this message should not be sent until flush completes! */
- if (write(s->stream_fd.fd, TDREMUS_DONE, strlen(TDREMUS_DONE)) != 4)
- return -1;
-
- return 0;
-}
-
-
-/* called when data is pending in s->rfd */
-static void remus_server_event(event_id_t id, char mode, void *private)
-{
- struct tdremus_state *s = (struct tdremus_state *)private;
- td_driver_t *driver = s->tdremus_driver;
- char req[5];
-
- // RPRINTF("replication data waiting\n");
-
- /* TODO: add a get_connection_by_event_id() function.
- * for now we can assume that the fd is s->stream_fd */
-
- if (mread(s->stream_fd.fd, req, sizeof(req) - 1) < 0) {
- RPRINTF("error reading server event, activating backup\n");
- switch_mode(driver, mode_unprotected);
- return;
- }
-
- req[4] = '\0';
-
- if (!strcmp(req, TDREMUS_WRITE))
- server_do_wreq(driver);
- else if (!strcmp(req, TDREMUS_SUBMIT))
- server_do_sreq(driver);
- else if (!strcmp(req, TDREMUS_COMMIT))
- server_do_creq(driver);
- else
- RPRINTF("unknown request received: %s\n", req);
-
- return;
-
-}
-
-/* unprotected */
-
-void unprotected_queue_read(td_driver_t *driver, td_request_t treq)
-{
- struct tdremus_state *s = (struct tdremus_state *)driver->data;
-
- /* wait for previous ramdisk to flush before servicing reads */
- if (server_writes_inflight(driver)) {
- /* for now lets just return EBUSY.
- * if there are any left-over requests in prev,
- * kick em again.
- */
- if(!s->ramdisk.inflight) /* nothing in inprogress */
- ramdisk_flush(driver, s);
-
- td_complete_request(treq, -EBUSY);
- }
- else {
- /* here we just pass reads through */
- td_forward_request(treq);
- }
-}
-
-/* For a recoverable remus solution we need to log unprotected writes here */
-void unprotected_queue_write(td_driver_t *driver, td_request_t treq)
-{
- struct tdremus_state *s = (struct tdremus_state *)driver->data;
-
- /* wait for previous ramdisk to flush */
- if (server_writes_inflight(driver)) {
- RPRINTF("queue_write: waiting for queue to drain");
- if(!s->ramdisk.inflight) /* nothing in inprogress. Kick prev */
- ramdisk_flush(driver, s);
- td_complete_request(treq, -EBUSY);
- }
- else {
- // RPRINTF("servicing write request on backup\n");
- /* NOTE: DRBD style bitmap tracking could go here */
- td_forward_request(treq);
- }
-}
-
-static int unprotected_start(td_driver_t *driver)
-{
- struct tdremus_state *s = (struct tdremus_state *)driver->data;
-
- RPRINTF("failure detected, activating passthrough\n");
-
- /* close the server socket */
- close_stream_fd(s);
-
- /* unregister the replication stream */
- tapdisk_server_unregister_event(s->server_fd.id);
-
- /* close the replication stream */
- close(s->server_fd.fd);
- s->server_fd.fd = -1;
-
- /* install the unprotected read/write handlers */
- tapdisk_remus.td_queue_read = unprotected_queue_read;
- tapdisk_remus.td_queue_write = unprotected_queue_write;
-
- return 0;
-}
-
-
-/* control */
-
-static inline int resolve_address(const char* addr, struct in_addr* ia)
-{
- struct hostent* he;
- uint32_t ip;
-
- if (!(he = gethostbyname(addr))) {
- RPRINTF("error resolving %s: %d\n", addr, h_errno);
- return -1;
- }
-
- if (!he->h_addr_list[0]) {
- RPRINTF("no address found for %s\n", addr);
- return -1;
- }
-
- /* network byte order */
- ip = *((uint32_t**)he->h_addr_list)[0];
- ia->s_addr = ip;
-
- return 0;
-}
-
-static int get_args(td_driver_t *driver, const char* name)
-{
- struct tdremus_state *state = (struct tdremus_state *)driver->data;
- char* host;
- char* port;
-// char* driver_str;
-// char* parent;
-// int type;
-// char* path;
-// unsigned long ulport;
-// int i;
-// struct sockaddr_in server_addr_in;
-
- int gai_status;
- int valid_addr;
- struct addrinfo gai_hints;
- struct addrinfo *servinfo, *servinfo_itr;
-
- memset(&gai_hints, 0, sizeof gai_hints);
- gai_hints.ai_family = AF_UNSPEC;
- gai_hints.ai_socktype = SOCK_STREAM;
-
- port = strchr(name, ':');
- if (!port) {
- RPRINTF("missing host in %s\n", name);
- return -ENOENT;
- }
- if (!(host = strndup(name, port - name))) {
- RPRINTF("unable to allocate host\n");
- return -ENOMEM;
- }
- port++;
-
- if ((gai_status = getaddrinfo(host, port, &gai_hints, &servinfo)) != 0) {
- RPRINTF("getaddrinfo error: %s\n", gai_strerror(gai_status));
- return -ENOENT;
- }
-
- /* TODO: do something smarter here */
- valid_addr = 0;
- for(servinfo_itr = servinfo; servinfo_itr != NULL; servinfo_itr = servinfo_itr->ai_next) {
- void *addr;
- char *ipver;
-
- if (servinfo_itr->ai_family == AF_INET) {
- valid_addr = 1;
- memset(&state->sa, 0, sizeof(state->sa));
- state->sa = *(struct sockaddr_in *)servinfo_itr->ai_addr;
- break;
- }
- }
- freeaddrinfo(servinfo);
-
- if (!valid_addr)
- return -ENOENT;
-
- RPRINTF("host: %s, port: %d\n", inet_ntoa(state->sa.sin_addr), ntohs(state->sa.sin_port));
-
- return 0;
-}
-
-static int switch_mode(td_driver_t *driver, enum tdremus_mode mode)
-{
- struct tdremus_state *s = (struct tdremus_state *)driver->data;
- int rc;
-
- if (mode == s->mode)
- return 0;
-
- if (s->queue_flush)
- if ((rc = s->queue_flush(driver)) < 0) {
- // fall back to unprotected mode on error
- RPRINTF("switch_mode: error flushing queue (old: %d, new: %d)", s->mode, mode);
- mode = mode_unprotected;
- }
-
- if (mode == mode_unprotected)
- rc = unprotected_start(driver);
- else if (mode == mode_primary)
- rc = primary_start(driver);
- else if (mode == mode_backup)
- rc = backup_start(driver);
- else {
- RPRINTF("unknown mode requested: %d\n", mode);
- rc = -1;
- }
-
- if (!rc)
- s->mode = mode;
-
- return rc;
-}
-
-static void ctl_request(event_id_t id, char mode, void *private)
-{
- struct tdremus_state *s = (struct tdremus_state *)private;
- td_driver_t *driver = s->tdremus_driver;
- char msg[80];
- int rc;
-
- // RPRINTF("data waiting on control fifo\n");
-
- if (!(rc = read(s->ctl_fd.fd, msg, sizeof(msg) - 1 /* append nul */))) {
- RPRINTF("0-byte read received, reopening FIFO\n");
- /*TODO: we may have to unregister/re-register with tapdisk_server */
- close(s->ctl_fd.fd);
- RPRINTF("FIFO closed\n");
- if ((s->ctl_fd.fd = open(s->ctl_path, O_RDWR)) < 0) {
- RPRINTF("error reopening FIFO: %d\n", errno);
- }
- return;
- }
-
- if (rc < 0) {
- RPRINTF("error reading from FIFO: %d\n", errno);
- return;
- }
-
- /* TODO: need to get driver somehow */
- msg[rc] = '\0';
- if (!strncmp(msg, "flush", 5)) {
- if (s->queue_flush)
- if ((rc = s->queue_flush(driver))) {
- RPRINTF("error passing flush request to backup");
- ctl_respond(s, TDREMUS_FAIL);
- }
- } else {
- RPRINTF("unknown command: %s\n", msg);
- }
-}
-
-static int ctl_respond(struct tdremus_state *s, const char *response)
-{
- int rc;
-
- if ((rc = write(s->msg_fd.fd, response, strlen(response))) < 0) {
- RPRINTF("error writing notification: %d\n", errno);
- close(s->msg_fd.fd);
- if ((s->msg_fd.fd = open(s->msg_path, O_RDWR)) < 0)
- RPRINTF("error reopening FIFO: %d\n", errno);
- }
-
- return rc;
-}
-
-/* must be called after the underlying driver has been initialized */
-static int ctl_open(td_driver_t *driver, const char* name)
-{
- struct tdremus_state *s = (struct tdremus_state *)driver->data;
- int i, l;
-
- /* first we must ensure that BLKTAP_CTRL_DIR exists */
- if (mkdir(BLKTAP_CTRL_DIR, 0755) && errno != EEXIST)
- {
- DPRINTF("error creating directory %s: %d\n", BLKTAP_CTRL_DIR, errno);
- return -1;
- }
-
- /* use the device name to create the control fifo path */
- if (asprintf(&s->ctl_path, BLKTAP_CTRL_DIR "/remus_%s", name) < 0)
- return -1;
- /* scrub fifo pathname */
- for (i = strlen(BLKTAP_CTRL_DIR) + 1, l = strlen(s->ctl_path); i < l; i++) {
- if (strchr(":/", s->ctl_path[i]))
- s->ctl_path[i] = '_';
- }
- if (asprintf(&s->msg_path, "%s.msg", s->ctl_path) < 0)
- goto err_ctlfifo;
-
- if (mkfifo(s->ctl_path, S_IRWXU|S_IRWXG|S_IRWXO) && errno != EEXIST) {
- RPRINTF("error creating control FIFO %s: %d\n", s->ctl_path, errno);
- goto err_msgfifo;
- }
-
- if (mkfifo(s->msg_path, S_IRWXU|S_IRWXG|S_IRWXO) && errno != EEXIST) {
- RPRINTF("error creating message FIFO %s: %d\n", s->msg_path, errno);
- goto err_msgfifo;
- }
-
- /* RDWR so that fd doesn't block select when no writer is present */
- if ((s->ctl_fd.fd = open(s->ctl_path, O_RDWR)) < 0) {
- RPRINTF("error opening control FIFO %s: %d\n", s->ctl_path, errno);
- goto err_msgfifo;
- }
-
- if ((s->msg_fd.fd = open(s->msg_path, O_RDWR)) < 0) {
- RPRINTF("error opening message FIFO %s: %d\n", s->msg_path, errno);
- goto err_openctlfifo;
- }
-
- RPRINTF("control FIFO %s\n", s->ctl_path);
- RPRINTF("message FIFO %s\n", s->msg_path);
-
- return 0;
-
- err_openctlfifo:
- close(s->ctl_fd.fd);
- err_msgfifo:
- free(s->msg_path);
- s->msg_path = NULL;
- err_ctlfifo:
- free(s->ctl_path);
- s->ctl_path = NULL;
- return -1;
-}
-
-static void ctl_close(td_driver_t *driver)
-{
- struct tdremus_state *s = (struct tdremus_state *)driver->data;
-
- /* TODO: close *all* connections */
-
- if(s->ctl_fd.fd)
- close(s->ctl_fd.fd);
-
- if (s->ctl_path) {
- unlink(s->ctl_path);
- free(s->ctl_path);
- s->ctl_path = NULL;
- }
- if (s->msg_path) {
- unlink(s->msg_path);
- free(s->msg_path);
- s->msg_path = NULL;
- }
-}
-
-static int ctl_register(struct tdremus_state *s)
-{
- RPRINTF("registering ctl fifo\n");
-
- /* register ctl fd */
- s->ctl_fd.id = tapdisk_server_register_event(SCHEDULER_POLL_READ_FD, s->ctl_fd.fd, 0, ctl_request, s);
-
- if (s->ctl_fd.id < 0) {
- RPRINTF("error registering ctrl FIFO %s: %d\n", s->ctl_path, s->ctl_fd.id);
- return -1;
- }
-
- return 0;
-}
-
-/* interface */
-
-static int tdremus_open(td_driver_t *driver, const char *name,
- td_flag_t flags)
-{
- struct tdremus_state *s = (struct tdremus_state *)driver->data;
- int rc;
-
- RPRINTF("opening %s\n", name);
-
- /* first we need to get the underlying vbd for this driver stack. To do so we
- * need to know the vbd's id. Fortunately, for tapdisk2 this is hard-coded as
- * 0 (see tapdisk2.c)
- */
- device_vbd = tapdisk_server_get_vbd(0);
-
- memset(s, 0, sizeof(*s));
- s->server_fd.fd = -1;
- s->stream_fd.fd = -1;
- s->ctl_fd.fd = -1;
- s->msg_fd.fd = -1;
-
- /* TODO: this is only needed so that the server can send writes down
- * the driver stack from the stream_fd event handler */
- s->tdremus_driver = driver;
-
- /* parse name to get info etc */
- if ((rc = get_args(driver, name)))
- return rc;
-
- if ((rc = ctl_open(driver, name))) {
- RPRINTF("error setting up control channel\n");
- free(s->driver_data);
- return rc;
- }
-
- if ((rc = ctl_register(s))) {
- RPRINTF("error registering control channel\n");
- free(s->driver_data);
- return rc;
- }
-
- if (!(rc = remus_bind(s)))
- rc = switch_mode(driver, mode_backup);
- else if (rc == -2)
- rc = switch_mode(driver, mode_primary);
-
- if (!rc)
- return 0;
-
- tdremus_close(driver);
- return -EIO;
-}
-
-static int tdremus_close(td_driver_t *driver)
-{
- struct tdremus_state *s = (struct tdremus_state *)driver->data;
-
- RPRINTF("closing\n");
- if (s->ramdisk.inprogress)
- hashtable_destroy(s->ramdisk.inprogress, 0);
-
- if (s->driver_data) {
- free(s->driver_data);
- s->driver_data = NULL;
- }
- if (s->server_fd.fd >= 0) {
- close(s->server_fd.fd);
- s->server_fd.fd = -1;
- }
- if (s->stream_fd.fd >= 0)
- close_stream_fd(s);
-
- ctl_close(driver);
-
- return 0;
-}
-
-static int tdremus_get_parent_id(td_driver_t *driver, td_disk_id_t *id)
-{
- /* we shouldn't have a parent... for now */
- return -EINVAL;
-}
-
-static int tdremus_validate_parent(td_driver_t *driver,
- td_driver_t *pdriver, td_flag_t flags)
-{
- return 0;
-}
-
-struct tap_disk tapdisk_remus = {
- .disk_type = "tapdisk_remus",
- .private_data_size = sizeof(struct tdremus_state),
- .td_open = tdremus_open,
- .td_queue_read = unprotected_queue_read,
- .td_queue_write = unprotected_queue_write,
- .td_close = tdremus_close,
- .td_get_parent_id = tdremus_get_parent_id,
- .td_validate_parent = tdremus_validate_parent,
- .td_debug = NULL,
-};
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * A note on write transactions:
- * Writes that require updating the BAT or bitmaps cannot be signaled
- * as complete until all updates have reached disk. Transactions are
- * used to ensure proper ordering in these cases. The two types of
- * transactions are as follows:
- * - Bitmap updates only: data writes that require updates to the same
- * bitmap are grouped in a transaction. Only after all data writes
- * in a transaction complete does the bitmap write commence. Only
- * after the bitmap write finishes are the data writes signalled as
- * complete.
- * - BAT and bitmap updates: data writes are grouped in transactions
- * as above, but a special extra write is included in the transaction,
- * which zeros out the newly allocated bitmap on disk. When the data
- * writes and the zero-bitmap write complete, the BAT and bitmap writes
- * are started in parallel. The transaction is completed only after both
- * the BAT and bitmap writes successfully return.
- */
-
-#include <errno.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <sys/stat.h>
-#include <sys/ioctl.h>
-#include <string.h> /* for memset. */
-#include <libaio.h>
-#include <sys/mman.h>
-
-#include "libvhd.h"
-#include "tapdisk.h"
-#include "tapdisk-driver.h"
-#include "tapdisk-interface.h"
-#include "tapdisk-disktype.h"
-
-unsigned int SPB;
-
-#define DEBUGGING 2
-#define ASSERTING 1
-#define MICROSOFT_COMPAT
-
-#define VHD_BATMAP_MAX_RETRIES 10
-
-#define __TRACE(s) \
- do { \
- DBG(TLOG_DBG, "%s: QUEUED: %" PRIu64 ", COMPLETED: %" \
- PRIu64", RETURNED: %" PRIu64 ", DATA_ALLOCATED: " \
- "%lu, BBLK: 0x%04x\n", \
- s->vhd.file, s->queued, s->completed, s->returned, \
- VHD_REQS_DATA - s->vreq_free_count, \
- s->bat.pbw_blk); \
- } while(0)
-
-#define __ASSERT(_p) \
- if (!(_p)) { \
- DPRINTF("%s:%d: FAILED ASSERTION: '%s'\n", \
- __FILE__, __LINE__, #_p); \
- DBG(TLOG_WARN, "%s:%d: FAILED ASSERTION: '%s'\n", \
- __FILE__, __LINE__, #_p); \
- tlog_flush(); \
- abort(); \
- }
-
-#if (DEBUGGING == 1)
- #define DBG(level, _f, _a...) DPRINTF(_f, ##_a)
- #define ERR(err, _f, _a...) DPRINTF("ERROR: %d: " _f, err, ##_a)
- #define TRACE(s) ((void)0)
-#elif (DEBUGGING == 2)
- #define DBG(level, _f, _a...) tlog_write(level, _f, ##_a)
- #define ERR(err, _f, _a...) tlog_error(err, _f, ##_a)
- #define TRACE(s) __TRACE(s)
-#else
- #define DBG(level, _f, _a...) ((void)0)
- #define ERR(err, _f, _a...) ((void)0)
- #define TRACE(s) ((void)0)
-#endif
-
-#if (ASSERTING == 1)
- #define ASSERT(_p) __ASSERT(_p)
-#else
- #define ASSERT(_p) ((void)0)
-#endif
-
-/******VHD DEFINES******/
-#define VHD_CACHE_SIZE 32
-
-#define VHD_REQS_DATA TAPDISK_DATA_REQUESTS
-#define VHD_REQS_META (VHD_CACHE_SIZE + 2)
-#define VHD_REQS_TOTAL (VHD_REQS_DATA + VHD_REQS_META)
-
-#define VHD_OP_BAT_WRITE 0
-#define VHD_OP_DATA_READ 1
-#define VHD_OP_DATA_WRITE 2
-#define VHD_OP_BITMAP_READ 3
-#define VHD_OP_BITMAP_WRITE 4
-#define VHD_OP_ZERO_BM_WRITE 5
-
-#define VHD_BM_BAT_LOCKED 0
-#define VHD_BM_BAT_CLEAR 1
-#define VHD_BM_BIT_CLEAR 2
-#define VHD_BM_BIT_SET 3
-#define VHD_BM_NOT_CACHED 4
-#define VHD_BM_READ_PENDING 5
-
-#define VHD_FLAG_OPEN_RDONLY 1
-#define VHD_FLAG_OPEN_NO_CACHE 2
-#define VHD_FLAG_OPEN_QUIET 4
-#define VHD_FLAG_OPEN_STRICT 8
-#define VHD_FLAG_OPEN_QUERY 16
-#define VHD_FLAG_OPEN_PREALLOCATE 32
-
-#define VHD_FLAG_BAT_LOCKED 1
-#define VHD_FLAG_BAT_WRITE_STARTED 2
-
-#define VHD_FLAG_BM_UPDATE_BAT 1
-#define VHD_FLAG_BM_WRITE_PENDING 2
-#define VHD_FLAG_BM_READ_PENDING 4
-#define VHD_FLAG_BM_LOCKED 8
-
-#define VHD_FLAG_REQ_UPDATE_BAT 1
-#define VHD_FLAG_REQ_UPDATE_BITMAP 2
-#define VHD_FLAG_REQ_QUEUED 4
-#define VHD_FLAG_REQ_FINISHED 8
-
-#define VHD_FLAG_TX_LIVE 1
-#define VHD_FLAG_TX_UPDATE_BAT 2
-
-typedef uint8_t vhd_flag_t;
-
-struct vhd_state;
-struct vhd_request;
-
-struct vhd_req_list {
- struct vhd_request *head;
- struct vhd_request *tail;
-};
-
-struct vhd_transaction {
- int error;
- int closed;
- int started;
- int finished;
- vhd_flag_t status;
- struct vhd_req_list requests;
-};
-
-struct vhd_request {
- int error;
- uint8_t op;
- vhd_flag_t flags;
- td_request_t treq;
- struct tiocb tiocb;
- struct vhd_state *state;
- struct vhd_request *next;
- struct vhd_transaction *tx;
-};
-
-struct vhd_bat_state {
- vhd_bat_t bat;
- vhd_batmap_t batmap;
- vhd_flag_t status;
- uint32_t pbw_blk; /* blk num of pending write */
- uint64_t pbw_offset; /* file offset of same */
- struct vhd_request req; /* for writing bat table */
- struct vhd_request zero_req; /* for initializing bitmaps */
- char *bat_buf;
-};
-
-struct vhd_bitmap {
- u32 blk;
- u64 seqno; /* lru sequence number */
- vhd_flag_t status;
-
- char *map; /* map should only be modified
- * in finish_bitmap_write */
- char *shadow; /* in-memory bitmap changes are
- * made to shadow and copied to
- * map only after having been
- * flushed to disk */
- struct vhd_transaction tx; /* transaction data structure
- * encapsulating data, bitmap,
- * and bat writes */
- struct vhd_req_list queue; /* data writes waiting for next
- * transaction */
- struct vhd_req_list waiting; /* pending requests that cannot
- * be serviced until this bitmap
- * is read from disk */
- struct vhd_request req;
-};
-
-struct vhd_state {
- vhd_flag_t flags;
-
- /* VHD stuff */
- vhd_context_t vhd;
- u32 spp; /* sectors per page */
- u32 spb; /* sectors per block */
- u64 next_db; /* pointer to the next
- * (unallocated) datablock */
-
- struct vhd_bat_state bat;
-
- u64 bm_lru; /* lru sequence number */
- u32 bm_secs; /* size of bitmap, in sectors */
- struct vhd_bitmap *bitmap[VHD_CACHE_SIZE];
-
- int bm_free_count;
- struct vhd_bitmap *bitmap_free[VHD_CACHE_SIZE];
- struct vhd_bitmap bitmap_list[VHD_CACHE_SIZE];
-
- int vreq_free_count;
- struct vhd_request *vreq_free[VHD_REQS_DATA];
- struct vhd_request vreq_list[VHD_REQS_DATA];
-
- td_driver_t *driver;
-
- uint64_t queued;
- uint64_t completed;
- uint64_t returned;
- uint64_t reads;
- uint64_t read_size;
- uint64_t writes;
- uint64_t write_size;
-};
-
-#define test_vhd_flag(word, flag) ((word) & (flag))
-#define set_vhd_flag(word, flag) ((word) |= (flag))
-#define clear_vhd_flag(word, flag) ((word) &= ~(flag))
-
-#define bat_entry(s, blk) ((s)->bat.bat.bat[(blk)])
-
-static void vhd_complete(void *, struct tiocb *, int);
-static void finish_data_transaction(struct vhd_state *, struct vhd_bitmap *);
-
-static struct vhd_state *_vhd_master;
-static unsigned long _vhd_zsize;
-static char *_vhd_zeros;
-
-static int
-vhd_initialize(struct vhd_state *s)
-{
- if (_vhd_zeros)
- return 0;
-
- _vhd_zsize = 2 * getpagesize();
- if (test_vhd_flag(s->flags, VHD_FLAG_OPEN_PREALLOCATE))
- _vhd_zsize += VHD_BLOCK_SIZE;
-
- _vhd_zeros = mmap(0, _vhd_zsize, PROT_READ,
- MAP_SHARED | MAP_ANON, -1, 0);
- if (_vhd_zeros == MAP_FAILED) {
- EPRINTF("vhd_initialize failed: %d\n", -errno);
- _vhd_zeros = NULL;
- _vhd_zsize = 0;
- return -errno;
- }
-
- _vhd_master = s;
- return 0;
-}
-
-static void
-vhd_free(struct vhd_state *s)
-{
- if (_vhd_master != s || !_vhd_zeros)
- return;
-
- munmap(_vhd_zeros, _vhd_zsize);
- _vhd_zsize = 0;
- _vhd_zeros = NULL;
- _vhd_master = NULL;
-}
-
-static char *
-_get_vhd_zeros(const char *func, unsigned long size)
-{
- if (!_vhd_zeros || _vhd_zsize < size) {
- EPRINTF("invalid zero request from %s: %lu, %lu, %p\n",
- func, size, _vhd_zsize, _vhd_zeros);
- ASSERT(0);
- }
-
- return _vhd_zeros;
-}
-
-#define vhd_zeros(size) _get_vhd_zeros(__func__, size)
-
-static inline void
-set_batmap(struct vhd_state *s, uint32_t blk)
-{
- if (s->bat.batmap.map) {
- vhd_batmap_set(&s->vhd, &s->bat.batmap, blk);
- DBG(TLOG_DBG, "block 0x%x completely full\n", blk);
- }
-}
-
-static inline int
-test_batmap(struct vhd_state *s, uint32_t blk)
-{
- if (!s->bat.batmap.map)
- return 0;
- return vhd_batmap_test(&s->vhd, &s->bat.batmap, blk);
-}
-
-static int
-vhd_kill_footer(struct vhd_state *s)
-{
- int err;
- off_t end;
- char *zeros;
-
- if (s->vhd.footer.type == HD_TYPE_FIXED)
- return 0;
-
- err = posix_memalign((void **)&zeros, 512, 512);
- if (err)
- return -err;
-
- err = 1;
- memset(zeros, 0xc7c7c7c7, 512);
-
- if ((end = lseek(s->vhd.fd, 0, SEEK_END)) == -1)
- goto fail;
-
- if (lseek(s->vhd.fd, (end - 512), SEEK_SET) == -1)
- goto fail;
-
- if (write(s->vhd.fd, zeros, 512) != 512)
- goto fail;
-
- err = 0;
-
- fail:
- free(zeros);
- if (err)
- return (errno ? -errno : -EIO);
- return 0;
-}
-
-static inline int
-find_next_free_block(struct vhd_state *s)
-{
- int err;
- off_t eom;
- uint32_t i, entry;
-
- err = vhd_end_of_headers(&s->vhd, &eom);
- if (err)
- return err;
-
- s->next_db = secs_round_up(eom);
-
- for (i = 0; i < s->bat.bat.entries; i++) {
- entry = bat_entry(s, i);
- if (entry != DD_BLK_UNUSED && entry >= s->next_db)
- s->next_db = entry + s->spb + s->bm_secs;
- }
-
- return 0;
-}
-
-static void
-vhd_free_bat(struct vhd_state *s)
-{
- free(s->bat.bat.bat);
- free(s->bat.batmap.map);
- free(s->bat.bat_buf);
- memset(&s->bat, 0, sizeof(struct vhd_bat));
-}
-
-static int
-vhd_initialize_bat(struct vhd_state *s)
-{
- int err, psize, batmap_required, i;
-
- memset(&s->bat, 0, sizeof(struct vhd_bat));
-
- psize = getpagesize();
-
- err = vhd_read_bat(&s->vhd, &s->bat.bat);
- if (err) {
- EPRINTF("%s: reading bat: %d\n", s->vhd.file, err);
- return err;
- }
-
- batmap_required = 1;
- if (test_vhd_flag(s->flags, VHD_FLAG_OPEN_RDONLY)) {
- batmap_required = 0;
- } else {
- err = find_next_free_block(s);
- if (err)
- goto fail;
- }
-
- if (vhd_has_batmap(&s->vhd)) {
- for (i = 0; i < VHD_BATMAP_MAX_RETRIES; i++) {
- err = vhd_read_batmap(&s->vhd, &s->bat.batmap);
- if (err) {
- EPRINTF("%s: reading batmap: %d\n",
- s->vhd.file, err);
- if (batmap_required)
- goto fail;
- } else {
- break;
- }
- }
- if (err)
- EPRINTF("%s: ignoring non-critical batmap error\n",
- s->vhd.file);
- }
-
- err = posix_memalign((void **)&s->bat.bat_buf,
- VHD_SECTOR_SIZE, VHD_SECTOR_SIZE);
- if (err) {
- s->bat.bat_buf = NULL;
- goto fail;
- }
-
- return 0;
-
-fail:
- vhd_free_bat(s);
- return err;
-}
-
-static void
-vhd_free_bitmap_cache(struct vhd_state *s)
-{
- int i;
- struct vhd_bitmap *bm;
-
- for (i = 0; i < VHD_CACHE_SIZE; i++) {
- bm = s->bitmap_list + i;
- free(bm->map);
- free(bm->shadow);
- s->bitmap_free[i] = NULL;
- }
-
- memset(s->bitmap_list, 0, sizeof(struct vhd_bitmap) * VHD_CACHE_SIZE);
-}
-
-static int
-vhd_initialize_bitmap_cache(struct vhd_state *s)
-{
- int i, err, map_size;
- struct vhd_bitmap *bm;
-
- memset(s->bitmap_list, 0, sizeof(struct vhd_bitmap) * VHD_CACHE_SIZE);
-
- s->bm_lru = 0;
- map_size = vhd_sectors_to_bytes(s->bm_secs);
- s->bm_free_count = VHD_CACHE_SIZE;
-
- for (i = 0; i < VHD_CACHE_SIZE; i++) {
- bm = s->bitmap_list + i;
-
- err = posix_memalign((void **)&bm->map, 512, map_size);
- if (err) {
- bm->map = NULL;
- goto fail;
- }
-
- err = posix_memalign((void **)&bm->shadow, 512, map_size);
- if (err) {
- bm->shadow = NULL;
- goto fail;
- }
-
- memset(bm->map, 0, map_size);
- memset(bm->shadow, 0, map_size);
- s->bitmap_free[i] = bm;
- }
-
- return 0;
-
-fail:
- vhd_free_bitmap_cache(s);
- return err;
-}
-
-static int
-vhd_initialize_dynamic_disk(struct vhd_state *s)
-{
- int err;
-
- err = vhd_get_header(&s->vhd);
- if (err) {
- if (!test_vhd_flag(s->flags, VHD_FLAG_OPEN_QUIET))
- EPRINTF("Error reading VHD DD header.\n");
- return err;
- }
-
- if (s->vhd.header.hdr_ver != 0x00010000) {
- EPRINTF("unsupported header version! (0x%x)\n",
- s->vhd.header.hdr_ver);
- return -EINVAL;
- }
-
- s->spp = getpagesize() >> VHD_SECTOR_SHIFT;
- s->spb = s->vhd.header.block_size >> VHD_SECTOR_SHIFT;
- s->bm_secs = secs_round_up_no_zero(s->spb >> 3);
-
- if (test_vhd_flag(s->flags, VHD_FLAG_OPEN_NO_CACHE))
- return 0;
-
- err = vhd_initialize_bat(s);
- if (err)
- return err;
-
- err = vhd_initialize_bitmap_cache(s);
- if (err) {
- vhd_free_bat(s);
- return err;
- }
-
- return 0;
-}
-
-static int
-vhd_check_version(struct vhd_state *s)
-{
- if (strncmp(s->vhd.footer.crtr_app, "tap", 3))
- return 0;
-
- if (s->vhd.footer.crtr_ver > VHD_CURRENT_VERSION) {
- if (!test_vhd_flag(s->flags, VHD_FLAG_OPEN_QUIET))
- EPRINTF("WARNING: %s vhd creator version 0x%08x, "
- "but only versions up to 0x%08x are "
- "supported for IO\n", s->vhd.file,
- s->vhd.footer.crtr_ver, VHD_CURRENT_VERSION);
-
- return -EINVAL;
- }
-
- return 0;
-}
-
-static void
-vhd_log_open(struct vhd_state *s)
-{
- char buf[5];
- uint32_t i, allocated, full;
-
- if (test_vhd_flag(s->flags, VHD_FLAG_OPEN_QUIET))
- return;
-
- snprintf(buf, sizeof(buf), "%s", s->vhd.footer.crtr_app);
- if (!vhd_type_dynamic(&s->vhd)) {
- DPRINTF("%s version: %s 0x%08x\n",
- s->vhd.file, buf, s->vhd.footer.crtr_ver);
- return;
- }
-
- allocated = 0;
- full = 0;
-
- for (i = 0; i < s->bat.bat.entries; i++) {
- if (bat_entry(s, i) != DD_BLK_UNUSED)
- allocated++;
- if (test_batmap(s, i))
- full++;
- }
-
- DPRINTF("%s version: %s 0x%08x, b: %u, a: %u, f: %u, n: %"PRIu64"\n",
- s->vhd.file, buf, s->vhd.footer.crtr_ver, s->bat.bat.entries,
- allocated, full, s->next_db);
-}
-
-static int
-__vhd_open(td_driver_t *driver, const char *name, vhd_flag_t flags)
-{
- int i, o_flags, err;
- struct vhd_state *s;
-
- DBG(TLOG_INFO, "vhd_open: %s\n", name);
- if (test_vhd_flag(flags, VHD_FLAG_OPEN_STRICT))
- libvhd_set_log_level(1);
-
- s = (struct vhd_state *)driver->data;
- memset(s, 0, sizeof(struct vhd_state));
-
- s->flags = flags;
- s->driver = driver;
-
- err = vhd_initialize(s);
- if (err)
- return err;
-
- o_flags = ((test_vhd_flag(flags, VHD_FLAG_OPEN_RDONLY)) ?
- VHD_OPEN_RDONLY : VHD_OPEN_RDWR);
-
- err = vhd_open(&s->vhd, name, o_flags);
- if (err) {
- libvhd_set_log_level(1);
- err = vhd_open(&s->vhd, name, o_flags);
- if (err) {
- EPRINTF("Unable to open [%s] (%d)!\n", name, err);
- return err;
- }
- }
-
- err = vhd_check_version(s);
- if (err)
- goto fail;
-
- s->spb = s->spp = 1;
-
- if (vhd_type_dynamic(&s->vhd)) {
- err = vhd_initialize_dynamic_disk(s);
- if (err)
- goto fail;
- }
-
- vhd_log_open(s);
-
- SPB = s->spb;
-
- s->vreq_free_count = VHD_REQS_DATA;
- for (i = 0; i < VHD_REQS_DATA; i++)
- s->vreq_free[i] = s->vreq_list + i;
-
- driver->info.size = s->vhd.footer.curr_size >> VHD_SECTOR_SHIFT;
- driver->info.sector_size = VHD_SECTOR_SIZE;
- driver->info.info = 0;
-
- DBG(TLOG_INFO, "vhd_open: done (sz:%"PRIu64", sct:%"PRIu64
- ", inf:%u)\n",
- driver->info.size, driver->info.sector_size, driver->info.info);
-
- if (test_vhd_flag(flags, VHD_FLAG_OPEN_STRICT) &&
- !test_vhd_flag(flags, VHD_FLAG_OPEN_RDONLY)) {
- err = vhd_kill_footer(s);
- if (err) {
- DPRINTF("ERROR killing footer: %d\n", err);
- goto fail;
- }
- s->writes++;
- }
-
- return 0;
-
- fail:
- vhd_free_bat(s);
- vhd_free_bitmap_cache(s);
- vhd_close(&s->vhd);
- vhd_free(s);
- return err;
-}
-
-static int
-_vhd_open(td_driver_t *driver, const char *name, td_flag_t flags)
-{
- vhd_flag_t vhd_flags = 0;
-
- if (flags & TD_OPEN_RDONLY)
- vhd_flags |= VHD_FLAG_OPEN_RDONLY;
- if (flags & TD_OPEN_QUIET)
- vhd_flags |= VHD_FLAG_OPEN_QUIET;
- if (flags & TD_OPEN_STRICT)
- vhd_flags |= VHD_FLAG_OPEN_STRICT;
- if (flags & TD_OPEN_QUERY)
- vhd_flags |= (VHD_FLAG_OPEN_QUERY |
- VHD_FLAG_OPEN_QUIET |
- VHD_FLAG_OPEN_RDONLY |
- VHD_FLAG_OPEN_NO_CACHE);
-
- /* pre-allocate for all but NFS and LVM storage */
- if (driver->storage != TAPDISK_STORAGE_TYPE_NFS &&
- driver->storage != TAPDISK_STORAGE_TYPE_LVM)
- vhd_flags |= VHD_FLAG_OPEN_PREALLOCATE;
-
- return __vhd_open(driver, name, vhd_flags);
-}
-
-static void
-vhd_log_close(struct vhd_state *s)
-{
- uint32_t i, allocated, full;
-
- if (test_vhd_flag(s->flags, VHD_FLAG_OPEN_QUIET))
- return;
-
- allocated = 0;
- full = 0;
-
- for (i = 0; i < s->bat.bat.entries; i++) {
- if (bat_entry(s, i) != DD_BLK_UNUSED)
- allocated++;
- if (test_batmap(s, i))
- full++;
- }
-
- DPRINTF("%s: b: %u, a: %u, f: %u, n: %"PRIu64"\n",
- s->vhd.file, s->bat.bat.entries, allocated, full, s->next_db);
-}
-
-static int
-_vhd_close(td_driver_t *driver)
-{
- int err;
- struct vhd_state *s;
- struct vhd_bitmap *bm;
-
- DBG(TLOG_WARN, "vhd_close\n");
- s = (struct vhd_state *)driver->data;
-
- /* don't write footer if tapdisk is read-only */
- if (test_vhd_flag(s->flags, VHD_FLAG_OPEN_RDONLY))
- goto free;
-
- /*
- * write footer if:
- * - we killed it on open (opened with strict)
- * - we've written data since opening
- */
- if (test_vhd_flag(s->flags, VHD_FLAG_OPEN_STRICT) || s->writes) {
- memcpy(&s->vhd.bat, &s->bat.bat, sizeof(vhd_bat_t));
- err = vhd_write_footer(&s->vhd, &s->vhd.footer);
- memset(&s->vhd.bat, 0, sizeof(vhd_bat_t));
-
- if (err)
- EPRINTF("writing %s footer: %d\n", s->vhd.file, err);
-
- if (!vhd_has_batmap(&s->vhd))
- goto free;
-
- err = vhd_write_batmap(&s->vhd, &s->bat.batmap);
- if (err)
- EPRINTF("writing %s batmap: %d\n", s->vhd.file, err);
- }
-
- free:
- vhd_log_close(s);
- vhd_free_bat(s);
- vhd_free_bitmap_cache(s);
- vhd_close(&s->vhd);
- vhd_free(s);
-
- memset(s, 0, sizeof(struct vhd_state));
-
- return 0;
-}
-
-int
-vhd_validate_parent(td_driver_t *child_driver,
- td_driver_t *parent_driver, td_flag_t flags)
-{
- uint32_t status;
- struct stat stats;
- struct vhd_state *child = (struct vhd_state *)child_driver->data;
- struct vhd_state *parent;
-
- if (parent_driver->type != DISK_TYPE_VHD) {
- if (child_driver->type != DISK_TYPE_VHD)
- return -EINVAL;
- if (child->vhd.footer.type != HD_TYPE_DIFF)
- return -EINVAL;
- if (!vhd_parent_raw(&child->vhd))
- return -EINVAL;
- return 0;
- }
-
- parent = (struct vhd_state *)parent_driver->data;
-
- /*
- * This check removed because of cases like:
- * - parent VHD marked as 'hidden'
- * - parent VHD modified during coalesce
- */
- /*
- if (stat(parent->vhd.file, &stats)) {
- DPRINTF("ERROR stating parent file %s\n", parent->vhd.file);
- return -errno;
- }
-
- if (child->hdr.prt_ts != vhd_time(stats.st_mtime)) {
- DPRINTF("ERROR: parent file has been modified since "
- "snapshot. Child image no longer valid.\n");
- return -EINVAL;
- }
- */
-
- if (vhd_uuid_compare(&child->vhd.header.prt_uuid, &parent->vhd.footer.uuid)) {
- DPRINTF("ERROR: %s: %s, %s: parent uuid has changed since "
- "snapshot. Child image no longer valid.\n",
- __func__, child->vhd.file, parent->vhd.file);
- return -EINVAL;
- }
-
- /* TODO: compare sizes */
-
- return 0;
-}
-
-int
-vhd_get_parent_id(td_driver_t *driver, td_disk_id_t *id)
-{
- int err;
- char *parent;
- struct vhd_state *s;
-
- DBG(TLOG_DBG, "\n");
- memset(id, 0, sizeof(td_disk_id_t));
-
- s = (struct vhd_state *)driver->data;
-
- if (s->vhd.footer.type != HD_TYPE_DIFF)
- return TD_NO_PARENT;
-
- err = vhd_parent_locator_get(&s->vhd, &parent);
- if (err)
- return err;
-
- id->name = parent;
- id->drivertype = DISK_TYPE_VHD;
- if (vhd_parent_raw(&s->vhd)) {
- DPRINTF("VHD: parent is raw\n");
- id->drivertype = DISK_TYPE_AIO;
- }
- return 0;
-}
-
-static inline void
-clear_req_list(struct vhd_req_list *list)
-{
- list->head = list->tail = NULL;
-}
-
-static inline void
-add_to_tail(struct vhd_req_list *list, struct vhd_request *e)
-{
- if (!list->head)
- list->head = list->tail = e;
- else
- list->tail = list->tail->next = e;
-}
-
-static inline int
-remove_from_req_list(struct vhd_req_list *list, struct vhd_request *e)
-{
- struct vhd_request *i = list->head;
-
- if (list->head == e) {
- if (list->tail == e)
- clear_req_list(list);
- else
- list->head = list->head->next;
- return 0;
- }
-
- while (i->next) {
- if (i->next == e) {
- if (list->tail == e) {
- i->next = NULL;
- list->tail = i;
- } else
- i->next = i->next->next;
- return 0;
- }
- i = i->next;
- }
-
- return -EINVAL;
-}
-
-static inline void
-init_vhd_request(struct vhd_state *s, struct vhd_request *req)
-{
- memset(req, 0, sizeof(struct vhd_request));
- req->state = s;
-}
-
-static inline void
-init_tx(struct vhd_transaction *tx)
-{
- memset(tx, 0, sizeof(struct vhd_transaction));
-}
-
-static inline void
-add_to_transaction(struct vhd_transaction *tx, struct vhd_request *r)
-{
- ASSERT(!tx->closed);
-
- r->tx = tx;
- tx->started++;
- add_to_tail(&tx->requests, r);
- set_vhd_flag(tx->status, VHD_FLAG_TX_LIVE);
-
- DBG(TLOG_DBG, "blk: 0x%04"PRIx64", lsec: 0x%08"PRIx64", tx: %p, "
- "started: %d, finished: %d, status: %u\n",
- r->treq.sec / SPB, r->treq.sec, tx,
- tx->started, tx->finished, tx->status);
-}
-
-static inline int
-transaction_completed(struct vhd_transaction *tx)
-{
- return (tx->started == tx->finished);
-}
-
-static inline void
-init_bat(struct vhd_state *s)
-{
- s->bat.req.tx = NULL;
- s->bat.req.next = NULL;
- s->bat.req.error = 0;
- s->bat.pbw_blk = 0;
- s->bat.pbw_offset = 0;
- s->bat.status = 0;
-}
-
-static inline void
-lock_bat(struct vhd_state *s)
-{
- set_vhd_flag(s->bat.status, VHD_FLAG_BAT_LOCKED);
-}
-
-static inline void
-unlock_bat(struct vhd_state *s)
-{
- clear_vhd_flag(s->bat.status, VHD_FLAG_BAT_LOCKED);
-}
-
-static inline int
-bat_locked(struct vhd_state *s)
-{
- return test_vhd_flag(s->bat.status, VHD_FLAG_BAT_LOCKED);
-}
-
-static inline void
-init_vhd_bitmap(struct vhd_state *s, struct vhd_bitmap *bm)
-{
- bm->blk = 0;
- bm->seqno = 0;
- bm->status = 0;
- init_tx(&bm->tx);
- clear_req_list(&bm->queue);
- clear_req_list(&bm->waiting);
- memset(bm->map, 0, vhd_sectors_to_bytes(s->bm_secs));
- memset(bm->shadow, 0, vhd_sectors_to_bytes(s->bm_secs));
- init_vhd_request(s, &bm->req);
-}
-
-static inline struct vhd_bitmap *
-get_bitmap(struct vhd_state *s, uint32_t block)
-{
- int i;
- struct vhd_bitmap *bm;
-
- for (i = 0; i < VHD_CACHE_SIZE; i++) {
- bm = s->bitmap[i];
- if (bm && bm->blk == block)
- return bm;
- }
-
- return NULL;
-}
-
-static inline void
-lock_bitmap(struct vhd_bitmap *bm)
-{
- set_vhd_flag(bm->status, VHD_FLAG_BM_LOCKED);
-}
-
-static inline void
-unlock_bitmap(struct vhd_bitmap *bm)
-{
- clear_vhd_flag(bm->status, VHD_FLAG_BM_LOCKED);
-}
-
-static inline int
-bitmap_locked(struct vhd_bitmap *bm)
-{
- return test_vhd_flag(bm->status, VHD_FLAG_BM_LOCKED);
-}
-
-static inline int
-bitmap_valid(struct vhd_bitmap *bm)
-{
- return !test_vhd_flag(bm->status, VHD_FLAG_BM_READ_PENDING);
-}
-
-static inline int
-bitmap_in_use(struct vhd_bitmap *bm)
-{
- return (test_vhd_flag(bm->status, VHD_FLAG_BM_READ_PENDING) ||
- test_vhd_flag(bm->status, VHD_FLAG_BM_WRITE_PENDING) ||
- test_vhd_flag(bm->tx.status, VHD_FLAG_TX_UPDATE_BAT) ||
- bm->waiting.head || bm->tx.requests.head || bm->queue.head);
-}
-
-static inline int
-bitmap_full(struct vhd_state *s, struct vhd_bitmap *bm)
-{
- int i, n;
-
- n = s->spb >> 3;
- for (i = 0; i < n; i++)
- if (bm->map[i] != (char)0xFF)
- return 0;
-
- DBG(TLOG_DBG, "bitmap 0x%04x full\n", bm->blk);
- return 1;
-}
-
-static struct vhd_bitmap *
-remove_lru_bitmap(struct vhd_state *s)
-{
- int i, idx = 0;
- u64 seq = s->bm_lru;
- struct vhd_bitmap *bm, *lru = NULL;
-
- for (i = 0; i < VHD_CACHE_SIZE; i++) {
- bm = s->bitmap[i];
- if (bm && bm->seqno < seq && !bitmap_locked(bm)) {
- idx = i;
- lru = bm;
- seq = lru->seqno;
- }
- }
-
- if (lru) {
- s->bitmap[idx] = NULL;
- ASSERT(!bitmap_in_use(lru));
- }
-
- return lru;
-}
-
-static int
-alloc_vhd_bitmap(struct vhd_state *s, struct vhd_bitmap **bitmap, uint32_t blk)
-{
- struct vhd_bitmap *bm;
-
- *bitmap = NULL;
-
- if (s->bm_free_count > 0) {
- bm = s->bitmap_free[--s->bm_free_count];
- } else {
- bm = remove_lru_bitmap(s);
- if (!bm)
- return -EBUSY;
- }
-
- init_vhd_bitmap(s, bm);
- bm->blk = blk;
- *bitmap = bm;
-
- return 0;
-}
-
-static inline uint64_t
-__bitmap_lru_seqno(struct vhd_state *s)
-{
- int i;
- struct vhd_bitmap *bm;
-
- if (s->bm_lru == 0xffffffff) {
- s->bm_lru = 0;
- for (i = 0; i < VHD_CACHE_SIZE; i++) {
- bm = s->bitmap[i];
- if (bm) {
- bm->seqno >>= 1;
- if (bm->seqno > s->bm_lru)
- s->bm_lru = bm->seqno;
- }
- }
- }
-
- return ++s->bm_lru;
-}
-
-static inline void
-touch_bitmap(struct vhd_state *s, struct vhd_bitmap *bm)
-{
- bm->seqno = __bitmap_lru_seqno(s);
-}
-
-static inline void
-install_bitmap(struct vhd_state *s, struct vhd_bitmap *bm)
-{
- int i;
- for (i = 0; i < VHD_CACHE_SIZE; i++) {
- if (!s->bitmap[i]) {
- touch_bitmap(s, bm);
- s->bitmap[i] = bm;
- return;
- }
- }
-
- ASSERT(0);
-}
-
-static inline void
-free_vhd_bitmap(struct vhd_state *s, struct vhd_bitmap *bm)
-{
- int i;
-
- for (i = 0; i < VHD_CACHE_SIZE; i++)
- if (s->bitmap[i] == bm)
- break;
-
- ASSERT(!bitmap_locked(bm));
- ASSERT(!bitmap_in_use(bm));
- ASSERT(i < VHD_CACHE_SIZE);
-
- s->bitmap[i] = NULL;
- s->bitmap_free[s->bm_free_count++] = bm;
-}
-
-static int
-read_bitmap_cache(struct vhd_state *s, uint64_t sector, uint8_t op)
-{
- u32 blk, sec;
- struct vhd_bitmap *bm;
-
- /* in fixed disks, every block is present */
- if (s->vhd.footer.type == HD_TYPE_FIXED)
- return VHD_BM_BIT_SET;
-
- blk = sector / s->spb;
- sec = sector % s->spb;
-
- if (blk > s->vhd.header.max_bat_size) {
- DPRINTF("ERROR: sec %"PRIu64" out of range, op = %d\n",
- sector, op);
- return -EINVAL;
- }
-
- if (bat_entry(s, blk) == DD_BLK_UNUSED) {
- if (op == VHD_OP_DATA_WRITE &&
- s->bat.pbw_blk != blk && bat_locked(s))
- return VHD_BM_BAT_LOCKED;
-
- return VHD_BM_BAT_CLEAR;
- }
-
- if (test_batmap(s, blk)) {
- DBG(TLOG_DBG, "batmap set for 0x%04x\n", blk);
- return VHD_BM_BIT_SET;
- }
-
- bm = get_bitmap(s, blk);
- if (!bm)
- return VHD_BM_NOT_CACHED;
-
- /* bump lru count */
- touch_bitmap(s, bm);
-
- if (test_vhd_flag(bm->status, VHD_FLAG_BM_READ_PENDING))
- return VHD_BM_READ_PENDING;
-
- return ((vhd_bitmap_test(&s->vhd, bm->map, sec)) ?
- VHD_BM_BIT_SET : VHD_BM_BIT_CLEAR);
-}
-
-static int
-read_bitmap_cache_span(struct vhd_state *s,
- uint64_t sector, int nr_secs, int value)
-{
- int ret;
- u32 blk, sec;
- struct vhd_bitmap *bm;
-
- /* in fixed disks, every block is present */
- if (s->vhd.footer.type == HD_TYPE_FIXED)
- return nr_secs;
-
- sec = sector % s->spb;
- blk = sector / s->spb;
-
- if (test_batmap(s, blk))
- return MIN(nr_secs, s->spb - sec);
-
- bm = get_bitmap(s, blk);
-
- ASSERT(bm && bitmap_valid(bm));
-
- for (ret = 0; sec < s->spb && ret < nr_secs; sec++, ret++)
- if (vhd_bitmap_test(&s->vhd, bm->map, sec) != value)
- break;
-
- return ret;
-}
-
-static inline struct vhd_request *
-alloc_vhd_request(struct vhd_state *s)
-{
- struct vhd_request *req = NULL;
-
- if (s->vreq_free_count > 0) {
- req = s->vreq_free[--s->vreq_free_count];
- ASSERT(req->treq.secs == 0);
- init_vhd_request(s, req);
- return req;
- }
-
- return NULL;
-}
-
-static inline void
-free_vhd_request(struct vhd_state *s, struct vhd_request *req)
-{
- memset(req, 0, sizeof(struct vhd_request));
- s->vreq_free[s->vreq_free_count++] = req;
-}
-
-static inline void
-aio_read(struct vhd_state *s, struct vhd_request *req, uint64_t offset)
-{
- struct tiocb *tiocb = &req->tiocb;
-
- td_prep_read(tiocb, s->vhd.fd, req->treq.buf,
- vhd_sectors_to_bytes(req->treq.secs),
- offset, vhd_complete, req);
- td_queue_tiocb(s->driver, tiocb);
-
- s->queued++;
- s->reads++;
- s->read_size += req->treq.secs;
- TRACE(s);
-}
-
-static inline void
-aio_write(struct vhd_state *s, struct vhd_request *req, uint64_t offset)
-{
- struct tiocb *tiocb = &req->tiocb;
-
- td_prep_write(tiocb, s->vhd.fd, req->treq.buf,
- vhd_sectors_to_bytes(req->treq.secs),
- offset, vhd_complete, req);
- td_queue_tiocb(s->driver, tiocb);
-
- s->queued++;
- s->writes++;
- s->write_size += req->treq.secs;
- TRACE(s);
-}
-
-static inline uint64_t
-reserve_new_block(struct vhd_state *s, uint32_t blk)
-{
- int gap = 0;
-
- ASSERT(!test_vhd_flag(s->bat.status, VHD_FLAG_BAT_WRITE_STARTED));
-
- /* data region of segment should begin on page boundary */
- if ((s->next_db + s->bm_secs) % s->spp)
- gap = (s->spp - ((s->next_db + s->bm_secs) % s->spp));
-
- s->bat.pbw_blk = blk;
- s->bat.pbw_offset = s->next_db + gap;
-
- return s->next_db;
-}
-
-static int
-schedule_bat_write(struct vhd_state *s)
-{
- int i;
- u32 blk;
- char *buf;
- u64 offset;
- struct vhd_request *req;
-
- ASSERT(bat_locked(s));
-
- req = &s->bat.req;
- buf = s->bat.bat_buf;
- blk = s->bat.pbw_blk;
-
- init_vhd_request(s, req);
- memcpy(buf, &bat_entry(s, blk - (blk % 128)), 512);
-
- ((u32 *)buf)[blk % 128] = s->bat.pbw_offset;
-
- for (i = 0; i < 128; i++)
- BE32_OUT(&((u32 *)buf)[i]);
-
- offset = s->vhd.header.table_offset + (blk - (blk % 128)) * 4;
- req->treq.secs = 1;
- req->treq.buf = buf;
- req->op = VHD_OP_BAT_WRITE;
- req->next = NULL;
-
- aio_write(s, req, offset);
- set_vhd_flag(s->bat.status, VHD_FLAG_BAT_WRITE_STARTED);
-
- DBG(TLOG_DBG, "blk: 0x%04x, pbwo: 0x%08"PRIx64", "
- "table_offset: 0x%08"PRIx64"\n", blk, s->bat.pbw_offset, offset);
-
- return 0;
-}
-
-static void
-schedule_zero_bm_write(struct vhd_state *s,
- struct vhd_bitmap *bm, uint64_t lb_end)
-{
- uint64_t offset;
- struct vhd_request *req = &s->bat.zero_req;
-
- init_vhd_request(s, req);
-
- offset = vhd_sectors_to_bytes(lb_end);
- req->op = VHD_OP_ZERO_BM_WRITE;
- req->treq.sec = s->bat.pbw_blk * s->spb;
- req->treq.secs = (s->bat.pbw_offset - lb_end) + s->bm_secs;
- req->treq.buf = vhd_zeros(vhd_sectors_to_bytes(req->treq.secs));
- req->next = NULL;
-
- DBG(TLOG_DBG, "blk: 0x%04x, writing zero bitmap at 0x%08"PRIx64"\n",
- s->bat.pbw_blk, offset);
-
- lock_bitmap(bm);
- add_to_transaction(&bm->tx, req);
- aio_write(s, req, offset);
-}
-
-static int
-update_bat(struct vhd_state *s, uint32_t blk)
-{
- int err;
- uint64_t lb_end;
- struct vhd_bitmap *bm;
-
- ASSERT(bat_entry(s, blk) == DD_BLK_UNUSED);
-
- if (bat_locked(s)) {
- ASSERT(s->bat.pbw_blk == blk);
- return 0;
- }
-
- /* empty bitmap could already be in
- * cache if earlier bat update failed */
- bm = get_bitmap(s, blk);
- if (!bm) {
- /* install empty bitmap in cache */
- err = alloc_vhd_bitmap(s, &bm, blk);
- if (err)
- return err;
-
- install_bitmap(s, bm);
- }
-
- lock_bat(s);
- lb_end = reserve_new_block(s, blk);
- schedule_zero_bm_write(s, bm, lb_end);
- set_vhd_flag(bm->tx.status, VHD_FLAG_TX_UPDATE_BAT);
-
- return 0;
-}
-
-static int
-allocate_block(struct vhd_state *s, uint32_t blk)
-{
- char *zeros;
- int err, gap;
- uint64_t offset, size;
- struct vhd_bitmap *bm;
-
- ASSERT(bat_entry(s, blk) == DD_BLK_UNUSED);
-
- if (bat_locked(s)) {
- ASSERT(s->bat.pbw_blk == blk);
- if (s->bat.req.error)
- return -EBUSY;
- return 0;
- }
-
- gap = 0;
- s->bat.pbw_blk = blk;
- offset = vhd_sectors_to_bytes(s->next_db);
-
- /* data region of segment should begin on page boundary */
- if ((s->next_db + s->bm_secs) % s->spp) {
- gap = (s->spp - ((s->next_db + s->bm_secs) % s->spp));
- s->next_db += gap;
- }
-
- s->bat.pbw_offset = s->next_db;
-
- DBG(TLOG_DBG, "blk: 0x%04x, pbwo: 0x%08"PRIx64"\n",
- blk, s->bat.pbw_offset);
-
- if (lseek(s->vhd.fd, offset, SEEK_SET) == (off_t)-1) {
- ERR(errno, "lseek failed\n");
- return -errno;
- }
-
- size = vhd_sectors_to_bytes(s->spb + s->bm_secs + gap);
- err = write(s->vhd.fd, vhd_zeros(size), size);
- if (err != size) {
- err = (err == -1 ? -errno : -EIO);
- ERR(err, "write failed");
- return err;
- }
-
- /* empty bitmap could already be in
- * cache if earlier bat update failed */
- bm = get_bitmap(s, blk);
- if (!bm) {
- /* install empty bitmap in cache */
- err = alloc_vhd_bitmap(s, &bm, blk);
- if (err)
- return err;
-
- install_bitmap(s, bm);
- }
-
- lock_bat(s);
- lock_bitmap(bm);
- schedule_bat_write(s);
- add_to_transaction(&bm->tx, &s->bat.req);
-
- return 0;
-}
-
-static int
-schedule_data_read(struct vhd_state *s, td_request_t treq, vhd_flag_t flags)
-{
- u64 offset;
- u32 blk = 0, sec = 0;
- struct vhd_bitmap *bm;
- struct vhd_request *req;
-
- if (s->vhd.footer.type == HD_TYPE_FIXED) {
- offset = vhd_sectors_to_bytes(treq.sec);
- goto make_request;
- }
-
- blk = treq.sec / s->spb;
- sec = treq.sec % s->spb;
- bm = get_bitmap(s, blk);
- offset = bat_entry(s, blk);
-
- ASSERT(offset != DD_BLK_UNUSED);
- ASSERT(test_batmap(s, blk) || (bm && bitmap_valid(bm)));
-
- offset += s->bm_secs + sec;
- offset = vhd_sectors_to_bytes(offset);
-
- make_request:
- req = alloc_vhd_request(s);
- if (!req)
- return -EBUSY;
-
- req->treq = treq;
- req->flags = flags;
- req->op = VHD_OP_DATA_READ;
- req->next = NULL;
-
- aio_read(s, req, offset);
-
- DBG(TLOG_DBG, "%s: lsec: 0x%08"PRIx64", blk: 0x%04x, sec: 0x%04x, "
- "nr_secs: 0x%04x, offset: 0x%08"PRIx64", flags: 0x%08x, buf: %p\n",
- s->vhd.file, treq.sec, blk, sec, treq.secs, offset, req->flags,
- treq.buf);
-
- return 0;
-}
-
-static int
-schedule_data_write(struct vhd_state *s, td_request_t treq, vhd_flag_t flags)
-{
- int err;
- u64 offset;
- u32 blk = 0, sec = 0;
- struct vhd_bitmap *bm = NULL;
- struct vhd_request *req;
-
- if (s->vhd.footer.type == HD_TYPE_FIXED) {
- offset = vhd_sectors_to_bytes(treq.sec);
- goto make_request;
- }
-
- blk = treq.sec / s->spb;
- sec = treq.sec % s->spb;
- offset = bat_entry(s, blk);
-
- if (test_vhd_flag(flags, VHD_FLAG_REQ_UPDATE_BAT)) {
- if (test_vhd_flag(s->flags, VHD_FLAG_OPEN_PREALLOCATE))
- err = allocate_block(s, blk);
- else
- err = update_bat(s, blk);
-
- if (err)
- return err;
-
- offset = s->bat.pbw_offset;
- }
-
- offset += s->bm_secs + sec;
- offset = vhd_sectors_to_bytes(offset);
-
- make_request:
- req = alloc_vhd_request(s);
- if (!req)
- return -EBUSY;
-
- req->treq = treq;
- req->flags = flags;
- req->op = VHD_OP_DATA_WRITE;
- req->next = NULL;
-
- if (test_vhd_flag(flags, VHD_FLAG_REQ_UPDATE_BITMAP)) {
- bm = get_bitmap(s, blk);
- ASSERT(bm && bitmap_valid(bm));
- lock_bitmap(bm);
-
- if (bm->tx.closed) {
- add_to_tail(&bm->queue, req);
- set_vhd_flag(req->flags, VHD_FLAG_REQ_QUEUED);
- } else
- add_to_transaction(&bm->tx, req);
- }
-
- aio_write(s, req, offset);
-
- DBG(TLOG_DBG, "%s: lsec: 0x%08"PRIx64", blk: 0x%04x, sec: 0x%04x, "
- "nr_secs: 0x%04x, offset: 0x%08"PRIx64", flags: 0x%08x\n",
- s->vhd.file, treq.sec, blk, sec, treq.secs, offset, req->flags);
-
- return 0;
-}
-
-static int
-schedule_bitmap_read(struct vhd_state *s, uint32_t blk)
-{
- int err;
- u64 offset;
- struct vhd_bitmap *bm;
- struct vhd_request *req = NULL;
-
- ASSERT(vhd_type_dynamic(&s->vhd));
-
- offset = bat_entry(s, blk);
-
- ASSERT(offset != DD_BLK_UNUSED);
- ASSERT(!get_bitmap(s, blk));
-
- offset = vhd_sectors_to_bytes(offset);
-
- err = alloc_vhd_bitmap(s, &bm, blk);
- if (err)
- return err;
-
- req = &bm->req;
- init_vhd_request(s, req);
-
- req->treq.sec = blk * s->spb;
- req->treq.secs = s->bm_secs;
- req->treq.buf = bm->map;
- req->treq.cb = NULL;
- req->op = VHD_OP_BITMAP_READ;
- req->next = NULL;
-
- aio_read(s, req, offset);
- lock_bitmap(bm);
- install_bitmap(s, bm);
- set_vhd_flag(bm->status, VHD_FLAG_BM_READ_PENDING);
-
- DBG(TLOG_DBG, "%s: lsec: 0x%08"PRIx64", blk: 0x%04x, nr_secs: 0x%04x, "
- "offset: 0x%08"PRIx64"\n", s->vhd.file, req->treq.sec, blk,
- req->treq.secs, offset);
-
- return 0;
-}
-
-static void
-schedule_bitmap_write(struct vhd_state *s, uint32_t blk)
-{
- u64 offset;
- struct vhd_bitmap *bm;
- struct vhd_request *req;
-
- bm = get_bitmap(s, blk);
- offset = bat_entry(s, blk);
-
- ASSERT(vhd_type_dynamic(&s->vhd));
- ASSERT(bm && bitmap_valid(bm) &&
- !test_vhd_flag(bm->status, VHD_FLAG_BM_WRITE_PENDING));
-
- if (offset == DD_BLK_UNUSED) {
- ASSERT(bat_locked(s) && s->bat.pbw_blk == blk);
- offset = s->bat.pbw_offset;
- }
-
- offset = vhd_sectors_to_bytes(offset);
-
- req = &bm->req;
- init_vhd_request(s, req);
-
- req->treq.sec = blk * s->spb;
- req->treq.secs = s->bm_secs;
- req->treq.buf = bm->shadow;
- req->treq.cb = NULL;
- req->op = VHD_OP_BITMAP_WRITE;
- req->next = NULL;
-
- aio_write(s, req, offset);
- lock_bitmap(bm);
- touch_bitmap(s, bm); /* bump lru count */
- set_vhd_flag(bm->status, VHD_FLAG_BM_WRITE_PENDING);
-
- DBG(TLOG_DBG, "%s: blk: 0x%04x, sec: 0x%08"PRIx64", nr_secs: 0x%04x, "
- "offset: 0x%"PRIx64"\n", s->vhd.file, blk, req->treq.sec,
- req->treq.secs, offset);
-}
-
-/*
- * queued requests will be submitted once the bitmap
- * describing them is read and the requests are validated.
- */
-static int
-__vhd_queue_request(struct vhd_state *s, uint8_t op, td_request_t treq)
-{
- u32 blk;
- struct vhd_bitmap *bm;
- struct vhd_request *req;
-
- ASSERT(vhd_type_dynamic(&s->vhd));
-
- blk = treq.sec / s->spb;
- bm = get_bitmap(s, blk);
-
- ASSERT(bm && test_vhd_flag(bm->status, VHD_FLAG_BM_READ_PENDING));
-
- req = alloc_vhd_request(s);
- if (!req)
- return -EBUSY;
-
- req->treq = treq;
- req->op = op;
- req->next = NULL;
-
- add_to_tail(&bm->waiting, req);
- lock_bitmap(bm);
-
- DBG(TLOG_DBG, "%s: lsec: 0x%08"PRIx64", blk: 0x%04x nr_secs: 0x%04x, "
- "op: %u\n", s->vhd.file, treq.sec, blk, treq.secs, op);
-
- TRACE(s);
- return 0;
-}
-
-static void
-vhd_queue_read(td_driver_t *driver, td_request_t treq)
-{
- struct vhd_state *s = (struct vhd_state *)driver->data;
-
- DBG(TLOG_DBG, "%s: lsec: 0x%08"PRIx64", secs: 0x%04x (seg: %d)\n",
- s->vhd.file, treq.sec, treq.secs, treq.sidx);
-
- while (treq.secs) {
- int err;
- td_request_t clone;
-
- err = 0;
- clone = treq;
-
- switch (read_bitmap_cache(s, clone.sec, VHD_OP_DATA_READ)) {
- case -EINVAL:
- err = -EINVAL;
- goto fail;
-
- case VHD_BM_BAT_CLEAR:
- clone.secs = MIN(clone.secs, s->spb - (clone.sec % s->spb));
- td_forward_request(clone);
- break;
-
- case VHD_BM_BIT_CLEAR:
- clone.secs = read_bitmap_cache_span(s, clone.sec, clone.secs, 0);
- td_forward_request(clone);
- break;
-
- case VHD_BM_BIT_SET:
- clone.secs = read_bitmap_cache_span(s, clone.sec, clone.secs, 1);
- err = schedule_data_read(s, clone, 0);
- if (err)
- goto fail;
- break;
-
- case VHD_BM_NOT_CACHED:
- err = schedule_bitmap_read(s, clone.sec / s->spb);
- if (err)
- goto fail;
-
- clone.secs = MIN(clone.secs, s->spb - (clone.sec % s->spb));
- err = __vhd_queue_request(s, VHD_OP_DATA_READ, clone);
- if (err)
- goto fail;
- break;
-
- case VHD_BM_READ_PENDING:
- clone.secs = MIN(clone.secs, s->spb - (clone.sec % s->spb));
- err = __vhd_queue_request(s, VHD_OP_DATA_READ, clone);
- if (err)
- goto fail;
- break;
-
- case VHD_BM_BAT_LOCKED:
- default:
- ASSERT(0);
- break;
- }
-
- treq.sec += clone.secs;
- treq.secs -= clone.secs;
- treq.buf += vhd_sectors_to_bytes(clone.secs);
- continue;
-
- fail:
- clone.secs = treq.secs;
- td_complete_request(clone, err);
- break;
- }
-}
-
-static void
-vhd_queue_write(td_driver_t *driver, td_request_t treq)
-{
- struct vhd_state *s = (struct vhd_state *)driver->data;
-
- DBG(TLOG_DBG, "%s: lsec: 0x%08"PRIx64", secs: 0x%04x, (seg: %d)\n",
- s->vhd.file, treq.sec, treq.secs, treq.sidx);
-
- while (treq.secs) {
- int err;
- uint8_t flags;
- td_request_t clone;
-
- err = 0;
- flags = 0;
- clone = treq;
-
- switch (read_bitmap_cache(s, clone.sec, VHD_OP_DATA_WRITE)) {
- case -EINVAL:
- err = -EINVAL;
- goto fail;
-
- case VHD_BM_BAT_LOCKED:
- err = -EBUSY;
- clone.blocked = 1;
- goto fail;
-
- case VHD_BM_BAT_CLEAR:
- flags = (VHD_FLAG_REQ_UPDATE_BAT |
- VHD_FLAG_REQ_UPDATE_BITMAP);
- clone.secs = MIN(clone.secs, s->spb - (clone.sec % s->spb));
- err = schedule_data_write(s, clone, flags);
- if (err)
- goto fail;
- break;
-
- case VHD_BM_BIT_CLEAR:
- flags = VHD_FLAG_REQ_UPDATE_BITMAP;
- clone.secs = read_bitmap_cache_span(s, clone.sec, clone.secs, 0);
- err = schedule_data_write(s, clone, flags);
- if (err)
- goto fail;
- break;
-
- case VHD_BM_BIT_SET:
- clone.secs = read_bitmap_cache_span(s, clone.sec, clone.secs, 1);
- err = schedule_data_write(s, clone, 0);
- if (err)
- goto fail;
- break;
-
- case VHD_BM_NOT_CACHED:
- clone.secs = MIN(clone.secs, s->spb - (clone.sec % s->spb));
- err = schedule_bitmap_read(s, clone.sec / s->spb);
- if (err)
- goto fail;
-
- err = __vhd_queue_request(s, VHD_OP_DATA_WRITE, clone);
- if (err)
- goto fail;
- break;
-
- case VHD_BM_READ_PENDING:
- clone.secs = MIN(clone.secs, s->spb - (clone.sec % s->spb));
- err = __vhd_queue_request(s, VHD_OP_DATA_WRITE, clone);
- if (err)
- goto fail;
- break;
-
- default:
- ASSERT(0);
- break;
- }
-
- treq.sec += clone.secs;
- treq.secs -= clone.secs;
- treq.buf += vhd_sectors_to_bytes(clone.secs);
- continue;
-
- fail:
- clone.secs = treq.secs;
- td_complete_request(clone, err);
- break;
- }
-}
-
-static inline void
-signal_completion(struct vhd_request *list, int error)
-{
- struct vhd_state *s;
- struct vhd_request *r, *next;
-
- if (!list)
- return;
-
- r = list;
- s = list->state;
-
- while (r) {
- int err;
-
- err = (error ? error : r->error);
- next = r->next;
- td_complete_request(r->treq, err);
- DBG(TLOG_DBG, "lsec: 0x%08"PRIx64", blk: 0x%04"PRIx64", "
- "err: %d\n", r->treq.sec, r->treq.sec / s->spb, err);
- free_vhd_request(s, r);
- r = next;
-
- s->returned++;
- TRACE(s);
- }
-}
-
-static void
-start_new_bitmap_transaction(struct vhd_state *s, struct vhd_bitmap *bm)
-{
- int i, error = 0;
- struct vhd_transaction *tx;
- struct vhd_request *r, *next;
-
- if (!bm->queue.head)
- return;
-
- DBG(TLOG_DBG, "blk: 0x%04x\n", bm->blk);
-
- r = bm->queue.head;
- tx = &bm->tx;
- clear_req_list(&bm->queue);
-
- if (r && bat_entry(s, bm->blk) == DD_BLK_UNUSED)
- tx->error = -EIO;
-
- while (r) {
- next = r->next;
- r->next = NULL;
- clear_vhd_flag(r->flags, VHD_FLAG_REQ_QUEUED);
-
- add_to_transaction(tx, r);
- if (test_vhd_flag(r->flags, VHD_FLAG_REQ_FINISHED)) {
- tx->finished++;
- if (!r->error) {
- u32 sec = r->treq.sec % s->spb;
- for (i = 0; i < r->treq.secs; i++)
- vhd_bitmap_set(&s->vhd,
- bm->shadow, sec + i);
- }
- }
- r = next;
- }
-
- /* perhaps all the queued writes already completed? */
- if (tx->started && transaction_completed(tx))
- finish_data_transaction(s, bm);
-}
-
-static void
-finish_bat_transaction(struct vhd_state *s, struct vhd_bitmap *bm)
-{
- struct vhd_transaction *tx = &bm->tx;
-
- if (!bat_locked(s))
- return;
-
- if (s->bat.pbw_blk != bm->blk)
- return;
-
- if (!s->bat.req.error)
- goto release;
-
- if (!test_vhd_flag(tx->status, VHD_FLAG_TX_LIVE))
- goto release;
-
- tx->closed = 1;
- return;
-
- release:
- DBG(TLOG_DBG, "blk: 0x%04x\n", bm->blk);
- unlock_bat(s);
- init_bat(s);
-}
-
-static void
-finish_bitmap_transaction(struct vhd_state *s,
- struct vhd_bitmap *bm, int error)
-{
- int map_size;
- struct vhd_transaction *tx = &bm->tx;
-
- DBG(TLOG_DBG, "blk: 0x%04x, err: %d\n", bm->blk, error);
- tx->error = (tx->error ? tx->error : error);
- map_size = vhd_sectors_to_bytes(s->bm_secs);
-
- if (!test_vhd_flag(s->flags, VHD_FLAG_OPEN_PREALLOCATE)) {
- if (test_vhd_flag(tx->status, VHD_FLAG_TX_UPDATE_BAT)) {
- /* still waiting for bat write */
- ASSERT(bm->blk == s->bat.pbw_blk);
- ASSERT(test_vhd_flag(s->bat.status,
- VHD_FLAG_BAT_WRITE_STARTED));
- s->bat.req.tx = tx;
- return;
- }
- }
-
- if (tx->error) {
- /* undo changes to shadow */
- memcpy(bm->shadow, bm->map, map_size);
- } else {
- /* complete atomic write */
- memcpy(bm->map, bm->shadow, map_size);
- if (!test_batmap(s, bm->blk) && bitmap_full(s, bm))
- set_batmap(s, bm->blk);
- }
-
- /* transaction done; signal completions */
- signal_completion(tx->requests.head, tx->error);
- init_tx(tx);
- start_new_bitmap_transaction(s, bm);
-
- if (!bitmap_in_use(bm))
- unlock_bitmap(bm);
-
- finish_bat_transaction(s, bm);
-}
-
-static void
-finish_data_transaction(struct vhd_state *s, struct vhd_bitmap *bm)
-{
- struct vhd_transaction *tx = &bm->tx;
-
- DBG(TLOG_DBG, "blk: 0x%04x\n", bm->blk);
-
- tx->closed = 1;
-
- if (!tx->error)
- return schedule_bitmap_write(s, bm->blk);
-
- return finish_bitmap_transaction(s, bm, 0);
-}
-
-static void
-finish_bat_write(struct vhd_request *req)
-{
- struct vhd_bitmap *bm;
- struct vhd_transaction *tx;
- struct vhd_state *s = req->state;
-
- s->returned++;
- TRACE(s);
-
- bm = get_bitmap(s, s->bat.pbw_blk);
-
- DBG(TLOG_DBG, "blk 0x%04x, pbwo: 0x%08"PRIx64", err %d\n",
- s->bat.pbw_blk, s->bat.pbw_offset, req->error);
- ASSERT(bm && bitmap_valid(bm));
- ASSERT(bat_locked(s) &&
- test_vhd_flag(s->bat.status, VHD_FLAG_BAT_WRITE_STARTED));
-
- tx = &bm->tx;
- ASSERT(test_vhd_flag(tx->status, VHD_FLAG_TX_LIVE));
-
- if (!req->error) {
- bat_entry(s, s->bat.pbw_blk) = s->bat.pbw_offset;
- s->next_db = s->bat.pbw_offset + s->spb + s->bm_secs;
- } else
- tx->error = req->error;
-
- if (test_vhd_flag(s->flags, VHD_FLAG_OPEN_PREALLOCATE)) {
- tx->finished++;
- remove_from_req_list(&tx->requests, req);
- if (transaction_completed(tx))
- finish_data_transaction(s, bm);
- } else {
- clear_vhd_flag(tx->status, VHD_FLAG_TX_UPDATE_BAT);
- if (s->bat.req.tx)
- finish_bitmap_transaction(s, bm, req->error);
- }
-
- finish_bat_transaction(s, bm);
-}
-
-static void
-finish_zero_bm_write(struct vhd_request *req)
-{
- u32 blk;
- struct vhd_bitmap *bm;
- struct vhd_transaction *tx = req->tx;
- struct vhd_state *s = req->state;
-
- s->returned++;
- TRACE(s);
-
- blk = req->treq.sec / s->spb;
- bm = get_bitmap(s, blk);
-
- DBG(TLOG_DBG, "blk: 0x%04x\n", blk);
- ASSERT(bat_locked(s));
- ASSERT(s->bat.pbw_blk == blk);
- ASSERT(bm && bitmap_valid(bm) && bitmap_locked(bm));
-
- tx->finished++;
- remove_from_req_list(&tx->requests, req);
-
- if (req->error) {
- unlock_bat(s);
- init_bat(s);
- tx->error = req->error;
- clear_vhd_flag(tx->status, VHD_FLAG_TX_UPDATE_BAT);
- } else
- schedule_bat_write(s);
-
- if (transaction_completed(tx))
- finish_data_transaction(s, bm);
-}
-
-static void
-finish_bitmap_read(struct vhd_request *req)
-{
- u32 blk;
- struct vhd_bitmap *bm;
- struct vhd_request *r, *next;
- struct vhd_state *s = req->state;
-
- s->returned++;
- TRACE(s);
-
- blk = req->treq.sec / s->spb;
- bm = get_bitmap(s, blk);
-
- DBG(TLOG_DBG, "blk: 0x%04x\n", blk);
- ASSERT(bm && test_vhd_flag(bm->status, VHD_FLAG_BM_READ_PENDING));
-
- r = bm->waiting.head;
- clear_req_list(&bm->waiting);
- clear_vhd_flag(bm->status, VHD_FLAG_BM_READ_PENDING);
-
- if (!req->error) {
- memcpy(bm->shadow, bm->map, vhd_sectors_to_bytes(s->bm_secs));
-
- while (r) {
- struct vhd_request tmp;
-
- tmp = *r;
- next = r->next;
- free_vhd_request(s, r);
-
- ASSERT(tmp.op == VHD_OP_DATA_READ ||
- tmp.op == VHD_OP_DATA_WRITE);
-
- if (tmp.op == VHD_OP_DATA_READ)
- vhd_queue_read(s->driver, tmp.treq);
- else if (tmp.op == VHD_OP_DATA_WRITE)
- vhd_queue_write(s->driver, tmp.treq);
-
- r = next;
- }
- } else {
- int err = req->error;
- unlock_bitmap(bm);
- free_vhd_bitmap(s, bm);
- return signal_completion(r, err);
- }
-
- if (!bitmap_in_use(bm))
- unlock_bitmap(bm);
-}
-
-static void
-finish_bitmap_write(struct vhd_request *req)
-{
- u32 blk;
- struct vhd_bitmap *bm;
- struct vhd_transaction *tx;
- struct vhd_state *s = req->state;
-
- s->returned++;
- TRACE(s);
-
- blk = req->treq.sec / s->spb;
- bm = get_bitmap(s, blk);
- tx = &bm->tx;
-
- DBG(TLOG_DBG, "blk: 0x%04x, started: %d, finished: %d\n",
- blk, tx->started, tx->finished);
- ASSERT(tx->closed);
- ASSERT(bm && bitmap_valid(bm));
- ASSERT(test_vhd_flag(bm->status, VHD_FLAG_BM_WRITE_PENDING));
-
- clear_vhd_flag(bm->status, VHD_FLAG_BM_WRITE_PENDING);
-
- finish_bitmap_transaction(s, bm, req->error);
-}
-
-static void
-finish_data_read(struct vhd_request *req)
-{
- struct vhd_state *s = req->state;
-
- DBG(TLOG_DBG, "lsec 0x%08"PRIx64", blk: 0x%04"PRIx64"\n",
- req->treq.sec, req->treq.sec / s->spb);
- signal_completion(req, 0);
-}
-
-static void
-finish_data_write(struct vhd_request *req)
-{
- int i;
- struct vhd_transaction *tx = req->tx;
- struct vhd_state *s = (struct vhd_state *)req->state;
-
- set_vhd_flag(req->flags, VHD_FLAG_REQ_FINISHED);
-
- if (tx) {
- u32 blk, sec;
- struct vhd_bitmap *bm;
-
- blk = req->treq.sec / s->spb;
- sec = req->treq.sec % s->spb;
- bm = get_bitmap(s, blk);
-
- ASSERT(bm && bitmap_valid(bm) && bitmap_locked(bm));
-
- tx->finished++;
-
- DBG(TLOG_DBG, "lsec: 0x%08"PRIx64", blk: 0x04%"PRIx64", "
- "tx->started: %d, tx->finished: %d\n", req->treq.sec,
- req->treq.sec / s->spb, tx->started, tx->finished);
-
- if (!req->error)
- for (i = 0; i < req->treq.secs; i++)
- vhd_bitmap_set(&s->vhd, bm->shadow, sec + i);
-
- if (transaction_completed(tx))
- finish_data_transaction(s, bm);
-
- } else if (!test_vhd_flag(req->flags, VHD_FLAG_REQ_QUEUED)) {
- ASSERT(!req->next);
- DBG(TLOG_DBG, "lsec: 0x%08"PRIx64", blk: 0x%04"PRIx64"\n",
- req->treq.sec, req->treq.sec / s->spb);
- signal_completion(req, 0);
- }
-}
-
-void
-vhd_complete(void *arg, struct tiocb *tiocb, int err)
-{
- struct vhd_request *req = (struct vhd_request *)arg;
- struct vhd_state *s = req->state;
- struct iocb *io = &tiocb->iocb;
-
- s->completed++;
- TRACE(s);
-
- req->error = err;
-
- if (req->error)
- ERR(req->error, "%s: op: %u, lsec: %"PRIu64", secs: %u, "
- "nbytes: %lu, blk: %"PRIu64", blk_offset: %u",
- s->vhd.file, req->op, req->treq.sec, req->treq.secs,
- io->u.c.nbytes, req->treq.sec / s->spb,
- bat_entry(s, req->treq.sec / s->spb));
-
- switch (req->op) {
- case VHD_OP_DATA_READ:
- finish_data_read(req);
- break;
-
- case VHD_OP_DATA_WRITE:
- finish_data_write(req);
- break;
-
- case VHD_OP_BITMAP_READ:
- finish_bitmap_read(req);
- break;
-
- case VHD_OP_BITMAP_WRITE:
- finish_bitmap_write(req);
- break;
-
- case VHD_OP_ZERO_BM_WRITE:
- finish_zero_bm_write(req);
- break;
-
- case VHD_OP_BAT_WRITE:
- finish_bat_write(req);
- break;
-
- default:
- ASSERT(0);
- break;
- }
-}
-
-void
-vhd_debug(td_driver_t *driver)
-{
- int i;
- struct vhd_state *s = (struct vhd_state *)driver->data;
-
- DBG(TLOG_WARN, "%s: QUEUED: 0x%08"PRIx64", COMPLETED: 0x%08"PRIx64", "
- "RETURNED: 0x%08"PRIx64"\n", s->vhd.file, s->queued, s->completed,
- s->returned);
- DBG(TLOG_WARN, "WRITES: 0x%08"PRIx64", AVG_WRITE_SIZE: %f\n",
- s->writes, (s->writes ? ((float)s->write_size / s->writes) : 0.0));
- DBG(TLOG_WARN, "READS: 0x%08"PRIx64", AVG_READ_SIZE: %f\n",
- s->reads, (s->reads ? ((float)s->read_size / s->reads) : 0.0));
-
- DBG(TLOG_WARN, "ALLOCATED REQUESTS: (%lu total)\n", VHD_REQS_DATA);
- for (i = 0; i < VHD_REQS_DATA; i++) {
- struct vhd_request *r = &s->vreq_list[i];
- td_request_t *t = &r->treq;
- if (t->secs)
- DBG(TLOG_WARN, "%d: id: 0x%04"PRIx64", err: %d, op: %d,"
- " lsec: 0x%08"PRIx64", flags: %d, this: %p, "
- "next: %p, tx: %p\n", i, t->id, r->error, r->op,
- t->sec, r->flags, r, r->next, r->tx);
- }
-
- DBG(TLOG_WARN, "BITMAP CACHE:\n");
- for (i = 0; i < VHD_CACHE_SIZE; i++) {
- int qnum = 0, wnum = 0, rnum = 0;
- struct vhd_bitmap *bm = s->bitmap[i];
- struct vhd_transaction *tx;
- struct vhd_request *r;
-
- if (!bm)
- continue;
-
- tx = &bm->tx;
- r = bm->queue.head;
- while (r) {
- qnum++;
- r = r->next;
- }
-
- r = bm->waiting.head;
- while (r) {
- wnum++;
- r = r->next;
- }
-
- r = tx->requests.head;
- while (r) {
- rnum++;
- r = r->next;
- }
-
- DBG(TLOG_WARN, "%d: blk: 0x%04x, status: 0x%08x, q: %p, qnum: %d, w: %p, "
- "wnum: %d, locked: %d, in use: %d, tx: %p, tx_error: %d, "
- "started: %d, finished: %d, status: %u, reqs: %p, nreqs: %d\n",
- i, bm->blk, bm->status, bm->queue.head, qnum, bm->waiting.head,
- wnum, bitmap_locked(bm), bitmap_in_use(bm), tx, tx->error,
- tx->started, tx->finished, tx->status, tx->requests.head, rnum);
- }
-
- DBG(TLOG_WARN, "BAT: status: 0x%08x, pbw_blk: 0x%04x, "
- "pbw_off: 0x%08"PRIx64", tx: %p\n", s->bat.status, s->bat.pbw_blk,
- s->bat.pbw_offset, s->bat.req.tx);
-
-/*
- for (i = 0; i < s->hdr.max_bat_size; i++)
- DPRINTF("%d: %u\n", i, s->bat.bat[i]);
-*/
-}
-
-struct tap_disk tapdisk_vhd = {
- .disk_type = "tapdisk_vhd",
- .flags = 0,
- .private_data_size = sizeof(struct vhd_state),
- .td_open = _vhd_open,
- .td_close = _vhd_close,
- .td_queue_read = vhd_queue_read,
- .td_queue_write = vhd_queue_write,
- .td_get_parent_id = vhd_get_parent_id,
- .td_validate_parent = vhd_validate_parent,
- .td_debug = vhd_debug,
-};
+++ /dev/null
-#ifndef BSWAP_H
-#define BSWAP_H
-
-//#include "config-host.h"
-
-#include <inttypes.h>
-
-#if defined(__NetBSD__)
-#include <sys/endian.h>
-#include <sys/types.h>
-#elif defined(__OpenBSD__)
-#include <machine/endian.h>
-#define bswap_16(x) swap16(x)
-#define bswap_32(x) swap32(x)
-#define bswap_64(x) swap64(x)
-#elif defined(__linux__)
-
-#include <endian.h>
-#include <byteswap.h>
-
-static inline uint16_t bswap16(uint16_t x)
-{
- return bswap_16(x);
-}
-
-static inline uint32_t bswap32(uint32_t x)
-{
- return bswap_32(x);
-}
-
-static inline uint64_t bswap64(uint64_t x)
-{
- return bswap_64(x);
-}
-
-static inline void bswap16s(uint16_t *s)
-{
- *s = bswap16(*s);
-}
-
-static inline void bswap32s(uint32_t *s)
-{
- *s = bswap32(*s);
-}
-
-static inline void bswap64s(uint64_t *s)
-{
- *s = bswap64(*s);
-}
-
-#endif
-
-#if defined(WORDS_BIGENDIAN)
-#define be_bswap(v, size) (v)
-#define le_bswap(v, size) bswap ## size(v)
-#define be_bswaps(v, size)
-#define le_bswaps(p, size) *p = bswap ## size(*p);
-#else
-#define le_bswap(v, size) (v)
-#define be_bswap(v, size) bswap ## size(v)
-#define le_bswaps(v, size)
-#define be_bswaps(p, size) *p = bswap ## size(*p);
-#endif
-
-#define CPU_CONVERT(endian, size, type)\
-static inline type endian ## size ## _to_cpu(type v)\
-{\
- return endian ## _bswap(v, size);\
-}\
-\
-static inline type cpu_to_ ## endian ## size(type v)\
-{\
- return endian ## _bswap(v, size);\
-}\
-\
-static inline void endian ## size ## _to_cpus(type *p)\
-{\
- endian ## _bswaps(p, size)\
-}\
-\
-static inline void cpu_to_ ## endian ## size ## s(type *p)\
-{\
- endian ## _bswaps(p, size)\
-}\
-\
-static inline type endian ## size ## _to_cpup(const type *p)\
-{\
- return endian ## size ## _to_cpu(*p);\
-}\
-\
-static inline void cpu_to_ ## endian ## size ## w(type *p, type v)\
-{\
- *p = cpu_to_ ## endian ## size(v);\
-}
-
-CPU_CONVERT(be, 16, uint16_t)
-CPU_CONVERT(be, 32, uint32_t)
-CPU_CONVERT(be, 64, uint64_t)
-
-CPU_CONVERT(le, 16, uint16_t)
-CPU_CONVERT(le, 32, uint32_t)
-CPU_CONVERT(le, 64, uint64_t)
-
-/* unaligned versions (optimized for frequent unaligned accesses)*/
-
-#if defined(__i386__) || defined(__powerpc__)
-
-#define cpu_to_le16wu(p, v) cpu_to_le16w(p, v)
-#define cpu_to_le32wu(p, v) cpu_to_le32w(p, v)
-#define le16_to_cpupu(p) le16_to_cpup(p)
-#define le32_to_cpupu(p) le32_to_cpup(p)
-
-#define cpu_to_be16wu(p, v) cpu_to_be16w(p, v)
-#define cpu_to_be32wu(p, v) cpu_to_be32w(p, v)
-
-#else
-
-static inline void cpu_to_le16wu(uint16_t *p, uint16_t v)
-{
- uint8_t *p1 = (uint8_t *)p;
-
- p1[0] = v;
- p1[1] = v >> 8;
-}
-
-static inline void cpu_to_le32wu(uint32_t *p, uint32_t v)
-{
- uint8_t *p1 = (uint8_t *)p;
-
- p1[0] = v;
- p1[1] = v >> 8;
- p1[2] = v >> 16;
- p1[3] = v >> 24;
-}
-
-static inline uint16_t le16_to_cpupu(const uint16_t *p)
-{
- const uint8_t *p1 = (const uint8_t *)p;
- return p1[0] | (p1[1] << 8);
-}
-
-static inline uint32_t le32_to_cpupu(const uint32_t *p)
-{
- const uint8_t *p1 = (const uint8_t *)p;
- return p1[0] | (p1[1] << 8) | (p1[2] << 16) | (p1[3] << 24);
-}
-
-static inline void cpu_to_be16wu(uint16_t *p, uint16_t v)
-{
- uint8_t *p1 = (uint8_t *)p;
-
- p1[0] = v >> 8;
- p1[1] = v;
-}
-
-static inline void cpu_to_be32wu(uint32_t *p, uint32_t v)
-{
- uint8_t *p1 = (uint8_t *)p;
-
- p1[0] = v >> 24;
- p1[1] = v >> 16;
- p1[2] = v >> 8;
- p1[3] = v;
-}
-
-#endif
-
-#ifdef WORDS_BIGENDIAN
-#define cpu_to_32wu cpu_to_be32wu
-#else
-#define cpu_to_32wu cpu_to_le32wu
-#endif
-
-#undef le_bswap
-#undef be_bswap
-#undef le_bswaps
-#undef be_bswaps
-
-#endif /* BSWAP_H */
+++ /dev/null
-#!/bin/sh
-
-cat > .gcrypt.c << EOF
-#include <gcrypt.h>
-int main(void)
-{
- gcry_md_hash_buffer(GCRY_MD_MD5, NULL, NULL, 0);
- return 0;
-}
-EOF
-
-if $1 -o .gcrypt .gcrypt.c -lgcrypt 2>/dev/null ; then
- echo "yes"
-else
- echo "no"
-fi
-
-rm -f .gcrypt*
+++ /dev/null
-/* Copyright (C) 2004 Christopher Clark <firstname.lastname@cl.cam.ac.uk> */
-
-/*
- * There are duplicates of this code in:
- * - tools/xenstore/hashtable.c
- */
-
-#include "hashtable.h"
-#include "hashtable_private.h"
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <math.h>
-
-/*
-Credit for primes table: Aaron Krowne
- http://br.endernet.org/~akrowne/
- http://planetmath.org/encyclopedia/GoodHashTablePrimes.html
-*/
-static const unsigned int primes[] = {
- 53, 97, 193, 389,
- 769, 1543, 3079, 6151,
- 12289, 24593, 49157, 98317,
- 196613, 393241, 786433, 1572869,
- 3145739, 6291469, 12582917, 25165843,
- 50331653, 100663319, 201326611, 402653189,
- 805306457, 1610612741
-};
-const unsigned int prime_table_length = sizeof(primes)/sizeof(primes[0]);
-const float max_load_factor = 0.65;
-
-/*****************************************************************************/
-struct hashtable *
-create_hashtable(unsigned int minsize,
- unsigned int (*hashf) (void*),
- int (*eqf) (void*,void*))
-{
- struct hashtable *h;
- unsigned int pindex, size = primes[0];
- /* Check requested hashtable isn't too large */
- if (minsize > (1u << 30)) return NULL;
- /* Enforce size as prime */
- for (pindex=0; pindex < prime_table_length; pindex++) {
- if (primes[pindex] > minsize) { size = primes[pindex]; break; }
- }
- h = (struct hashtable *)malloc(sizeof(struct hashtable));
- if (NULL == h) return NULL; /*oom*/
- h->table = (struct entry **)malloc(sizeof(struct entry*) * size);
- if (NULL == h->table) { free(h); return NULL; } /*oom*/
- memset(h->table, 0, size * sizeof(struct entry *));
- h->tablelength = size;
- h->primeindex = pindex;
- h->entrycount = 0;
- h->hashfn = hashf;
- h->eqfn = eqf;
- h->loadlimit = (unsigned int) ceil(size * max_load_factor);
- return h;
-}
-
-/*****************************************************************************/
-unsigned int
-hash(struct hashtable *h, void *k)
-{
- /* Aim to protect against poor hash functions by adding logic here
- * - logic taken from java 1.4 hashtable source */
- unsigned int i = h->hashfn(k);
- i += ~(i << 9);
- i ^= ((i >> 14) | (i << 18)); /* >>> */
- i += (i << 4);
- i ^= ((i >> 10) | (i << 22)); /* >>> */
- return i;
-}
-
-/*****************************************************************************/
-static int
-hashtable_expand(struct hashtable *h)
-{
- /* Double the size of the table to accomodate more entries */
- struct entry **newtable;
- struct entry *e;
- struct entry **pE;
- unsigned int newsize, i, index;
- /* Check we're not hitting max capacity */
- if (h->primeindex == (prime_table_length - 1)) return 0;
- newsize = primes[++(h->primeindex)];
-
- newtable = (struct entry **)malloc(sizeof(struct entry*) * newsize);
- if (NULL != newtable)
- {
- memset(newtable, 0, newsize * sizeof(struct entry *));
- /* This algorithm is not 'stable'. ie. it reverses the list
- * when it transfers entries between the tables */
- for (i = 0; i < h->tablelength; i++) {
- while (NULL != (e = h->table[i])) {
- h->table[i] = e->next;
- index = indexFor(newsize,e->h);
- e->next = newtable[index];
- newtable[index] = e;
- }
- }
- free(h->table);
- h->table = newtable;
- }
- /* Plan B: realloc instead */
- else
- {
- newtable = (struct entry **)
- realloc(h->table, newsize * sizeof(struct entry *));
- if (NULL == newtable) { (h->primeindex)--; return 0; }
- h->table = newtable;
- memset(newtable[h->tablelength], 0, newsize - h->tablelength);
- for (i = 0; i < h->tablelength; i++) {
- for (pE = &(newtable[i]), e = *pE; e != NULL; e = *pE) {
- index = indexFor(newsize,e->h);
- if (index == i)
- {
- pE = &(e->next);
- }
- else
- {
- *pE = e->next;
- e->next = newtable[index];
- newtable[index] = e;
- }
- }
- }
- }
- h->tablelength = newsize;
- h->loadlimit = (unsigned int) ceil(newsize * max_load_factor);
- return -1;
-}
-
-/*****************************************************************************/
-unsigned int
-hashtable_count(struct hashtable *h)
-{
- return h->entrycount;
-}
-
-/*****************************************************************************/
-int
-hashtable_insert(struct hashtable *h, void *k, void *v)
-{
- /* This method allows duplicate keys - but they shouldn't be used */
- unsigned int index;
- struct entry *e;
- if (++(h->entrycount) > h->loadlimit)
- {
- /* Ignore the return value. If expand fails, we should
- * still try cramming just this value into the existing table
- * -- we may not have memory for a larger table, but one more
- * element may be ok. Next time we insert, we'll try expanding again.*/
- hashtable_expand(h);
- }
- e = (struct entry *)malloc(sizeof(struct entry));
- if (NULL == e) { --(h->entrycount); return 0; } /*oom*/
- e->h = hash(h,k);
- index = indexFor(h->tablelength,e->h);
- e->k = k;
- e->v = v;
- e->next = h->table[index];
- h->table[index] = e;
- return -1;
-}
-
-/*****************************************************************************/
-void * /* returns value associated with key */
-hashtable_search(struct hashtable *h, void *k)
-{
- struct entry *e;
- unsigned int hashvalue, index;
- hashvalue = hash(h,k);
- index = indexFor(h->tablelength,hashvalue);
- e = h->table[index];
- while (NULL != e)
- {
- /* Check hash value to short circuit heavier comparison */
- if ((hashvalue == e->h) && (h->eqfn(k, e->k))) return e->v;
- e = e->next;
- }
- return NULL;
-}
-
-/*****************************************************************************/
-void * /* returns value associated with key */
-hashtable_remove(struct hashtable *h, void *k)
-{
- /* TODO: consider compacting the table when the load factor drops enough,
- * or provide a 'compact' method. */
-
- struct entry *e;
- struct entry **pE;
- void *v;
- unsigned int hashvalue, index;
-
- hashvalue = hash(h,k);
- index = indexFor(h->tablelength,hash(h,k));
- pE = &(h->table[index]);
- e = *pE;
- while (NULL != e)
- {
- /* Check hash value to short circuit heavier comparison */
- if ((hashvalue == e->h) && (h->eqfn(k, e->k)))
- {
- *pE = e->next;
- h->entrycount--;
- v = e->v;
- freekey(e->k);
- free(e);
- return v;
- }
- pE = &(e->next);
- e = e->next;
- }
- return NULL;
-}
-
-/*****************************************************************************/
-/* destroy */
-void
-hashtable_destroy(struct hashtable *h, int free_values)
-{
- unsigned int i;
- struct entry *e, *f;
- struct entry **table = h->table;
- if (free_values)
- {
- for (i = 0; i < h->tablelength; i++)
- {
- e = table[i];
- while (NULL != e)
- { f = e; e = e->next; freekey(f->k); free(f->v); free(f); }
- }
- }
- else
- {
- for (i = 0; i < h->tablelength; i++)
- {
- e = table[i];
- while (NULL != e)
- { f = e; e = e->next; freekey(f->k); free(f); }
- }
- }
- free(h->table);
- free(h);
-}
-
-/*
- * Copyright (c) 2002, Christopher Clark
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *
- * * Neither the name of the original author; nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
+++ /dev/null
-/* Copyright (C) 2002 Christopher Clark <firstname.lastname@cl.cam.ac.uk> */
-
-/*
- * There are duplicates of this code in:
- * - tools/xenstore/hashtable.h
- */
-
-#ifndef __HASHTABLE_CWC22_H__
-#define __HASHTABLE_CWC22_H__
-
-struct hashtable;
-
-/* Example of use:
- *
- * struct hashtable *h;
- * struct some_key *k;
- * struct some_value *v;
- *
- * static unsigned int hash_from_key_fn( void *k );
- * static int keys_equal_fn ( void *key1, void *key2 );
- *
- * h = create_hashtable(16, hash_from_key_fn, keys_equal_fn);
- * k = (struct some_key *) malloc(sizeof(struct some_key));
- * v = (struct some_value *) malloc(sizeof(struct some_value));
- *
- * (initialise k and v to suitable values)
- *
- * if (! hashtable_insert(h,k,v) )
- * { exit(-1); }
- *
- * if (NULL == (found = hashtable_search(h,k) ))
- * { printf("not found!"); }
- *
- * if (NULL == (found = hashtable_remove(h,k) ))
- * { printf("Not found\n"); }
- *
- */
-
-/* Macros may be used to define type-safe(r) hashtable access functions, with
- * methods specialized to take known key and value types as parameters.
- *
- * Example:
- *
- * Insert this at the start of your file:
- *
- * DEFINE_HASHTABLE_INSERT(insert_some, struct some_key, struct some_value);
- * DEFINE_HASHTABLE_SEARCH(search_some, struct some_key, struct some_value);
- * DEFINE_HASHTABLE_REMOVE(remove_some, struct some_key, struct some_value);
- *
- * This defines the functions 'insert_some', 'search_some' and 'remove_some'.
- * These operate just like hashtable_insert etc., with the same parameters,
- * but their function signatures have 'struct some_key *' rather than
- * 'void *', and hence can generate compile time errors if your program is
- * supplying incorrect data as a key (and similarly for value).
- *
- * Note that the hash and key equality functions passed to create_hashtable
- * still take 'void *' parameters instead of 'some key *'. This shouldn't be
- * a difficult issue as they're only defined and passed once, and the other
- * functions will ensure that only valid keys are supplied to them.
- *
- * The cost for this checking is increased code size and runtime overhead
- * - if performance is important, it may be worth switching back to the
- * unsafe methods once your program has been debugged with the safe methods.
- * This just requires switching to some simple alternative defines - eg:
- * #define insert_some hashtable_insert
- *
- */
-
-/*****************************************************************************
- * create_hashtable
-
- * @name create_hashtable
- * @param minsize minimum initial size of hashtable
- * @param hashfunction function for hashing keys
- * @param key_eq_fn function for determining key equality
- * @return newly created hashtable or NULL on failure
- */
-
-struct hashtable *
-create_hashtable(unsigned int minsize,
- unsigned int (*hashfunction) (void*),
- int (*key_eq_fn) (void*,void*));
-
-/*****************************************************************************
- * hashtable_insert
-
- * @name hashtable_insert
- * @param h the hashtable to insert into
- * @param k the key - hashtable claims ownership and will free on removal
- * @param v the value - does not claim ownership
- * @return non-zero for successful insertion
- *
- * This function will cause the table to expand if the insertion would take
- * the ratio of entries to table size over the maximum load factor.
- *
- * This function does not check for repeated insertions with a duplicate key.
- * The value returned when using a duplicate key is undefined -- when
- * the hashtable changes size, the order of retrieval of duplicate key
- * entries is reversed.
- * If in doubt, remove before insert.
- */
-
-int
-hashtable_insert(struct hashtable *h, void *k, void *v);
-
-#define DEFINE_HASHTABLE_INSERT(fnname, keytype, valuetype) \
-int fnname (struct hashtable *h, keytype *k, valuetype *v) \
-{ \
- return hashtable_insert(h,k,v); \
-}
-
-/*****************************************************************************
- * hashtable_search
-
- * @name hashtable_search
- * @param h the hashtable to search
- * @param k the key to search for - does not claim ownership
- * @return the value associated with the key, or NULL if none found
- */
-
-void *
-hashtable_search(struct hashtable *h, void *k);
-
-#define DEFINE_HASHTABLE_SEARCH(fnname, keytype, valuetype) \
-valuetype * fnname (struct hashtable *h, keytype *k) \
-{ \
- return (valuetype *) (hashtable_search(h,k)); \
-}
-
-/*****************************************************************************
- * hashtable_remove
-
- * @name hashtable_remove
- * @param h the hashtable to remove the item from
- * @param k the key to search for - does not claim ownership
- * @return the value associated with the key, or NULL if none found
- */
-
-void * /* returns value */
-hashtable_remove(struct hashtable *h, void *k);
-
-#define DEFINE_HASHTABLE_REMOVE(fnname, keytype, valuetype) \
-valuetype * fnname (struct hashtable *h, keytype *k) \
-{ \
- return (valuetype *) (hashtable_remove(h,k)); \
-}
-
-
-/*****************************************************************************
- * hashtable_count
-
- * @name hashtable_count
- * @param h the hashtable
- * @return the number of items stored in the hashtable
- */
-unsigned int
-hashtable_count(struct hashtable *h);
-
-
-/*****************************************************************************
- * hashtable_destroy
-
- * @name hashtable_destroy
- * @param h the hashtable
- * @param free_values whether to call 'free' on the remaining values
- */
-
-void
-hashtable_destroy(struct hashtable *h, int free_values);
-
-#endif /* __HASHTABLE_CWC22_H__ */
-
-/*
- * Copyright (c) 2002, Christopher Clark
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *
- * * Neither the name of the original author; nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
+++ /dev/null
-/* Copyright (C) 2002, 2004 Christopher Clark <firstname.lastname@cl.cam.ac.uk> */
-
-#include "hashtable.h"
-#include "hashtable_private.h"
-#include "hashtable_itr.h"
-#include <stdlib.h> /* defines NULL */
-
-struct hashtable_itr {
- struct hashtable *h;
- struct entry *e;
- struct entry *parent;
- unsigned int index;
-};
-
-/*****************************************************************************/
-/* hashtable_iterator - iterator constructor */
-
-struct hashtable_itr *
-hashtable_iterator(struct hashtable *h)
-{
- unsigned int i, tablelength;
- struct hashtable_itr *itr = (struct hashtable_itr *)
- malloc(sizeof(struct hashtable_itr));
- if (NULL == itr) return NULL;
- itr->h = h;
- itr->e = NULL;
- itr->parent = NULL;
- tablelength = h->tablelength;
- itr->index = tablelength;
- if (0 == h->entrycount) return itr;
-
- for (i = 0; i < tablelength; i++)
- {
- if (NULL != h->table[i])
- {
- itr->e = h->table[i];
- itr->index = i;
- break;
- }
- }
- return itr;
-}
-
-/*****************************************************************************/
-/* key - return the key of the (key,value) pair at the current position */
-/* value - return the value of the (key,value) pair at the current position */
-
-void *
-hashtable_iterator_key(struct hashtable_itr *i)
-{ return i->e->k; }
-
-void *
-hashtable_iterator_value(struct hashtable_itr *i)
-{ return i->e->v; }
-
-/*****************************************************************************/
-/* advance - advance the iterator to the next element
- * returns zero if advanced to end of table */
-
-int
-hashtable_iterator_advance(struct hashtable_itr *itr)
-{
- unsigned int j,tablelength;
- struct entry **table;
- struct entry *next;
- if (NULL == itr->e) return 0; /* stupidity check */
-
- next = itr->e->next;
- if (NULL != next)
- {
- itr->parent = itr->e;
- itr->e = next;
- return -1;
- }
- tablelength = itr->h->tablelength;
- itr->parent = NULL;
- if (tablelength <= (j = ++(itr->index)))
- {
- itr->e = NULL;
- return 0;
- }
- table = itr->h->table;
- while (NULL == (next = table[j]))
- {
- if (++j >= tablelength)
- {
- itr->index = tablelength;
- itr->e = NULL;
- return 0;
- }
- }
- itr->index = j;
- itr->e = next;
- return -1;
-}
-
-/*****************************************************************************/
-/* remove - remove the entry at the current iterator position
- * and advance the iterator, if there is a successive
- * element.
- * If you want the value, read it before you remove:
- * beware memory leaks if you don't.
- * Returns zero if end of iteration. */
-
-int
-hashtable_iterator_remove(struct hashtable_itr *itr)
-{
- struct entry *remember_e, *remember_parent;
- int ret;
-
- /* Do the removal */
- if (NULL == (itr->parent))
- {
- /* element is head of a chain */
- itr->h->table[itr->index] = itr->e->next;
- } else {
- /* element is mid-chain */
- itr->parent->next = itr->e->next;
- }
- /* itr->e is now outside the hashtable */
- remember_e = itr->e;
- itr->h->entrycount--;
- freekey(remember_e->k);
-
- /* Advance the iterator, correcting the parent */
- remember_parent = itr->parent;
- ret = hashtable_iterator_advance(itr);
- if (itr->parent == remember_e) { itr->parent = remember_parent; }
- free(remember_e);
- return ret;
-}
-
-/*****************************************************************************/
-int /* returns zero if not found */
-hashtable_iterator_search(struct hashtable_itr *itr,
- struct hashtable *h, void *k)
-{
- struct entry *e, *parent;
- unsigned int hashvalue, index;
-
- hashvalue = hash(h,k);
- index = indexFor(h->tablelength,hashvalue);
-
- e = h->table[index];
- parent = NULL;
- while (NULL != e)
- {
- /* Check hash value to short circuit heavier comparison */
- if ((hashvalue == e->h) && (h->eqfn(k, e->k)))
- {
- itr->index = index;
- itr->e = e;
- itr->parent = parent;
- itr->h = h;
- return -1;
- }
- parent = e;
- e = e->next;
- }
- return 0;
-}
-
-
-/*
- * Copyright (c) 2002, 2004, Christopher Clark
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *
- * * Neither the name of the original author; nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
+++ /dev/null
-/* Copyright (C) 2002, 2004 Christopher Clark <firstname.lastname@cl.cam.ac.uk> */
-
-#ifndef __HASHTABLE_ITR_CWC22__
-#define __HASHTABLE_ITR_CWC22__
-#include "hashtable.h"
-#include "hashtable_private.h" /* needed to enable inlining */
-
-struct hashtable_itr;
-
-/*****************************************************************************/
-/* hashtable_iterator
- */
-
-struct hashtable_itr *
-hashtable_iterator(struct hashtable *h);
-
-/*****************************************************************************/
-/* hashtable_iterator_key
- * - return the value of the (key,value) pair at the current position */
-
-void *
-hashtable_iterator_key(struct hashtable_itr *i);
-
-/*****************************************************************************/
-/* value - return the value of the (key,value) pair at the current position */
-
-void *
-hashtable_iterator_value(struct hashtable_itr *i);
-
-/*****************************************************************************/
-/* advance - advance the iterator to the next element
- * returns zero if advanced to end of table */
-
-int
-hashtable_iterator_advance(struct hashtable_itr *itr);
-
-/*****************************************************************************/
-/* remove - remove current element and advance the iterator to the next element
- * NB: if you need the value to free it, read it before
- * removing. ie: beware memory leaks!
- * returns zero if advanced to end of table */
-
-int
-hashtable_iterator_remove(struct hashtable_itr *itr);
-
-/*****************************************************************************/
-/* search - overwrite the supplied iterator, to point to the entry
- * matching the supplied key.
- h points to the hashtable to be searched.
- * returns zero if not found. */
-int
-hashtable_iterator_search(struct hashtable_itr *itr,
- struct hashtable *h, void *k);
-
-#define DEFINE_HASHTABLE_ITERATOR_SEARCH(fnname, keytype) \
-int fnname (struct hashtable_itr *i, struct hashtable *h, keytype *k) \
-{ \
- return (hashtable_iterator_search(i,h,k)); \
-}
-
-
-
-#endif /* __HASHTABLE_ITR_CWC22__*/
-
-/*
- * Copyright (c) 2002, 2004, Christopher Clark
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *
- * * Neither the name of the original author; nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
+++ /dev/null
-/* Copyright (C) 2002, 2004 Christopher Clark <firstname.lastname@cl.cam.ac.uk> */
-
-/*
- * There are duplicates of this code in:
- * - tools/xenstore/hashtable_private.h
- */
-
-#ifndef __HASHTABLE_PRIVATE_CWC22_H__
-#define __HASHTABLE_PRIVATE_CWC22_H__
-
-#include "hashtable.h"
-
-/*****************************************************************************/
-struct entry
-{
- void *k, *v;
- unsigned int h;
- struct entry *next;
-};
-
-struct hashtable {
- unsigned int tablelength;
- struct entry **table;
- unsigned int entrycount;
- unsigned int loadlimit;
- unsigned int primeindex;
- unsigned int (*hashfn) (void *k);
- int (*eqfn) (void *k1, void *k2);
-};
-
-/*****************************************************************************/
-unsigned int
-hash(struct hashtable *h, void *k);
-
-/*****************************************************************************/
-/* indexFor */
-static inline unsigned int
-indexFor(unsigned int tablelength, unsigned int hashvalue) {
- return (hashvalue % tablelength);
-};
-
-/* Only works if tablelength == 2^N */
-/*static inline unsigned int
-indexFor(unsigned int tablelength, unsigned int hashvalue)
-{
- return (hashvalue & (tablelength - 1u));
-}
-*/
-
-/*****************************************************************************/
-#define freekey(X) free(X)
-/*define freekey(X) ; */
-
-
-/*****************************************************************************/
-
-#endif /* __HASHTABLE_PRIVATE_CWC22_H__*/
-
-/*
- * Copyright (c) 2002, Christopher Clark
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *
- * * Neither the name of the original author; nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
+++ /dev/null
-/* Copyright (C) 2002 Christopher Clark <firstname.lastname@cl.cam.ac.uk> */
-
-#include "hashtable.h"
-#include "hashtable_private.h"
-#include "hashtable_utility.h"
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-
-/*****************************************************************************/
-/* hashtable_change
- *
- * function to change the value associated with a key, where there already
- * exists a value bound to the key in the hashtable.
- * Source due to Holger Schemel.
- *
- * */
-int
-hashtable_change(struct hashtable *h, void *k, void *v)
-{
- struct entry *e;
- unsigned int hashvalue, index;
- hashvalue = hash(h,k);
- index = indexFor(h->tablelength,hashvalue);
- e = h->table[index];
- while (NULL != e)
- {
- /* Check hash value to short circuit heavier comparison */
- if ((hashvalue == e->h) && (h->eqfn(k, e->k)))
- {
- free(e->v);
- e->v = v;
- return -1;
- }
- e = e->next;
- }
- return 0;
-}
-
-/*
- * Copyright (c) 2002, Christopher Clark
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *
- * * Neither the name of the original author; nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
+++ /dev/null
-/* Copyright (C) 2002 Christopher Clark <firstname.lastname@cl.cam.ac.uk> */
-
-#ifndef __HASHTABLE_CWC22_UTILITY_H__
-#define __HASHTABLE_CWC22_UTILITY_H__
-
-/*****************************************************************************
- * hashtable_change
- *
- * function to change the value associated with a key, where there already
- * exists a value bound to the key in the hashtable.
- * Source due to Holger Schemel.
- *
- * @name hashtable_change
- * @param h the hashtable
- * @param key
- * @param value
- *
- */
-int
-hashtable_change(struct hashtable *h, void *k, void *v);
-
-#endif /* __HASHTABLE_CWC22_H__ */
-
-/*
- * Copyright (c) 2002, Christopher Clark
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *
- * * Neither the name of the original author; nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
+++ /dev/null
-/* img2qcow.c
- *
- * Generates a qcow format disk and fills it from an existing image.
- *
- * (c) 2006 Julian Chesterfield and Andrew Warfield
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License version 2
- * as published by the Free Software Foundation; or, when distributed
- * separately from the Linux kernel or incorporated into other
- * software packages, subject to the following license:
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this source file (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy, modify,
- * merge, publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-
-#include <errno.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <sys/statvfs.h>
-#include <sys/stat.h>
-#include <sys/ioctl.h>
-#include <string.h>
-#include <zlib.h>
-#include <inttypes.h>
-#include <libaio.h>
-
-#include "bswap.h"
-#include "aes.h"
-#include "tapdisk.h"
-#include "tapdisk-server.h"
-#include "tapdisk-driver.h"
-#include "tapdisk-interface.h"
-#include "tapdisk-disktype.h"
-#include "qcow.h"
-#include "blk.h"
-
-
-#if 1
-#define DFPRINTF(_f, _a...) fprintf ( stderr, _f , ## _a )
-#else
-#define DFPRINTF(_f, _a...) ((void)0)
-#endif
-
-/* *BSD has no O_LARGEFILE */
-#ifndef O_LARGEFILE
-#define O_LARGEFILE 0
-#endif
-
-#define BLOCK_PROCESSSZ 4096
-#define QCOW_VBD 0
-#define PROGRESS_QUANT 2
-
-static int running = 1, complete = 0;
-static int returned_events = 0, submit_events = 0;
-static uint32_t read_idx = 0;
-td_driver_t *ddqcow;
-td_vbd_t* qcow_vbd;
-static uint64_t prev = 0, written = 0;
-static char output[(100/PROGRESS_QUANT) + 5];
-
-extern tapdisk_server_t server;
-
-
-static void print_bytes(void *ptr, int length)
-{
- int i,k;
- unsigned char *p = ptr;
-
- DFPRINTF("Buf dump, length %d:\n",length);
- for (k = 0; k < length; k++) {
- DFPRINTF("%x",*p);
- *p++;
- if(k % 16 == 0) DFPRINTF("\n");
- else if(k % 2 == 0) DFPRINTF(" ");
- }
- DFPRINTF("\n");
- return;
-}
-
-static void debug_output(uint64_t progress, uint64_t size)
-{
- //Output progress every PROGRESS_QUANT
- uint64_t blocks = size/(100/PROGRESS_QUANT);
-
- if (progress/blocks > prev) {
- memcpy(output+prev+1,"=>",2);
- prev++;
- DFPRINTF("\r%s %"PRIi64"%%",
- output, (int64_t)((prev-1)*PROGRESS_QUANT));
- }
- return;
-}
-
-static int get_image_info(td_disk_info_t *driver, int fd)
-{
- int ret;
- long size;
- unsigned long total_size;
- struct statvfs statBuf;
- struct stat stat;
- uint64_t sector_size=DEFAULT_SECTOR_SIZE;
-
- ret = fstat(fd, &stat);
- if (ret != 0) {
- DFPRINTF("ERROR: fstat failed, Couldn't stat image");
- return -EINVAL;
- }
-
- if (S_ISBLK(stat.st_mode)) {
- /*Accessing block device directly*/
- if (blk_getimagesize(fd, &driver->size) != 0)
- return -EINVAL;
-
- DFPRINTF("Image size: \n\tpre sector_shift [%"PRIu64"]\n\tpost "
- "sector_shift [%"PRIu64"]\n",
- (uint64_t)(driver->size << SECTOR_SHIFT),
- (uint64_t)driver->size);
-
- /*Get the sector size*/
- if (!blk_getsectorsize(fd, §or_size))
- driver->sector_size = sector_size;
-
- } else {
- /*Local file? try fstat instead*/
- driver->size = (stat.st_size >> SECTOR_SHIFT);
- driver->sector_size = DEFAULT_SECTOR_SIZE;
- DFPRINTF("Image size: [%"PRIu64"]\n",
- (uint64_t)driver->size);
- }
-
- return 0;
-}
-
-void send_responses(td_request_t treq, int err)
-{
- if (err < 0) {
- DFPRINTF("AIO FAILURE: res [%d]!\n",err);
- return;
- }
-
- returned_events++;
-
- free(treq.buf);
-}
-
-int main(int argc, const char *argv[])
-{
- int ret = -1, fd, len, err;
- struct timeval timeout;
- uint64_t i;
- char *buf = NULL;
- td_request_t treq;
- td_disk_info_t info;
- td_vbd_request_t* vreq;
-
- if (argc != 3) {
- fprintf(stderr, "Qcow-utils: v1.0.0\n");
- fprintf(stderr, "usage: %s <QCOW FILENAME> <SRC IMAGE>\n",
- argv[0]);
- exit(-1);
- }
-
-
- /*Open image*/
- fd = open(argv[2], O_RDONLY | O_LARGEFILE);
-
- if (fd == -1) {
- DFPRINTF("Unable to open [%s], (err %d)!\n",argv[2],0 - errno);
- exit(-1);
- }
-
- get_image_info(&info, fd);
-
- /*Create qcow file*/
- ret = qcow_create(argv[1],info.size<<SECTOR_SHIFT,NULL,0);
-
- if (ret < 0) {
- DFPRINTF("Unable to create QCOW file\n");
- exit(-1);
- } else DFPRINTF("Qcow file created: size %"PRIu64" sectors\n",
- (uint64_t)info.size);
-
- /* Open Qcow image*/
- err = tapdisk_server_initialize();
- if( err ) {
- DPRINTF("qcow2raw Couldn't initialize server instance.\n");
- return err;
- }
-
- err=tapdisk_vbd_initialize(QCOW_VBD);
- if( err ) {
- DPRINTF("qcow2raw Couldn't initialize qcow vbd.\n");
- return err;
- }
-
- qcow_vbd = tapdisk_server_get_vbd(QCOW_VBD);
- if (!qcow_vbd) {
- err = -ENODEV;
- DPRINTF("qcow2raw Couldn't create qcow vbd.\n");
- return err;
- }
-
- err = tapdisk_vbd_open_vdi(qcow_vbd, argv[1], DISK_TYPE_QCOW,
- TAPDISK_STORAGE_TYPE_DEFAULT,
- 0);
- if( err ) {
- DPRINTF("qcow2raw Couldn't open qcow file.\n");
- return err;
- }
-
- ddqcow=(tapdisk_vbd_first_image(qcow_vbd))->driver;
-
- /*Initialise the output string*/
- memset(output,0x20,(100/PROGRESS_QUANT)+5);
- output[0] = '[';
- output[(100/PROGRESS_QUANT)+2] = ']';
- output[(100/PROGRESS_QUANT)+3] = '\0';
- DFPRINTF("%s",output);
-
- i = 0;
- while (running) {
-
- if (!complete) {
- /*Read sector from image*/
- if (lseek(fd, i*512, SEEK_SET) == (off_t)-1) {
- DFPRINTF("Unable to access file offset %"PRIu64"\n",
- (uint64_t)i*512);
- exit(-1);
- }
-
- if( (ret = posix_memalign((void **)&buf,
- BLOCK_PROCESSSZ,
- BLOCK_PROCESSSZ)) != 0) {
- DFPRINTF("Unable to read memalign buf (%d)\n",ret);
- exit(-1);
- }
-
- /*We attempt to read 4k sized blocks*/
- len = read(fd, buf, BLOCK_PROCESSSZ);
- if (len < 512) {
- DFPRINTF("Unable to read sector %"PRIu64"\n",
- (uint64_t) (i));
- complete = 1;
- continue;
- }
-
- len = (len >> 9);
-
- treq.op = TD_OP_WRITE;
- treq.buf = buf;
- treq.sec = i;
- treq.secs = len;
- treq.image = 0;
- treq.cb = send_responses;
- treq.cb_data = buf;
- treq.id = 0;
- treq.sidx = 0;
- vreq = calloc(1, sizeof(td_vbd_request_t));
- treq.private = vreq;
-
- vreq->submitting = 1;
- INIT_LIST_HEAD(&vreq->next);
- tapdisk_vbd_move_request(treq.private,
- &qcow_vbd->pending_requests);
-
- ddqcow->ops->td_queue_write(ddqcow,treq);
- --vreq->submitting;
-
- submit_events++;
-
- i += len;
-
- if (i == info.size)
- complete = 1;
-
- tapdisk_submit_all_tiocbs(&server.aio_queue);
- debug_output(i,info.size);
- }
-
- while(returned_events != submit_events) {
- ret = scheduler_wait_for_events(&server.scheduler);
- if (ret < 0) {
- DFPRINTF("server wait returned %d\n", ret);
- sleep(2);
- }
- }
-
- if (complete && (returned_events == submit_events))
- running = 0;
- }
- memcpy(output+prev+1,"=",1);
- DFPRINTF("\r%s 100%%\nTRANSFER COMPLETE\n\n", output);
-
- ddqcow->ops->td_close(ddqcow);
- free(ddqcow->data);
-
- return 0;
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#include <time.h>
-#include <stdio.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <inttypes.h>
-
-#include "io-optimize.h"
-#include "tapdisk-log.h"
-
-#if (!defined(TEST) && defined(DEBUG))
-#define DBG(ctx, f, a...) tlog_write(TLOG_DBG, f, ##a)
-#elif defined(TEST)
-#define DBG(ctx, f, a...) printf(f, ##a)
-#else
-#define DBG(ctx, f, a...) ((void)0)
-#endif
-
-static void print_merged_iocbs(struct opioctx *ctx,
- struct iocb **iocbs, int num_iocbs);
-
-void
-opio_free(struct opioctx *ctx)
-{
- free(ctx->opios);
- ctx->opios = NULL;
-
- free(ctx->free_opios);
- ctx->free_opios = NULL;
-
- free(ctx->iocb_queue);
- ctx->iocb_queue = NULL;
-
- free(ctx->event_queue);
- ctx->event_queue = NULL;
-}
-
-int
-opio_init(struct opioctx *ctx, int num_iocbs)
-{
- int i;
-
- memset(ctx, 0, sizeof(struct opioctx));
-
- ctx->num_opios = num_iocbs;
- ctx->free_opio_cnt = num_iocbs;
- ctx->opios = calloc(1, sizeof(struct opio) * num_iocbs);
- ctx->free_opios = calloc(1, sizeof(struct opio *) * num_iocbs);
- ctx->iocb_queue = calloc(1, sizeof(struct iocb *) * num_iocbs);
- ctx->event_queue = calloc(1, sizeof(struct io_event) * num_iocbs);
-
- if (!ctx->opios || !ctx->free_opios ||
- !ctx->iocb_queue || !ctx->event_queue)
- goto fail;
-
- for (i = 0; i < num_iocbs; i++)
- ctx->free_opios[i] = &ctx->opios[i];
-
- return 0;
-
- fail:
- opio_free(ctx);
- return -ENOMEM;
-}
-
-static inline struct opio *
-alloc_opio(struct opioctx *ctx)
-{
- if (ctx->free_opio_cnt <= 0)
- return NULL;
- return ctx->free_opios[--ctx->free_opio_cnt];
-}
-
-static inline void
-free_opio(struct opioctx *ctx, struct opio *op)
-{
- memset(op, 0, sizeof(struct opio));
- ctx->free_opios[ctx->free_opio_cnt++] = op;
-}
-
-static inline void
-restore_iocb(struct opio *op)
-{
- struct iocb *io = op->iocb;
-
- io->data = op->data;
- io->u.c.buf = op->buf;
- io->u.c.nbytes = op->nbytes;
-}
-
-static inline int
-iocb_optimized(struct opioctx *ctx, struct iocb *io)
-{
- unsigned long iop = (unsigned long)io->data;
- unsigned long start = (unsigned long)ctx->opios;
- unsigned long end = start + (ctx->num_opios * sizeof(struct opio));
-
- return (iop >= start && iop < end);
-}
-
-static inline int
-contiguous_sectors(struct iocb *l, struct iocb *r)
-{
- return (l->u.c.offset + l->u.c.nbytes == r->u.c.offset);
-}
-
-static inline int
-contiguous_buffers(struct iocb *l, struct iocb *r)
-{
- return (l->u.c.buf + l->u.c.nbytes == r->u.c.buf);
-}
-
-static inline int
-contiguous_iocbs(struct iocb *l, struct iocb *r)
-{
- return ((l->aio_fildes == r->aio_fildes) &&
- contiguous_sectors(l, r) &&
- contiguous_buffers(l, r));
-}
-
-static inline void
-init_opio_list(struct opio *op)
-{
- op->list.head = op->list.tail = op;
-}
-
-static struct opio *
-opio_iocb_init(struct opioctx *ctx, struct iocb *io)
-{
- struct opio *op;
-
- op = alloc_opio(ctx);
- if (!op)
- return NULL;
-
- op->buf = io->u.c.buf;
- op->nbytes = io->u.c.nbytes;
- op->offset = io->u.c.offset;
- op->data = io->data;
- op->iocb = io;
- io->data = op;
-
- init_opio_list(op);
-
- return op;
-}
-
-static inline struct opio *
-opio_get(struct opioctx *ctx, struct iocb *io)
-{
- if (iocb_optimized(ctx, io))
- return (struct opio *)io->data;
- else
- return opio_iocb_init(ctx, io);
-}
-
-static int
-merge_tail(struct opioctx *ctx, struct iocb *head, struct iocb *io)
-{
- struct opio *ophead, *opio;
-
- ophead = opio_get(ctx, head);
- if (!ophead)
- return -ENOMEM;
-
- opio = opio_get(ctx, io);
- if (!opio)
- return -ENOMEM;
-
- opio->head = ophead;
- head->u.c.nbytes += io->u.c.nbytes;
- ophead->list.tail = ophead->list.tail->next = opio;
-
- return 0;
-}
-
-static int
-merge(struct opioctx *ctx, struct iocb *head, struct iocb *io)
-{
- if (head->aio_lio_opcode != io->aio_lio_opcode)
- return -EINVAL;
-
- if (!contiguous_iocbs(head, io))
- return -EINVAL;
-
- return merge_tail(ctx, head, io);
-}
-
-int
-io_merge(struct opioctx *ctx, struct iocb **queue, int num)
-{
- int i, on_queue;
- struct iocb *io, **q;
- struct opio *ophead;
-
- if (!num)
- return 0;
-
- on_queue = 0;
- q = ctx->iocb_queue;
- memcpy(q, queue, num * sizeof(struct iocb *));
-
- for (i = 1; i < num; i++) {
- io = q[i];
- if (merge(ctx, queue[on_queue], io) != 0)
- queue[++on_queue] = io;
- }
-
-#if (defined(TEST) || defined(DEBUG))
- print_merged_iocbs(ctx, queue, on_queue + 1);
-#endif
-
- return ++on_queue;
-}
-
-static int
-expand_iocb(struct opioctx *ctx, struct iocb **queue, struct iocb *io)
-{
- int idx;
- struct opio *op, *next;
-
- idx = 0;
- op = (struct opio *)io->data;
- while (op) {
- next = op->next;
- restore_iocb(op);
- queue[idx++] = op->iocb;
- free_opio(ctx, op);
- op = next;
- }
-
- return idx;
-}
-
-int
-io_expand_iocbs(struct opioctx *ctx, struct iocb **queue, int idx, int num)
-{
- int i, on_queue;
- struct iocb *io, **q;
-
- if (!num)
- return 0;
-
- on_queue = 0;
- q = ctx->iocb_queue;
- memcpy(q, queue, num * sizeof(struct iocb *));
-
- for (i = idx; i < num; i++) {
- io = q[i];
- if (!iocb_optimized(ctx, io))
- queue[on_queue++] = io;
- else
- on_queue += expand_iocb(ctx, queue + on_queue, io);
- }
-
- return on_queue;
-}
-
-static int
-expand_event(struct opioctx *ctx,
- struct io_event *event, struct io_event *queue, int idx)
-{
- int err;
- struct iocb *io;
- struct io_event *ep;
- struct opio *ophead, *op, *next;
-
- io = event->obj;
- ophead = (struct opio *)io->data;
- op = ophead;
-
- if (event->res == io->u.c.nbytes)
- err = 0;
- else if ((int)event->res < 0)
- err = (int)event->res;
- else
- err = -EIO;
-
- while (op) {
- next = op->next;
- ep = &queue[idx++];
- ep->obj = op->iocb;
- ep->res = (err ? err : op->nbytes);
- restore_iocb(op);
- free_opio(ctx, op);
- op = next;
- }
-
- return idx;
-}
-
-int
-io_split(struct opioctx *ctx, struct io_event *events, int num)
-{
- int on_queue;
- struct iocb *io;
- struct io_event *ep, *q;
-
- if (!num)
- return 0;
-
- on_queue = 0;
- q = ctx->event_queue;
- memcpy(q, events, num * sizeof(struct io_event));
-
- for (ep = q; num-- > 0; ep++) {
- io = ep->obj;
- if (!iocb_optimized(ctx, io))
- events[on_queue++] = *ep;
- else
- on_queue = expand_event(ctx, ep, events, on_queue);
- }
-
- return on_queue;
-}
-
-/******************************************************************************
-debug print functions
-******************************************************************************/
-static inline void
-__print_iocb(struct opioctx *ctx, struct iocb *io, char *prefix)
-{
- char *type;
-
- type = (io->aio_lio_opcode == IO_CMD_PREAD ? "read" : "write");
-
- DBG(ctx, "%soff: %08llx, nbytes: %04lx, buf: %p, type: %s, data: %08lx,"
- " optimized: %d\n", prefix, io->u.c.offset, io->u.c.nbytes,
- io->u.c.buf, type, (unsigned long)io->data,
- iocb_optimized(ctx, io));
-}
-
-static char *null_prefix = "";
-#define print_iocb(ctx, io) __print_iocb(ctx, io, null_prefix)
-
-static void
-print_iocbs(struct opioctx *ctx, struct iocb **iocbs, int num_iocbs)
-{
- int i;
- char pref[10];
- struct iocb *io;
-
- DBG(ctx, "iocbs:\n");
- for (i = 0; i < num_iocbs; i++) {
- io = iocbs[i];
- snprintf(pref, 10, "%d: ", i);
- __print_iocb(ctx, io, pref);
- }
-}
-
-static void
-print_optimized_iocbs(struct opioctx *ctx, struct opio *op, int *cnt)
-{
- char pref[10];
-
- while (op) {
- snprintf(pref, 10, " %d: ", (*cnt)++);
- __print_iocb(ctx, op->iocb, pref);
- op = op->next;
- }
-}
-
-static void
-print_merged_iocbs(struct opioctx *ctx, struct iocb **iocbs, int num_iocbs)
-{
- int i, cnt;
- char pref[10];
- struct iocb *io;
- struct opio *op;
-
- DBG(ctx, "merged iocbs:\n");
- for (i = 0, cnt = 0; i < num_iocbs; i++) {
- io = iocbs[i];
- snprintf(pref, 10, "%d: ", cnt++);
- __print_iocb(ctx, io, pref);
-
- if (iocb_optimized(ctx, io)) {
- op = (struct opio *)io->data;
- print_optimized_iocbs(ctx, op->next, &cnt);
- }
- }
-}
-
-static void
-print_events(struct opioctx *ctx, struct io_event *events, int num_events)
-{
- int i;
- struct iocb *io;
-
- for (i = 0; i < num_events; i++) {
- io = events[i].obj;
- print_iocb(ctx, io);
- }
-}
-/******************************************************************************
-end debug print functions
-******************************************************************************/
-
-#if defined(TEST)
-
-#define hmask 0x80000000UL
-#define smask 0x40000000UL
-#define make_data(idx, is_head, sparse) \
- (void *)((idx) | ((is_head) ? hmask : 0) | ((sparse) ? smask : 0))
-#define data_idx(data) (int)((unsigned long)(data) & (0x0fffffff))
-#define data_is_head(data) (((unsigned long)(data) & hmask) ? 1 : 0)
-#define data_is_sparse(data) (((unsigned long)(data) & smask) ? 1 : 0)
-
-static void
-usage(void)
-{
- fprintf(stderr, "usage: io_optimize [-n num_runs] "
- "[-i num_iocbs] [-s num_secs] [-r random_seed]\n");
- exit(-1);
-}
-
-static int xalloc_cnt, xfree_cnt;
-static inline char *
-xalloc(int size)
-{
- char *buf = malloc(size);
- if (!buf) {
- fprintf(stderr, "xalloc failed\n");
- exit(ENOMEM);
- }
- xalloc_cnt++;
- return buf;
-}
-
-static inline void
-xfree(void *buf)
-{
- free(buf);
- xfree_cnt++;
-}
-
-static void
-randomize_iocbs(struct iocb **iocbs, int num_iocbs, int num_secs)
-{
- int i, j;
-
- i = 0;
- while (i < num_iocbs) {
- char *buf;
- short type;
- int segs, sparse_mem;
- uint64_t offset, nbytes;
-
- type = (random() % 10 < 5 ? IO_CMD_PREAD : IO_CMD_PWRITE);
- offset = ((random() % num_secs) << 9);
-
- if (random() % 10 < 4) {
- segs = 1;
- nbytes = (((random() % 7) + 1) << 9);
- } else {
- segs = (random() % 10) + 1;
- nbytes = 4096;
- }
-
- if (i + segs > num_iocbs)
- segs = (num_iocbs - i);
-
- sparse_mem = (random() % 10 < 2 ? 1 : 0);
-
- if (sparse_mem)
- buf = xalloc(nbytes);
- else
- buf = xalloc(segs * nbytes);
-
- for (j = 0; j < segs; j++) {
- struct iocb *io = iocbs[i + j];
- io->aio_lio_opcode = type;
- io->u.c.nbytes = nbytes;
- io->u.c.offset = offset;
- io->u.c.buf = buf;
- offset += nbytes;
-
- io->data = make_data(i + j, (j == 0), sparse_mem);
-
- if (j + 1 < segs && sparse_mem)
- buf = xalloc(nbytes);
- else
- buf += nbytes;
- }
-
- i += segs;
- }
-}
-
-static int
-simulate_io(struct iocb **iocbs, struct io_event *events, int num_iocbs)
-{
- int i, done;
- struct iocb *io;
- struct io_event *ep;
-
- if (num_iocbs > 1)
- done = (random() % (num_iocbs - 1)) + 1;
- else
- done = num_iocbs;
-
- for (i = 0; i < done; i++) {
- io = iocbs[i];
- ep = &events[i];
- ep->obj = io;
- ep->res = (random() % 10 < 8 ? io->u.c.nbytes : 0);
- }
-
- return done;
-}
-
-static inline void
-process_events(struct opioctx *ctx,
- struct iocb *iocb_list, struct io_event *events, int num)
-{
- int i;
- struct iocb *io;
-
- for (i = 0; i < num; i++) {
- io = events[i].obj;
- print_iocb(ctx, io);
- if (data_idx(io->data) != (io - iocb_list)) {
- printf("corrupt data! data_idx = %d, io = %d\n",
- data_idx(io->data), (io - iocb_list));
- exit(-1);
- }
- if (data_is_head(io->data) || data_is_sparse(io->data))
- xfree(io->u.c.buf);
- memset(io, 0, sizeof(struct iocb));
- }
-}
-
-static inline void
-init_optest(struct iocb *iocb_list,
- struct iocb **iocbs, struct io_event *events, int num)
-{
- int i;
-
- memset(iocb_list, 0, num * sizeof(struct iocb));
- memset(events, 0, num * sizeof(struct io_event));
-
- for (i = 0; i < num; i++)
- iocbs[i] = &iocb_list[i];
-}
-
-int
-main(int argc, char **argv)
-{
- uint64_t num_secs;
- struct opioctx ctx;
- struct io_event *events;
- int i, c, num_runs, num_iocbs, seed;
- struct iocb *iocb_list, **iocbs, **ioqueue;
-
- num_runs = 1;
- num_iocbs = 300;
- seed = time(NULL);
- num_secs = ((4ULL << 20) >> 9); /* 4GB disk */
-
- while ((c = getopt(argc, argv, "n:i:s:r:h")) != -1) {
- switch (c) {
- case 'n':
- num_runs = atoi(optarg);
- break;
- case 'i':
- num_iocbs = atoi(optarg);
- break;
- case 's':
- num_secs = strtoull(optarg, NULL, 10);
- break;
- case 'r':
- seed = atoi(optarg);
- break;
- case 'h':
- usage();
- case '?':
- fprintf(stderr, "Unrecognized option: -%c\n", optopt);
- usage();
- }
- }
-
- printf("Running %d tests with %d iocbs on %llu sectors, seed = %d\n",
- num_runs, num_iocbs, num_secs, seed);
-
- srand(seed);
-
- iocb_list = malloc(num_iocbs * sizeof(struct iocb));
- iocbs = malloc(num_iocbs * sizeof(struct iocb *));
- events = malloc(num_iocbs * sizeof(struct io_event));
-
- if (!iocb_list || !iocbs || !events || opio_init(&ctx, num_iocbs)) {
- fprintf(stderr, "initialization failed\n");
- exit(ENOMEM);
- }
-
- for (i = 0; i < num_runs; i++) {
- int op_rem, op_done, num_split, num_events, num_done;
-
- ioqueue = iocbs;
- init_optest(iocb_list, ioqueue, events, num_iocbs);
- randomize_iocbs(ioqueue, num_iocbs, num_secs);
- print_iocbs(&ctx, ioqueue, num_iocbs);
-
- op_done = 0;
- num_done = 0;
- op_rem = io_merge(&ctx, ioqueue, num_iocbs);
- print_iocbs(&ctx, ioqueue, op_rem);
- print_merged_iocbs(&ctx, ioqueue, op_rem);
-
- while (num_done < num_iocbs) {
- DBG(&ctx, "optimized remaining: %d\n", op_rem);
-
- DBG(&ctx, "simulating\n");
- num_events = simulate_io(ioqueue + op_done, events, op_rem);
- print_events(&ctx, events, num_events);
-
- DBG(&ctx, "splitting %d\n", num_events);
- num_split = io_split(&ctx, events, num_events);
- print_events(&ctx, events, num_split);
-
- DBG(&ctx, "processing %d\n", num_split);
- process_events(&ctx, iocb_list, events, num_split);
-
- op_rem -= num_events;
- op_done += num_events;
- num_done += num_split;
- }
-
- DBG(&ctx, "run %d: processed: %d, xallocs: %d, xfrees: %d\n",
- i, num_done, xalloc_cnt, xfree_cnt);
- if (xalloc_cnt != xfree_cnt)
- exit(-1);
- xalloc_cnt = xfree_cnt = 0;
- }
-
- free(iocbs);
- free(events);
- free(iocb_list);
- opio_free(&ctx);
-
- return 0;
-}
-#endif
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#ifndef __IO_OPTIMIZE_H__
-#define __IO_OPTIMIZE_H__
-
-#include <libaio.h>
-
-struct opio;
-
-struct opio_list {
- struct opio *head;
- struct opio *tail;
-};
-
-struct opio {
- char *buf;
- unsigned long nbytes;
- long long offset;
- void *data;
- struct iocb *iocb;
- struct io_event event;
- struct opio *head;
- struct opio *next;
- struct opio_list list;
-};
-
-struct opioctx {
- int num_opios;
- int free_opio_cnt;
- struct opio *opios;
- struct opio **free_opios;
- struct iocb **iocb_queue;
- struct io_event *event_queue;
-};
-
-int opio_init(struct opioctx *ctx, int num_iocbs);
-void opio_free(struct opioctx *ctx);
-int io_merge(struct opioctx *ctx, struct iocb **queue, int num);
-int io_split(struct opioctx *ctx, struct io_event *events, int num);
-int io_expand_iocbs(struct opioctx *ctx, struct iocb **queue, int idx, int num);
-
-#endif
+++ /dev/null
-/*
- * Copyright (c) 2010, XenSource Inc.
- * All rights reserved.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation; either version 2 of
- * the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; If not, see <http://www.gnu.org/licenses/>.
- */
-
-/*
- * kernel 2.6.21 added eventfd(2) support, kernel 2.6.22 eventfds for
- * aio. libaio 0.3.107 updated the header file, but few systems have
- * it. define a custom iocb_common struct instead, and work around a
- * potentially missing sys/eventfd.h. this header should vanish over
- * time.
- */
-
-#ifndef __LIBAIO_COMPAT
-#define __LIBAIO_COMPAT
-
-#include "../../config.h"
-#include <libaio.h>
-#include <unistd.h>
-#include <sys/syscall.h>
-
-struct __compat_io_iocb_common {
- char __pad_buf[8];
- char __pad_nbytes[8];
- long long offset;
- long long __pad3;
- unsigned flags;
- unsigned resfd;
-};
-
-static inline void __io_set_eventfd(struct iocb *iocb, int eventfd)
-{
- struct __compat_io_iocb_common *c;
- c = (struct __compat_io_iocb_common*)&iocb->u.c;
- c->flags |= (1 << 0);
- c->resfd = eventfd;
-}
-
-#ifdef HAVE_SYS_EVENTFD_H
-
-#include <sys/eventfd.h>
-
-static inline int tapdisk_sys_eventfd(int initval)
-{
- return eventfd(initval, 0);
-}
-
-#else /* Fallback */
-#ifndef SYS_eventfd
-#ifndef __NR_eventfd
-# if defined(__alpha__)
-# define __NR_eventfd 478
-# elif defined(__arm__)
-# define __NR_eventfd (__NR_SYSCALL_BASE+351)
-# elif defined(__ia64__)
-# define __NR_eventfd 1309
-# elif defined(__i386__)
-# define __NR_eventfd 323
-# elif defined(__m68k__)
-# define __NR_eventfd 319
-# elif 0 && defined(__mips__)
-# error __NR_eventfd?
-# define __NR_eventfd (__NR_Linux + 319)
-# define __NR_eventfd (__NR_Linux + 278)
-# define __NR_eventfd (__NR_Linux + 282)
-# elif defined(__hppa__)
-# define __NR_eventfd (__NR_Linux + 304)
-# elif defined(__PPC__) || defined(__powerpc64__)
-# define __NR_eventfd 307
-# elif defined(__s390__) || defined(__s390x__)
-# define __NR_eventfd 318
-# elif defined(__sparc__)
-# define __NR_eventfd 313
-# elif defined(__x86_64__)
-# define __NR_eventfd 284
-# endif
-#else
-# error __NR_eventfd?
-#endif
-#define SYS_eventfd __NR_eventfd
-#endif
-
-static inline int tapdisk_sys_eventfd(int initval)
-{
- return syscall(SYS_eventfd, initval, 0);
-}
-#endif
-
-#endif /* __LIBAIO_COMPAT */
+++ /dev/null
-/*
- * Copyright (c) 2007, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/*
- * This module implements a "dot locking" style advisory file locking algorithm.
- */
-
-#include <unistd.h>
-#include <fcntl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <errno.h>
-#include <time.h>
-#include <dirent.h>
-#include <limits.h>
-#include "lock.h"
-
-#define unlikely(x) __builtin_expect(!!(x), 0)
-
-/* format: xenlk.hostname.uuid.<xf><rw>*/
-#define LF_POSTFIX ".xenlk"
-#define LFXL_FORMAT LF_POSTFIX ".%s.%s.x%s"
-#define LFFL_FORMAT LF_POSTFIX ".%s.%s.f%s"
-#define RETRY_MAX 16
-
-#if defined(LOGS)
-#define LOG(format, args...) printf("%d: ", __LINE__); printf(format, ## args)
-#else
-#define LOG(format, args...)
-#endif
-
-/* random wait - up to .5 seconds */
-#define XSLEEP usleep(random() & 0x7ffff)
-
-typedef int (*eval_func)(char *name, int readonly);
-
-static char *create_lockfn(char *fn_to_lock)
-{
- char *lockfn;
-
- /* allocate string to hold constructed lock file */
- lockfn = malloc(strlen(fn_to_lock) + strlen(LF_POSTFIX) + 1);
- if (unlikely(!lockfn)) {
- return 0;
- }
-
- /* append postfix to file to lock */
- strcpy(lockfn, fn_to_lock);
- strcat(lockfn, LF_POSTFIX);
-
- return lockfn;
-}
-
-static char *create_lockfn_link(char *fn_to_lock, char *format,
- char *uuid, int readonly)
-{
- char hostname[128];
- char *lockfn_link;
- char *ptr;
-
- /* get hostname */
- if (unlikely(gethostname(hostname, sizeof(hostname)) == -1)) {
- return 0;
- }
-
- /* allocate string to hold constructed lock file link */
- lockfn_link = malloc(strlen(fn_to_lock) + strlen(LF_POSTFIX) +
- strlen(hostname) + strlen(uuid) + 8);
- if (unlikely(!lockfn_link)) {
- return 0;
- }
-
- /* construct lock file link with specific format */
- strcpy(lockfn_link, fn_to_lock);
- ptr = lockfn_link + strlen(lockfn_link);
- sprintf(ptr, format, hostname, uuid, readonly ? "r" : "w");
-
- return lockfn_link;
-}
-
-static int NFSnormalizedStatTime(char *fn, struct stat *statnow, int *reterrno)
-{
- int result = LOCK_OK;
- int uniq;
- char *buf;
- int fd;
- int pid = (int)getpid();
- int clstat;
-
- *reterrno = 0;
-
- /* create file to normalize time */
- srandom((int)time(0) ^ pid);
- uniq = random() % 0xffffff;
- buf = malloc(strlen(fn) + 24);
- if (unlikely(!buf)) { result = LOCK_ENOMEM; goto finish; }
-
- strcpy(buf, fn);
- sprintf(buf + strlen(buf), ".xen%08d.tmp", uniq);
-
- fd = open(buf, O_WRONLY | O_CREAT, 0644);
- if (fd == -1) { *reterrno = errno; result = LOCK_EOPEN; goto finish; }
- clstat = close(fd);
- if (unlikely(clstat == -1)) {
- LOG("fail on close\n");
- }
- if (lstat(buf, statnow) == -1) {
- unlink(buf);
- *reterrno = errno;
- result = LOCK_ESTAT;
- goto finish;
- }
- unlink(buf);
-
-finish:
- return result;
-}
-
-static int writer_eval(char *name, int readonly)
-{
- return name[strlen(name)-1] == 'w';
-}
-
-static int reader_eval(char *name, int readonly)
-{
- return name[strlen(name)-1] == 'r' && !readonly;
-}
-
-static int lock_holder(char *fn, char *lockfn, char *lockfn_link,
- int force, int readonly, int *stole, eval_func eval,
- int *elt, int *ioerror)
-{
- int status = 0;
- int ustat;
- DIR *pd = 0;
- struct dirent *dptr;
- char *ptr;
- char *dirname = malloc(strlen(lockfn));
- char *uname = malloc(strlen(lockfn_link) + 8);
- int elt_established = 0;
- int fd;
- char tmpbuf[4096];
-
- *stole = 0;
- *ioerror = 0;
- *elt = 0;
-
- if (!dirname) goto finish;
- if (!uname) goto finish;
-
- /* get directory */
- ptr = strrchr(lockfn, '/');
- if (!ptr) {
- strcpy(dirname, ".");
- } else {
- int numbytes = ptr - lockfn;
- strncpy(dirname, lockfn, numbytes);
- dirname[numbytes] = '\0';
- }
- pd = opendir(dirname);
- if (!pd) {
- *ioerror = errno ? errno : EIO;
- goto finish;
- }
-
- /*
- * scan through directory entries and use eval function
- * if we have a match (i.e. reader or writer lock) but
- * note that if we are forcing, we will remove any and
- * all locks that appear for target of our lock, regardless
- * if it a reader/writer owns the lock.
- */
- errno = 0;
- dptr = readdir(pd);
- if (!dptr) {
- *ioerror = EIO;
- }
- while (dptr) {
- char *p1 = strrchr(fn, '/');
- char *p2 = strrchr(lockfn, '/');
- char *p3 = strrchr(lockfn_link, '/');
- if (p1) p1+=1;
- if (p2) p2+=1;
- if (p3) p3+=1;
- if (strcmp(dptr->d_name, p1 ? p1 : fn) &&
- strcmp(dptr->d_name, p2 ? p2 : lockfn) &&
- strcmp(dptr->d_name, p3 ? p3 : lockfn_link) &&
- !strncmp(dptr->d_name, p1 ? p1 : fn, strlen(p1?p1:fn))) {
- strcpy(uname, dirname);
- strcat(uname, "/");
- strcat(uname, dptr->d_name);
- if (!elt_established) {
- /* read final lock file and extract lease time */
- fd = open(uname, O_RDONLY, 0644);
- memset(tmpbuf, 0, sizeof(tmpbuf));
- if (read(fd, tmpbuf, sizeof(tmpbuf)) < 0) {
- *ioerror = errno;
- status = 1;
- close(fd);
- goto finish;
- }
- close(fd);
- ptr = strrchr(tmpbuf, '.');
- if (ptr) {
- *elt = atoi(ptr+1);
- elt_established = 1;
- }
- }
- if (force) {
- ustat = unlink(uname);
- if (ustat == -1) {
- LOG("failed to unlink %s\n", uname);
- }
- *stole = 1;
- *elt = 0;
- } else {
- if ((*eval)(dptr->d_name, readonly)) {
- closedir(pd);
- status = 1;
- goto finish;
- }
- }
- }
- dptr = readdir(pd);
- if (!dptr && errno) {
- *ioerror = EIO;
- }
- }
-
- closedir(pd);
-
-finish:
- free(dirname);
- free(uname);
-
- /* if IO error, force a taken status */
- return (*ioerror) ? 1 : status;
-}
-
-int lock(char *fn_to_lock, char *uuid, int force, int readonly, int *lease_time, int *retstatus)
-{
- char *lockfn = 0;
- char *lockfn_xlink = 0;
- char *lockfn_flink = 0;
- char *buf = 0;
- int fd;
- int status = 0;
- struct stat stat1, stat2;
- int retry_attempts = 0;
- int clstat;
- int tmpstat;
- int stealx = 0;
- int stealw = 0;
- int stealr = 0;
- int established_lease_time = 0;
- char tmpbuf[4096];
- int ioerr;
-
- if (!fn_to_lock || !uuid) {
- *retstatus = LOCK_EBADPARM;
- return EINVAL;
- }
-
- *retstatus = 0;
-
- /* seed random with time/pid combo */
- srandom((int)time(0) ^ getpid());
-
- /* build lock file strings */
- lockfn = create_lockfn(fn_to_lock);
- if (unlikely(!lockfn)) { status = ENOMEM; *retstatus = LOCK_ENOMEM; goto finish; }
-
- lockfn_xlink = create_lockfn_link(fn_to_lock, LFXL_FORMAT,
- uuid, readonly);
- if (unlikely(!lockfn_xlink)) { status = ENOMEM; *retstatus = LOCK_ENOMEM; goto finish; }
-
- lockfn_flink = create_lockfn_link(fn_to_lock, LFFL_FORMAT, uuid,
- readonly);
- if (unlikely(!lockfn_flink)) { status = ENOMEM; *retstatus = LOCK_ENOMEM; goto finish; }
-
-try_again:
- if (retry_attempts++ > RETRY_MAX) {
- if (*retstatus == LOCK_EXLOCK_OPEN) {
- struct stat statnow, stat_exlock;
- int diff;
-
- if (lstat(lockfn, &stat_exlock) == -1) {
- goto finish;
- }
-
- if (NFSnormalizedStatTime(fn_to_lock, &statnow, &ioerr)) {
- goto finish;
- }
-
- diff = (int)statnow.st_mtime - (int)stat_exlock.st_mtime;
- if (diff > DEFAULT_LEASE_TIME_SECS) {
- unlink(lockfn);
- retry_attempts = 0;
- goto try_again;
- }
- }
- goto finish;
- }
-
- /* try to open exlusive lockfile */
- fd = open(lockfn, O_WRONLY | O_CREAT | O_EXCL, 0644);
- if (fd == -1) {
- LOG("Initial lockfile creation failed %s force=%d, errno=%d\n",
- lockfn, force, errno);
- if (errno == EIO) {
- *retstatus = LOCK_EXLOCK_OPEN;
- status = EIO;
- goto finish;
- }
- /* already owned? (hostname & uuid match, skip time bits) */
- errno = 0;
- fd = open(lockfn, O_RDWR, 0644);
- if (fd != -1) {
- buf = malloc(strlen(lockfn_xlink)+1);
- if (!buf) {
- clstat = close(fd);
- if (unlikely(clstat == -1)) {
- LOG("fail on close\n");
- }
- *retstatus = LOCK_ENOMEM;
- status = ENOMEM;
- goto finish;
- }
- if (read(fd, buf, strlen(lockfn_xlink)) !=
- (strlen(lockfn_xlink))) {
- clstat = close(fd);
- if (unlikely(clstat == -1)) {
- LOG("fail on close\n");
- }
- free(buf);
- goto force_lock;
- }
- if (!strncmp(buf, lockfn_xlink, strlen(lockfn_xlink)-1)) {
- LOG("lock owned by us, reasserting\n");
- /* our lock, reassert by rewriting below */
- if (lseek(fd, 0, SEEK_SET) == -1) {
- clstat = close(fd);
- if (unlikely(clstat == -1)) {
- LOG("fail on close\n");
- }
- goto force_lock;
- }
- free(buf);
- goto skip;
- }
- free(buf);
- clstat = close(fd);
- if (unlikely(clstat == -1)) {
- LOG("fail on close\n");
- }
- }
-force_lock:
- if (errno == EIO) {
- *retstatus = LOCK_EXLOCK_OPEN;
- status = EIO;
- goto finish;
- }
- if (force) {
- /* remove lock file, we are forcing lock, try again */
- status = unlink(lockfn);
- if (unlikely(status == -1)) {
- if (errno == EIO) {
- *retstatus = LOCK_EXLOCK_OPEN;
- status = EIO;
- goto finish;
- }
- LOG("force removal of %s lockfile failed, "
- "errno=%d, trying again\n", lockfn, errno);
- }
- stealx = 1;
- }
- XSLEEP;
- *retstatus = LOCK_EXLOCK_OPEN;
- goto try_again;
- }
-
- LOG("lockfile created %s\n", lockfn);
-
-skip:
- /*
- * write into the temporary xlock
- */
- if (write(fd, lockfn_xlink, strlen(lockfn_xlink)) !=
- strlen(lockfn_xlink)) {
- if (errno == EIO) {
- *retstatus = LOCK_EXLOCK_WRITE;
- status = EIO;
- goto finish;
- }
- status = errno;
- clstat = close(fd);
- if (unlikely(clstat == -1)) {
- LOG("fail on close\n");
- }
- XSLEEP;
- *retstatus = LOCK_EXLOCK_WRITE;
- if (unlink(lockfn) == -1) {
- LOG("removal of %s lockfile failed, "
- "errno=%d, trying again\n", lockfn, errno);
- }
- goto try_again;
- }
- clstat = close(fd);
- if (unlikely(clstat == -1)) {
- LOG("fail on close\n");
- }
-
- while (retry_attempts++ < RETRY_MAX) {
- tmpstat = link(lockfn, lockfn_xlink);
- LOG("linking %s and %s\n", lockfn, lockfn_xlink);
- if ((tmpstat == -1) && (errno != EEXIST)) {
- LOG("link status is %d, errno=%d\n", tmpstat, errno);
- }
-
- if ((lstat(lockfn, &stat1) == -1) ||
- (lstat(lockfn_xlink, &stat2) == -1)) {
- /* try again, cleanup first */
- tmpstat = unlink(lockfn);
- if (unlikely(tmpstat == -1)) {
- LOG("error removing lock file %s", lockfn);
- }
- tmpstat = unlink(lockfn_xlink);
- if (unlikely(tmpstat == -1)) {
- LOG("error removing linked lock file %s",
- lockfn_xlink);
- }
- XSLEEP;
- status = LOCK_ESTAT;
- goto finish;
- }
-
- /* compare inodes */
- if (stat1.st_ino == stat2.st_ino) {
- /* success, inodes are the same */
- /* should we check that st_nlink's are also 2?? */
- *retstatus = LOCK_OK;
- status = 0;
- tmpstat = unlink(lockfn_xlink);
- if (unlikely(tmpstat == -1)) {
- LOG("error removing linked lock file %s",
- lockfn_xlink);
- }
- goto finish;
- } else {
- status = errno;
- /* try again, cleanup first */
- tmpstat = unlink(lockfn);
- if (unlikely(tmpstat == -1)) {
- LOG("error removing lock file %s", lockfn);
- }
- tmpstat = unlink(lockfn_xlink);
- if (unlikely(tmpstat == -1)) {
- LOG("error removing linked lock file %s",
- lockfn_xlink);
- }
- XSLEEP;
- *retstatus = LOCK_EINODE;
- goto try_again;
- }
- }
-
-finish:
- if (!*retstatus) {
-
- /* we have exclusive lock */
-
- status = 0;
-
- /* fast check, see if we own a final lock and are reasserting */
- if (!lstat(lockfn_flink, &stat1)) {
- char *ptr;
-
- /* set the return value to notice this is a reassert */
- *retstatus = 1;
-
- /* read existing lock file and extract
- established lease time */
- fd = open(lockfn_flink, O_RDONLY, 0644);
- memset(tmpbuf, 0, sizeof(tmpbuf));
- if (read(fd, tmpbuf, sizeof(tmpbuf)) < 0) {
- if (errno == EIO) {
- close(fd);
- *retstatus = LOCK_EINODE;
- status = EIO;
- goto skip_scan;
- }
- }
- close(fd);
- ptr = strrchr(tmpbuf, '.');
- if (ptr) {
- *lease_time = atoi(ptr+1);
- } else {
- *lease_time = 10; /* wkchack */
- }
- goto skip_scan;
- } else {
- if (errno == EIO) {
- *retstatus = LOCK_EINODE;
- status = EIO;
- goto skip_scan;
- }
- }
-
- /* we allow exclusive writer, or multiple readers */
- if (lock_holder(fn_to_lock, lockfn, lockfn_flink, force,
- readonly, &stealw, writer_eval,
- &established_lease_time, &ioerr)) {
- if (ioerr) {
- *retstatus = LOCK_EREAD;
- status = ioerr;
- goto skip_scan;
- }
- *retstatus = LOCK_EHELD_WR;
- } else if (lock_holder(fn_to_lock, lockfn, lockfn_flink, force,
- readonly, &stealr, reader_eval,
- &established_lease_time, &ioerr)) {
- if (ioerr) {
- *retstatus = LOCK_EREAD;
- status = ioerr;
- goto skip_scan;
- }
- *retstatus = LOCK_EHELD_RD;
- }
- if (established_lease_time) *lease_time =
- established_lease_time;
- }
-
-skip_scan:
- if (*retstatus >= 0) {
- /* update file, changes last modify time */
- fd = open(lockfn_flink, O_WRONLY | O_CREAT, 0644);
- if (fd == -1) {
- *retstatus = LOCK_EOPEN;
- status = errno;
- } else {
- char tmpbuf[32];
- int failed_write;
- memset(tmpbuf, 0, sizeof(tmpbuf));
- sprintf(tmpbuf, ".%d", *lease_time);
- failed_write = write(fd, lockfn_flink,
- strlen(lockfn_flink)) !=
- strlen(lockfn_flink);
- if (failed_write) status = errno;
- failed_write |= write(fd, tmpbuf, strlen(tmpbuf)) !=
- strlen(tmpbuf);
- if (failed_write) status = errno;
- if (failed_write) {
- clstat = close(fd);
- if (unlikely(clstat == -1)) {
- LOG("fail on close\n");
- }
- XSLEEP;
- *retstatus = LOCK_EUPDATE;
- goto try_again;
- }
- }
- clstat = close(fd);
- if (unlikely(clstat == -1)) {
- LOG("fail on close\n");
- }
- }
-
- if (!*retstatus && force && (stealx || stealw || stealr)) {
- struct timeval timeout;
-
- /* enforce quiet time on steal */
- timeout.tv_sec = *lease_time;
- timeout.tv_usec = 0;
- select(0, 0, 0, 0, &timeout);
- }
-
- /* remove exclusive lock, final read/write locks will hold */
- tmpstat = unlink(lockfn);
- if (unlikely(tmpstat == -1)) {
- LOG("error removing exclusive lock file %s",
- lockfn);
- }
-
- free(lockfn);
- free(lockfn_xlink);
- free(lockfn_flink);
-
- /* set lease time to -1 if error, so no one is apt to use it */
- if (*retstatus < 0) *lease_time = -1;
-
- LOG("returning status %d, errno=%d\n", status, errno);
- return status;
-}
-
-
-int unlock(char *fn_to_unlock, char *uuid, int readonly, int *status)
-{
- char *lockfn_link = 0;
- int reterrno = 0;
-
- if (!fn_to_unlock || !uuid) {
- *status = LOCK_EBADPARM;
- return 0;
- }
-
- lockfn_link = create_lockfn_link(fn_to_unlock, LFFL_FORMAT, uuid,
- readonly);
- if (unlikely(!lockfn_link)) { *status = LOCK_ENOMEM; goto finish; }
-
- if (unlink(lockfn_link) == -1) {
- LOG("error removing linked lock file %s", lockfn_link);
- reterrno = errno;
- *status = LOCK_ENOLOCK;
- goto finish;
- }
-
- *status = LOCK_OK;
-
-finish:
- free(lockfn_link);
- return reterrno;
-}
-
-int lock_delta(char *fn, int *ret_lease, int *max_lease)
-{
- int reterrno = 0;
- DIR *pd = 0;
- struct dirent *dptr;
- char *ptr;
- int result = INT_MAX;
- struct stat statbuf, statnow;
- char *dirname = malloc(strlen(fn));
- char *uname = malloc(strlen(fn) + 8);
- int elt_established = 0;
- char *dotptr;
- char tmpbuf[4096];
- int fd;
-
- if (!fn || !dirname || !uname) {
- *ret_lease = LOCK_EBADPARM;
- *max_lease = -1;
- return 0;
- }
-
- if (NFSnormalizedStatTime(fn, &statnow, &reterrno)) {
- result = LOCK_ESTAT;
- goto finish;
- }
-
- /* get directory */
- ptr = strrchr(fn, '/');
- if (!ptr) {
- strcpy(dirname, ".");
- ptr = fn;
- } else {
- int numbytes = ptr - fn;
- strncpy(dirname, fn, numbytes);
- ptr += 1;
- }
- pd = opendir(dirname);
- if (!pd) { reterrno = errno; goto finish; }
-
- dptr = readdir(pd);
- while (dptr) {
- if (strcmp(dptr->d_name, ptr) &&
- !strncmp(dptr->d_name, ptr, strlen(ptr))) {
- char *fpath = malloc(strlen(dptr->d_name) +
- strlen(dirname) + 2);
- if (!fpath) {
- closedir(pd);
- result = LOCK_ENOMEM;
- goto finish;
- }
- strcpy(fpath, dirname);
- strcat(fpath, "/");
- strcat(fpath, dptr->d_name);
- if (lstat(fpath, &statbuf) != -1) {
- int diff = (int)statnow.st_mtime -
- (int)statbuf.st_mtime;
- /* adjust diff if someone updated the lock
- between now and when we created the "now"
- file
- */
- diff = (diff < 0) ? 0 : diff;
- result = diff < result ? diff : result;
- } else {
- closedir(pd);
- reterrno = errno;
- goto finish;
- }
-
- if (!elt_established) {
- /* read final lock file and extract lease time */
- fd = open(fpath, O_RDONLY, 0644);
- memset(tmpbuf, 0, sizeof(tmpbuf));
- if (read(fd, tmpbuf, sizeof(tmpbuf)) < 0) {
- /* error on read? */
- }
- close(fd);
- dotptr = strrchr(tmpbuf, '.');
- if (dotptr) {
- *max_lease = atoi(dotptr+1);
- elt_established = 1;
- }
- }
-
- free(fpath);
- }
- dptr = readdir(pd);
- }
-
- closedir(pd);
-
-finish:
- free(dirname);
- free(uname);
-
- /* returns smallest lock time, or error */
- if (result == INT_MAX) result = LOCK_ENOLOCK;
-
- /* set lease time to -1 if error, so no one is apt to use it */
- if ((result < 0) || reterrno) *max_lease = -1;
- *ret_lease = result;
- return reterrno;
-}
-
-#if defined(TEST)
-/*
- * the following is for sanity testing.
- */
-
-static void usage(char *prg)
-{
- printf("usage %s\n"
- " dtr <filename>]\n"
- " p <filename> [num iterations]\n"
- " u <filename> [0|1] [<uniqid>]\n"
- " l <filename> [0|1] [0|1] [<uniqid>] [<leasetime>]\n", prg);
- printf(" p : perf test lock take and reassert\n");
- printf(" d : delta lock time\n");
- printf(" t : test the file (after random locks)\n");
- printf(" r : random lock tests (must ^C)\n");
- printf(" u : unlock, readonly? uniqID (default is PID)\n");
- printf(" l : lock, readonly? force?, uniqID (default is PID), lease time\n");
-}
-
-static void test_file(char *fn)
-{
- FILE *fptr;
- int prev_count = 0;
- int count, pid, time;
-
- fptr = fopen(fn, "r");
- if (!fptr) {
- LOG("ERROR on file %s open, errno=%d\n", fn, errno);
- return;
- }
-
- while (!feof(fptr)) {
- fscanf(fptr, "%d %d %d\n", &count, &pid, &time);
- if (prev_count != count) {
- LOG("ERROR: prev_count=%d, count=%d, pid=%d, time=%d\n",
- prev_count, count, pid, time);
- }
- prev_count = count + 1;
- }
-}
-
-static void random_locks(char *fn)
-{
- int pid = getpid();
- int status;
- char *filebuf = malloc(256);
- int count = 0;
- int dummy;
- int clstat;
- char uuid[12];
- int readonly;
- int lease = DEFAULT_LEASE_TIME_SECS;
- int err;
-
- /* this will never return, kill to exit */
-
- srandom((int)time(0) ^ pid);
-
- LOG("pid: %d using file %s\n", pid, fn);
- sprintf(uuid, "%08d", pid);
-
- while (1) {
- XSLEEP;
- readonly = random() & 1;
- sysstatus = lock(fn, uuid, 0, readonly, &lease, status);
- if (status == LOCK_OK) {
- /* got lock, open, read, modify write close file */
- int fd = open(fn, O_RDWR, 0644);
- if (fd == -1) {
- LOG("pid: %d ERROR on file %s open, errno=%d\n",
- pid, fn, errno);
- } else {
- if (!readonly) {
- /* ugly code to read data in test format */
- /* format is "%d %d %d" 'count pid time' */
- struct stat statbuf;
- int bytes;
- status = stat(fn, &statbuf);
- if (status != -1) {
- if (statbuf.st_size > 256) {
- lseek(fd, -256, SEEK_END);
- }
- memset(filebuf, 0, 256);
- bytes = read(fd, filebuf, 256);
- if (bytes) {
- int bw = bytes-2;
- while (bw && filebuf[bw]!='\n')
- bw--;
- if (!bw) bw = -1;
- sscanf(&filebuf[bw+1],
- "%d %d %d",
- &count, &dummy, &dummy);
- count += 1;
- }
- lseek(fd, 0, SEEK_END);
- sprintf(filebuf, "%d %d %d\n",
- count, pid, (int)time(0));
- write(fd, filebuf, strlen(filebuf));
- } else {
- LOG("pid: %d ERROR on file %s stat, "
- "errno=%d\n", pid, fn, errno);
- }
- }
- clstat = close(fd);
- if (unlikely(clstat == -1)) {
- LOG("fail on close\n");
- }
- }
- XSLEEP;
- err = unlock(fn, uuid, readonly, &status);
- LOG("unlock status is %d (err=%d)\n", status, err);
- }
- }
-}
-
-static void perf_lock(char *fn, int loops)
-{
- int sysstatus;
- char buf[9];
- int start = loops;
- int lease = DEFAULT_LEASE_TIME_SECS;
-
- sprintf(buf, "%08d", getpid());
-
- while (loops--) {
- sysstatus = lock(fn, buf, 0, 0, &lease, &status);
- if (status < 0) {
- printf("failed to get lock at iteration %d errno=%d\n",
- start - loops, errno);
- return;
- }
- }
- unlock(fn, buf, 0, &status);
-}
-
-int main(int argc, char *argv[])
-{
- int status;
- char *ptr;
- char uuid[12];
- int force;
- int readonly;
- int max_lease, cur_lease;
- int intstatus;
- int lease = DEFAULT_LEASE_TIME_SECS;
-
- if (argc < 3) {
- usage(argv[0]);
- return 0;
- }
-
- sprintf(uuid, "%08d", getpid());
- ptr = uuid;
-
- if (!strcmp(argv[1],"d")) {
- status = lock_delta(argv[2], &cur_lease, &max_lease);
-
- printf("lock delta for %s is %d seconds, max lease is %d\n",
- argv[2], cur_lease, max_lease);
- } else if (!strcmp(argv[1],"t")) {
- test_file(argv[2]);
- } else if (!strcmp(argv[1],"r")) {
- random_locks(argv[2]);
- } else if (!strcmp(argv[1],"p")) {
- perf_lock(argv[2], argc < 3 ? 100000 : atoi(argv[3]));
- } else if (!strcmp(argv[1],"l")) {
- if (argc < 4) force = 0; else force = atoi(argv[3]);
- if (argc < 5) readonly = 0; else readonly = atoi(argv[4]);
- if (argc >= 6) ptr = argv[5];
- if (argc == 7) lease = atoi(argv[6]);
- status = lock(argv[2], ptr, readonly, force, &lease, &intstatus);
- printf("lock status = %d\n", status);
- } else if (!strcmp(argv[1],"u") ) {
- if (argc < 5) readonly = 0; else readonly = atoi(argv[3]);
- if (argc == 5) ptr = argv[4];
- status = unlock(argv[2], ptr, readonly, &intstatus);
- printf("unlock status = %d\n", intstatus);
- } else {
- usage(argv[0]);
- }
-
- return status;
-}
-#elif defined(UTIL)
-/*
- * the following is used for non-libary, standalone
- * program utility as a shell program
- */
-
-static void usage(char *prg)
-{
- printf("usage %s\n"
- " delta <filename>\n"
- " unlock <filename> <r|w> <uniqid>\n"
- " lock <filename> <r|w> <0|1> <uniqid> <leasetime>\n", prg);
- printf(" delta : get time since lock last refreshed\n");
- printf(" returns delta time and max lease time in seconds\n");
- printf(" unlock: unlock request filename, r|w, uniqID\n");
- printf(" returns status (success is 0)\n");
- printf(" lock : lock request filename, r|w, force?, uniqID, lease time request\n");
- printf(" returns status (success is 0) and established lease time in seconds\n");
-}
-
-int main(int argc, char *argv[])
-{
- int status = 0;
- int dlock;
- char *ptr;
- int force;
- int readonly;
- int cur_lease, max_lease, intstatus;
- int lease = DEFAULT_LEASE_TIME_SECS;
-
- if (argc < 3) {
- if (argc == 2 && !strcmp(argv[1], "-h")) {
- usage(argv[0]);
- } else {
- printf("%d\n", LOCK_EUSAGE);
- }
- return 0;
- }
-
- if (!strcmp(argv[1],"delta") && (argc == 3)) {
- status = lock_delta(argv[2], &cur_lease, &max_lease);
- printf("%d %d\n", cur_lease, max_lease);
- } else if (!strcmp(argv[1],"lock") && (argc == 7)) {
- readonly = (strcmp(argv[3], "r") == 0) ? 1 : 0;
- force = atoi(argv[4]);
- ptr = argv[5];
- lease = atoi(argv[6]);
- status = lock(argv[2], ptr, force, readonly, &lease, &intstatus);
- printf("%d %d\n", intstatus, lease);
- } else if (!strcmp(argv[1],"unlock") && (argc == 5)) {
- readonly = (strcmp(argv[3], "r") == 0) ? 1 : 0;
- ptr = argv[4];
- status = unlock(argv[2], ptr, readonly, &intstatus);
- printf("%d\n", intstatus);
- } else {
- printf("%d\n", LOCK_EUSAGE);
- }
-
- /* this is either 0 or a system defined errno */
- return status;
-}
-#endif
+++ /dev/null
-/*
- * Copyright (c) 2007, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#define DEFAULT_LEASE_TIME_SECS 30
-
-int lock(char *fn_to_lock, char *uuid, int force, int readonly, int *lease_time, int *retstat);
-int unlock(char *fn_to_unlock, char *uuid, int readonly, int *retstat);
-int lock_delta(char *fn_to_check, int *cur_lease_time, int *max_lease_time);
-
-typedef enum {
- LOCK_OK = 0,
- LOCK_EBADPARM = -1,
- LOCK_ENOMEM = -2,
- LOCK_ESTAT = -3,
- LOCK_EHELD_WR = -4,
- LOCK_EHELD_RD = -5,
- LOCK_EOPEN = -6,
- LOCK_EXLOCK_OPEN = -7,
- LOCK_EXLOCK_WRITE= -8,
- LOCK_EINODE = -9,
- LOCK_EUPDATE = -10,
- LOCK_EREAD = -11,
- LOCK_EREMOVE = -12,
- LOCK_ENOLOCK = -13,
- LOCK_EUSAGE = -14,
-} lock_error;
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/* log.h: API for writelog communication */
-
-#ifndef __LOG_H__
-#define __LOG_H__ 1
-
-#include <inttypes.h>
-
-#include <xen/io/ring.h>
-/* for wmb et al */
-#include <xenctrl.h>
-
-#define LOGCMD_SHMP "shmp"
-#define LOGCMD_PEEK "peek"
-#define LOGCMD_CLEAR "clrw"
-#define LOGCMD_GET "getw"
-#define LOGCMD_KICK "kick"
-
-#define CTLRSPLEN_SHMP 256
-#define CTLRSPLEN_PEEK 4
-#define CTLRSPLEN_CLEAR 4
-#define CTLRSPLEN_GET 4
-#define CTLRSPLEN_KICK 0
-
-/* shmregion is arbitrarily capped at 8 megs for a minimum of
- * 64 MB of data per read (if there are no contiguous regions)
- * In the off-chance that there is more dirty data, multiple
- * reads must be done */
-#define SHMSIZE (8 * 1024 * 1024)
-#define SRINGSIZE 4096
-
-/* The shared memory region is split up into 3 subregions:
- * The first half is reserved for the dirty bitmap log.
- * The second half begins with 1 page for read request descriptors,
- * followed by a big area for supplying read data.
- */
-static inline void* bmstart(void* shm)
-{
- return shm;
-}
-
-static inline void* bmend(void* shm)
-{
- return shm + SHMSIZE/2;
-}
-
-static inline void* sringstart(void* shm)
-{
- return bmend(shm);
-}
-
-static inline void* sdatastart(void* shm)
-{
- return sringstart(shm) + SRINGSIZE;
-}
-
-static inline void* sdataend(void* shm)
-{
- return shm + SHMSIZE;
-}
-
-/* format for messages between log client and server */
-struct log_ctlmsg {
- char msg[4];
- char params[16];
-};
-
-/* extent descriptor */
-struct disk_range {
- uint64_t sector;
- uint32_t count;
-};
-
-/* dirty write logging space. This is an extent ring at the front,
- * full of disk_ranges plus a pointer into the data area */
-/* I think I'd rather have the header in front of each data section to
- * avoid having two separate spaces that can run out, but then I'd either
- * lose page alignment on the data blocks or spend an entire page on the
- * header */
-
-struct log_extent {
- uint64_t sector;
- uint32_t count;
- uint32_t offset; /* offset from start of data area to start of extent */
-};
-
-/* struct above should be 16 bytes, or 256 extents/page */
-
-typedef struct log_extent log_request_t;
-typedef struct log_extent log_response_t;
-
-DEFINE_RING_TYPES(log, log_request_t, log_response_t);
-
-#define LOG_HEADER_PAGES 4
-
-#endif
+++ /dev/null
-/* start - public domain MD5 implementation */
-/*
- * This code implements the MD5 message-digest algorithm.
- * The algorithm is due to Ron Rivest. This code was
- * written by Colin Plumb in 1993, no copyright is claimed.
- * This code is in the public domain; do with it what you wish.
- *
- * Equivalent code is available from RSA Data Security, Inc.
- * This code has been tested against that, and is equivalent,
- * except that you don't need to include two pages of legalese
- * with every copy.
- *
- * To compute the message digest of a chunk of bytes, declare an
- * MD5Context structure, pass it to MD5Init, call MD5Update as
- * needed on buffers full of bytes, and then call MD5Final, which
- * will fill a supplied 16-byte array with the digest.
- */
-
-#include <string.h>
-#include <stdint.h>
-
-struct MD5Context {
- uint32_t buf[4];
- uint32_t bits[2];
- uint8_t in[64];
-};
-
-static void MD5Init(struct MD5Context *context);
-static void MD5Update(struct MD5Context *context, unsigned char const *buf,
- unsigned len);
-static void MD5Final(unsigned char digest[16], struct MD5Context *context);
-static void MD5Transform(uint32_t buf[4], uint32_t const in[16]);
-
-
-typedef struct MD5Context MD5_CTX;
-
-
-/**
- * md5_sum - MD5 hash for a data block
- * @addr: Pointers to the data area
- * @len: Lengths of the data block
- * @mac: Buffer for the hash
- */
-void md5_sum(const uint8_t *addr, const size_t len, uint8_t *mac)
-{
- MD5_CTX ctx;
-
- MD5Init(&ctx);
- MD5Update(&ctx, addr, len);
- MD5Final(mac, &ctx);
-}
-
-
-#ifndef WORDS_BIGENDIAN
-#define byteReverse(buf, len) /* Nothing */
-#else
-/*
- * Note: this code is harmless on little-endian machines.
- */
-static void byteReverse(unsigned char *buf, unsigned longs)
-{
- uint32_t t;
- do {
- t = (uint32_t) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
- ((unsigned) buf[1] << 8 | buf[0]);
- *(uint32_t *) buf = t;
- buf += 4;
- } while (--longs);
-}
-#endif
-
-/*
- * Start MD5 accumulation. Set bit count to 0 and buffer to mysterious
- * initialization constants.
- */
-void MD5Init(struct MD5Context *ctx)
-{
- ctx->buf[0] = 0x67452301;
- ctx->buf[1] = 0xefcdab89;
- ctx->buf[2] = 0x98badcfe;
- ctx->buf[3] = 0x10325476;
-
- ctx->bits[0] = 0;
- ctx->bits[1] = 0;
-}
-
-/*
- * Update context to reflect the concatenation of another buffer full
- * of bytes.
- */
-void MD5Update(struct MD5Context *ctx, unsigned char const *buf, unsigned len)
-{
- uint32_t t;
-
- /* Update bitcount */
-
- t = ctx->bits[0];
- if ((ctx->bits[0] = t + ((uint32_t) len << 3)) < t)
- ctx->bits[1]++; /* Carry from low to high */
- ctx->bits[1] += len >> 29;
-
- t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */
-
- /* Handle any leading odd-sized chunks */
-
- if (t) {
- unsigned char *p = (unsigned char *) ctx->in + t;
-
- t = 64 - t;
- if (len < t) {
- memcpy(p, buf, len);
- return;
- }
- memcpy(p, buf, t);
- byteReverse(ctx->in, 16);
- MD5Transform(ctx->buf, (uint32_t *) ctx->in);
- buf += t;
- len -= t;
- }
- /* Process data in 64-byte chunks */
-
- while (len >= 64) {
- memcpy(ctx->in, buf, 64);
- byteReverse(ctx->in, 16);
- MD5Transform(ctx->buf, (uint32_t *) ctx->in);
- buf += 64;
- len -= 64;
- }
-
- /* Handle any remaining bytes of data. */
-
- memcpy(ctx->in, buf, len);
-}
-
-/*
- * Final wrapup - pad to 64-byte boundary with the bit pattern
- * 1 0* (64-bit count of bits processed, MSB-first)
- */
-void MD5Final(unsigned char digest[16], struct MD5Context *ctx)
-{
- unsigned count;
- unsigned char *p;
-
- /* Compute number of bytes mod 64 */
- count = (ctx->bits[0] >> 3) & 0x3F;
-
- /* Set the first char of padding to 0x80. This is safe since there is
- always at least one byte free */
- p = ctx->in + count;
- *p++ = 0x80;
-
- /* Bytes of padding needed to make 64 bytes */
- count = 64 - 1 - count;
-
- /* Pad out to 56 mod 64 */
- if (count < 8) {
- /* Two lots of padding: Pad the first block to 64 bytes */
- memset(p, 0, count);
- byteReverse(ctx->in, 16);
- MD5Transform(ctx->buf, (uint32_t *) ctx->in);
-
- /* Now fill the next block with 56 bytes */
- memset(ctx->in, 0, 56);
- } else {
- /* Pad block to 56 bytes */
- memset(p, 0, count - 8);
- }
- byteReverse(ctx->in, 14);
-
- /* Append length in bits and transform */
- ((uint32_t *) ctx->in)[14] = ctx->bits[0];
- ((uint32_t *) ctx->in)[15] = ctx->bits[1];
-
- MD5Transform(ctx->buf, (uint32_t *) ctx->in);
- byteReverse((unsigned char *) ctx->buf, 4);
- memcpy(digest, ctx->buf, 16);
- memset(ctx, 0, sizeof(*ctx)); /* In case it's sensitive */
-}
-
-/* The four core functions - F1 is optimized somewhat */
-
-/* #define F1(x, y, z) (x & y | ~x & z) */
-#define F1(x, y, z) (z ^ (x & (y ^ z)))
-#define F2(x, y, z) F1(z, x, y)
-#define F3(x, y, z) (x ^ y ^ z)
-#define F4(x, y, z) (y ^ (x | ~z))
-
-/* This is the central step in the MD5 algorithm. */
-#define MD5STEP(f, w, x, y, z, data, s) \
- ( w += f(x, y, z) + data, w = w<<s | w>>(32-s), w += x )
-
-/*
- * The core of the MD5 algorithm, this alters an existing MD5 hash to
- * reflect the addition of 16 longwords of new data. MD5Update blocks
- * the data and converts bytes into longwords for this routine.
- */
-static void MD5Transform(uint32_t buf[4], uint32_t const in[16])
-{
- register uint32_t a, b, c, d;
-
- a = buf[0];
- b = buf[1];
- c = buf[2];
- d = buf[3];
-
- MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
- MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
- MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
- MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
- MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
- MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
- MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
- MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
- MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
- MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
- MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
- MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
- MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
- MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
- MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
- MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
-
- MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
- MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
- MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
- MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
- MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
- MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
- MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
- MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
- MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
- MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
- MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
- MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
- MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
- MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
- MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
- MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
-
- MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
- MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
- MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
- MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
- MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
- MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
- MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
- MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
- MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
- MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
- MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
- MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
- MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
- MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
- MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
- MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
-
- MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
- MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
- MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
- MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
- MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
- MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
- MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
- MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
- MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
- MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
- MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
- MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
- MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
- MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
- MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
- MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
-
- buf[0] += a;
- buf[1] += b;
- buf[2] += c;
- buf[3] += d;
-}
+++ /dev/null
-#ifndef MD5_H
-#define MD5_H
-
-#include <stdint.h>
-#include <stddef.h>
-
-/**
- * md5_sum - MD5 hash for a data block
- * @addr: Pointers to the data area
- * @len: Lengths of the data block
- * @mac: Buffer for the hash
- */
-void md5_sum(const uint8_t *addr, const size_t len, uint8_t *mac);
-
-#endif
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#ifndef __TAP_PROFILE_H__
-#define __TAP_PROFILE_H__
-
-#ifndef _GNU_SOURCE
- #define _GNU_SOURCE
-#endif
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <syslog.h>
-#include <sys/time.h>
-#include <time.h>
-#include <fcntl.h>
-#include <inttypes.h>
-
-//#define PROFILING
-//#define LOGGING
-
-#define TAPPROF_IN 1
-#define TAPPROF_OUT 2
-
-struct profile_times {
- char *fn_name;
- uint64_t in, out_sum, cnt;
-};
-
-struct profile_info {
- FILE *log;
- int size;
- char *name;
- unsigned long long seq;
- struct profile_times *pt;
-};
-
-#ifdef PROFILING
-
-static inline void
-tp_open(struct profile_info *prof, char *tap_name, char *log_name, int size)
-{
- memset(prof, 0, sizeof(struct profile_info));
-#ifdef LOGGING
- prof->log = fopen(log_name, "w");
-#endif
- prof->size = size;
- prof->name = strdup(tap_name);
- prof->pt = malloc(sizeof(struct profile_times) * prof->size);
- if (prof->pt)
- memset(prof->pt, 0, sizeof(struct profile_times) * prof->size);
-}
-
-static inline void
-tp_close(struct profile_info *prof)
-{
- int i;
- struct profile_times *pt;
-
- for (i = 0; i < prof->size; i++) {
- pt = &prof->pt[i];
- if (pt->fn_name) {
- syslog(LOG_DEBUG, "%s: %s: cnt: %llu, avg time: %llu\n",
- prof->name, pt->fn_name, pt->cnt,
- ((pt->cnt) ? (pt->out_sum / pt->cnt) : 0));
- free(pt->fn_name);
- }
- }
-
-#ifdef LOGGING
- if (prof->log)
- fclose(prof->log);
-#endif
- free(prof->name);
- if (prof->pt)
- free(prof->pt);
-}
-
-static inline u64
-tp_get_id(struct profile_info *prof)
-{
- return prof->seq++;
-}
-
-static inline int
-tp_fn_id(struct profile_info *prof, const char *name)
-{
- int i;
- struct profile_times *pt;
-
- for (i = 0; i < prof->size; i++) {
- pt = &prof->pt[i];
- if (!pt->fn_name)
- return i;
- if (!strcmp(pt->fn_name, name))
- return i;
- }
-
- return prof->size - 1;
-}
-
-static inline void
-__tp_in(struct profile_info *prof, const char *func)
-{
- long long _time;
- int idx = tp_fn_id(prof, func);
- struct profile_times *pt = &prof->pt[idx];
-
- if (!pt->fn_name)
- pt->fn_name = strdup(func);
-
- asm volatile(".byte 0x0f, 0x31" : "=A" (_time));
- pt->in = _time;
-}
-
-#define tp_in(prof) __tp_in(prof, __func__)
-
-static inline void
-__tp_out(struct profile_info *prof, const char *func)
-{
- long long _time;
- int idx = tp_fn_id(prof, func);
- struct profile_times *pt = &prof->pt[idx];
-
- if (!pt->fn_name || !pt->in)
- return;
-
- asm volatile(".byte 0x0f, 0x31" : "=A" (_time));
- pt->cnt++;
- pt->out_sum += (_time - pt->in);
- pt->in = 0;
-}
-
-#define tp_out(prof) __tp_out(prof, __func__)
-
-static inline void
-__tp_log(struct profile_info *prof, u64 id, const char *func, int direction)
-{
- long long _time;
- asm volatile(".byte 0x0f, 0x31" : "=A" (_time));
-
- if (direction == TAPPROF_IN)
- __tp_in(prof, func);
- else
- __tp_out(prof, func);
-
-#ifdef LOGGING
- if (prof->log)
- fprintf(prof->log, "%s: %s: %llu, %lld\n", func,
- ((direction == TAPPROF_IN) ? "in" : "out"), id, _time);
-#endif
-}
-
-#define tp_log(prof, id, direction) __tp_log(prof, id, __func__, direction)
-
-#else
-#define tp_open(prof, tname, lname, size) ((void)0)
-#define tp_close(prof) ((void)0)
-#define tp_in(prof) ((void)0)
-#define tp_out(prof) ((void)0)
-#define tp_log(prof, sec, direction) ((void)0)
-#endif
-
-#endif
+++ /dev/null
-/* qcow-create.c
- *
- * Generates a qcow format disk.
- *
- * (c) 2006 Andrew Warfield and Julian Chesterfield
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License version 2
- * as published by the Free Software Foundation; or, when distributed
- * separately from the Linux kernel or incorporated into other
- * software packages, subject to the following license:
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this source file (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy, modify,
- * merge, publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-
-#include <errno.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <sys/statvfs.h>
-#include <sys/stat.h>
-#include <sys/ioctl.h>
-#include <string.h>
-#include "tapdisk.h"
-#include "qcow.h"
-
-#if 1
-#define DFPRINTF(_f, _a...) fprintf ( stderr, _f , ## _a )
-#else
-#define DFPRINTF(_f, _a...) ((void)0)
-#endif
-
-#define MAX_NAME_LEN 1000
-
-void help(void)
-{
- fprintf(stderr, "Qcow-utils: v1.0.0\n");
- fprintf(stderr,
- "usage: qcow-create [-h help] [-r reserve] <SIZE(MB)> <FILENAME> "
- "[<BACKING_FILENAME>]\n");
- exit(-1);
-}
-
-int main(int argc, char *argv[])
-{
- int ret = -1, c, backed = 0;
- int sparse = 1;
- uint64_t size;
- char filename[MAX_NAME_LEN], bfilename[MAX_NAME_LEN];
-
- for(;;) {
- c = getopt(argc, argv, "hr");
- if (c == -1)
- break;
- switch(c) {
- case 'h':
- help();
- exit(0);
- break;
- case 'r':
- sparse = 0;
- break;
- default:
- fprintf(stderr, "Unknown option\n");
- help();
- }
- }
-
- printf("Optind %d, argc %d\n", optind, argc);
- if ( !(optind == (argc - 2) || optind == (argc - 3)) )
- help();
-
- size = atoi(argv[optind++]);
- size = size << 20;
-
- if (snprintf(filename, MAX_NAME_LEN, "%s",argv[optind++]) >=
- MAX_NAME_LEN) {
- fprintf(stderr,"Device name too long\n");
- exit(-1);
- }
-
- if (optind != argc) {
- /*Backing file argument*/
- backed = 1;
- if (snprintf(bfilename, MAX_NAME_LEN, "%s",argv[optind++]) >=
- MAX_NAME_LEN) {
- fprintf(stderr,"Device name too long\n");
- exit(-1);
- }
- }
-
- DFPRINTF("Creating file size %"PRIu64", name %s\n",(uint64_t)size, filename);
- if (!backed)
- ret = qcow_create(filename,size,NULL,sparse);
- else
- ret = qcow_create(filename,size,bfilename,sparse);
-
- if (ret < 0)
- DPRINTF("Unable to create QCOW file\n");
- else
- DPRINTF("QCOW file successfully created\n");
-
- return 0;
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#ifndef _QCOW_H_
-#define _QCOW_H_
-
-#include "aes.h"
-/**************************************************************/
-/* QEMU COW block driver with compression and encryption support */
-
-#define QCOW_MAGIC (('Q' << 24) | ('F' << 16) | ('I' << 8) | 0xfb)
-#define XEN_MAGIC (('X' << 24) | ('E' << 16) | ('N' << 8) | 0xfb)
-#define QCOW_VERSION 1
-
-#define QCOW_CRYPT_NONE 0x00
-#define QCOW_CRYPT_AES 0x01
-
-#define QCOW_OFLAG_COMPRESSED (1LL << 63)
-#define SPARSE_FILE 0x01
-#define EXTHDR_L1_BIG_ENDIAN 0x02
-
-#ifndef O_BINARY
-#define O_BINARY 0
-#endif
-
-#define ROUNDUP(l, s) \
-({ \
- (uint64_t)( \
- (l + (s - 1)) - ((l + (s - 1)) % s)); \
-})
-
-typedef struct QCowHeader {
- uint32_t magic;
- uint32_t version;
- uint64_t backing_file_offset;
- uint32_t backing_file_size;
- uint32_t mtime;
- uint64_t size; /* in bytes */
- uint8_t cluster_bits;
- uint8_t l2_bits;
- uint32_t crypt_method;
- uint64_t l1_table_offset;
-} QCowHeader;
-
-/*Extended header for Xen enhancements*/
-typedef struct QCowHeader_ext {
- uint32_t xmagic;
- uint32_t cksum;
- uint32_t min_cluster_alloc;
- uint32_t flags;
-} QCowHeader_ext;
-
-uint32_t gen_cksum(char *ptr, int len);
-int get_filesize(char *filename, uint64_t *size, struct stat *st);
-int qtruncate(int fd, off_t length, int sparse);
-
-#define L2_CACHE_SIZE 16 /*Fixed allocation in Qemu*/
-
-struct tdqcow_state {
- int fd; /*Main Qcow file descriptor */
- uint64_t fd_end; /*Store a local record of file length */
- char *name; /*Record of the filename*/
- uint32_t backing_file_size;
- uint64_t backing_file_offset;
- uint8_t extended; /*File contains extended header*/
- int encrypted; /*File contents are encrypted or plain*/
- int cluster_bits; /*Determines length of cluster as
- *indicated by file hdr*/
- int cluster_size; /*Length of cluster*/
- int cluster_sectors; /*Number of sectors per cluster*/
- int cluster_alloc; /*Blktap fix for allocating full
- *extents*/
- int min_cluster_alloc; /*Blktap historical extent alloc*/
- int sparse; /*Indicates whether to preserve sparseness*/
- int l2_bits; /*Size of L2 table entry*/
- int l2_size; /*Full table size*/
- int l1_size; /*L1 table size*/
- uint64_t cluster_offset_mask;
- uint64_t l1_table_offset; /*L1 table offset from beginning of
- *file*/
- uint64_t *l1_table; /*L1 table entries*/
- uint64_t *l2_cache; /*We maintain a cache of size
- *L2_CACHE_SIZE of most read entries*/
- uint64_t l2_cache_offsets[L2_CACHE_SIZE]; /*L2 cache entries*/
- uint32_t l2_cache_counts[L2_CACHE_SIZE]; /*Cache access record*/
- uint8_t *cluster_cache;
- uint8_t *cluster_data;
- uint64_t cluster_cache_offset; /**/
- uint32_t crypt_method; /*current crypt method, 0 if no
- *key yet */
- uint32_t crypt_method_header; /**/
- AES_KEY aes_encrypt_key; /*AES key*/
- AES_KEY aes_decrypt_key; /*AES key*/
-
- /* libaio state */
- int aio_free_count;
- int max_aio_reqs;
- struct qcow_request *aio_requests;
- struct qcow_request **aio_free_list;
-
-};
-
-int qcow_create(const char *filename, uint64_t total_size,
- const char *backing_file, int sparse);
-
-#endif //_QCOW_H_
+++ /dev/null
-/* qcow2raw.c
- *
- * Generates raw image data from an existing qcow image
- *
- * (c) 2006 Julian Chesterfield and Andrew Warfield
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License version 2
- * as published by the Free Software Foundation; or, when distributed
- * separately from the Linux kernel or incorporated into other
- * software packages, subject to the following license:
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this source file (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy, modify,
- * merge, publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-
-#include <errno.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <inttypes.h>
-#include <unistd.h>
-#include <sys/statvfs.h>
-#include <sys/stat.h>
-#include <sys/ioctl.h>
-#include <string.h>
-
-#include "bswap.h"
-#include "aes.h"
-#include "blk.h"
-#include "tapdisk.h"
-#include "tapdisk-server.h"
-#include "tapdisk-driver.h"
-#include "tapdisk-interface.h"
-#include "tapdisk-disktype.h"
-#include "qcow.h"
-
-#if 1
-#define DFPRINTF(_f, _a...) fprintf ( stderr, _f , ## _a )
-#else
-#define DFPRINTF(_f, _a...) ((void)0)
-#endif
-
-
-/* *BSD has no O_LARGEFILE */
-#ifndef O_LARGEFILE
-#define O_LARGEFILE 0
-#endif
-
-#define BLOCK_PROCESSSZ 4096
-#define QCOW_VBD 0
-#define AIO_VBD 1
-#define WINDOW 32
-#define PROGRESS_QUANT 2
-
-static int running = 1, complete = 0;
-static int returned_read_events = 0, returned_write_events = 0;
-static int submit_events = 0;
-static uint32_t read_idx = 0;
-td_driver_t *ddqcow, *ddaio;
-td_vbd_t* qcow_vbd, *aio_vbd;
-static uint64_t prev = 0, written = 0;
-static char output[(100/PROGRESS_QUANT) + 5];
-
-extern tapdisk_server_t server;
-
-struct request_info {
- void* buf;
- uint64_t logical_sec;
- int pending;
-};
-
-static void print_bytes(void *ptr, int length)
-{
- int i,k;
- unsigned char *p = ptr;
-
- DFPRINTF("Buf dump, length %d:\n",length);
- for (k = 0; k < length; k++) {
- DFPRINTF("%x",*p);
- *p++;
- if (k % 16 == 0) DFPRINTF("\n");
- else if (k % 2 == 0) DFPRINTF(" ");
- }
- DFPRINTF("\n");
- return;
-}
-
-static void debug_output(uint64_t progress, uint64_t size)
-{
- //Output progress every PROGRESS_QUANT
- uint64_t blocks = size/(100/PROGRESS_QUANT);
-
- if (progress/blocks > prev) {
- memcpy(output+prev+1,"=>",2);
- prev++;
- DFPRINTF("\r%s %"PRIu64"%%",
- output, (uint64_t)((prev-1)*PROGRESS_QUANT));
- }
- return;
-}
-
-static void send_write_responses(td_request_t treq, int err)
-{
- struct request_info* req;
-
- if (err < 0) {
- DFPRINTF("AIO FAILURE: res [%d]!\n",err);
- return;
- }
- returned_write_events+=treq.secs;
- written += treq.secs;
-
- req= (struct request_info*)treq.cb_data;
-
- //Wait for whole request to complete.
- req->pending-=treq.secs;
- if(req->pending)
- return;
-
- //Whole request has completed, we can free buffers.
- free(req->buf);
- free(req);
-
- debug_output(written, ddaio->info.size);
-
- return;
-}
-
-static void send_read_responses(td_request_t treq, int err)
-{
- int ret;
- struct request_info* req;
- td_vbd_request_t* vreq;
-
- if (err < 0) {
- DFPRINTF("AIO FAILURE: res [%d]!\n",err);
- return;
- }
- returned_read_events+=treq.secs;
-
- req= (struct request_info*)treq.cb_data;
-
- //do nothing until all fragments complete.
- req->pending-=treq.secs;
-
- if(req->pending)
- return;
-
- //This read is done.
- tapdisk_vbd_complete_vbd_request(qcow_vbd, treq.private);
-
-
- treq.op = TD_OP_WRITE;
- treq.buf = req->buf;
- treq.sec = req->logical_sec;
- treq.secs = BLOCK_PROCESSSZ>>9;
- treq.image = tapdisk_vbd_first_image(aio_vbd);
- treq.cb = send_write_responses;
- treq.id = 0;
- treq.sidx = 0;
-
- req->pending = BLOCK_PROCESSSZ>>9;
- treq.cb_data = req;
-
- vreq = calloc(1, sizeof(td_vbd_request_t));
- treq.private = vreq;
-
- //Put it in the VBD's queue, so we don't lose
- //track of it.
- vreq->submitting = 1;
- INIT_LIST_HEAD(&vreq->next);
- tapdisk_vbd_move_request(treq.private,
- &aio_vbd->pending_requests);
-
- ddaio->ops->td_queue_write(ddaio,treq);
- --vreq->submitting;
-
- tapdisk_submit_all_tiocbs(&server.aio_queue);
-
- return;
-}
-
-int main(int argc, const char *argv[])
-{
- int ret = -1, fd, len,input;
- uint64_t size;
- struct timeval timeout;
- uint64_t i;
- char *buf = NULL;
- struct stat finfo;
- td_request_t treq;
- td_vbd_request_t* vreq;
- struct request_info* req;
- int err;
-
- if (argc != 3) {
- fprintf(stderr, "Qcow-utils: v1.0.0\n");
- fprintf(stderr, "usage: %s <Dest File descriptor> "
- "<Qcow SRC IMAGE>\n",
- argv[0]);
- exit(-1);
- }
-
- err = tapdisk_server_initialize();
- if( err ) {
- DPRINTF("qcow2raw Couldn't initialize server instance.\n");
- return err;
- }
-
- err=tapdisk_vbd_initialize(QCOW_VBD);
- if( err ) {
- DPRINTF("qcow2raw Couldn't initialize qcow vbd.\n");
- return err;
- }
-
- qcow_vbd = tapdisk_server_get_vbd(QCOW_VBD);
- if (!qcow_vbd) {
- err = -ENODEV;
- DPRINTF("qcow2raw Couldn't create qcow vbd.\n");
- return err;
- }
-
- err = tapdisk_vbd_open_vdi(qcow_vbd, argv[2], DISK_TYPE_QCOW,
- TAPDISK_STORAGE_TYPE_DEFAULT,
- TD_OPEN_RDONLY);
- if( err ) {
- DPRINTF("qcow2raw Couldn't open qcow file.\n");
- return err;
- }
-
- ddqcow=(tapdisk_vbd_first_image(qcow_vbd))->driver;
-
- /*Setup aio destination file*/
- ret = stat(argv[1],&finfo);
- if (ret == -1) {
- /*Check errno*/
- switch(errno) {
- case ENOENT:
- /*File doesn't exist, create*/
- fd = open(argv[1],
- O_RDWR | O_LARGEFILE | O_CREAT, 0644);
- if (fd < 0) {
- DFPRINTF("ERROR creating file [%s] "
- "(errno %d)\n",
- argv[1], 0 - errno);
- exit(-1);
- }
- if (ftruncate(fd, (off_t)ddqcow->info.size<<9) < 0) {
- DFPRINTF("Unable to create file "
- "[%s] of size %"PRIu64" (errno %d). "
- "Exiting...\n",
- argv[1],
- (uint64_t)ddqcow->info.size<<9,
- 0 - errno);
- close(fd);
- exit(-1);
- }
- close(fd);
- break;
- case ENXIO:
- DFPRINTF("ERROR Device [%s] does not exist\n",argv[1]);
- exit(-1);
- default:
- DFPRINTF("An error occurred opening Device [%s] "
- "(errno %d)\n",
- argv[1], 0 - errno);
- exit(-1);
- }
- } else {
- fprintf(stderr, "WARNING: All existing data in "
- "%s will be overwritten.\nDo you wish to continue? "
- "(y or n) ",
- argv[1]);
- if (getchar() != 'y') {
- DFPRINTF("Exiting...\n");
- exit(-1);
- }
-
- /*TODO - Test the existing file or device for adequate space*/
- fd = open(argv[1], O_RDWR | O_LARGEFILE);
- if (fd < 0) {
- DFPRINTF("ERROR: opening file [%s] (errno %d)\n",
- argv[1], 0 - errno);
- exit(-1);
- }
-
- if (S_ISBLK(finfo.st_mode)) {
- if (blk_getimagesize(fd, &size) != 0) {
- close(fd);
- return -1;
- }
-
- if (size < ddqcow->info.size<<9) {
- DFPRINTF("ERROR: Not enough space on device "
- "%s (%"PRIu64" bytes available, "
- "%"PRIu64" bytes required\n",
- argv[1], size,
- (uint64_t)ddqcow->info.size<<9);
- close(fd);
- exit(-1);
- }
- } else {
- if (ftruncate(fd, (off_t)ddqcow->info.size<<9) < 0) {
- DFPRINTF("Unable to create file "
- "[%s] of size %"PRIu64" (errno %d). "
- "Exiting...\n",
- argv[1],
- (uint64_t)ddqcow->info.size<<9,
- 0 - errno);
- close(fd);
- exit(-1);
- } else DFPRINTF("File [%s] truncated to length %"PRIu64" "
- "(%"PRIu64")\n",
- argv[1],
- (uint64_t)ddqcow->info.size<<9,
- (uint64_t)ddqcow->info.size);
- }
- close(fd);
- }
-
- //Now the output file should be there, reopen it as an aio VBD
- err=tapdisk_vbd_initialize(AIO_VBD);
- if( err ) {
- DPRINTF("qcow2raw Couldn't initialize aio vbd.\n");
- return err;
- }
-
- aio_vbd = tapdisk_server_get_vbd(AIO_VBD);
- if (!aio_vbd) {
- err = -ENODEV;
- DPRINTF("qcow2raw Couldn't create aio vbd.\n");
- return err;
- }
-
- err = tapdisk_vbd_open_vdi(aio_vbd, argv[1], DISK_TYPE_AIO,
- TAPDISK_STORAGE_TYPE_DEFAULT,
- 0);
- if( err ) {
- DPRINTF("qcow2raw Couldn't open aio file.\n");
- return err;
- }
-
- ddaio=(tapdisk_vbd_first_image(aio_vbd))->driver;
-
- /*Initialise the output string*/
- memset(output,0x20,(100/PROGRESS_QUANT)+5);
- output[0] = '[';
- output[(100/PROGRESS_QUANT)+2] = ']';
- output[(100/PROGRESS_QUANT)+3] = '\0';
- DFPRINTF("%s",output);
-
- i = 0;
- while (running) {
- timeout.tv_sec = 0;
-
- if (!complete) {
- /*Read Pages from qcow image*/
- if ( (ret = posix_memalign((void **)&buf,
- BLOCK_PROCESSSZ,
- BLOCK_PROCESSSZ))
- != 0) {
- DFPRINTF("Unable to alloc memory (%d)\n",ret);
- exit(-1);
- }
-
- /*Attempt to read 4k sized blocks*/
- submit_events+=BLOCK_PROCESSSZ>>9;
-
- //Set up the read request
- treq.op = TD_OP_READ;
- treq.buf = buf;
- treq.sec = i;
- treq.secs = BLOCK_PROCESSSZ>>9;
- treq.image = tapdisk_vbd_first_image(qcow_vbd);
- treq.cb = send_read_responses;
- treq.id = 0;
- treq.sidx = 0;
-
- req = calloc(1, sizeof(struct request_info));
- req->buf = buf;
- req->logical_sec = i;
- req->pending = BLOCK_PROCESSSZ>>9;
- treq.cb_data = req;
-
- vreq = calloc(1, sizeof(td_vbd_request_t));
- treq.private = vreq;
-
- //Put it in the VBD's queue, so we don't lose
- //track of it.
- vreq->submitting = 1;
- INIT_LIST_HEAD(&vreq->next);
- tapdisk_vbd_move_request(treq.private,
- &qcow_vbd->pending_requests);
-
- ddqcow->ops->td_queue_read(ddqcow, treq);
- --vreq->submitting;
-
- i += BLOCK_PROCESSSZ>>9;
-
- if (i >= ddqcow->info.size)
- complete = 1;
-
-
- tapdisk_submit_all_tiocbs(&server.aio_queue);
- }
-
-
- while(returned_write_events != submit_events) {
- ret = scheduler_wait_for_events(&server.scheduler);
- if (ret < 0) {
- DFPRINTF("server wait returned %d\n", ret);
- sleep(2);
- }
- }
- if (complete && (returned_write_events == submit_events))
- running = 0;
- }
- memcpy(output+prev+1,"=",1);
- DFPRINTF("\r%s 100%%\nTRANSFER COMPLETE\n\n", output);
-
- ddqcow->ops->td_close(ddqcow);
- ddaio->ops->td_close(ddaio);
- free(ddqcow->data);
- free(ddaio->data);
-
- return 0;
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include <errno.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <sys/time.h>
-
-#include "scheduler.h"
-#include "tapdisk-log.h"
-
-#define DBG(_f, _a...) tlog_write(TLOG_DBG, _f, ##_a)
-
-#define SCHEDULER_MAX_TIMEOUT 600
-#define SCHEDULER_POLL_FD (SCHEDULER_POLL_READ_FD | \
- SCHEDULER_POLL_WRITE_FD | \
- SCHEDULER_POLL_EXCEPT_FD)
-
-#define MIN(a, b) ((a) <= (b) ? (a) : (b))
-#define MAX(a, b) ((a) >= (b) ? (a) : (b))
-
-#define scheduler_for_each_event(s, event, tmp) \
- list_for_each_entry_safe(event, tmp, &(s)->events, next)
-
-typedef struct event {
- char mode;
- event_id_t id;
-
- int fd;
- int timeout;
- int deadline;
-
- event_cb_t cb;
- void *private;
-
- struct list_head next;
-} event_t;
-
-static void
-scheduler_prepare_events(scheduler_t *s)
-{
- int diff;
- struct timeval now;
- event_t *event, *tmp;
-
- FD_ZERO(&s->read_fds);
- FD_ZERO(&s->write_fds);
- FD_ZERO(&s->except_fds);
-
- s->max_fd = 0;
- s->timeout = SCHEDULER_MAX_TIMEOUT;
-
- gettimeofday(&now, NULL);
-
- scheduler_for_each_event(s, event, tmp) {
- if (event->mode & SCHEDULER_POLL_READ_FD) {
- FD_SET(event->fd, &s->read_fds);
- s->max_fd = MAX(event->fd, s->max_fd);
- }
-
- if (event->mode & SCHEDULER_POLL_WRITE_FD) {
- FD_SET(event->fd, &s->write_fds);
- s->max_fd = MAX(event->fd, s->max_fd);
- }
-
- if (event->mode & SCHEDULER_POLL_EXCEPT_FD) {
- FD_SET(event->fd, &s->except_fds);
- s->max_fd = MAX(event->fd, s->max_fd);
- }
-
- if (event->mode & SCHEDULER_POLL_TIMEOUT) {
- diff = event->deadline - now.tv_sec;
- if (diff > 0)
- s->timeout = MIN(s->timeout, diff);
- else
- s->timeout = 0;
- }
- }
-
- s->timeout = MIN(s->timeout, s->max_timeout);
-}
-
-static void
-scheduler_event_callback(event_t *event, char mode)
-{
- if (event->mode & SCHEDULER_POLL_TIMEOUT) {
- struct timeval now;
- gettimeofday(&now, NULL);
- event->deadline = now.tv_sec + event->timeout;
- }
-
- event->cb(event->id, mode, event->private);
-}
-
-static void
-scheduler_run_events(scheduler_t *s)
-{
- struct timeval now;
- event_t *event, *tmp;
-
- gettimeofday(&now, NULL);
-
- again:
- s->restart = 0;
-
- scheduler_for_each_event(s, event, tmp) {
- if ((event->mode & SCHEDULER_POLL_READ_FD) &&
- FD_ISSET(event->fd, &s->read_fds)) {
- FD_CLR(event->fd, &s->read_fds);
- scheduler_event_callback(event, SCHEDULER_POLL_READ_FD);
- goto next;
- }
-
- if ((event->mode & SCHEDULER_POLL_WRITE_FD) &&
- FD_ISSET(event->fd, &s->write_fds)) {
- FD_CLR(event->fd, &s->write_fds);
- scheduler_event_callback(event, SCHEDULER_POLL_WRITE_FD);
- goto next;
- }
-
- if ((event->mode & SCHEDULER_POLL_EXCEPT_FD) &&
- FD_ISSET(event->fd, &s->except_fds)) {
- FD_CLR(event->fd, &s->except_fds);
- scheduler_event_callback(event, SCHEDULER_POLL_EXCEPT_FD);
- goto next;
- }
-
- if ((event->mode & SCHEDULER_POLL_TIMEOUT) &&
- (event->deadline <= now.tv_sec))
- scheduler_event_callback(event, SCHEDULER_POLL_TIMEOUT);
-
- next:
- if (s->restart)
- goto again;
- }
-}
-
-int
-scheduler_register_event(scheduler_t *s, char mode, int fd,
- int timeout, event_cb_t cb, void *private)
-{
- event_t *event;
- struct timeval now;
-
- if (!cb)
- return -EINVAL;
-
- if (!(mode & SCHEDULER_POLL_TIMEOUT) && !(mode & SCHEDULER_POLL_FD))
- return -EINVAL;
-
- event = calloc(1, sizeof(event_t));
- if (!event)
- return -ENOMEM;
-
- gettimeofday(&now, NULL);
-
- INIT_LIST_HEAD(&event->next);
-
- event->mode = mode;
- event->fd = fd;
- event->timeout = timeout;
- event->deadline = now.tv_sec + timeout;
- event->cb = cb;
- event->private = private;
- event->id = s->uuid++;
-
- if (!s->uuid)
- s->uuid++;
-
- list_add_tail(&event->next, &s->events);
-
- return event->id;
-}
-
-void
-scheduler_unregister_event(scheduler_t *s, event_id_t id)
-{
- event_t *event, *tmp;
-
- if (!id)
- return;
-
- scheduler_for_each_event(s, event, tmp)
- if (event->id == id) {
- list_del(&event->next);
- free(event);
- s->restart = 1;
- break;
- }
-}
-
-void
-scheduler_set_max_timeout(scheduler_t *s, int timeout)
-{
- if (timeout >= 0)
- s->max_timeout = MIN(s->max_timeout, timeout);
-}
-
-int
-scheduler_wait_for_events(scheduler_t *s)
-{
- int ret;
- struct timeval tv;
-
- scheduler_prepare_events(s);
-
- tv.tv_sec = s->timeout;
- tv.tv_usec = 0;
-
- DBG("timeout: %d, max_timeout: %d\n",
- s->timeout, s->max_timeout);
-
- ret = select(s->max_fd + 1, &s->read_fds,
- &s->write_fds, &s->except_fds, &tv);
-
- s->restart = 0;
- s->timeout = SCHEDULER_MAX_TIMEOUT;
- s->max_timeout = SCHEDULER_MAX_TIMEOUT;
-
- if (ret < 0)
- return ret;
-
- scheduler_run_events(s);
-
- return ret;
-}
-
-void
-scheduler_initialize(scheduler_t *s)
-{
- memset(s, 0, sizeof(scheduler_t));
-
- s->uuid = 1;
-
- FD_ZERO(&s->read_fds);
- FD_ZERO(&s->write_fds);
- FD_ZERO(&s->except_fds);
-
- INIT_LIST_HEAD(&s->events);
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#ifndef _SCHEDULER_H_
-#define _SCHEDULER_H_
-
-#include <sys/select.h>
-
-#include "list.h"
-
-#define SCHEDULER_POLL_READ_FD 0x1
-#define SCHEDULER_POLL_WRITE_FD 0x2
-#define SCHEDULER_POLL_EXCEPT_FD 0x4
-#define SCHEDULER_POLL_TIMEOUT 0x8
-
-typedef int event_id_t;
-typedef void (*event_cb_t) (event_id_t id, char mode, void *private);
-
-typedef struct scheduler {
- fd_set read_fds;
- fd_set write_fds;
- fd_set except_fds;
-
- struct list_head events;
-
- int uuid;
- int max_fd;
- int timeout;
- int restart;
- int max_timeout;
-} scheduler_t;
-
-void scheduler_initialize(scheduler_t *);
-event_id_t scheduler_register_event(scheduler_t *, char mode,
- int fd, int timeout,
- event_cb_t cb, void *private);
-void scheduler_unregister_event(scheduler_t *, event_id_t);
-void scheduler_set_max_timeout(scheduler_t *, int);
-int scheduler_wait_for_events(scheduler_t *);
-
-#endif
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/* client harness for tapdisk log */
-
-#include <errno.h>
-#include <fcntl.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <sys/mman.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <sys/un.h>
-
-#include "log.h"
-
-#define BDPRINTF(_f, _a...) fprintf (stderr, "log: " _f "\n", ## _a)
-
-#define BWPRINTF(_f, _a...) fprintf (stderr, "log: " _f "\n", ## _a)
-
-struct writelog {
- char* shmpath;
- uint32_t shmsize;
- void* shm;
-
- /* next unprocessed item in the writelog */
- void* cur;
- unsigned int inflight;
-
- /* pointer to start and end of free data space for requests */
- void* dhd;
- void* dtl;
-
- log_sring_t* sring;
- log_front_ring_t fring;
-};
-
-/* bytes free on the data ring */
-static inline unsigned int dring_avail(struct writelog* wl)
-{
- /* one byte reserved to distinguish empty from full */
- if (wl->dhd == wl->dtl)
- return sdataend(wl->shm) - sdatastart(wl->shm) - 1;
-
- if (wl->dhd < wl->dtl)
- return wl->dtl - wl->dhd - 1;
-
- return (sdataend(wl->shm) - wl->dhd) + (wl->dtl - sdatastart(wl->shm)) - 1;
-}
-
-/* advance ring pointer by len bytes */
-static inline void* dring_advance(struct writelog* wl, void* start, size_t len)
-{
- void* next;
- int dsz = sdataend(wl->shm) - sdatastart(wl->shm);
-
- next = start + (len % dsz);
- if (next > sdataend(wl->shm))
- next -= dsz;
-
- return next;
-}
-
-static void usage(void)
-{
- fprintf(stderr, "usage: tapdisk-client <sock>\n");
-}
-
-/* returns socket file descriptor */
-static int tdctl_open(const char* sockpath)
-{
- struct sockaddr_un saddr;
- int fd;
-
- if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
- BWPRINTF("error creating socket: %s", strerror(errno));
- return -1;
- }
-
- memset(&saddr, 0, sizeof(saddr));
- saddr.sun_family = AF_UNIX;
- memcpy(saddr.sun_path, sockpath, strlen(sockpath));
-
- if (connect(fd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0) {
- BWPRINTF("error connecting to socket %s: %s", sockpath, strerror(errno));
- close(fd);
- return -1;
- }
-
- return fd;
-}
-
-static int ctl_talk(int fd, struct log_ctlmsg* msg, char* rsp, int rsplen)
-{
- int rc;
-
- if ((rc = write(fd, msg, sizeof(*msg))) < 0) {
- BWPRINTF("error sending ctl request: %s", strerror(errno));
- return -1;
- } else if (rc < sizeof(*msg)) {
- BWPRINTF("short ctl write (%d/%zd bytes)", rc, sizeof(*msg));
- return -1;
- }
-
- if (!rsplen)
- return 0;
-
- if ((rc = read(fd, rsp, rsplen)) < 0) {
- BWPRINTF("error reading ctl response: %s", strerror(errno));
- return -1;
- } else if (rc < rsplen) {
- BWPRINTF("short ctl read (%d/%d bytes)", rc, rsplen);
- return -1;
- }
-
- return 0;
-}
-
-static int ctl_get_shmem(int fd, struct writelog* wl)
-{
- struct log_ctlmsg req;
- char rsp[CTLRSPLEN_SHMP + 1];
- int rc;
-
- memset(&req, 0, sizeof(req));
- memset(rsp, 0, sizeof(rsp));
-
- memcpy(req.msg, LOGCMD_SHMP, 4);
- if ((rc = ctl_talk(fd, &req, rsp, CTLRSPLEN_SHMP)) < 0) {
- BWPRINTF("error getting shared memory parameters");
- return -1;
- }
-
- memcpy(&wl->shmsize, rsp, sizeof(wl->shmsize));
- wl->shmpath = strdup(rsp + sizeof(wl->shmsize));
-
- BDPRINTF("shared memory parameters: size: %u, path: %s",
- wl->shmsize, wl->shmpath);
-
- return 0;
-}
-
-static void ctlmsg_init(struct log_ctlmsg* msg, const char* cmd)
-{
- memset(msg, 0, sizeof(*msg));
- memcpy(msg->msg, cmd, 4);
-}
-
-static int ctl_get_writes(int fd)
-{
- struct log_ctlmsg req;
- char rsp[CTLRSPLEN_GET];
- int rc;
-
- ctlmsg_init(&req, LOGCMD_GET);
-
- if ((rc = ctl_talk(fd, &req, rsp, CTLRSPLEN_GET)) < 0) {
- BWPRINTF("error getting writes");
- return -1;
- }
-
- return 0;
-}
-
-static int ctl_peek_writes(int fd)
-{
- struct log_ctlmsg req;
- char rsp[CTLRSPLEN_PEEK];
- int rc;
-
- ctlmsg_init(&req, LOGCMD_PEEK);
-
- if ((rc = ctl_talk(fd, &req, rsp, CTLRSPLEN_PEEK)) < 0) {
- BWPRINTF("error peeking writes");
- return -1;
- }
-
- return 0;
-}
-
-/* submit pending requests */
-static int ctl_kick(int fd)
-{
- struct log_ctlmsg req;
- int rc;
-
- ctlmsg_init(&req, LOGCMD_KICK);
-
- if ((rc = ctl_talk(fd, &req, NULL, 0)) < 0) {
- BWPRINTF("error kicking ring");
- return -1;
- }
-
- return 0;
-}
-
-static int ctl_clear_writes(int fd)
-{
- struct log_ctlmsg req;
- char rsp[CTLRSPLEN_CLEAR];
- int rc;
-
- ctlmsg_init(&req, LOGCMD_CLEAR);
-
- if ((rc = ctl_talk(fd, &req, rsp, CTLRSPLEN_CLEAR)) < 0) {
- BWPRINTF("error clearing writes");
- return -1;
- }
-
- return 0;
-}
-
-static int writelog_map(struct writelog* wl)
-{
- int fd;
- void* shm;
-
- if ((fd = shm_open(wl->shmpath, O_RDWR, 0750)) < 0) {
- BWPRINTF("could not open shared memory at %s: %s", wl->shmpath,
- strerror(errno));
- return -1;
- }
-
- wl->shm = mmap(NULL, wl->shmsize, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
- close(fd);
- if (wl->shm == MAP_FAILED) {
- BWPRINTF("could not mmap write log shm: %s", strerror(errno));
- return -1;
- }
- wl->cur = wl->shm;
- wl->inflight = 0;
- wl->dhd = wl->dtl = sdatastart(wl->shm);
-
- BDPRINTF("shm cookie: 0x%x, data size: %u", *((uint32_t*)wl->shm),
- dring_avail(wl));
-
- wl->sring = sringstart(wl->shm);
- /* need some thought about what to do on reconnect */
- FRONT_RING_INIT(&wl->fring, wl->sring, SRINGSIZE);
-
- return 0;
-}
-
-static int writelog_dump(struct writelog* wl)
-{
- struct disk_range* range = wl->shm;
-
- for (range = wl->shm; (void*)range < bmend(wl->shm); range++) {
- if (!range->count)
- break;
-
- BDPRINTF("dirty extent: %"PRIu64":%u",
- range->sector, range->count);
- }
-
- return 0;
-}
-
-/* walk dirty map and enqueue read requests.
- * returns: 0 when entire bitmap has been enqueued,
- * 1 when the ring is full
- * -1 on error
- */
-static int writelog_enqueue_requests(struct writelog* wl)
-{
- struct disk_range* range = wl->shm;
- log_request_t* req;
-
- for (range = wl->cur; (void*)range < bmend(wl->shm); range++) {
- if (!range->count)
- break;
-
- if (RING_FULL(&wl->fring))
- break;
-
- /* insert range into request stream */
- /* 1. get next request slot from ring */
- /* 2. ensure enough shm space is available */
-
- BDPRINTF("enqueueing dirty extent: %"PRIu64":%u (ring space: %d/%d)",
- range->sector, range->count, RING_FREE_REQUESTS(&wl->fring),
- RING_SIZE(&wl->fring));
-
- req = RING_GET_REQUEST(&wl->fring, wl->fring.req_prod_pvt);
-
- req->sector = range->sector;
- req->count = range->count;
- /* ... */
- req->offset = 0;
-
- wl->fring.req_prod_pvt++;
- wl->inflight++;
- }
-
- wl->cur = range;
-
- if (range->count)
- return 1;
-
- return 0;
-}
-
-static int writelog_dequeue_responses(struct writelog* wl)
-{
- RING_IDX rstart, rend;
- log_response_t rsp;
-
- rstart = wl->fring.rsp_cons;
- rend = wl->sring->rsp_prod;
-
- BDPRINTF("ring kicked (start = %u, end = %u)", rstart, rend);
-
- while (rstart != rend) {
- memcpy(&rsp, RING_GET_RESPONSE(&wl->fring, rstart), sizeof(rsp));
- BDPRINTF("ctl: read response %"PRIu64":%u", rsp.sector, rsp.count);
- wl->fring.rsp_cons = ++rstart;
- wl->inflight--;
- }
-
- return 0;
-}
-
-static int writelog_free(struct writelog* wl)
-{
- if (wl->shmpath) {
- free(wl->shmpath);
- wl->shmpath = NULL;
- }
- if (wl->shm) {
- munmap(wl->shm, wl->shmsize);
- wl->shm = NULL;
- }
-
- return 0;
-}
-
-int get_writes(struct writelog* wl, int fd, int peek)
-{
- int rc;
-
- if (peek)
- rc = ctl_peek_writes(fd);
- else
- rc = ctl_get_writes(fd);
-
- if (rc < 0)
- return rc;
-
- wl->cur = wl->shm;
-
- return 0;
-}
-
-int await_responses(struct writelog* wl, int fd)
-{
- struct log_ctlmsg msg;
- int rc;
-
- /* sit on socket waiting for kick */
- if ((rc = read(fd, &msg, sizeof(msg))) < 0) {
- BWPRINTF("error reading from control socket: %s", strerror(errno));
- return -1;
- } else if (!rc) {
- BWPRINTF("EOF on control socket");
- return -1;
- } else if (rc < sizeof(msg)) {
- BWPRINTF("short reply (%d/%d bytes)", rc, (int) sizeof(msg));
- return -1;
- }
-
- if (strncmp(msg.msg, LOGCMD_KICK, 4)) {
- BWPRINTF("Unknown message received: %.4s", msg.msg);
- return -1;
- }
-
- if (writelog_dequeue_responses(wl) < 0)
- return -1;
-
- return 0;
-}
-
-/* read_loop:
- * 1. extract dirty bitmap
- * 2. feed as much as possible onto ring
- * 3. kick
- * 4. as responses come back, feed more of the dirty bitmap
- * into the ring
- * 5. when entire bitmap has been queued, go to 1?
- */
-int read_loop(struct writelog* wl, int fd)
-{
- int rc;
-
- if (get_writes(wl, fd, 1) < 0)
- return -1;
- writelog_dump(wl);
-
- do {
- rc = writelog_enqueue_requests(wl);
-
- if (RING_FREE_REQUESTS(&wl->fring) < RING_SIZE(&wl->fring))
- RING_PUSH_REQUESTS(&wl->fring);
- if (ctl_kick(fd) < 0)
- return -1;
-
- /* collect responses */
- if (wl->inflight && await_responses(wl, fd) < 0)
- return -1;
- } while (rc > 0);
-
- return rc;
-}
-
-int main(int argc, char* argv[])
-{
- int fd;
- struct writelog wl;
- char cmd;
-
- if (argc < 2) {
- usage();
- return 1;
- }
-
- if (argc < 3)
- cmd = 'p';
- else
- cmd = argv[2][0];
-
- fd = tdctl_open(argv[1]);
-
- if (ctl_get_shmem(fd, &wl) < 0)
- return 1;
-
- if (writelog_map(&wl) < 0) {
- BWPRINTF("Error mapping write log: %s", strerror(errno));
- return 1;
- }
-
- switch (cmd) {
- case 'p':
- if (get_writes(&wl, fd, 1) < 0)
- return 1;
- writelog_dump(&wl);
- break;
- case 'c':
- if (ctl_clear_writes(fd) < 0)
- return 1;
- break;
- case 'g':
- if (get_writes(&wl, fd, 0) < 0)
- return 1;
- writelog_dump(&wl);
- break;
- case 'r':
- if (read_loop(&wl, fd) < 0)
- return 1;
- break;
- default:
- usage();
- return 1;
- }
-
- writelog_free(&wl);
- close(fd);
-
- return 0;
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include <stdio.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <string.h>
-#include <signal.h>
-#include <sys/un.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <sys/ioctl.h>
-#include <sys/socket.h>
-
-#include "list.h"
-#include "tapdisk.h"
-#include "blktap2.h"
-#include "blktaplib.h"
-#include "tapdisk-vbd.h"
-#include "tapdisk-utils.h"
-#include "tapdisk-server.h"
-#include "tapdisk-message.h"
-#include "tapdisk-disktype.h"
-
-struct tapdisk_control {
- char *path;
- int socket;
- int event_id;
-};
-
-struct tapdisk_control_connection {
- int socket;
- event_id_t event_id;
-};
-
-static struct tapdisk_control td_control;
-
-static void
-tapdisk_control_initialize(void)
-{
- td_control.socket = -1;
- td_control.event_id = -1;
-
- signal(SIGPIPE, SIG_IGN);
-}
-
-void
-tapdisk_control_close(void)
-{
- if (td_control.path) {
- unlink(td_control.path);
- free(td_control.path);
- td_control.path = NULL;
- }
-
- if (td_control.socket != -1) {
- close(td_control.socket);
- td_control.socket = -1;
- }
-}
-
-static struct tapdisk_control_connection *
-tapdisk_control_allocate_connection(int fd)
-{
- struct tapdisk_control_connection *connection;
- size_t sz;
-
- connection = calloc(1, sizeof(*connection));
- if (!connection) {
- EPRINTF("calloc");
- return NULL;
- }
-
- connection->socket = fd;
- return connection;
-}
-
-static void
-tapdisk_control_close_connection(struct tapdisk_control_connection *connection)
-{
- tapdisk_server_unregister_event(connection->event_id);
- close(connection->socket);
- free(connection);
-}
-
-static int
-tapdisk_control_read_message(int fd, tapdisk_message_t *message, int timeout)
-{
- fd_set readfds;
- int ret, len, offset;
- struct timeval tv, *t;
-
- t = NULL;
- offset = 0;
- len = sizeof(tapdisk_message_t);
-
- if (timeout) {
- tv.tv_sec = timeout;
- tv.tv_usec = 0;
- t = &tv;
- }
-
- memset(message, 0, sizeof(tapdisk_message_t));
-
- while (offset < len) {
- FD_ZERO(&readfds);
- FD_SET(fd, &readfds);
-
- ret = select(fd + 1, &readfds, NULL, NULL, t);
- if (ret == -1)
- break;
- else if (FD_ISSET(fd, &readfds)) {
- ret = read(fd, message + offset, len - offset);
- if (ret <= 0)
- break;
- offset += ret;
- } else
- break;
- }
-
- if (offset != len) {
- EPRINTF("failure reading message (wanted %d but got %d)\n",
- len, offset);
- return -EIO;
- }
-
- DPRINTF("received '%s' message (uuid = %u)\n",
- tapdisk_message_name(message->type), message->cookie);
-
- return 0;
-}
-
-static int
-tapdisk_control_write_message(int fd, tapdisk_message_t *message, int timeout)
-{
- fd_set writefds;
- int ret, len, offset;
- struct timeval tv, *t;
-
- t = NULL;
- offset = 0;
- len = sizeof(tapdisk_message_t);
-
- if (timeout) {
- tv.tv_sec = timeout;
- tv.tv_usec = 0;
- t = &tv;
- }
-
- DPRINTF("sending '%s' message (uuid = %u)\n",
- tapdisk_message_name(message->type), message->cookie);
-
- while (offset < len) {
- FD_ZERO(&writefds);
- FD_SET(fd, &writefds);
-
- /* we don't bother reinitializing tv. at worst, it will wait a
- * bit more time than expected. */
-
- ret = select(fd + 1, NULL, &writefds, NULL, t);
- if (ret == -1)
- break;
- else if (FD_ISSET(fd, &writefds)) {
- ret = write(fd, message + offset, len - offset);
- if (ret <= 0)
- break;
- offset += ret;
- } else
- break;
- }
-
- if (offset != len) {
- EPRINTF("failure writing message\n");
- return -EIO;
- }
-
- return 0;
-}
-
-static int
-tapdisk_control_validate_request(tapdisk_message_t *request)
-{
- if (strnlen(request->u.params.path,
- TAPDISK_MESSAGE_MAX_PATH_LENGTH) >=
- TAPDISK_MESSAGE_MAX_PATH_LENGTH)
- return EINVAL;
-
- return 0;
-}
-
-static void
-tapdisk_control_list_minors(struct tapdisk_control_connection *connection,
- tapdisk_message_t *request)
-{
- int i;
- td_vbd_t *vbd;
- struct list_head *head;
- tapdisk_message_t response;
-
- i = 0;
- memset(&response, 0, sizeof(response));
-
- response.type = TAPDISK_MESSAGE_LIST_MINORS_RSP;
- response.cookie = request->cookie;
-
- head = tapdisk_server_get_all_vbds();
-
- list_for_each_entry(vbd, head, next) {
- response.u.minors.list[i++] = vbd->minor;
- if (i >= TAPDISK_MESSAGE_MAX_MINORS) {
- response.type = TAPDISK_MESSAGE_ERROR;
- response.u.response.error = ERANGE;
- break;
- }
- }
-
- response.u.minors.count = i;
- tapdisk_control_write_message(connection->socket, &response, 2);
- tapdisk_control_close_connection(connection);
-}
-
-static void
-tapdisk_control_list(struct tapdisk_control_connection *connection,
- tapdisk_message_t *request)
-{
- td_vbd_t *vbd;
- struct list_head *head;
- tapdisk_message_t response;
- int count, i;
-
- memset(&response, 0, sizeof(response));
- response.type = TAPDISK_MESSAGE_LIST_RSP;
- response.cookie = request->cookie;
-
- head = tapdisk_server_get_all_vbds();
-
- count = 0;
- list_for_each_entry(vbd, head, next)
- count++;
-
- list_for_each_entry(vbd, head, next) {
- response.u.list.count = count--;
- response.u.list.minor = vbd->minor;
- response.u.list.state = vbd->state;
- response.u.list.path[0] = 0;
-
- if (!list_empty(&vbd->images)) {
- td_image_t *image = list_entry(vbd->images.next,
- td_image_t, next);
- snprintf(response.u.list.path,
- sizeof(response.u.list.path),
- "%s:%s",
- tapdisk_disk_types[image->type]->name,
- image->name);
- }
-
- tapdisk_control_write_message(connection->socket, &response, 2);
- }
-
- response.u.list.count = count;
- response.u.list.minor = -1;
- response.u.list.path[0] = 0;
-
- tapdisk_control_write_message(connection->socket, &response, 2);
- tapdisk_control_close_connection(connection);
-}
-
-static void
-tapdisk_control_get_pid(struct tapdisk_control_connection *connection,
- tapdisk_message_t *request)
-{
- tapdisk_message_t response;
-
- memset(&response, 0, sizeof(response));
- response.type = TAPDISK_MESSAGE_PID_RSP;
- response.cookie = request->cookie;
- response.u.tapdisk_pid = getpid();
-
- tapdisk_control_write_message(connection->socket, &response, 2);
- tapdisk_control_close_connection(connection);
-}
-
-static void
-tapdisk_control_attach_vbd(struct tapdisk_control_connection *connection,
- tapdisk_message_t *request)
-{
- tapdisk_message_t response;
- char *devname;
- td_vbd_t *vbd;
- struct blktap2_params params;
- image_t image;
- int minor, err;
-
- /*
- * TODO: check for max vbds per process
- */
-
- vbd = tapdisk_server_get_vbd(request->cookie);
- if (vbd) {
- err = -EEXIST;
- goto out;
- }
-
- minor = request->cookie;
- if (minor < 0) {
- err = -EINVAL;
- goto out;
- }
-
- vbd = tapdisk_vbd_create(minor);
- if (!vbd) {
- err = -ENOMEM;
- goto out;
- }
-
- err = asprintf(&devname, BLKTAP2_RING_DEVICE"%d", minor);
- if (err == -1) {
- err = -ENOMEM;
- goto fail_vbd;
- }
-
- err = tapdisk_vbd_attach(vbd, devname, minor);
- free(devname);
- if (err)
- goto fail_vbd;
-
- tapdisk_server_add_vbd(vbd);
-
-out:
- memset(&response, 0, sizeof(response));
- response.type = TAPDISK_MESSAGE_ATTACH_RSP;
- response.cookie = request->cookie;
- response.u.response.error = -err;
-
- tapdisk_control_write_message(connection->socket, &response, 2);
- tapdisk_control_close_connection(connection);
-
- return;
-
-fail_vbd:
- tapdisk_vbd_detach(vbd);
- free(vbd);
- goto out;
-}
-
-
-static void
-tapdisk_control_detach_vbd(struct tapdisk_control_connection *connection,
- tapdisk_message_t *request)
-{
- tapdisk_message_t response;
- td_vbd_t *vbd;
- int err;
-
- vbd = tapdisk_server_get_vbd(request->cookie);
- if (!vbd) {
- err = -EINVAL;
- goto out;
- }
-
- tapdisk_vbd_detach(vbd);
-
- if (list_empty(&vbd->images)) {
- tapdisk_server_remove_vbd(vbd);
- free(vbd);
- }
-
- err = 0;
-out:
- memset(&response, 0, sizeof(response));
- response.type = TAPDISK_MESSAGE_DETACH_RSP;
- response.cookie = request->cookie;
- response.u.response.error = -err;
-
- tapdisk_control_write_message(connection->socket, &response, 2);
- tapdisk_control_close_connection(connection);
-}
-
-static void
-tapdisk_control_open_image(struct tapdisk_control_connection *connection,
- tapdisk_message_t *request)
-{
- int err;
- image_t image;
- td_vbd_t *vbd;
- td_flag_t flags;
- tapdisk_message_t response;
- struct blktap2_params params;
-
- vbd = tapdisk_server_get_vbd(request->cookie);
- if (!vbd) {
- err = -EINVAL;
- goto out;
- }
-
- if (vbd->minor == -1) {
- err = -EINVAL;
- goto out;
- }
-
- if (vbd->name) {
- err = -EALREADY;
- goto out;
- }
-
- flags = 0;
- if (request->u.params.flags & TAPDISK_MESSAGE_FLAG_RDONLY)
- flags |= TD_OPEN_RDONLY;
- if (request->u.params.flags & TAPDISK_MESSAGE_FLAG_SHARED)
- flags |= TD_OPEN_SHAREABLE;
- if (request->u.params.flags & TAPDISK_MESSAGE_FLAG_ADD_CACHE)
- flags |= TD_OPEN_ADD_CACHE;
- if (request->u.params.flags & TAPDISK_MESSAGE_FLAG_VHD_INDEX)
- flags |= TD_OPEN_VHD_INDEX;
- if (request->u.params.flags & TAPDISK_MESSAGE_FLAG_LOG_DIRTY)
- flags |= TD_OPEN_LOG_DIRTY;
-
- vbd->name = strndup(request->u.params.path,
- sizeof(request->u.params.path));
- if (!vbd->name) {
- err = -ENOMEM;
- goto out;
- }
-
- err = tapdisk_vbd_parse_stack(vbd, request->u.params.path);
- if (err)
- goto out;
-
- err = tapdisk_vbd_open_stack(vbd, request->u.params.storage, flags);
- if (err)
- goto out;
-
- err = tapdisk_vbd_get_image_info(vbd, &image);
- if (err)
- goto fail_close;
-
- params.capacity = image.size;
- params.sector_size = image.secsize;
- strncpy(params.name, vbd->name, BLKTAP2_MAX_MESSAGE_LEN - 1);
- params.name[BLKTAP2_MAX_MESSAGE_LEN - 1] = '\0';
-
- err = ioctl(vbd->ring.fd, BLKTAP2_IOCTL_CREATE_DEVICE, ¶ms);
- if (err && errno != EEXIST) {
- err = -errno;
- EPRINTF("create device failed: %d\n", err);
- goto fail_close;
- }
-
- err = 0;
-
-out:
- memset(&response, 0, sizeof(response));
- response.cookie = request->cookie;
-
- if (err) {
- response.type = TAPDISK_MESSAGE_ERROR;
- response.u.response.error = -err;
- } else {
- response.u.image.sectors = image.size;
- response.u.image.sector_size = image.secsize;
- response.u.image.info = image.info;
- response.type = TAPDISK_MESSAGE_OPEN_RSP;
- }
-
- tapdisk_control_write_message(connection->socket, &response, 2);
- tapdisk_control_close_connection(connection);
-
- return;
-
-fail_close:
- tapdisk_vbd_close_vdi(vbd);
- free(vbd->name);
- vbd->name = NULL;
- goto out;
-}
-
-static void
-tapdisk_control_close_image(struct tapdisk_control_connection *connection,
- tapdisk_message_t *request)
-{
- tapdisk_message_t response;
- td_vbd_t *vbd;
- int err;
-
- vbd = tapdisk_server_get_vbd(request->cookie);
- if (!vbd) {
- err = -EINVAL;
- goto out;
- }
-
- if (!list_empty(&vbd->pending_requests)) {
- err = -EAGAIN;
- goto out;
- }
-
- tapdisk_vbd_close_vdi(vbd);
-
- /* NB. vbd->name free should probably belong into close_vdi,
- but the current blktap1 reopen-stuff likely depends on a
- lifetime extended until shutdown. */
- free(vbd->name);
- vbd->name = NULL;
-
- if (vbd->minor == -1) {
- tapdisk_server_remove_vbd(vbd);
- tapdisk_vbd_free(vbd);
- }
-
- err = 0;
-out:
- memset(&response, 0, sizeof(response));
- response.type = TAPDISK_MESSAGE_CLOSE_RSP;
- response.cookie = request->cookie;
- response.u.response.error = -err;
-
- tapdisk_control_write_message(connection->socket, &response, 2);
- tapdisk_control_close_connection(connection);
-}
-
-static void
-tapdisk_control_pause_vbd(struct tapdisk_control_connection *connection,
- tapdisk_message_t *request)
-{
- int err;
- td_vbd_t *vbd;
- tapdisk_message_t response;
-
- memset(&response, 0, sizeof(response));
-
- response.type = TAPDISK_MESSAGE_PAUSE_RSP;
-
- vbd = tapdisk_server_get_vbd(request->cookie);
- if (!vbd) {
- err = -EINVAL;
- goto out;
- }
-
- do {
- err = tapdisk_vbd_pause(vbd);
-
- if (!err || err != -EAGAIN)
- break;
-
- tapdisk_server_iterate();
- } while (1);
-
-out:
- response.cookie = request->cookie;
- response.u.response.error = -err;
- tapdisk_control_write_message(connection->socket, &response, 2);
- tapdisk_control_close_connection(connection);
-}
-
-static void
-tapdisk_control_resume_vbd(struct tapdisk_control_connection *connection,
- tapdisk_message_t *request)
-{
- int err;
- td_vbd_t *vbd;
- tapdisk_message_t response;
-
- memset(&response, 0, sizeof(response));
-
- response.type = TAPDISK_MESSAGE_RESUME_RSP;
-
- vbd = tapdisk_server_get_vbd(request->cookie);
- if (!vbd) {
- err = -EINVAL;
- goto out;
- }
-
- if (!td_flag_test(vbd->state, TD_VBD_PAUSED)) {
- err = -EINVAL;
- goto out;
- }
-
- if (request->u.params.path[0]) {
- free(vbd->name);
- vbd->name = strndup(request->u.params.path,
- sizeof(request->u.params.path));
- if (!vbd->name) {
- err = -ENOMEM;
- goto out;
- }
- } else if (!vbd->name) {
- err = -EINVAL;
- goto out;
- }
-
- err = tapdisk_vbd_parse_stack(vbd, vbd->name);
- if (err)
- goto out;
-
- err = tapdisk_vbd_resume(vbd, NULL, -1);
- if (err)
- goto out;
-
-out:
- response.cookie = request->cookie;
- response.u.response.error = -err;
- tapdisk_control_write_message(connection->socket, &response, 2);
- tapdisk_control_close_connection(connection);
-}
-
-static void
-tapdisk_control_handle_request(event_id_t id, char mode, void *private)
-{
- int err;
- tapdisk_message_t message;
- struct tapdisk_control_connection *connection =
- (struct tapdisk_control_connection *)private;
-
- if (tapdisk_control_read_message(connection->socket, &message, 2)) {
- EPRINTF("failed to read message from %d\n", connection->socket);
- tapdisk_control_close_connection(connection);
- return;
- }
-
- err = tapdisk_control_validate_request(&message);
- if (err)
- goto fail;
-
- switch (message.type) {
- case TAPDISK_MESSAGE_PID:
- return tapdisk_control_get_pid(connection, &message);
- case TAPDISK_MESSAGE_LIST_MINORS:
- return tapdisk_control_list_minors(connection, &message);
- case TAPDISK_MESSAGE_LIST:
- return tapdisk_control_list(connection, &message);
- case TAPDISK_MESSAGE_ATTACH:
- return tapdisk_control_attach_vbd(connection, &message);
- case TAPDISK_MESSAGE_DETACH:
- return tapdisk_control_detach_vbd(connection, &message);
- case TAPDISK_MESSAGE_OPEN:
- return tapdisk_control_open_image(connection, &message);
- case TAPDISK_MESSAGE_PAUSE:
- return tapdisk_control_pause_vbd(connection, &message);
- case TAPDISK_MESSAGE_RESUME:
- return tapdisk_control_resume_vbd(connection, &message);
- case TAPDISK_MESSAGE_CLOSE:
- return tapdisk_control_close_image(connection, &message);
- default: {
- tapdisk_message_t response;
- fail:
-
- EPRINTF("received unsupported message '%s'\n",
- tapdisk_message_name(message.type));
-
- memset(&response, 0, sizeof(response));
-
- response.type = TAPDISK_MESSAGE_ERROR;
- response.u.response.error = (err ? -err : EINVAL);
- tapdisk_control_write_message(connection->socket, &response, 2);
-
- tapdisk_control_close_connection(connection);
- break;
- }
- }
-}
-
-static void
-tapdisk_control_accept(event_id_t id, char mode, void *private)
-{
- int err, fd;
- struct tapdisk_control_connection *connection;
-
- fd = accept(td_control.socket, NULL, NULL);
- if (fd == -1) {
- EPRINTF("failed to accept new control connection: %d\n", errno);
- return;
- }
-
- connection = tapdisk_control_allocate_connection(fd);
- if (!connection) {
- close(fd);
- EPRINTF("failed to allocate new control connection\n");
- }
-
- err = tapdisk_server_register_event(SCHEDULER_POLL_READ_FD,
- connection->socket, 0,
- tapdisk_control_handle_request,
- connection);
- if (err == -1) {
- close(fd);
- free(connection);
- EPRINTF("failed to register new control event: %d\n", err);
- }
-
- connection->event_id = err;
-}
-
-static int
-tapdisk_control_mkdir(const char *dir)
-{
- int err;
- char *ptr, *name, *start;
-
- err = access(dir, W_OK | R_OK);
- if (!err)
- return 0;
-
- name = strdup(dir);
- if (!name)
- return -ENOMEM;
-
- start = name;
-
- for (;;) {
- ptr = strchr(start + 1, '/');
- if (ptr)
- *ptr = '\0';
-
- err = mkdir(name, 0755);
- if (err && errno != EEXIST) {
- err = -errno;
- EPRINTF("failed to create directory %s: %d\n",
- name, err);
- break;
- }
-
- if (!ptr)
- break;
- else {
- *ptr = '/';
- start = ptr + 1;
- }
- }
-
- free(name);
- return err;
-}
-
-static int
-tapdisk_control_create_socket(char **socket_path)
-{
- int err, flags;
- struct sockaddr_un saddr;
-
- err = tapdisk_control_mkdir(BLKTAP2_CONTROL_DIR);
- if (err) {
- EPRINTF("failed to create directory %s: %d\n",
- BLKTAP2_CONTROL_DIR, err);
- return err;
- }
-
- err = asprintf(&td_control.path, "%s/%s%d",
- BLKTAP2_CONTROL_DIR, BLKTAP2_CONTROL_SOCKET, getpid());
- if (err == -1) {
- td_control.path = NULL;
- err = (errno ? : ENOMEM);
- goto fail;
- }
-
- if (unlink(td_control.path) && errno != ENOENT) {
- err = errno;
- EPRINTF("failed to unlink %s: %d\n", td_control.path, errno);
- goto fail;
- }
-
- td_control.socket = socket(AF_UNIX, SOCK_STREAM, 0);
- if (td_control.socket == -1) {
- err = errno;
- EPRINTF("failed to create control socket: %d\n", err);
- goto fail;
- }
-
- memset(&saddr, 0, sizeof(saddr));
- strncpy(saddr.sun_path, td_control.path, sizeof(saddr.sun_path) - 1);
- saddr.sun_family = AF_UNIX;
-
- err = bind(td_control.socket,
- (const struct sockaddr *)&saddr, sizeof(saddr));
- if (err == -1) {
- err = errno;
- EPRINTF("failed to bind to %s: %d\n", saddr.sun_path, err);
- goto fail;
- }
-
- err = listen(td_control.socket, 10);
- if (err == -1) {
- err = errno;
- EPRINTF("failed to listen: %d\n", err);
- goto fail;
- }
-
- err = tapdisk_server_register_event(SCHEDULER_POLL_READ_FD,
- td_control.socket, 0,
- tapdisk_control_accept, NULL);
- if (err < 0) {
- EPRINTF("failed to add watch: %d\n", err);
- goto fail;
- }
-
- td_control.event_id = err;
- *socket_path = td_control.path;
-
- return 0;
-
-fail:
- tapdisk_control_close();
- return err;
-}
-
-int
-tapdisk_control_open(char **path)
-{
- int err;
-
- tapdisk_control_initialize();
-
- return tapdisk_control_create_socket(path);
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef __TAPDISK_CONTROL_H__
-#define __TAPDISK_CONTROL_H__
-
-int tapdisk_control_open(char **path);
-void tapdisk_control_close(void);
-
-#endif
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#include <stdio.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-#include <libgen.h> /* for basename(3) */
-#include <unistd.h>
-
-#include "list.h"
-#include "scheduler.h"
-#include "tapdisk-vbd.h"
-#include "tapdisk-server.h"
-#include "tapdisk-disktype.h"
-#include "tapdisk-utils.h"
-#include "libvhd.h"
-
-#define POLL_READ 0
-#define POLL_WRITE 1
-
-#define SPB_SHIFT (VHD_BLOCK_SHIFT - SECTOR_SHIFT)
-
-struct tapdisk_stream_poll {
- int pipe[2];
- int set;
-};
-
-struct tapdisk_stream_request {
- uint64_t sec;
- uint32_t secs;
- uint64_t seqno;
- blkif_request_t blkif_req;
- struct list_head next;
-};
-
-struct tapdisk_stream {
- td_vbd_t *vbd;
-
- unsigned int id;
-
- int err;
-
- uint64_t cur;
- uint64_t start;
- uint64_t end;
-
- uint64_t started;
- uint64_t completed;
-
- struct tapdisk_stream_poll poll;
- event_id_t enqueue_event_id;
-
- struct list_head free_list;
- struct list_head pending_list;
- struct list_head completed_list;
-
- struct tapdisk_stream_request requests[MAX_REQUESTS];
-};
-
-static unsigned int tapdisk_stream_count;
-
-static void tapdisk_stream_close_image(struct tapdisk_stream *);
-
-static char *program;
-static struct tapdisk_stream stream1, stream2;
-static vhd_context_t vhd1;
-
-static void
-usage(FILE *stream)
-{
- printf("usage: %s <-n type:/path/to/image> <-m type:/path/to/image>\n",
- program);
-}
-
-static int
-open_vhd(const char *path, vhd_context_t *vhd)
-{
- int err;
-
- err = vhd_open(vhd, path, VHD_OPEN_RDONLY);
- if (err) {
- printf("error opening %s: %d\n", path, err);
- return err;
- }
-
- err = vhd_get_bat(vhd);
- if (err)
- {
- printf("error reading BAT for %s: %d\n", path, err);
- vhd_close(vhd);
- return err;
- }
-
- return 0;
-}
-
-static inline void
-tapdisk_stream_poll_initialize(struct tapdisk_stream_poll *p)
-{
- p->set = 0;
- p->pipe[POLL_READ] = p->pipe[POLL_WRITE] = -1;
-}
-
-static int
-tapdisk_stream_poll_open(struct tapdisk_stream_poll *p)
-{
- int err;
-
- tapdisk_stream_poll_initialize(p);
-
- err = pipe(p->pipe);
- if (err)
- return -errno;
-
- err = fcntl(p->pipe[POLL_READ], F_SETFL, O_NONBLOCK);
- if (err)
- goto out;
-
- err = fcntl(p->pipe[POLL_WRITE], F_SETFL, O_NONBLOCK);
- if (err)
- goto out;
-
- return 0;
-
-out:
- close(p->pipe[POLL_READ]);
- close(p->pipe[POLL_WRITE]);
- tapdisk_stream_poll_initialize(p);
- return -errno;
-}
-
-static void
-tapdisk_stream_poll_close(struct tapdisk_stream_poll *p)
-{
- if (p->pipe[POLL_READ] != -1)
- close(p->pipe[POLL_READ]);
- if (p->pipe[POLL_WRITE] != -1)
- close(p->pipe[POLL_WRITE]);
- tapdisk_stream_poll_initialize(p);
-}
-
-static inline void
-tapdisk_stream_poll_clear(struct tapdisk_stream_poll *p)
-{
- int dummy;
-
- read_exact(p->pipe[POLL_READ], &dummy, sizeof(dummy));
- p->set = 0;
-}
-
-static inline void
-tapdisk_stream_poll_set(struct tapdisk_stream_poll *p)
-{
- int dummy = 0;
-
- if (!p->set) {
- write_exact(p->pipe[POLL_WRITE], &dummy, sizeof(dummy));
- p->set = 1;
- }
-}
-
-static inline int
-tapdisk_stream_stop(struct tapdisk_stream *s)
-{
- return ((s->cur == s->end || s->err) &&
- list_empty(&s->pending_list) &&
- list_empty(&s->completed_list));
-}
-
-static inline void
-tapdisk_stream_initialize_request(struct tapdisk_stream_request *req)
-{
- memset(req, 0, sizeof(*req));
- INIT_LIST_HEAD(&req->next);
-}
-
-static inline int
-tapdisk_stream_request_idx(struct tapdisk_stream *s,
- struct tapdisk_stream_request *req)
-{
- return (req - s->requests);
-}
-
-static inline struct tapdisk_stream_request *
-tapdisk_stream_get_request(struct tapdisk_stream *s)
-{
- struct tapdisk_stream_request *req;
-
- if (list_empty(&s->free_list))
- return NULL;
-
- req = list_entry(s->free_list.next,
- struct tapdisk_stream_request, next);
-
- list_del_init(&req->next);
- tapdisk_stream_initialize_request(req);
-
- return req;
-}
-
-static inline void
-tapdisk_stream_queue_completed(struct tapdisk_stream *s,
- struct tapdisk_stream_request *sreq)
-{
- struct tapdisk_stream_request *itr;
-
- list_for_each_entry(itr, &s->completed_list, next)
- if (sreq->seqno < itr->seqno) {
- list_add_tail(&sreq->next, &itr->next);
- return;
- }
-
- list_add_tail(&sreq->next, &s->completed_list);
-}
-
-static int
-tapdisk_result_compare(struct tapdisk_stream_request *sreq1,
- struct tapdisk_stream_request *sreq2)
-{
- unsigned long idx1, idx2;
- char *buf1, *buf2;
- int result;
-
- assert(sreq1->seqno == sreq2->seqno);
- assert(sreq1->secs == sreq2->secs);
- idx1 = (unsigned long)tapdisk_stream_request_idx(&stream1,
- sreq1);
- idx2 = (unsigned long)tapdisk_stream_request_idx(&stream2,
- sreq2);
- buf1 = (char *)MMAP_VADDR(stream1.vbd->ring.vstart, idx1, 0);
- buf2 = (char *)MMAP_VADDR(stream2.vbd->ring.vstart, idx2, 0);
-
- result = memcmp(buf1, buf2, sreq1->secs << SECTOR_SHIFT);
- return result;
-}
-
-static int
-tapdisk_stream_process_data(void)
-{
- struct tapdisk_stream_request *sreq1, *sreq2, *tmp1, *tmp2;
- int advance_both;
- int result = 0;
-
- sreq1 = list_entry(stream1.completed_list.next,
- struct tapdisk_stream_request, next);
- sreq2 = list_entry(stream2.completed_list.next,
- struct tapdisk_stream_request, next);
- tmp1 = list_entry(sreq1->next.next,
- struct tapdisk_stream_request, next);
- tmp2 = list_entry(sreq2->next.next,
- struct tapdisk_stream_request, next);
- while (result == 0 &&
- &sreq1->next != &stream1.completed_list &&
- &sreq2->next != &stream2.completed_list) {
- //printf("checking: %llu|%llu\n", sreq1->seqno, sreq2->seqno);
- advance_both = 1;
- if (sreq1->seqno < sreq2->seqno) {
- advance_both = 0;
- goto advance1;
- }
- if (sreq1->seqno > sreq2->seqno)
- goto advance2;
-
- result = tapdisk_result_compare(sreq1, sreq2);
-
- stream1.completed++;
- stream2.completed++;
-
- list_del_init(&sreq1->next);
- list_add_tail(&sreq1->next, &stream1.free_list);
- list_del_init(&sreq2->next);
- list_add_tail(&sreq2->next, &stream2.free_list);
-
-advance1:
- sreq1 = tmp1;
- tmp1 = list_entry(tmp1->next.next,
- struct tapdisk_stream_request, next);
- if (!advance_both)
- continue;
-advance2:
- sreq2 = tmp2;
- tmp2 = list_entry(tmp2->next.next,
- struct tapdisk_stream_request, next);
- }
-
- return result;
-}
-
-static void
-tapdisk_stream_dequeue(void *arg, blkif_response_t *rsp)
-{
- struct tapdisk_stream *s = (struct tapdisk_stream *)arg;
- struct tapdisk_stream_request *sreq = s->requests + rsp->id;
-
- list_del_init(&sreq->next);
-
- if (rsp->status == BLKIF_RSP_OKAY)
- tapdisk_stream_queue_completed(s, sreq);
- else {
- s->err = EIO;
- list_add_tail(&sreq->next, &s->free_list);
- fprintf(stderr, "error reading sector 0x%"PRIx64"\n", sreq->sec);
- }
-
- if (tapdisk_stream_process_data()) {
- fprintf(stderr, "mismatch at sector 0x%"PRIx64"\n",
- sreq->sec);
- stream1.err = EINVAL;
- stream2.err = EINVAL;
- }
-
- tapdisk_stream_poll_set(&stream1.poll);
- tapdisk_stream_poll_set(&stream2.poll);
-}
-
-static inline int
-tapdisk_stream_enqueue_copy(struct tapdisk_stream *s,
- struct tapdisk_stream_request *r)
-{
- td_vbd_t *vbd;
- blkif_request_t *breq;
- td_vbd_request_t *vreq;
- struct tapdisk_stream_request *sreq;
- int idx;
-
- vbd = stream2.vbd;
- sreq = tapdisk_stream_get_request(s);
- if (!sreq)
- return 1;
-
- idx = tapdisk_stream_request_idx(s, sreq);
-
- sreq->sec = r->sec;
- sreq->secs = r->secs;
- sreq->seqno = r->seqno;
-
- breq = &sreq->blkif_req;
- breq->id = idx;
- breq->nr_segments = r->blkif_req.nr_segments;
- breq->sector_number = r->blkif_req.sector_number;
- breq->operation = BLKIF_OP_READ;
-
- for (int i = 0; i < r->blkif_req.nr_segments; i++) {
- struct blkif_request_segment *seg = breq->seg + i;
- seg->first_sect = r->blkif_req.seg[i].first_sect;
- seg->last_sect = r->blkif_req.seg[i].last_sect;
- }
- s->cur += sreq->secs;
-
- vreq = vbd->request_list + idx;
- assert(list_empty(&vreq->next));
- assert(vreq->secs_pending == 0);
-
- memcpy(&vreq->req, breq, sizeof(*breq));
- vbd->received++;
- vreq->vbd = vbd;
-
- tapdisk_vbd_move_request(vreq, &vbd->new_requests);
- list_add_tail(&sreq->next, &s->pending_list);
-
- return 0;
-}
-
-static void
-tapdisk_stream_enqueue1(void)
-{
- td_vbd_t *vbd;
- int i, idx, psize, blk;
- struct tapdisk_stream *s = &stream1;
-
- vbd = s->vbd;
- psize = getpagesize();
-
- while (s->cur < s->end && !s->err) {
- blkif_request_t *breq;
- td_vbd_request_t *vreq;
- struct tapdisk_stream_request *sreq;
-
- /* skip any blocks that are not present in this image */
- blk = s->cur >> SPB_SHIFT;
- while (s->cur < s->end && vhd1.bat.bat[blk] == DD_BLK_UNUSED) {
- //printf("skipping block %d\n", blk);
- blk++;
- s->cur = blk << SPB_SHIFT;
- }
-
- if (s->cur >= s->end)
- break;
-
- sreq = tapdisk_stream_get_request(s);
- if (!sreq)
- break;
-
- idx = tapdisk_stream_request_idx(s, sreq);
-
- sreq->sec = s->cur;
- sreq->secs = 0;
- sreq->seqno = s->started++;
-
- breq = &sreq->blkif_req;
- breq->id = idx;
- breq->nr_segments = 0;
- breq->sector_number = sreq->sec;
- breq->operation = BLKIF_OP_READ;
-
- for (i = 0; i < BLKIF_MAX_SEGMENTS_PER_REQUEST; i++) {
- uint32_t secs;
- struct blkif_request_segment *seg = breq->seg + i;
-
- secs = MIN(s->end - s->cur, psize >> SECTOR_SHIFT);
- secs = MIN(((blk + 1) << SPB_SHIFT) - s->cur, secs);
- if (!secs)
- break;
-
- sreq->secs += secs;
- s->cur += secs;
-
- seg->first_sect = 0;
- seg->last_sect = secs - 1;
- breq->nr_segments++;
- }
-
- vreq = vbd->request_list + idx;
-
- assert(list_empty(&vreq->next));
- assert(vreq->secs_pending == 0);
-
- memcpy(&vreq->req, breq, sizeof(*breq));
- vbd->received++;
- vreq->vbd = vbd;
-
- tapdisk_vbd_move_request(vreq, &vbd->new_requests);
- list_add_tail(&sreq->next, &s->pending_list);
- }
-
- tapdisk_vbd_issue_requests(vbd);
-}
-
-static void
-tapdisk_stream_enqueue2(void)
-{
- td_vbd_t *vbd;
- int i, blk;
- struct tapdisk_stream_request *itr;
- struct tapdisk_stream *s = &stream2;
-
- vbd = s->vbd;
-
- /* issue the same requests that we issued on stream1 */
- list_for_each_entry(itr, &stream1.completed_list, next) {
- if (itr->sec < s->cur)
- continue;
- if (tapdisk_stream_enqueue_copy(s, itr))
- goto done;
- }
-
- list_for_each_entry(itr, &stream1.pending_list, next) {
- if (itr->sec < s->cur)
- continue;
- if (tapdisk_stream_enqueue_copy(s, itr))
- goto done;
- }
-
- stream2.cur = stream1.cur;
-
-done:
- tapdisk_vbd_issue_requests(vbd);
-}
-
-static inline int
-tapdisk_diff_done(void)
-{
- return (tapdisk_stream_stop(&stream1) && tapdisk_stream_stop(&stream2));
-}
-
-static void
-tapdisk_diff_stop(void)
-{
- tapdisk_stream_close_image(&stream1);
- tapdisk_stream_close_image(&stream2);
-}
-
-static void
-tapdisk_stream_enqueue(event_id_t id, char mode, void *arg)
-{
- struct tapdisk_stream *s = (struct tapdisk_stream *)arg;
-
- tapdisk_stream_poll_clear(&s->poll);
-
- if (tapdisk_diff_done()) {
- tapdisk_diff_stop();
- return;
- }
-
- if (s == &stream1)
- tapdisk_stream_enqueue1();
- else if (s == &stream2)
- tapdisk_stream_enqueue2();
- else
- assert(0);
-
- if (tapdisk_diff_done()) {
- // we have to check again for the case when stream1 had no
- // blocks at all
- tapdisk_diff_stop();
- return;
- }
-}
-
-static int
-tapdisk_stream_open_image(struct tapdisk_stream *s, const char *path, int type)
-{
- int err;
- image_t image;
-
- s->id = tapdisk_stream_count++;
-
- err = tapdisk_vbd_initialize(s->id);
- if (err)
- goto out;
-
- s->vbd = tapdisk_server_get_vbd(s->id);
- if (!s->vbd) {
- err = ENODEV;
- goto out;
- }
-
- tapdisk_vbd_set_callback(s->vbd, tapdisk_stream_dequeue, s);
-
- err = tapdisk_vbd_open_vdi(s->vbd, path, type,
- TAPDISK_STORAGE_TYPE_DEFAULT,
- TD_OPEN_RDONLY);
- if (err)
- goto out;
-
- s->vbd->reopened = 1;
-
- err = tapdisk_vbd_get_image_info(s->vbd, &image);
- if (err) {
- fprintf(stderr, "failed getting image size: %d\n", err);
- return err;
- }
-
- s->start = 0;
- s->cur = s->start;
- s->end = image.size;
-
- err = 0;
-
-out:
- if (err)
- fprintf(stderr, "failed to open image %s: %d\n", path, err);
- return err;
-}
-
-static void
-tapdisk_stream_close_image(struct tapdisk_stream *s)
-{
- td_vbd_t *vbd;
-
- vbd = tapdisk_server_get_vbd(s->id);
- if (vbd) {
- tapdisk_vbd_close_vdi(vbd);
- tapdisk_server_remove_vbd(vbd);
- free((void *)vbd->ring.vstart);
- free(vbd->name);
- free(vbd);
- s->vbd = NULL;
- }
-}
-
-static int
-tapdisk_stream_initialize_requests(struct tapdisk_stream *s)
-{
- size_t size;
- td_ring_t *ring;
- int err, i, psize;
-
- ring = &s->vbd->ring;
- psize = getpagesize();
- size = psize * BLKTAP_MMAP_REGION_SIZE;
-
- /* sneaky -- set up ring->vstart so tapdisk_vbd will use our buffers */
- err = posix_memalign((void **)&ring->vstart, psize, size);
- if (err) {
- fprintf(stderr, "failed to allocate buffers: %d\n", err);
- ring->vstart = 0;
- return err;
- }
-
- for (i = 0; i < MAX_REQUESTS; i++) {
- struct tapdisk_stream_request *req = s->requests + i;
- tapdisk_stream_initialize_request(req);
- list_add_tail(&req->next, &s->free_list);
- }
-
- return 0;
-}
-
-static int
-tapdisk_stream_register_enqueue_event(struct tapdisk_stream *s)
-{
- int err;
- struct tapdisk_stream_poll *p = &s->poll;
-
- err = tapdisk_stream_poll_open(p);
- if (err)
- goto out;
-
- err = tapdisk_server_register_event(SCHEDULER_POLL_READ_FD,
- p->pipe[POLL_READ], 0,
- tapdisk_stream_enqueue, s);
- if (err < 0)
- goto out;
-
- s->enqueue_event_id = err;
- err = 0;
-
-out:
- if (err)
- fprintf(stderr, "failed to register event: %d\n", err);
- return err;
-}
-
-static void
-tapdisk_stream_unregister_enqueue_event(struct tapdisk_stream *s)
-{
- if (s->enqueue_event_id) {
- tapdisk_server_unregister_event(s->enqueue_event_id);
- s->enqueue_event_id = 0;
- }
- tapdisk_stream_poll_close(&s->poll);
-}
-
-static inline void
-tapdisk_stream_initialize(struct tapdisk_stream *s)
-{
- memset(s, 0, sizeof(*s));
- INIT_LIST_HEAD(&s->free_list);
- INIT_LIST_HEAD(&s->pending_list);
- INIT_LIST_HEAD(&s->completed_list);
-}
-
-static int
-tapdisk_stream_open(struct tapdisk_stream *s, const char *arg)
-{
- int err, type;
- const char *path;
-
- type = tapdisk_disktype_parse_params(arg, &path);
- if (type < 0)
- return type;
-
- tapdisk_stream_initialize(s);
-
- err = tapdisk_stream_open_image(s, path, type);
- if (err)
- return err;
-
- err = tapdisk_stream_initialize_requests(s);
- if (err)
- return err;
-
- err = tapdisk_stream_register_enqueue_event(s);
- if (err)
- return err;
-
- tapdisk_stream_enqueue(s->enqueue_event_id,
- SCHEDULER_POLL_READ_FD, s);
-
- return 0;
-}
-
-static void
-tapdisk_stream_release(struct tapdisk_stream *s)
-{
- tapdisk_stream_close_image(s);
- tapdisk_stream_unregister_enqueue_event(s);
-}
-
-static int
-tapdisk_stream_run(struct tapdisk_stream *s)
-{
- tapdisk_stream_enqueue(s->enqueue_event_id, SCHEDULER_POLL_READ_FD, s);
- tapdisk_server_run();
- return s->err;
-}
-
-int
-main(int argc, char *argv[])
-{
- int c, err, type1;
- const char *arg1 = NULL, *arg2 = NULL;
- const disk_info_t *info;
- const char *path1;
-
- err = 0;
-
- program = basename(argv[0]);
-
- while ((c = getopt(argc, argv, "n:m:h")) != -1) {
- switch (c) {
- case 'n':
- arg1 = optarg;
- break;
- case 'm':
- arg2 = optarg;
- break;
- case 'h':
- usage(stdout);
- return 0;
- default:
- goto fail_usage;
- }
- }
-
- if (!arg1 || !arg2)
- goto fail_usage;
-
- type1 = tapdisk_disktype_parse_params(arg1, &path1);
- if (type1 < 0)
- return type1;
-
- if (type1 != DISK_TYPE_VHD) {
- printf("error: first VDI is not VHD\n");
- return EINVAL;
- }
-
- err = open_vhd(path1, &vhd1);
- if (err)
- return err;
-
- tapdisk_start_logging("tapdisk-diff");
-
- err = tapdisk_server_initialize();
- if (err)
- goto out;
-
- err = tapdisk_stream_open(&stream1, arg1);
- if (err) {
- fprintf(stderr, "Failed to open %s: %s\n",
- arg1, strerror(-err));
- goto out;
- }
-
- err = tapdisk_stream_open(&stream2, arg2);
- if (err) {
- fprintf(stderr, "Failed to open %s: %s\n",
- arg2, strerror(-err));
- goto out1;
- }
-
- if (stream1.end != stream2.end) {
- fprintf(stderr, "Image sizes differ: %"PRIu64" != %"PRIu64"\n",
- stream1.end, stream2.end);
- err = EINVAL;
- goto out2;
- }
-
- tapdisk_server_run();
-
-out2:
- tapdisk_stream_release(&stream2);
-out1:
- tapdisk_stream_release(&stream1);
-out:
- vhd_close(&vhd1);
- tapdisk_stop_logging();
-
- return err ? : stream1.err;
-
-fail_usage:
- usage(stderr);
- return 1;
-}
+++ /dev/null
-/*
- * Copyright (c) 2007, 2010, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include <stddef.h>
-#include <string.h>
-#include <errno.h>
-
-#include "tapdisk-disktype.h"
-#include "tapdisk-message.h"
-
-#define ARRAY_SIZE(a) (sizeof (a) / sizeof *(a))
-
-static const disk_info_t aio_disk = {
- "aio",
- "raw image (aio)",
- 0,
-};
-
-static const disk_info_t sync_disk = {
- "sync",
- "raw image (sync)",
- 0,
-};
-
-static const disk_info_t vmdk_disk = {
- "vmdk",
- "vmware image (vmdk)",
- 1,
-};
-
-static const disk_info_t vhdsync_disk = {
- "vhdsync",
- "virtual server image (vhd) - synchronous",
- 1,
-};
-
-static const disk_info_t vhd_disk = {
- "vhd",
- "virtual server image (vhd)",
- 0,
-};
-
-
-static const disk_info_t ram_disk = {
- "ram",
- "ramdisk image (ram)",
- 1,
-};
-
-static const disk_info_t qcow_disk = {
- "qcow",
- "qcow disk (qcow)",
- 0,
-};
-
-static const disk_info_t block_cache_disk = {
- "bc",
- "block cache image (bc)",
- 1,
-};
-
-static const disk_info_t vhd_index_disk = {
- "vhdi",
- "vhd index image (vhdi)",
- 1,
-};
-
-static const disk_info_t log_disk = {
- "log",
- "write logger (log)",
- 0,
-};
-
-static const disk_info_t remus_disk = {
- "remus",
- "remus disk replicator (remus)",
- 0,
-};
-
-const disk_info_t *tapdisk_disk_types[] = {
- [DISK_TYPE_AIO] = &aio_disk,
- [DISK_TYPE_SYNC] = &sync_disk,
- [DISK_TYPE_VMDK] = &vmdk_disk,
- [DISK_TYPE_VHDSYNC] = &vhdsync_disk,
- [DISK_TYPE_VHD] = &vhd_disk,
- [DISK_TYPE_RAM] = &ram_disk,
- [DISK_TYPE_QCOW] = &qcow_disk,
- [DISK_TYPE_BLOCK_CACHE] = &block_cache_disk,
- [DISK_TYPE_LOG] = &log_disk,
- [DISK_TYPE_VINDEX] = &vhd_index_disk,
- [DISK_TYPE_REMUS] = &remus_disk,
-};
-
-extern struct tap_disk tapdisk_aio;
-extern struct tap_disk tapdisk_vhdsync;
-extern struct tap_disk tapdisk_vhd;
-extern struct tap_disk tapdisk_ram;
-extern struct tap_disk tapdisk_qcow;
-extern struct tap_disk tapdisk_block_cache;
-extern struct tap_disk tapdisk_log;
-extern struct tap_disk tapdisk_remus;
-
-const struct tap_disk *tapdisk_disk_drivers[ARRAY_SIZE(tapdisk_disk_types)] = {
- [DISK_TYPE_AIO] = &tapdisk_aio,
- [DISK_TYPE_VHD] = &tapdisk_vhd,
- [DISK_TYPE_RAM] = &tapdisk_ram,
- [DISK_TYPE_QCOW] = &tapdisk_qcow,
- [DISK_TYPE_BLOCK_CACHE] = &tapdisk_block_cache,
- [DISK_TYPE_LOG] = &tapdisk_log,
- [DISK_TYPE_REMUS] = &tapdisk_remus,
-};
-
-int
-tapdisk_disktype_find(const char *name)
-{
- const disk_info_t *info;
- int i;
-
- for (i = 0; i < ARRAY_SIZE(tapdisk_disk_types); ++i) {
- info = tapdisk_disk_types[i];
- if (!info)
- continue;
-
- if (strcmp(name, info->name))
- continue;
-
- if (!tapdisk_disk_drivers[i])
- return -ENOSYS;
-
- return i;
- }
-
- return -ENOENT;
-}
-
-int
-tapdisk_disktype_parse_params(const char *params, const char **_path)
-{
- char name[DISK_TYPE_NAME_MAX], *ptr;
- size_t len;
- int type;
-
- ptr = strchr(params, ':');
- if (!ptr)
- return -EINVAL;
-
- len = ptr - params;
-
- if (len > sizeof(name) - 1)
- return -ENAMETOOLONG;
-
- memset(name, 0, sizeof(name));
- strncpy(name, params, len);
-
- type = tapdisk_disktype_find(name);
-
- if (type >= 0)
- *_path = params + len + 1;
-
- return type;
-}
-
-int
-tapdisk_parse_disk_type(const char *params, const char **_path, int *_type)
-{
- int type;
-
- type = tapdisk_disktype_parse_params(params, _path);
- if (type < 0)
- return type;
-
- *_type = type;
-
- return 0;
-}
+++ /dev/null
-/*
- * Copyright (c) 2007, 2010, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef __DISKTYPES_H__
-#define __DISKTYPES_H__
-
-#define DISK_TYPE_AIO 0
-#define DISK_TYPE_SYNC 1
-#define DISK_TYPE_VMDK 2
-#define DISK_TYPE_VHDSYNC 3
-#define DISK_TYPE_VHD 4
-#define DISK_TYPE_RAM 5
-#define DISK_TYPE_QCOW 6
-#define DISK_TYPE_BLOCK_CACHE 7
-#define DISK_TYPE_LOG 8
-#define DISK_TYPE_REMUS 9
-#define DISK_TYPE_VINDEX 10
-
-#define DISK_TYPE_NAME_MAX 32
-
-typedef struct disk_info {
- const char *name; /* driver name, e.g. 'aio' */
- char *desc; /* e.g. "raw image" */
- unsigned int flags;
-} disk_info_t;
-
-extern const disk_info_t *tapdisk_disk_types[];
-extern const struct tap_disk *tapdisk_disk_drivers[];
-
-/* one single controller for all instances of disk type */
-#define DISK_TYPE_SINGLE_CONTROLLER (1<<0)
-
-int tapdisk_disktype_find(const char *name);
-int tapdisk_disktype_parse_params(const char *params, const char **_path);
-int tapdisk_parse_disk_type(const char *, const char **, int *);
-
-#endif
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include <stdlib.h>
-
-#include "tapdisk-driver.h"
-#include "tapdisk-server.h"
-#include "tapdisk-disktype.h"
-
-td_driver_t *
-tapdisk_driver_allocate(int type, char *name, td_flag_t flags, int storage)
-{
- int err;
- td_driver_t *driver;
- const struct tap_disk *ops;
-
- ops = tapdisk_disk_drivers[type];
- if (!ops)
- return NULL;
-
- driver = calloc(1, sizeof(td_driver_t));
- if (!driver)
- return NULL;
-
- err = tapdisk_namedup(&driver->name, name);
- if (err)
- goto fail;
-
- driver->ops = ops;
- driver->type = type;
- driver->storage = storage;
- driver->data = calloc(1, ops->private_data_size);
- if (!driver->data)
- goto fail;
-
- if (td_flag_test(flags, TD_OPEN_RDONLY))
- td_flag_set(driver->state, TD_DRIVER_RDONLY);
-
- return driver;
-
-fail:
- free(driver->name);
- free(driver->data);
- free(driver);
- return NULL;
-}
-
-void
-tapdisk_driver_free(td_driver_t *driver)
-{
- if (!driver)
- return;
-
- if (driver->refcnt)
- return;
-
- if (td_flag_test(driver->state, TD_DRIVER_OPEN))
- EPRINTF("freeing open driver %s (state 0x%08x)\n",
- driver->name, driver->state);
-
- free(driver->name);
- free(driver->data);
- free(driver);
-}
-
-void
-tapdisk_driver_queue_tiocb(td_driver_t *driver, struct tiocb *tiocb)
-{
- tapdisk_server_queue_tiocb(tiocb);
-}
-
-void
-tapdisk_driver_debug(td_driver_t *driver)
-{
- if (driver->ops->td_debug)
- driver->ops->td_debug(driver);
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#ifndef _TAPDISK_DRIVER_H_
-#define _TAPDISK_DRIVER_H_
-
-#include "tapdisk.h"
-#include "scheduler.h"
-#include "tapdisk-queue.h"
-
-#define TD_DRIVER_OPEN 0x0001
-#define TD_DRIVER_RDONLY 0x0002
-
-struct td_driver_handle {
- int type;
- char *name;
-
- int storage;
-
- int refcnt;
- td_flag_t state;
-
- td_disk_info_t info;
-
- void *data;
- const struct tap_disk *ops;
-
- struct list_head next;
-};
-
-td_driver_t *tapdisk_driver_allocate(int, char *, td_flag_t, int);
-void tapdisk_driver_free(td_driver_t *);
-
-void tapdisk_driver_queue_tiocb(td_driver_t *, struct tiocb *);
-
-void tapdisk_driver_debug(td_driver_t *);
-
-#endif
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#include <stdlib.h>
-#include <unistd.h>
-#include <libaio.h>
-#include <syslog.h>
-#include <sys/time.h>
-
-#include "tapdisk-log.h"
-#include "tapdisk-filter.h"
-
-#define RSEED 7
-#define PRE_CHECK 0
-#define POST_CHECK 1
-
-#define WRITE_INTEGRITY "buffer integrity failure after write"
-#define READ_INTEGRITY "disk integrity failure after read"
-
-#define DBG(f, a...) tlog_write(TLOG_WARN, f, ##a)
-
-/*
- * simulate IO errors by knocking request size to zero before
- * submitting and restoring original size before returning
- */
-static inline void
-inject_fault(struct tfilter *filter, struct iocb *io)
-{
- struct fiocb *fio;
-
- if (!filter->ffree)
- return;
-
- fio = filter->flist[--filter->ffree];
-
- fio->bytes = io->u.c.nbytes;
- fio->data = io->data;
- io->u.c.nbytes = 0;
- io->data = fio;
-}
-
-static inline int
-fault_injected(struct tfilter *filter, struct iocb *io)
-{
- unsigned long iop = (unsigned long)io->data;
- unsigned long start = (unsigned long)filter->fiocbs;
- unsigned long end = start + (filter->iocbs * sizeof(struct fiocb));
-
- return (iop >= start && iop < end);
-}
-
-static inline void
-recover_fault(struct tfilter *filter, struct iocb *io)
-{
- struct fiocb *fio = (struct fiocb *)io->data;
-
- io->u.c.nbytes = fio->bytes;
- io->data = fio->data;
-
- memset(fio, 0, sizeof(struct fiocb));
- filter->flist[filter->ffree++] = fio;
-}
-
-static inline uint64_t
-chksum(char *buf)
-{
- int i, num = 512 >> 3;
- uint64_t *p = (uint64_t *)buf;
- uint64_t sum = 0;
-
- for (i = 0; i < num; i++)
- sum += p[i];
-
- return sum;
-}
-
-static inline void
-check_hash(struct tfilter *filter, uint64_t sec, char *buf, char *type)
-{
- uint64_t sum;
- struct dhash *hash;
-
- hash = filter->dhash + sec;
- if (!hash->time.tv_sec)
- return;
-
- sum = chksum(buf);
- if (hash->hash != chksum(buf)) {
- struct timeval now;
- gettimeofday(&now, NULL);
- DBG("%s: hash table: 0x%020" PRIx64 " at %012lu.%06llu, "
- "from disk: 0x%020" PRIx64 " at %012lu.%06llu\n",
- type, hash->hash, hash->time.tv_sec,
- (unsigned long long)hash->time.tv_usec, sum,
- now.tv_sec, (unsigned long long)now.tv_usec);
- }
-}
-
-static inline void
-insert_hash(struct tfilter *filter, uint64_t sec, char *buf)
-{
- struct dhash *hash;
-
- hash = filter->dhash + sec;
- hash->hash = chksum(buf);
- gettimeofday(&hash->time, NULL);
-}
-
-static void
-check_sector(struct tfilter *filter, int type, int rw, uint64_t sec, char *buf)
-{
- struct dhash *hash;
-
- if (sec >= filter->secs)
- return;
-
- hash = filter->dhash + sec;
-
- if (rw) {
- if (type == PRE_CHECK)
- insert_hash(filter, sec, buf);
- else
- check_hash(filter, sec, buf, WRITE_INTEGRITY);
- } else if (type == POST_CHECK) {
- check_hash(filter, sec, buf, READ_INTEGRITY);
- insert_hash(filter, sec, buf);
- }
-}
-
-static void
-check_data(struct tfilter *filter, int type, struct iocb *io)
-{
- int rw;
- uint64_t i, sec;
-
- rw = (io->aio_lio_opcode == IO_CMD_PWRITE);
-
- for (i = 0; i < io->u.c.nbytes; i += 512) {
- char *buf = io->u.c.buf + i;
- uint64_t sec = (io->u.c.offset + i) >> 9;
- check_sector(filter, type, rw, sec, buf);
- }
-}
-
-struct tfilter *
-tapdisk_init_tfilter(int mode, int iocbs, uint64_t secs)
-{
- int i;
- struct tfilter *filter = NULL;
-
- if (!mode)
- return NULL;
-
- filter = calloc(1, sizeof(struct tfilter));
- if (!filter)
- goto fail;
-
- filter->mode = mode;
- filter->secs = secs;
- filter->iocbs = iocbs;
-
- if (filter->mode & TD_INJECT_FAULTS) {
- filter->fiocbs = calloc(iocbs, sizeof(struct fiocb));
- filter->flist = calloc(iocbs, sizeof(struct fiocb *));
- if (!filter->fiocbs || !filter->flist)
- filter->mode &= ~TD_INJECT_FAULTS;
- else {
- srand(RSEED);
- filter->ffree = iocbs;
- for (i = 0; i < iocbs; i++)
- filter->flist[i] = filter->fiocbs + i;
- }
- }
-
- if (filter->mode & TD_CHECK_INTEGRITY) {
- filter->dhash = calloc(secs, sizeof(struct dhash));
- if (!filter->dhash)
- filter->mode &= ~TD_CHECK_INTEGRITY;
- }
-
- syslog(LOG_WARNING, "WARNING: "
- "FILTERING IN MODE 0x%04x\n", filter->mode);
-
- return filter;
-
- fail:
- tapdisk_free_tfilter(filter);
- return NULL;
-}
-
-void
-tapdisk_free_tfilter(struct tfilter *filter)
-{
- if (!filter)
- return;
-
- free(filter->dhash);
- free(filter->flist);
- free(filter->fiocbs);
- free(filter);
-}
-
-void
-tapdisk_filter_iocbs(struct tfilter *filter, struct iocb **iocbs, int num)
-{
- int i;
-
- if (!filter)
- return;
-
- for (i = 0; i < num; i++) {
- struct iocb *io = iocbs[i];
-
- if (filter->mode & TD_INJECT_FAULTS) {
- if ((random() % 100) <= TD_FAULT_RATE) {
- inject_fault(filter, io);
- continue;
- }
- }
-
- if (filter->mode & TD_CHECK_INTEGRITY)
- check_data(filter, PRE_CHECK, io);
- }
-}
-
-void
-tapdisk_filter_events(struct tfilter *filter, struct io_event *events, int num)
-{
- int i;
-
- if (!filter)
- return;
-
- for (i = 0; i < num; i++) {
- struct iocb *io = events[i].obj;
-
- if (filter->mode & TD_INJECT_FAULTS) {
- if (fault_injected(filter, io)) {
- recover_fault(filter, io);
- continue;
- }
- }
-
- if (filter->mode & TD_CHECK_INTEGRITY)
- check_data(filter, POST_CHECK, io);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#ifndef TAPDISK_FILTER_H
-#define TAPDISK_FILTER_H
-
-#include <libaio.h>
-#include <inttypes.h>
-#include <time.h>
-
-#define TD_INJECT_FAULTS 0x00001 /* simulate random IO failures */
-#define TD_CHECK_INTEGRITY 0x00002 /* check data integrity */
-
-#define TD_FAULT_RATE 5
-
-struct dhash {
- uint64_t hash;
- struct timeval time;
-};
-
-struct fiocb {
- size_t bytes;
- void *data;
-};
-
-struct tfilter {
- int mode;
- uint64_t secs;
- int iocbs;
-
- struct dhash *dhash;
-
- int ffree;
- struct fiocb *fiocbs;
- struct fiocb **flist;
-};
-
-struct tfilter *tapdisk_init_tfilter(int mode, int iocbs, uint64_t secs);
-void tapdisk_free_tfilter(struct tfilter *);
-void tapdisk_filter_iocbs(struct tfilter *, struct iocb **, int);
-void tapdisk_filter_events(struct tfilter *, struct io_event *, int);
-
-#endif
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include <errno.h>
-#include <unistd.h>
-#include <stdlib.h>
-#ifdef MEMSHR
-#include <memshr.h>
-#endif
-
-#include "tapdisk-image.h"
-#include "tapdisk-driver.h"
-#include "tapdisk-server.h"
-
-#define ERR(_err, _f, _a...) tlog_error(_err, _f, ##_a)
-
-td_image_t *
-tapdisk_image_allocate(const char *file, int type, int storage,
- td_flag_t flags, void *private)
-{
- int err;
- td_image_t *image;
-
- image = calloc(1, sizeof(td_image_t));
- if (!image)
- return NULL;
-
- err = tapdisk_namedup(&image->name, file);
- if (err) {
- free(image);
- return NULL;
- }
-
- image->type = type;
- image->flags = flags;
- image->storage = storage;
- image->private = private;
-#ifdef MEMSHR
- image->memshr_id = memshr_vbd_image_get(file);
-#endif
- INIT_LIST_HEAD(&image->next);
-
- return image;
-}
-
-void
-tapdisk_image_free(td_image_t *image)
-{
- if (!image)
- return;
-
- list_del(&image->next);
-
-#ifdef MEMSHR
- memshr_vbd_image_put(image->memshr_id);
-#endif
- free(image->name);
- tapdisk_driver_free(image->driver);
- free(image);
-}
-
-int
-tapdisk_image_check_td_request(td_image_t *image, td_request_t treq)
-{
- int rdonly;
- td_driver_t *driver;
- td_disk_info_t *info;
-
- driver = image->driver;
- if (!driver)
- return -ENODEV;
-
- info = &driver->info;
- rdonly = td_flag_test(image->flags, TD_OPEN_RDONLY);
-
- if (treq.op != TD_OP_READ && treq.op != TD_OP_WRITE)
- goto fail;
-
- if (treq.op == TD_OP_WRITE && rdonly)
- goto fail;
-
- if (treq.secs <= 0 || treq.sec + treq.secs > info->size)
- goto fail;
-
- return 0;
-
-fail:
- ERR(-EINVAL, "bad td request on %s (%s, %"PRIu64"): %d at %"PRIu64,
- image->name, (rdonly ? "ro" : "rw"), info->size, treq.op,
- treq.sec + treq.secs);
- return -EINVAL;
-
-}
-
-int
-tapdisk_image_check_ring_request(td_image_t *image, blkif_request_t *req)
-{
- td_driver_t *driver;
- td_disk_info_t *info;
- int i, psize, rdonly;
- uint64_t nsects, total;
-
- driver = image->driver;
- if (!driver)
- return -ENODEV;
-
- nsects = 0;
- total = 0;
- info = &driver->info;
-
- rdonly = td_flag_test(image->flags, TD_OPEN_RDONLY);
-
- if (req->operation != BLKIF_OP_READ &&
- req->operation != BLKIF_OP_WRITE)
- goto fail;
-
- if (req->operation == BLKIF_OP_WRITE && rdonly)
- goto fail;
-
- if (!req->nr_segments || req->nr_segments > MAX_SEGMENTS_PER_REQ)
- goto fail;
-
- total = 0;
- psize = getpagesize();
-
- for (i = 0; i < req->nr_segments; i++) {
- nsects = req->seg[i].last_sect - req->seg[i].first_sect + 1;
-
- if (req->seg[i].last_sect >= psize >> 9 || nsects <= 0)
- goto fail;
-
- total += nsects;
- }
-
- if (req->sector_number + nsects > info->size)
- goto fail;
-
- return 0;
-
-fail:
- ERR(-EINVAL, "bad request on %s (%s, %"PRIu64"): id: %"PRIu64": %d at %"PRIu64,
- image->name, (rdonly ? "ro" : "rw"), info->size, req->id,
- req->operation, req->sector_number + total);
- return -EINVAL;
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#ifndef _TAPDISK_IMAGE_H_
-#define _TAPDISK_IMAGE_H_
-
-#include "tapdisk.h"
-#include <xen/io/blkif.h>
-
-struct td_image_handle {
- int type;
- char *name;
- uint16_t memshr_id;
-
- td_flag_t flags;
- int storage;
-
- td_driver_t *driver;
- td_disk_info_t info;
-
- void *private;
-
- struct list_head next;
-};
-
-td_image_t *tapdisk_image_allocate(const char *, int, int, td_flag_t, void *);
-void tapdisk_image_free(td_image_t *);
-
-int tapdisk_image_check_td_request(td_image_t *, td_request_t);
-int tapdisk_image_check_ring_request(td_image_t *, blkif_request_t *);
-
-#endif
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include <errno.h>
-
-#include "tapdisk.h"
-#include "tapdisk-vbd.h"
-#include "tapdisk-image.h"
-#include "tapdisk-driver.h"
-#include "tapdisk-server.h"
-#include "tapdisk-interface.h"
-
-int
-td_load(td_image_t *image)
-{
- int err;
- td_image_t *shared;
- td_driver_t *driver;
-
- shared = tapdisk_server_get_shared_image(image);
- if (!shared)
- return -ENODEV;
-
- driver = shared->driver;
- if (!driver)
- return -EBADF;
-
- driver->refcnt++;
- image->driver = driver;
- image->info = driver->info;
-
- DPRINTF("loaded shared image %s (%d users, state: 0x%08x, type: %d)\n",
- driver->name, driver->refcnt, driver->state, driver->type);
- return 0;
-}
-
-int
-__td_open(td_image_t *image, td_disk_info_t *info)
-{
- int err;
- td_driver_t *driver;
-
- driver = image->driver;
- if (!driver) {
- driver = tapdisk_driver_allocate(image->type,
- image->name,
- image->flags,
- image->storage);
- if (!driver)
- return -ENOMEM;
-
- if (info) /* pre-seed driver->info for virtual drivers */
- driver->info = *info;
- }
-
- if (!td_flag_test(driver->state, TD_DRIVER_OPEN)) {
- err = driver->ops->td_open(driver, image->name, image->flags);
- if (err) {
- if (!image->driver)
- tapdisk_driver_free(driver);
- return err;
- }
-
- td_flag_set(driver->state, TD_DRIVER_OPEN);
- DPRINTF("opened image %s (%d users, state: 0x%08x, type: %d)\n",
- driver->name, driver->refcnt + 1,
- driver->state, driver->type);
- }
-
- image->driver = driver;
- image->info = driver->info;
- driver->refcnt++;
- return 0;
-}
-
-int
-td_open(td_image_t *image)
-{
- return __td_open(image, NULL);
-}
-
-int
-td_close(td_image_t *image)
-{
- td_driver_t *driver;
-
- driver = image->driver;
- if (!driver)
- return -ENODEV;
-
- driver->refcnt--;
- if (!driver->refcnt && td_flag_test(driver->state, TD_DRIVER_OPEN)) {
- driver->ops->td_close(driver);
- td_flag_clear(driver->state, TD_DRIVER_OPEN);
- }
-
- DPRINTF("closed image %s (%d users, state: 0x%08x, type: %d)\n",
- driver->name, driver->refcnt, driver->state, driver->type);
-
- return 0;
-}
-
-int
-td_get_parent_id(td_image_t *image, td_disk_id_t *id)
-{
- td_driver_t *driver;
-
- driver = image->driver;
- if (!driver)
- return -ENODEV;
-
- if (!td_flag_test(driver->state, TD_DRIVER_OPEN))
- return -EBADF;
-
- return driver->ops->td_get_parent_id(driver, id);
-}
-
-int
-td_validate_parent(td_image_t *image, td_image_t *parent)
-{
- td_driver_t *driver, *pdriver;
-
- driver = image->driver;
- pdriver = parent->driver;
- if (!driver || !pdriver)
- return -ENODEV;
-
- if (!td_flag_test(driver->state, TD_DRIVER_OPEN) ||
- !td_flag_test(pdriver->state, TD_DRIVER_OPEN))
- return -EBADF;
-
- return 0;
- return driver->ops->td_validate_parent(driver, pdriver, 0);
-}
-
-void
-td_queue_write(td_image_t *image, td_request_t treq)
-{
- int err;
- td_driver_t *driver;
-
- driver = image->driver;
- if (!driver) {
- err = -ENODEV;
- goto fail;
- }
-
- if (!td_flag_test(driver->state, TD_DRIVER_OPEN)) {
- err = -EBADF;
- goto fail;
- }
-
- err = tapdisk_image_check_td_request(image, treq);
- if (err)
- goto fail;
-
- driver->ops->td_queue_write(driver, treq);
- return;
-
-fail:
- td_complete_request(treq, err);
-}
-
-void
-td_queue_read(td_image_t *image, td_request_t treq)
-{
- int err;
- td_driver_t *driver;
-
- driver = image->driver;
- if (!driver) {
- err = -ENODEV;
- goto fail;
- }
-
- if (!td_flag_test(driver->state, TD_DRIVER_OPEN)) {
- err = -EBADF;
- goto fail;
- }
-
- err = tapdisk_image_check_td_request(image, treq);
- if (err)
- goto fail;
-
- driver->ops->td_queue_read(driver, treq);
- return;
-
-fail:
- td_complete_request(treq, err);
-}
-
-void
-td_forward_request(td_request_t treq)
-{
- tapdisk_vbd_forward_request(treq);
-}
-
-void
-td_complete_request(td_request_t treq, int res)
-{
- ((td_callback_t)treq.cb)(treq, res);
-}
-
-void
-td_queue_tiocb(td_driver_t *driver, struct tiocb *tiocb)
-{
- tapdisk_driver_queue_tiocb(driver, tiocb);
-}
-
-void
-td_prep_read(struct tiocb *tiocb, int fd, char *buf, size_t bytes,
- long long offset, td_queue_callback_t cb, void *arg)
-{
- tapdisk_prep_tiocb(tiocb, fd, 0, buf, bytes, offset, cb, arg);
-}
-
-void
-td_prep_write(struct tiocb *tiocb, int fd, char *buf, size_t bytes,
- long long offset, td_queue_callback_t cb, void *arg)
-{
- tapdisk_prep_tiocb(tiocb, fd, 1, buf, bytes, offset, cb, arg);
-}
-
-void
-td_debug(td_image_t *image)
-{
- td_driver_t *driver;
-
- driver = image->driver;
- if (!driver || !td_flag_test(driver->state, TD_DRIVER_OPEN))
-
- return;
-
- tapdisk_driver_debug(driver);
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#ifndef _TAPDISK_INTERFACE_H_
-#define _TAPDISK_INTERFACE_H_
-
-#include "tapdisk.h"
-#include "tapdisk-queue.h"
-
-int td_open(td_image_t *);
-int __td_open(td_image_t *, td_disk_info_t *);
-int td_load(td_image_t *);
-int td_close(td_image_t *);
-int td_get_parent_id(td_image_t *, td_disk_id_t *);
-int td_validate_parent(td_image_t *, td_image_t *);
-
-void td_queue_write(td_image_t *, td_request_t);
-void td_queue_read(td_image_t *, td_request_t);
-void td_forward_request(td_request_t);
-void td_complete_request(td_request_t, int);
-
-void td_debug(td_image_t *);
-
-void td_queue_tiocb(td_driver_t *, struct tiocb *);
-void td_prep_read(struct tiocb *, int, char *, size_t,
- long long, td_queue_callback_t, void *);
-void td_prep_write(struct tiocb *, int, char *, size_t,
- long long, td_queue_callback_t, void *);
-
-#endif
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#include <stdio.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdarg.h>
-#include <syslog.h>
-#include <inttypes.h>
-#include <sys/time.h>
-
-#include "tapdisk-log.h"
-#include "tapdisk-utils.h"
-
-#define MAX_ENTRY_LEN 512
-#define MAX_ERROR_MESSAGES 16
-
-struct error {
- int cnt;
- int err;
- char *func;
- char msg[MAX_ENTRY_LEN];
-};
-
-struct ehandle {
- int cnt;
- int dropped;
- struct error errors[MAX_ERROR_MESSAGES];
-};
-
-struct tlog {
- char *p;
- int size;
- uint64_t cnt;
- char *buf;
- int level;
- char *file;
- int append;
-};
-
-static struct ehandle tapdisk_err;
-static struct tlog tapdisk_log;
-
-void
-open_tlog(char *file, size_t bytes, int level, int append)
-{
- tapdisk_log.size = ((bytes + 511) & (~511));
-
- if (asprintf(&tapdisk_log.file, "%s.%d", file, getpid()) == -1)
- return;
-
- if (posix_memalign((void **)&tapdisk_log.buf, 512, tapdisk_log.size)) {
- free(tapdisk_log.file);
- tapdisk_log.buf = NULL;
- return;
- }
-
- memset(tapdisk_log.buf, 0, tapdisk_log.size);
-
- tapdisk_log.p = tapdisk_log.buf;
- tapdisk_log.level = level;
- tapdisk_log.append = append;
-}
-
-void
-close_tlog(void)
-{
- if (!tapdisk_log.buf)
- return;
-
- if (tapdisk_log.append)
- tlog_flush();
-
- free(tapdisk_log.buf);
- free(tapdisk_log.file);
-
- memset(&tapdisk_log, 0, sizeof(struct tlog));
-}
-
-void
-__tlog_write(int level, const char *func, const char *fmt, ...)
-{
- char *buf;
- va_list ap;
- struct timeval t;
- int ret, len, avail;
-
- if (!tapdisk_log.buf)
- return;
-
- if (level > tapdisk_log.level)
- return;
-
- avail = tapdisk_log.size - (tapdisk_log.p - tapdisk_log.buf);
- if (avail < MAX_ENTRY_LEN) {
- if (tapdisk_log.append)
- tlog_flush();
- tapdisk_log.p = tapdisk_log.buf;
- }
-
- buf = tapdisk_log.p;
- gettimeofday(&t, NULL);
- len = snprintf(buf, MAX_ENTRY_LEN - 1, "%08"PRIu64":%010ld.%06lld:"
- "%s ", tapdisk_log.cnt,
- t.tv_sec, (unsigned long long)t.tv_usec, func);
-
- va_start(ap, fmt);
- ret = vsnprintf(buf + len, MAX_ENTRY_LEN - (len + 1), fmt, ap);
- va_end(ap);
-
- len = (ret < MAX_ENTRY_LEN - (len + 1) ?
- len + ret : MAX_ENTRY_LEN - 1);
- buf[len] = '\0';
-
- tapdisk_log.cnt++;
- tapdisk_log.p += len;
-}
-
-void
-__tlog_error(int err, const char *func, const char *fmt, ...)
-{
- va_list ap;
- int i, len, ret;
- struct error *e;
- struct timeval t;
-
- err = (err > 0 ? err : -err);
-
- for (i = 0; i < tapdisk_err.cnt; i++) {
- e = &tapdisk_err.errors[i];
- if (e->err == err && e->func == func) {
- e->cnt++;
- return;
- }
- }
-
- if (tapdisk_err.cnt >= MAX_ERROR_MESSAGES) {
- tapdisk_err.dropped++;
- return;
- }
-
- gettimeofday(&t, NULL);
- e = &tapdisk_err.errors[tapdisk_err.cnt];
-
- len = snprintf(e->msg, MAX_ENTRY_LEN - 1, "%010ld.%06lld:%s ",
- t.tv_sec, (unsigned long long)t.tv_usec, func);
-
- va_start(ap, fmt);
- ret = vsnprintf(e->msg + len, MAX_ENTRY_LEN - (len + 1), fmt, ap);
- va_end(ap);
-
- len = (ret < MAX_ENTRY_LEN - (len + 1) ?
- len + ret : MAX_ENTRY_LEN - 1);
- e->msg[len] = '\0';
-
- e->cnt++;
- e->err = err;
- e->func = (char *)func;
- tapdisk_err.cnt++;
-}
-
-void
-tlog_print_errors(void)
-{
- int i;
- struct error *e;
-
- for (i = 0; i < tapdisk_err.cnt; i++) {
- e = &tapdisk_err.errors[i];
- syslog(LOG_INFO, "TAPDISK ERROR: errno %d at %s (cnt = %d): "
- "%s\n", e->err, e->func, e->cnt, e->msg);
- }
-
- if (tapdisk_err.dropped)
- syslog(LOG_INFO, "TAPDISK ERROR: %d other error messages "
- "dropped\n", tapdisk_err.dropped);
-}
-
-void
-tlog_flush_errors(void)
-{
- int i;
- struct error *e;
-
- for (i = 0; i < tapdisk_err.cnt; i++) {
- e = &tapdisk_err.errors[i];
- tlog_write(TLOG_WARN, "TAPDISK ERROR: errno %d at %s "
- "(cnt = %d): %s\n", e->err, e->func, e->cnt,
- e->msg);
- }
-
- if (tapdisk_err.dropped)
- tlog_write(TLOG_WARN, "TAPDISK ERROR: %d other error messages "
- "dropped\n", tapdisk_err.dropped);
-}
-
-void
-tlog_flush(void)
-{
- int fd, flags;
- size_t size, wsize;
-
- if (!tapdisk_log.buf)
- return;
-
- flags = O_CREAT | O_WRONLY | O_DIRECT | O_NONBLOCK;
- if (!tapdisk_log.append)
- flags |= O_TRUNC;
-
- fd = open(tapdisk_log.file, flags, 0644);
- if (fd == -1)
- return;
-
- if (tapdisk_log.append)
- if (lseek(fd, 0, SEEK_END) == (off_t)-1)
- goto out;
-
- tlog_flush_errors();
-
- size = tapdisk_log.p - tapdisk_log.buf;
- wsize = ((size + 511) & (~511));
-
- memset(tapdisk_log.buf + size, '\n', wsize - size);
- write_exact(fd, tapdisk_log.buf, wsize);
-
- tapdisk_log.p = tapdisk_log.buf;
-
-out:
- close(fd);
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#ifndef _TAPDISK_LOG_H_
-#define _TAPDISK_LOG_H_
-
-#define TLOG_WARN 0
-#define TLOG_INFO 1
-#define TLOG_DBG 2
-
-void open_tlog(char *file, size_t bytes, int level, int append);
-void close_tlog(void);
-void tlog_flush(void);
-void tlog_print_errors(void);
-
-void __tlog_write(int level, const char *func, const char *fmt, ...)
- __attribute__((format(printf, 3, 4)));
-void __tlog_error(int err, const char *func, const char *fmt, ...)
- __attribute__((format(printf, 3, 4)));
-
-#define tlog_write(_level, _f, _a...) \
- __tlog_write(_level, __func__, _f, ##_a)
-
-#define tlog_error(_err, _f, _a...) \
- __tlog_error(_err, __func__, _f, ##_a)
-
-#endif
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#include <errno.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <libaio.h>
-#ifdef __linux__
-#include <linux/version.h>
-#endif
-
-#include "tapdisk.h"
-#include "tapdisk-log.h"
-#include "tapdisk-queue.h"
-#include "tapdisk-filter.h"
-#include "tapdisk-server.h"
-#include "tapdisk-utils.h"
-
-#include "libaio-compat.h"
-#include "atomicio.h"
-
-#define WARN(_f, _a...) tlog_write(TLOG_WARN, _f, ##_a)
-#define DBG(_f, _a...) tlog_write(TLOG_DBG, _f, ##_a)
-#define ERR(_err, _f, _a...) tlog_error(_err, _f, ##_a)
-
-/*
- * We used a kernel patch to return an fd associated with the AIO context
- * so that we can concurrently poll on synchronous and async descriptors.
- * This is signalled by passing 1 as the io context to io_setup.
- */
-#define REQUEST_ASYNC_FD ((io_context_t)1)
-
-static inline void
-queue_tiocb(struct tqueue *queue, struct tiocb *tiocb)
-{
- struct iocb *iocb = &tiocb->iocb;
-
- if (queue->queued) {
- struct tiocb *prev = (struct tiocb *)
- queue->iocbs[queue->queued - 1]->data;
- prev->next = tiocb;
- }
-
- queue->iocbs[queue->queued++] = iocb;
-}
-
-static inline int
-deferred_tiocbs(struct tqueue *queue)
-{
- return (queue->deferred.head != NULL);
-}
-
-static inline void
-defer_tiocb(struct tqueue *queue, struct tiocb *tiocb)
-{
- struct tlist *list = &queue->deferred;
-
- if (!list->head)
- list->head = list->tail = tiocb;
- else
- list->tail = list->tail->next = tiocb;
-
- queue->tiocbs_deferred++;
- queue->deferrals++;
-}
-
-static inline void
-queue_deferred_tiocb(struct tqueue *queue)
-{
- struct tlist *list = &queue->deferred;
-
- if (list->head) {
- struct tiocb *tiocb = list->head;
-
- list->head = tiocb->next;
- if (!list->head)
- list->tail = NULL;
-
- queue_tiocb(queue, tiocb);
- queue->tiocbs_deferred--;
- }
-}
-
-static inline void
-queue_deferred_tiocbs(struct tqueue *queue)
-{
- while (!tapdisk_queue_full(queue) && deferred_tiocbs(queue))
- queue_deferred_tiocb(queue);
-}
-
-/*
- * td_complete may queue more tiocbs
- */
-static void
-complete_tiocb(struct tqueue *queue, struct tiocb *tiocb, unsigned long res)
-{
- int err;
- struct iocb *iocb = &tiocb->iocb;
-
- if (res == iocb->u.c.nbytes)
- err = 0;
- else if ((int)res < 0)
- err = (int)res;
- else
- err = -EIO;
-
- tiocb->cb(tiocb->arg, tiocb, err);
-}
-
-static int
-cancel_tiocbs(struct tqueue *queue, int err)
-{
- int queued;
- struct tiocb *tiocb;
-
- if (!queue->queued)
- return 0;
-
- /*
- * td_complete may queue more tiocbs, which
- * will overwrite the contents of queue->iocbs.
- * use a private linked list to keep track
- * of the tiocbs we're cancelling.
- */
- tiocb = queue->iocbs[0]->data;
- queued = queue->queued;
- queue->queued = 0;
-
- for (; tiocb != NULL; tiocb = tiocb->next)
- complete_tiocb(queue, tiocb, err);
-
- return queued;
-}
-
-static int
-fail_tiocbs(struct tqueue *queue, int succeeded, int total, int err)
-{
- ERR(err, "io_submit error: %d of %d failed",
- total - succeeded, total);
-
- /* take any non-submitted, merged iocbs
- * off of the queue, split them, and fail them */
- queue->queued = io_expand_iocbs(&queue->opioctx,
- queue->iocbs, succeeded, total);
-
- return cancel_tiocbs(queue, err);
-}
-
-/*
- * rwio
- */
-
-struct rwio {
- struct io_event *aio_events;
-};
-
-static void
-tapdisk_rwio_destroy(struct tqueue *queue)
-{
- struct rwio *rwio = queue->tio_data;
-
- if (rwio->aio_events) {
- free(rwio->aio_events);
- rwio->aio_events = NULL;
- }
-}
-
-static int
-tapdisk_rwio_setup(struct tqueue *queue, int size)
-{
- struct rwio *rwio = queue->tio_data;
- int err;
-
- rwio->aio_events = calloc(size, sizeof(struct io_event));
- if (!rwio->aio_events)
- return -errno;
-
- return 0;
-}
-
-static inline ssize_t
-tapdisk_rwio_rw(const struct iocb *iocb)
-{
- int fd = iocb->aio_fildes;
- char *buf = iocb->u.c.buf;
- long long off = iocb->u.c.offset;
- size_t size = iocb->u.c.nbytes;
- ssize_t (*func)(int, void *, size_t) =
- (iocb->aio_lio_opcode == IO_CMD_PWRITE ? vwrite : read);
-
- if (lseek(fd, off, SEEK_SET) == (off_t)-1)
- return -errno;
-
- if (atomicio(func, fd, buf, size) != size)
- return -errno;
-
- return size;
-}
-
-static int
-tapdisk_rwio_submit(struct tqueue *queue)
-{
- struct rwio *rwio = queue->tio_data;
- int i, merged, split;
- struct iocb *iocb;
- struct tiocb *tiocb;
- struct io_event *ep;
-
- if (!queue->queued)
- return 0;
-
- tapdisk_filter_iocbs(queue->filter, queue->iocbs, queue->queued);
- merged = io_merge(&queue->opioctx, queue->iocbs, queue->queued);
-
- queue->queued = 0;
-
- for (i = 0; i < merged; i++) {
- ep = rwio->aio_events + i;
- iocb = queue->iocbs[i];
- ep->obj = iocb;
- ep->res = tapdisk_rwio_rw(iocb);
- }
-
- split = io_split(&queue->opioctx, rwio->aio_events, merged);
- tapdisk_filter_events(queue->filter, rwio->aio_events, split);
-
- for (i = split, ep = rwio->aio_events; i-- > 0; ep++) {
- iocb = ep->obj;
- tiocb = iocb->data;
- complete_tiocb(queue, tiocb, ep->res);
- }
-
- queue_deferred_tiocbs(queue);
-
- return split;
-}
-
-static const struct tio td_tio_rwio = {
- .name = "rwio",
- .data_size = 0,
- .tio_setup = NULL,
- .tio_destroy = NULL,
- .tio_submit = tapdisk_rwio_submit
-};
-
-/*
- * libaio
- */
-
-struct lio {
- io_context_t aio_ctx;
- struct io_event *aio_events;
-
- int event_fd;
- int event_id;
-
- int flags;
-};
-
-#define LIO_FLAG_EVENTFD (1<<0)
-
-static int
-tapdisk_lio_check_resfd(void)
-{
-#if defined(__linux__)
- return tapdisk_linux_version() >= KERNEL_VERSION(2, 6, 22);
-#else
- return 1;
-#endif
-}
-
-static void
-tapdisk_lio_destroy_aio(struct tqueue *queue)
-{
- struct lio *lio = queue->tio_data;
-
- if (lio->event_fd >= 0) {
- close(lio->event_fd);
- lio->event_fd = -1;
- }
-
- if (lio->aio_ctx) {
- io_destroy(lio->aio_ctx);
- lio->aio_ctx = 0;
- }
-}
-
-static int
-__lio_setup_aio_poll(struct tqueue *queue, int qlen)
-{
- struct lio *lio = queue->tio_data;
- int err, fd;
-
- lio->aio_ctx = REQUEST_ASYNC_FD;
-
- fd = io_setup(qlen, &lio->aio_ctx);
- if (fd < 0) {
- lio->aio_ctx = 0;
- err = -errno;
-
- if (err == -EINVAL)
- goto fail_fd;
-
- goto fail;
- }
-
- lio->event_fd = fd;
-
- return 0;
-
-fail_fd:
- DPRINTF("Couldn't get fd for AIO poll support. This is probably "
- "because your kernel does not have the aio-poll patch "
- "applied.\n");
-fail:
- return err;
-}
-
-static int
-__lio_setup_aio_eventfd(struct tqueue *queue, int qlen)
-{
- struct lio *lio = queue->tio_data;
- int err;
-
- err = io_setup(qlen, &lio->aio_ctx);
- if (err < 0) {
- lio->aio_ctx = 0;
- return err;
- }
-
- lio->event_fd = tapdisk_sys_eventfd(0);
- if (lio->event_fd < 0)
- return -errno;
-
- lio->flags |= LIO_FLAG_EVENTFD;
-
- return 0;
-}
-
-static int
-tapdisk_lio_setup_aio(struct tqueue *queue, int qlen)
-{
- struct lio *lio = queue->tio_data;
- int err;
-
- lio->aio_ctx = 0;
- lio->event_fd = -1;
-
- /*
- * prefer the mainline eventfd(2) api, if available.
- * if not, fall back to the poll fd patch.
- */
-
- err = !tapdisk_lio_check_resfd();
- if (!err)
- err = __lio_setup_aio_eventfd(queue, qlen);
- if (err)
- err = __lio_setup_aio_poll(queue, qlen);
-
- if (err == -EAGAIN)
- goto fail_rsv;
-fail:
- return err;
-
-fail_rsv:
- DPRINTF("Couldn't setup AIO context. If you are trying to "
- "concurrently use a large number of blktap-based disks, you may "
- "need to increase the system-wide aio request limit. "
- "(e.g. 'echo 1048576 > /proc/sys/fs/aio-max-nr')\n");
- goto fail;
-}
-
-
-static void
-tapdisk_lio_destroy(struct tqueue *queue)
-{
- struct lio *lio = queue->tio_data;
-
- if (!lio)
- return;
-
- if (lio->event_id >= 0) {
- tapdisk_server_unregister_event(lio->event_id);
- lio->event_id = -1;
- }
-
- tapdisk_lio_destroy_aio(queue);
-
- if (lio->aio_events) {
- free(lio->aio_events);
- lio->aio_events = NULL;
- }
-}
-
-static void
-tapdisk_lio_set_eventfd(struct tqueue *queue, int n, struct iocb **iocbs)
-{
- struct lio *lio = queue->tio_data;
- int i;
-
- if (lio->flags & LIO_FLAG_EVENTFD)
- for (i = 0; i < n; ++i)
- __io_set_eventfd(iocbs[i], lio->event_fd);
-}
-
-static void
-tapdisk_lio_ack_event(struct tqueue *queue)
-{
- struct lio *lio = queue->tio_data;
- uint64_t val;
-
- if (lio->flags & LIO_FLAG_EVENTFD)
- read_exact(lio->event_fd, &val, sizeof(val));
-}
-
-static void
-tapdisk_lio_event(event_id_t id, char mode, void *private)
-{
- struct tqueue *queue = private;
- struct lio *lio;
- int i, ret, split;
- struct iocb *iocb;
- struct tiocb *tiocb;
- struct io_event *ep;
-
- tapdisk_lio_ack_event(queue);
-
- lio = queue->tio_data;
- ret = io_getevents(lio->aio_ctx, 0,
- queue->size, lio->aio_events, NULL);
- split = io_split(&queue->opioctx, lio->aio_events, ret);
- tapdisk_filter_events(queue->filter, lio->aio_events, split);
-
- DBG("events: %d, tiocbs: %d\n", ret, split);
-
- queue->iocbs_pending -= ret;
- queue->tiocbs_pending -= split;
-
- for (i = split, ep = lio->aio_events; i-- > 0; ep++) {
- iocb = ep->obj;
- tiocb = iocb->data;
- complete_tiocb(queue, tiocb, ep->res);
- }
-
- queue_deferred_tiocbs(queue);
-}
-
-static int
-tapdisk_lio_setup(struct tqueue *queue, int qlen)
-{
- struct lio *lio = queue->tio_data;
- size_t sz;
- int err;
-
- lio->event_id = -1;
-
- err = tapdisk_lio_setup_aio(queue, qlen);
- if (err)
- goto fail;
-
- lio->event_id =
- tapdisk_server_register_event(SCHEDULER_POLL_READ_FD,
- lio->event_fd, 0,
- tapdisk_lio_event,
- queue);
- err = lio->event_id;
- if (err < 0)
- goto fail;
-
- lio->aio_events = calloc(qlen, sizeof(struct io_event));
- if (!lio->aio_events) {
- err = -errno;
- goto fail;
- }
-
- return 0;
-
-fail:
- tapdisk_lio_destroy(queue);
- return err;
-}
-
-static int
-tapdisk_lio_submit(struct tqueue *queue)
-{
- struct lio *lio = queue->tio_data;
- int merged, submitted, err = 0;
-
- if (!queue->queued)
- return 0;
-
- tapdisk_filter_iocbs(queue->filter, queue->iocbs, queue->queued);
- merged = io_merge(&queue->opioctx, queue->iocbs, queue->queued);
- tapdisk_lio_set_eventfd(queue, merged, queue->iocbs);
- submitted = io_submit(lio->aio_ctx, merged, queue->iocbs);
-
- DBG("queued: %d, merged: %d, submitted: %d\n",
- queue->queued, merged, submitted);
-
- if (submitted < 0) {
- err = submitted;
- submitted = 0;
- } else if (submitted < merged)
- err = -EIO;
-
- queue->iocbs_pending += submitted;
- queue->tiocbs_pending += queue->queued;
- queue->queued = 0;
-
- if (err)
- queue->tiocbs_pending -=
- fail_tiocbs(queue, submitted, merged, err);
-
- return submitted;
-}
-
-static const struct tio td_tio_lio = {
- .name = "lio",
- .data_size = sizeof(struct lio),
- .tio_setup = tapdisk_lio_setup,
- .tio_destroy = tapdisk_lio_destroy,
- .tio_submit = tapdisk_lio_submit,
-};
-
-static void
-tapdisk_queue_free_io(struct tqueue *queue)
-{
- if (queue->tio) {
- if (queue->tio->tio_destroy)
- queue->tio->tio_destroy(queue);
- queue->tio = NULL;
- }
-
- if (queue->tio_data) {
- free(queue->tio_data);
- queue->tio_data = NULL;
- }
-}
-
-static int
-tapdisk_queue_init_io(struct tqueue *queue, int drv)
-{
- const struct tio *tio;
- int err;
-
- switch (drv) {
- case TIO_DRV_LIO:
- tio = &td_tio_lio;
- break;
- case TIO_DRV_RWIO:
- tio = &td_tio_rwio;
- break;
- default:
- err = -EINVAL;
- goto fail;
- }
-
- queue->tio_data = calloc(1, tio->data_size);
- if (!queue->tio_data) {
- PERROR("malloc(%zu)", tio->data_size);
- err = -errno;
- goto fail;
- }
-
- queue->tio = tio;
-
- if (tio->tio_setup) {
- err = tio->tio_setup(queue, queue->size);
- if (err)
- goto fail;
- }
-
- DPRINTF("I/O queue driver: %s\n", tio->name);
-
- return 0;
-
-fail:
- tapdisk_queue_free_io(queue);
- return err;
-}
-
-int
-tapdisk_init_queue(struct tqueue *queue, int size,
- int drv, struct tfilter *filter)
-{
- int i, err;
-
- memset(queue, 0, sizeof(struct tqueue));
-
- queue->size = size;
- queue->filter = filter;
-
- if (!size)
- return 0;
-
- err = tapdisk_queue_init_io(queue, drv);
- if (err)
- goto fail;
-
- queue->iocbs = calloc(size, sizeof(struct iocb *));
- if (!queue->iocbs) {
- err = -errno;
- goto fail;
- }
-
- err = opio_init(&queue->opioctx, size);
- if (err)
- goto fail;
-
- return 0;
-
- fail:
- tapdisk_free_queue(queue);
- return err;
-}
-
-void
-tapdisk_free_queue(struct tqueue *queue)
-{
- tapdisk_queue_free_io(queue);
-
- free(queue->iocbs);
- queue->iocbs = NULL;
-
- opio_free(&queue->opioctx);
-}
-
-void
-tapdisk_debug_queue(struct tqueue *queue)
-{
- struct tiocb *tiocb = queue->deferred.head;
-
- WARN("TAPDISK QUEUE:\n");
- WARN("size: %d, tio: %s, queued: %d, iocbs_pending: %d, "
- "tiocbs_pending: %d, tiocbs_deferred: %d, deferrals: %"PRIx64"\n",
- queue->size, queue->tio->name, queue->queued, queue->iocbs_pending,
- queue->tiocbs_pending, queue->tiocbs_deferred, queue->deferrals);
-
- if (tiocb) {
- WARN("deferred:\n");
- for (; tiocb != NULL; tiocb = tiocb->next) {
- struct iocb *io = &tiocb->iocb;
- WARN("%s of %lu bytes at %lld\n",
- (io->aio_lio_opcode == IO_CMD_PWRITE ?
- "write" : "read"),
- io->u.c.nbytes, io->u.c.offset);
- }
- }
-}
-
-void
-tapdisk_prep_tiocb(struct tiocb *tiocb, int fd, int rw, char *buf, size_t size,
- long long offset, td_queue_callback_t cb, void *arg)
-{
- struct iocb *iocb = &tiocb->iocb;
-
- if (rw)
- io_prep_pwrite(iocb, fd, buf, size, offset);
- else
- io_prep_pread(iocb, fd, buf, size, offset);
-
- iocb->data = tiocb;
- tiocb->cb = cb;
- tiocb->arg = arg;
- tiocb->next = NULL;
-}
-
-void
-tapdisk_queue_tiocb(struct tqueue *queue, struct tiocb *tiocb)
-{
- if (!tapdisk_queue_full(queue))
- queue_tiocb(queue, tiocb);
- else
- defer_tiocb(queue, tiocb);
-}
-
-
-/*
- * fail_tiocbs may queue more tiocbs
- */
-int
-tapdisk_submit_tiocbs(struct tqueue *queue)
-{
- return queue->tio->tio_submit(queue);
-}
-
-int
-tapdisk_submit_all_tiocbs(struct tqueue *queue)
-{
- int submitted = 0;
-
- do {
- submitted += tapdisk_submit_tiocbs(queue);
- } while (!tapdisk_queue_empty(queue));
-
- return submitted;
-}
-
-/*
- * cancel_tiocbs may queue more tiocbs
- */
-int
-tapdisk_cancel_tiocbs(struct tqueue *queue)
-{
- return cancel_tiocbs(queue, -EIO);
-}
-
-int
-tapdisk_cancel_all_tiocbs(struct tqueue *queue)
-{
- int cancelled = 0;
-
- do {
- cancelled += tapdisk_cancel_tiocbs(queue);
- } while (!tapdisk_queue_empty(queue));
-
- return cancelled;
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#ifndef TAPDISK_QUEUE_H
-#define TAPDISK_QUEUE_H
-
-#include <libaio.h>
-
-#include "io-optimize.h"
-#include "scheduler.h"
-
-struct tiocb;
-struct tfilter;
-
-typedef void (*td_queue_callback_t)(void *arg, struct tiocb *, int err);
-
-
-struct tiocb {
- td_queue_callback_t cb;
- void *arg;
-
- struct iocb iocb;
- struct tiocb *next;
-};
-
-struct tlist {
- struct tiocb *head;
- struct tiocb *tail;
-};
-
-struct tqueue {
- int size;
-
- const struct tio *tio;
- void *tio_data;
-
- struct opioctx opioctx;
-
- int queued;
- struct iocb **iocbs;
-
- /* number of iocbs pending in the aio layer */
- int iocbs_pending;
-
- /* number of tiocbs pending in the queue --
- * this is likely to be larger than iocbs_pending
- * due to request coalescing */
- int tiocbs_pending;
-
- /* iocbs may be deferred if the aio ring is full.
- * tapdisk_queue_complete will ensure deferred
- * iocbs are queued as slots become available. */
- struct tlist deferred;
- int tiocbs_deferred;
-
- /* optional tapdisk filter */
- struct tfilter *filter;
-
- uint64_t deferrals;
-};
-
-struct tio {
- const char *name;
- size_t data_size;
-
- int (*tio_setup) (struct tqueue *queue, int qlen);
- void (*tio_destroy) (struct tqueue *queue);
- int (*tio_submit) (struct tqueue *queue);
-};
-
-enum {
- TIO_DRV_LIO = 1,
- TIO_DRV_RWIO = 2,
-};
-
-/*
- * Interface for request producer (i.e., tapdisk)
- * NB: the following functions may cause additional tiocbs to be queued:
- * - tapdisk_submit_tiocbs
- * - tapdisk_cancel_tiocbs
- * - tapdisk_complete_tiocbs
- * The *_all_tiocbs variants will handle the first two cases;
- * be sure to call submit after calling complete in the third case.
- */
-#define tapdisk_queue_count(q) ((q)->queued)
-#define tapdisk_queue_empty(q) ((q)->queued == 0)
-#define tapdisk_queue_full(q) \
- (((q)->tiocbs_pending + (q)->queued) >= (q)->size)
-int tapdisk_init_queue(struct tqueue *, int size, int drv, struct tfilter *);
-void tapdisk_free_queue(struct tqueue *);
-void tapdisk_debug_queue(struct tqueue *);
-void tapdisk_queue_tiocb(struct tqueue *, struct tiocb *);
-int tapdisk_submit_tiocbs(struct tqueue *);
-int tapdisk_submit_all_tiocbs(struct tqueue *);
-int tapdisk_cancel_tiocbs(struct tqueue *);
-int tapdisk_cancel_all_tiocbs(struct tqueue *);
-void tapdisk_prep_tiocb(struct tiocb *, int, int, char *, size_t,
- long long, td_queue_callback_t, void *);
-
-#endif
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include <errno.h>
-
-#include "tapdisk-ring.h"
-
-static int
-tapdisk_uring_create_ctlfd(td_uring_t *ring)
-{
- int fd, err;
- struct sockaddr_un saddr;
-
- if (strnlen(ring->ctlfd_path, sizeof(saddr.sun_family)) >=
- sizeof(saddr.sun_family))
- return -ENAMETOOLONG;
-
- fd = socket(AF_UNIX, SOCK_STREAM, 0);
- if (fd == -1)
- return -errno;
-
- memset(&saddr, 0, sizeof(struct sockaddr_un));
- saddr.sun_family = AF_UNIX;
- memcpy(saddr.sun_path, ring->ctlfd_path, strlen(ring->ctlfd_path));
-
- err = unlink(ring->ctlfd_path);
- if (err == -1 && errno != ENOENT) {
- err = -errno;
- goto fail;
- }
-
- err = bind(fd, &saddr, sizeof(struct sockaddr_un));
- if (err == -1) {
- err = -errno;
- goto fail;
- }
-
- err = listen(fd, 1);
- if (err == -1) {
- err = -errno;
- goto fail;
- }
-
- ring->ctlfd = fd;
- return 0;
-
-fail:
- close(fd);
- return err;
-}
-
-static void
-tapdisk_uring_destroy_ctlfd(td_uring_t *ring)
-{
- if (ring->ctlfd) {
- close(ring->ctlfd);
- ring->ctlfd = 0;
- }
-
- if (ring->ctlfd_path) {
- unlink(ring->ctlfd_path);
- free(ring->ctlfd_path);
- ring->ctlfd_path = NULL;
- }
-}
-
-static int
-tapdisk_uring_connect_ctlfd(td_uring_t *ring)
-{
- int fd, err;
- struct sockaddr_un saddr;
-
- if (strnlen(ring->ctlfd_path, sizeof(saddr.sun_path)) >=
- sizeof(saddr.sun_path))
- return -ENAMETOOLONG;
-
- fd = socket(AF_UNIX, SOCK_STREAM, 0);
- if (fd == -1)
- return -errno;
-
- memset(&saddr, 0, sizeof(struct sockaddr_un));
- saddr.sun_family = AF_UNIX;
- memcpy(saddr.sun_path, ring->ctlfd_path, strlen(ring->ctlfd_path));
-
- err = connect(fd, &saddr, sizeof(saddr));
- if (err == -1) {
- err = -errno;
- goto fail;
- }
-
- ring->ctlfd = fd;
- return 0;
-
-fail:
- close(fd);
- return err;
-}
-
-static void
-tapdisk_uring_disconnect_ctlfd(td_uring_t *ring)
-{
- if (ring->ctlfd)
- close(ring->ctlfd);
- free(ring->ctlfd_path);
- ring->ctlfd_path = NULL;
-}
-
-static int
-tapdisk_uring_create_shmem(td_uring_t *ring)
-{
- int fd, err;
-
- fd = shm_open(ring->shmem_path, O_CREAT | O_RDWR, 0750);
- if (fd == -1)
- return -errno;
-
- err = ftruncate(fd, ring->shmem_size);
- if (err == -1) {
- err = -errno;
- goto out;
- }
-
- ring->shmem = mmap(NULL, ring->shmem_size,
- PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
- if (ring->shmem == MAP_FAILED) {
- ring->shmem = NULL;
- err = -errno;
- goto out;
- }
-
- err = 0;
-
-out:
- close(fd);
- return err;
-}
-
-static void
-tapdisk_uring_destroy_shmem(td_uring_t *ring)
-{
- if (ring->shmem) {
- munmap(ring->shmem, ring->shmem_size);
- ring->shmem = NULL;
- }
-
- if (ring->shmem_path) {
- shm_unlink(ring->shmem_path);
- free(ring->shmem_path);
- ring->shmem_path = NULL;
- }
-}
-
-static int
-tapdisk_uring_connect_shmem(td_uring_t *ring)
-{
- int fd, err;
- td_uring_header_t header, *p;
-
- fd = shm_open(ring->shmem_path, O_RDWR);
- if (fd == -1)
- return -errno;
-
- p = mmap(NULL, sizeof(td_uring_header_t),
- PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
- if (p == MAP_FAILED) {
- err = -errno;
- goto out;
- }
-
- memcpy(&header, p, sizeof(td_uring_header_t));
- munmap(p, sizeof(td_uring_header_t));
-
- if (memcmp(header.cookie,
- TAPDISK_URING_COOKIE, sizeof(header.cookie))) {
- err = -EINVAL;
- goto out;
- }
-
- if (header.version != TD_URING_CURRENT_VERSION) {
- err = -EINVAL;
- goto out;
- }
-
- ring->ring_size = header.ring_size;
- ring->data_size = header.data_size;
- ring->shmem_size = header.shmem_size;
-
- ring->shmem = mmap(NULL, ring->shmem_size,
- PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
- if (ring->shmem == MAP_FAILED) {
- rint->shmem = NULL;
- err = -errno;
- goto out;
- }
-
- err = 0;
-
-out:
- close(fd);
- return err;
-}
-
-static void
-tapdisk_uring_disconnect_shmem(td_uring_t *ring)
-{
- if (ring->shmem)
- munmap(ring->shmem, ring->shmem_size);
- free(ring->shmem_path);
- ring->shmem_path = NULL;
-}
-
-int
-tapdisk_uring_create(td_uring_t *ring, const char *location,
- uint32_t ring_size, uint32_t data_size)
-{
- int fd, err;
-
- memset(ring, 0, sizeof(td_uring_t));
-
- ring->ring_size = ring_size;
- ring->data_size = data_size;
- ring->shmem_size = ring_size + data_size + sizeof(td_uring_header_t);
-
- err = asprintf(&ring->shmem_path, "%s.shm", location);
- if (err == -1) {
- ring->shmem_path = NULL;
- err = -errno;
- goto fail;
- }
-
- err = asprintf(&ring->ctlfd_path, "%s.cfd", location);
- if (err == -1) {
- ring->ctlfd_path = NULL;
- err = -errno;
- goto fail;
- }
-
- err = tapdisk_uring_create_ctlfd(ring);
- if (err)
- goto fail;
-
- err = tapdisk_uring_create_shmem(ring);
- if (err)
- goto fail;
-
- ring->ring_area = (unsigned long)ring->shmem + sizeof(td_uring_header_t);
- ring->data_area = (unsigned long)ring->ring_area + ring->ring_size;
-
- return 0;
-
-fail:
- tapdisk_uring_destroy(ring);
- return err;
-}
-
-int
-tapdisk_uring_destroy(td_uring_t *ring)
-{
- tapdisk_uring_destroy_shmem(ring);
- tapdisk_uring_destroy_ctlfd(ring);
- return 0;
-}
-
-int
-tapdisk_uring_connect(td_uring_t *ring, const char *location)
-{
- int fd, err;
-
- memset(ring, 0, sizeof(td_uring_t));
-
- err = asprintf(&ring->shmem_path, "%s.shm", location);
- if (err == -1) {
- ring->shmem_path = NULL;
- err = -errno;
- goto fail;
- }
-
- err = asprintf(&ring->ctlfd_path, "%s.cfd", location);
- if (err == -1) {
- ring->ctlfd_path = NULL;
- err = -errno;
- goto fail;
- }
-
- err = tapdisk_uring_connect_ctlfd(ring);
- if (err)
- goto fail;
-
- err = tapdisk_uring_connect_shmem(ring);
- if (err)
- goto fail;
-
- err = 0;
-
-fail:
-}
-
-int
-tapdisk_uring_disconnect(td_uring_t *ring)
-{
- tapdisk_uring_disconnect_shmem(ring);
- tapdisk_uring_disconnect_ctlfd(ring);
- return 0;
-}
-
-static int
-tapdisk_ring_read_message(int fd, td_uring_message_t *message, int timeout)
-{
- fd_set readfds;
- int ret, len, offset;
- struct timeval tv, *t;
-
- t = NULL;
- offset = 0;
- len = sizeof(td_uring_message_t);
-
- if (timeout) {
- tv.tv_sec = timeout;
- tv.tv_usec = 0;
- t = &tv;
- }
-
- while (offset < len) {
- FD_ZERO(&readfds);
- FD_SET(fd, &readfds);
-
- /* we don't bother reinitializing tv. at worst, it will wait a
- * bit more time than expected. */
-
- ret = select(fd + 1, &readfds, NULL, NULL, t);
- if (ret == -1)
- break;
- else if (FD_ISSET(fd, &readfds)) {
- ret = read(fd, message + offset, len - offset);
- if (ret <= 0)
- break;
- offset += ret;
- } else
- break;
- }
-
- if (offset != len)
- return -EIO;
-
- return 0;
-}
-
-static int
-tapdisk_ring_write_message(int fd, td_uring_message_t *message, int timeout)
-{
- fd_set writefds;
- int ret, len, offset;
- struct timeval tv, *t;
-
- t = NULL;
- offset = 0;
- len = sizeof(td_uring_message_t);
-
- if (timeout) {
- tv.tv_sec = timeout;
- tv.tv_usec = 0;
- t = &tv;
- }
-
- while (offset < len) {
- FD_ZERO(&writefds);
- FD_SET(fd, &writefds);
-
- /* we don't bother reinitializing tv. at worst, it will wait a
- * bit more time than expected. */
-
- ret = select(fd + 1, NULL, &writefds, NULL, t);
- if (ret == -1)
- break;
- else if (FD_ISSET(fd, &writefds)) {
- ret = write(fd, message + offset, len - offset);
- if (ret <= 0)
- break;
- offset += ret;
- } else
- break;
- }
-
- if (offset != len)
- return -EIO;
-
- return 0;
-}
-
-int
-tapdisk_uring_poll(td_uring_t *ring)
-{
- int err;
- td_uring_message_t message;
-
- err = tapdisk_uring_read_message(ring->ctlfd, &message, 1);
- if (err)
- return err;
-
- if (message.type != TAPDISK_URING_MESSAGE_KICK)
- return -EINVAL;
-
- return 0;
-}
-
-int
-tapdisk_uring_kick(td_uring_t *ring)
-{
- td_uring_message_t message;
-
- memset(&message, 0, sizeof(td_uring_message_t));
- message.type = TAPDISK_URING_MESSAGE_KICK;
-
- return tapdisk_uring_write_message(ring->ctlfd, &message, 1);
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#ifndef _TAPDISK_RING_H_
-#define _TAPDISK_RING_H_
-
-#include <inttypes.h>
-
-#include <xenctrl.h>
-#include <xen/io/ring.h>
-
-typedef struct td_uring td_uring_t;
-typedef struct td_uring_header td_uring_header_t;
-typedef struct td_uring_request td_uring_request_t;
-typedef struct td_uring_response td_uring_response_t;
-
-struct td_uring {
- int ctlfd;
-
- char *shmem_path;
- char *ctlfd_path;
-
- void *shmem;
- void *ring_area;
- void *data_area;
-};
-
-struct td_uring_header {
- char cookie[8];
- uint32_t version;
- uint32_t shmem_size;
- uint32_t ring_size;
- uint32_t data_size;
- char reserved[4064];
-};
-
-struct td_uring_request {
- uint8_t op;
- uint64_t id;
- uint64_t sec;
- uint32_t secs;
- uint32_t offset;
-};
-
-struct td_uring_response {
- uint8_t op;
- uint64_t id;
- uint8_t status;
-};
-
-DEFINE_RING_TYPES(td_uring, td_uring_request_t, td_uring_response_t);
-
-int tapdisk_uring_create(td_uring_t *, const char *location,
- uint32_t ring_size, uint32_t data_size);
-int tapdisk_uring_destroy(td_uring_t *);
-
-int tapdisk_uring_connect(td_uring_t *, const char *location);
-int tapdisk_uring_disconnect(td_uring_t *);
-
-int tapdisk_uring_poll(td_uring_t *);
-int tapdisk_uring_kick(td_uring_t *);
-
-#endif
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include <stdio.h>
-#include <errno.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <sys/ioctl.h>
-#include <signal.h>
-
-#include "tapdisk-utils.h"
-#include "tapdisk-server.h"
-#include "tapdisk-driver.h"
-#include "tapdisk-interface.h"
-
-#define DBG(_level, _f, _a...) tlog_write(_level, _f, ##_a)
-#define ERR(_err, _f, _a...) tlog_error(_err, _f, ##_a)
-
- tapdisk_server_t server;
-
-#define tapdisk_server_for_each_vbd(vbd, tmp) \
- list_for_each_entry_safe(vbd, tmp, &server.vbds, next)
-
-td_image_t *
-tapdisk_server_get_shared_image(td_image_t *image)
-{
- td_vbd_t *vbd, *tmpv;
- td_image_t *img, *tmpi;
-
- if (!td_flag_test(image->flags, TD_OPEN_SHAREABLE))
- return NULL;
-
- tapdisk_server_for_each_vbd(vbd, tmpv)
- tapdisk_vbd_for_each_image(vbd, img, tmpi)
- if (img->type == image->type &&
- !strcmp(img->name, image->name))
- return img;
-
- return NULL;
-}
-
-struct list_head *
-tapdisk_server_get_all_vbds(void)
-{
- return &server.vbds;
-}
-
-td_vbd_t *
-tapdisk_server_get_vbd(uint16_t uuid)
-{
- td_vbd_t *vbd, *tmp;
-
- tapdisk_server_for_each_vbd(vbd, tmp)
- if (vbd->uuid == uuid)
- return vbd;
-
- return NULL;
-}
-
-void
-tapdisk_server_add_vbd(td_vbd_t *vbd)
-{
- list_add_tail(&vbd->next, &server.vbds);
-}
-
-void
-tapdisk_server_remove_vbd(td_vbd_t *vbd)
-{
- list_del(&vbd->next);
- INIT_LIST_HEAD(&vbd->next);
- tapdisk_server_check_state();
-}
-
-void
-tapdisk_server_queue_tiocb(struct tiocb *tiocb)
-{
- tapdisk_queue_tiocb(&server.aio_queue, tiocb);
-}
-
-void
-tapdisk_server_debug(void)
-{
- td_vbd_t *vbd, *tmp;
-
- tapdisk_debug_queue(&server.aio_queue);
-
- tapdisk_server_for_each_vbd(vbd, tmp)
- tapdisk_vbd_debug(vbd);
-
- tlog_flush();
-}
-
-void
-tapdisk_server_check_state(void)
-{
- if (list_empty(&server.vbds))
- server.run = 0;
-}
-
-event_id_t
-tapdisk_server_register_event(char mode, int fd,
- int timeout, event_cb_t cb, void *data)
-{
- return scheduler_register_event(&server.scheduler,
- mode, fd, timeout, cb, data);
-}
-
-void
-tapdisk_server_unregister_event(event_id_t event)
-{
- return scheduler_unregister_event(&server.scheduler, event);
-}
-
-void
-tapdisk_server_set_max_timeout(int seconds)
-{
- scheduler_set_max_timeout(&server.scheduler, seconds);
-}
-
-static void
-tapdisk_server_assert_locks(void)
-{
-
-}
-
-static void
-tapdisk_server_set_retry_timeout(void)
-{
- td_vbd_t *vbd, *tmp;
-
- tapdisk_server_for_each_vbd(vbd, tmp)
- if (tapdisk_vbd_retry_needed(vbd)) {
- tapdisk_server_set_max_timeout(TD_VBD_RETRY_INTERVAL);
- return;
- }
-}
-
-static void
-tapdisk_server_check_progress(void)
-{
- struct timeval now;
- td_vbd_t *vbd, *tmp;
-
- gettimeofday(&now, NULL);
-
- tapdisk_server_for_each_vbd(vbd, tmp)
- tapdisk_vbd_check_progress(vbd);
-}
-
-static void
-tapdisk_server_submit_tiocbs(void)
-{
- tapdisk_submit_all_tiocbs(&server.aio_queue);
-}
-
-static void
-tapdisk_server_kick_responses(void)
-{
- int n;
- td_vbd_t *vbd, *tmp;
-
- tapdisk_server_for_each_vbd(vbd, tmp)
- tapdisk_vbd_kick(vbd);
-}
-
-static void
-tapdisk_server_check_vbds(void)
-{
- td_vbd_t *vbd, *tmp;
-
- tapdisk_server_for_each_vbd(vbd, tmp)
- tapdisk_vbd_check_state(vbd);
-}
-
-static void
-tapdisk_server_stop_vbds(void)
-{
- td_vbd_t *vbd, *tmp;
-
- tapdisk_server_for_each_vbd(vbd, tmp)
- tapdisk_vbd_kill_queue(vbd);
-}
-
-static int
-tapdisk_server_init_aio(void)
-{
- return tapdisk_init_queue(&server.aio_queue, TAPDISK_TIOCBS,
- TIO_DRV_LIO, NULL);
-}
-
-static void
-tapdisk_server_close_aio(void)
-{
- tapdisk_free_queue(&server.aio_queue);
-}
-
-static void
-tapdisk_server_close(void)
-{
- tapdisk_server_close_aio();
-}
-
-void
-tapdisk_server_iterate(void)
-{
- int ret;
-
- tapdisk_server_assert_locks();
- tapdisk_server_set_retry_timeout();
- tapdisk_server_check_progress();
-
- ret = scheduler_wait_for_events(&server.scheduler);
- if (ret < 0)
- DBG(TLOG_WARN, "server wait returned %d\n", ret);
-
- tapdisk_server_check_vbds();
- tapdisk_server_submit_tiocbs();
- tapdisk_server_kick_responses();
-}
-
-static void
-__tapdisk_server_run(void)
-{
- while (server.run)
- tapdisk_server_iterate();
-}
-
-static void
-tapdisk_server_signal_handler(int signal)
-{
- td_vbd_t *vbd, *tmp;
- static int xfsz_error_sent = 0;
-
- switch (signal) {
- case SIGBUS:
- case SIGINT:
- tapdisk_server_for_each_vbd(vbd, tmp)
- tapdisk_vbd_close(vbd);
- break;
-
- case SIGXFSZ:
- ERR(EFBIG, "received SIGXFSZ");
- tapdisk_server_stop_vbds();
- if (xfsz_error_sent)
- break;
-
- xfsz_error_sent = 1;
- break;
-
- case SIGUSR1:
- tapdisk_server_debug();
- break;
- }
-}
-
-int
-tapdisk_server_init(void)
-{
- memset(&server, 0, sizeof(server));
- INIT_LIST_HEAD(&server.vbds);
-
- scheduler_initialize(&server.scheduler);
-
- return 0;
-}
-
-int
-tapdisk_server_complete(void)
-{
- int err;
-
- err = tapdisk_server_init_aio();
- if (err)
- goto fail;
-
- server.run = 1;
-
- return 0;
-
-fail:
- tapdisk_server_close_aio();
- return err;
-}
-
-int
-tapdisk_server_initialize(void)
-{
- int err;
-
- tapdisk_server_init();
-
- err = tapdisk_server_complete();
- if (err)
- goto fail;
-
- return 0;
-
-fail:
- tapdisk_server_close();
- return err;
-}
-
-int
-tapdisk_server_run()
-{
- int err;
-
- err = tapdisk_set_resource_limits();
- if (err)
- return err;
-
- signal(SIGBUS, tapdisk_server_signal_handler);
- signal(SIGINT, tapdisk_server_signal_handler);
- signal(SIGUSR1, tapdisk_server_signal_handler);
- signal(SIGXFSZ, tapdisk_server_signal_handler);
-
- __tapdisk_server_run();
- tapdisk_server_close();
-
- return 0;
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#ifndef _TAPDISK_SERVER_H_
-#define _TAPDISK_SERVER_H_
-
-#include "list.h"
-#include "tapdisk-vbd.h"
-#include "tapdisk-queue.h"
-
-struct tap_disk *tapdisk_server_find_driver_interface(int);
-
-td_image_t *tapdisk_server_get_shared_image(td_image_t *);
-
-struct list_head *tapdisk_server_get_all_vbds(void);
-td_vbd_t *tapdisk_server_get_vbd(td_uuid_t);
-void tapdisk_server_add_vbd(td_vbd_t *);
-void tapdisk_server_remove_vbd(td_vbd_t *);
-
-void tapdisk_server_queue_tiocb(struct tiocb *);
-
-void tapdisk_server_check_state(void);
-
-event_id_t tapdisk_server_register_event(char, int, int, event_cb_t, void *);
-void tapdisk_server_unregister_event(event_id_t);
-void tapdisk_server_set_max_timeout(int);
-
-int tapdisk_server_init(void);
-int tapdisk_server_initialize(void);
-int tapdisk_server_complete(void);
-int tapdisk_server_run(void);
-void tapdisk_server_iterate(void);
-
-#define TAPDISK_TIOCBS (TAPDISK_DATA_REQUESTS + 50)
-
-typedef struct tapdisk_server {
- int run;
- struct list_head vbds;
- scheduler_t scheduler;
- struct tqueue aio_queue;
-} tapdisk_server_t;
-
-#endif
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include <stdio.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-#include <unistd.h>
-
-#include "list.h"
-#include "scheduler.h"
-#include "tapdisk-vbd.h"
-#include "tapdisk-server.h"
-#include "tapdisk-disktype.h"
-#include "tapdisk-utils.h"
-
-#define POLL_READ 0
-#define POLL_WRITE 1
-
-#define MIN(a, b) ((a) < (b) ? (a) : (b))
-
-struct tapdisk_stream_poll {
- int pipe[2];
- int set;
-};
-
-struct tapdisk_stream_request {
- uint64_t sec;
- uint32_t secs;
- uint64_t seqno;
- blkif_request_t blkif_req;
- struct list_head next;
-};
-
-struct tapdisk_stream {
- td_vbd_t *vbd;
-
- unsigned int id;
- int in_fd;
- int out_fd;
-
- int err;
-
- uint64_t cur;
- uint64_t start;
- uint64_t end;
-
- uint64_t started;
- uint64_t completed;
-
- struct tapdisk_stream_poll poll;
- event_id_t enqueue_event_id;
-
- struct list_head free_list;
- struct list_head pending_list;
- struct list_head completed_list;
-
- struct tapdisk_stream_request requests[MAX_REQUESTS];
-};
-
-static unsigned int tapdisk_stream_count;
-
-static void tapdisk_stream_close_image(struct tapdisk_stream *);
-
-static void
-usage(const char *app, int err)
-{
- printf("usage: %s <-n type:/path/to/image> "
- "[-c sector count] [-s skip sectors]\n", app);
- exit(err);
-}
-
-static inline void
-tapdisk_stream_poll_initialize(struct tapdisk_stream_poll *p)
-{
- p->set = 0;
- p->pipe[POLL_READ] = p->pipe[POLL_WRITE] = -1;
-}
-
-static int
-tapdisk_stream_poll_open(struct tapdisk_stream_poll *p)
-{
- int err;
-
- tapdisk_stream_poll_initialize(p);
-
- err = pipe(p->pipe);
- if (err)
- return -errno;
-
- err = fcntl(p->pipe[POLL_READ], F_SETFL, O_NONBLOCK);
- if (err)
- goto out;
-
- err = fcntl(p->pipe[POLL_WRITE], F_SETFL, O_NONBLOCK);
- if (err)
- goto out;
-
- return 0;
-
-out:
- close(p->pipe[POLL_READ]);
- close(p->pipe[POLL_WRITE]);
- tapdisk_stream_poll_initialize(p);
- return -errno;
-}
-
-static void
-tapdisk_stream_poll_close(struct tapdisk_stream_poll *p)
-{
- if (p->pipe[POLL_READ] != -1)
- close(p->pipe[POLL_READ]);
- if (p->pipe[POLL_WRITE] != -1)
- close(p->pipe[POLL_WRITE]);
- tapdisk_stream_poll_initialize(p);
-}
-
-static inline void
-tapdisk_stream_poll_clear(struct tapdisk_stream_poll *p)
-{
- int dummy;
-
- read_exact(p->pipe[POLL_READ], &dummy, sizeof(dummy));
- p->set = 0;
-}
-
-static inline void
-tapdisk_stream_poll_set(struct tapdisk_stream_poll *p)
-{
- int dummy = 0;
-
- if (!p->set) {
- write_exact(p->pipe[POLL_WRITE], &dummy, sizeof(dummy));
- p->set = 1;
- }
-}
-
-static inline int
-tapdisk_stream_stop(struct tapdisk_stream *s)
-{
- return (list_empty(&s->pending_list) && (s->cur == s->end || s->err));
-}
-
-static inline void
-tapdisk_stream_initialize_request(struct tapdisk_stream_request *req)
-{
- memset(req, 0, sizeof(*req));
- INIT_LIST_HEAD(&req->next);
-}
-
-static inline int
-tapdisk_stream_request_idx(struct tapdisk_stream *s,
- struct tapdisk_stream_request *req)
-{
- return (req - s->requests);
-}
-
-static inline struct tapdisk_stream_request *
-tapdisk_stream_get_request(struct tapdisk_stream *s)
-{
- struct tapdisk_stream_request *req;
-
- if (list_empty(&s->free_list))
- return NULL;
-
- req = list_entry(s->free_list.next,
- struct tapdisk_stream_request, next);
-
- list_del_init(&req->next);
- tapdisk_stream_initialize_request(req);
-
- return req;
-}
-
-static void
-tapdisk_stream_print_request(struct tapdisk_stream *s,
- struct tapdisk_stream_request *sreq)
-{
- unsigned long idx = (unsigned long)tapdisk_stream_request_idx(s, sreq);
- char *buf = (char *)MMAP_VADDR(s->vbd->ring.vstart, idx, 0);
- write_exact(s->out_fd, buf, sreq->secs << SECTOR_SHIFT);
-}
-
-static void
-tapdisk_stream_write_data(struct tapdisk_stream *s)
-{
- struct tapdisk_stream_request *sreq, *tmp;
-
- list_for_each_entry_safe(sreq, tmp, &s->completed_list, next) {
- if (sreq->seqno != s->completed)
- break;
-
- s->completed++;
- tapdisk_stream_print_request(s, sreq);
-
- list_del_init(&sreq->next);
- list_add_tail(&sreq->next, &s->free_list);
- }
-}
-
-static inline void
-tapdisk_stream_queue_completed(struct tapdisk_stream *s,
- struct tapdisk_stream_request *sreq)
-{
- struct tapdisk_stream_request *itr;
-
- list_for_each_entry(itr, &s->completed_list, next)
- if (sreq->seqno < itr->seqno) {
- list_add_tail(&sreq->next, &itr->next);
- return;
- }
-
- list_add_tail(&sreq->next, &s->completed_list);
-}
-
-static void
-tapdisk_stream_dequeue(void *arg, blkif_response_t *rsp)
-{
- struct tapdisk_stream *s = (struct tapdisk_stream *)arg;
- struct tapdisk_stream_request *sreq = s->requests + rsp->id;
-
- list_del_init(&sreq->next);
-
- if (rsp->status == BLKIF_RSP_OKAY)
- tapdisk_stream_queue_completed(s, sreq);
- else {
- s->err = EIO;
- list_add_tail(&sreq->next, &s->free_list);
- fprintf(stderr, "error reading sector 0x%"PRIu64"\n", sreq->sec);
- }
-
- tapdisk_stream_write_data(s);
- tapdisk_stream_poll_set(&s->poll);
-}
-
-static void
-tapdisk_stream_enqueue(event_id_t id, char mode, void *arg)
-{
- td_vbd_t *vbd;
- int i, idx, psize;
- struct tapdisk_stream *s = (struct tapdisk_stream *)arg;
-
- vbd = s->vbd;
- tapdisk_stream_poll_clear(&s->poll);
-
- if (tapdisk_stream_stop(s)) {
- tapdisk_stream_close_image(s);
- return;
- }
-
- psize = getpagesize();
-
- while (s->cur < s->end && !s->err) {
- blkif_request_t *breq;
- td_vbd_request_t *vreq;
- struct tapdisk_stream_request *sreq;
-
- sreq = tapdisk_stream_get_request(s);
- if (!sreq)
- break;
-
- idx = tapdisk_stream_request_idx(s, sreq);
-
- sreq->sec = s->cur;
- sreq->secs = 0;
- sreq->seqno = s->started++;
-
- breq = &sreq->blkif_req;
- breq->id = idx;
- breq->nr_segments = 0;
- breq->sector_number = sreq->sec;
- breq->operation = BLKIF_OP_READ;
-
- for (i = 0; i < BLKIF_MAX_SEGMENTS_PER_REQUEST; i++) {
- uint32_t secs = MIN(s->end - s->cur, psize >> SECTOR_SHIFT);
- struct blkif_request_segment *seg = breq->seg + i;
-
- if (!secs)
- break;
-
- sreq->secs += secs;
- s->cur += secs;
-
- seg->first_sect = 0;
- seg->last_sect = secs - 1;
- breq->nr_segments++;
- }
-
- vreq = vbd->request_list + idx;
-
- assert(list_empty(&vreq->next));
- assert(vreq->secs_pending == 0);
-
- memcpy(&vreq->req, breq, sizeof(*breq));
- vbd->received++;
- vreq->vbd = vbd;
-
- tapdisk_vbd_move_request(vreq, &vbd->new_requests);
- list_add_tail(&sreq->next, &s->pending_list);
- }
-
- tapdisk_vbd_issue_requests(vbd);
-}
-
-static int
-tapdisk_stream_open_image(struct tapdisk_stream *s, const char *path, int type)
-{
- int err;
-
- s->id = tapdisk_stream_count++;
-
- err = tapdisk_server_initialize();
- if (err)
- goto out;
-
- err = tapdisk_vbd_initialize(s->id);
- if (err)
- goto out;
-
- s->vbd = tapdisk_server_get_vbd(s->id);
- if (!s->vbd) {
- err = ENODEV;
- goto out;
- }
-
- tapdisk_vbd_set_callback(s->vbd, tapdisk_stream_dequeue, s);
-
- err = tapdisk_vbd_open_vdi(s->vbd, path, type,
- TAPDISK_STORAGE_TYPE_DEFAULT,
- TD_OPEN_RDONLY);
- if (err)
- goto out;
-
- s->vbd->reopened = 1;
- err = 0;
-
-out:
- if (err)
- fprintf(stderr, "failed to open %s: %d\n", path, err);
- return err;
-}
-
-static void
-tapdisk_stream_close_image(struct tapdisk_stream *s)
-{
- td_vbd_t *vbd;
-
- vbd = tapdisk_server_get_vbd(s->id);
- if (vbd) {
- tapdisk_vbd_close_vdi(vbd);
- tapdisk_server_remove_vbd(vbd);
- free((void *)vbd->ring.vstart);
- free(vbd->name);
- free(vbd);
- s->vbd = NULL;
- }
-}
-
-static int
-tapdisk_stream_set_position(struct tapdisk_stream *s,
- uint64_t count, uint64_t skip)
-{
- int err;
- image_t image;
-
- err = tapdisk_vbd_get_image_info(s->vbd, &image);
- if (err) {
- fprintf(stderr, "failed getting image size: %d\n", err);
- return err;
- }
-
- if (count == (uint64_t)-1)
- count = image.size - skip;
-
- if (count + skip > image.size) {
- fprintf(stderr, "0x%"PRIx64" past end of image 0x%"PRIx64"\n",
- (uint64_t) (count + skip), (uint64_t) image.size);
- return -EINVAL;
- }
-
- s->start = skip;
- s->cur = s->start;
- s->end = s->start + count;
-
- return 0;
-}
-
-static int
-tapdisk_stream_initialize_requests(struct tapdisk_stream *s)
-{
- size_t size;
- td_ring_t *ring;
- int err, i, psize;
-
- ring = &s->vbd->ring;
- psize = getpagesize();
- size = psize * BLKTAP_MMAP_REGION_SIZE;
-
- /* sneaky -- set up ring->vstart so tapdisk_vbd will use our buffers */
- err = posix_memalign((void **)&ring->vstart, psize, size);
- if (err) {
- fprintf(stderr, "failed to allocate buffers: %d\n", err);
- ring->vstart = 0;
- return err;
- }
-
- for (i = 0; i < MAX_REQUESTS; i++) {
- struct tapdisk_stream_request *req = s->requests + i;
- tapdisk_stream_initialize_request(req);
- list_add_tail(&req->next, &s->free_list);
- }
-
- return 0;
-}
-
-static int
-tapdisk_stream_register_enqueue_event(struct tapdisk_stream *s)
-{
- int err;
- struct tapdisk_stream_poll *p = &s->poll;
-
- err = tapdisk_stream_poll_open(p);
- if (err)
- goto out;
-
- err = tapdisk_server_register_event(SCHEDULER_POLL_READ_FD,
- p->pipe[POLL_READ], 0,
- tapdisk_stream_enqueue, s);
- if (err < 0)
- goto out;
-
- s->enqueue_event_id = err;
- err = 0;
-
-out:
- if (err)
- fprintf(stderr, "failed to register event: %d\n", err);
- return err;
-}
-
-static void
-tapdisk_stream_unregister_enqueue_event(struct tapdisk_stream *s)
-{
- if (s->enqueue_event_id) {
- tapdisk_server_unregister_event(s->enqueue_event_id);
- s->enqueue_event_id = 0;
- }
- tapdisk_stream_poll_close(&s->poll);
-}
-
-static inline void
-tapdisk_stream_initialize(struct tapdisk_stream *s)
-{
- memset(s, 0, sizeof(*s));
- s->in_fd = s->out_fd = -1;
- INIT_LIST_HEAD(&s->free_list);
- INIT_LIST_HEAD(&s->pending_list);
- INIT_LIST_HEAD(&s->completed_list);
-}
-
-static int
-tapdisk_stream_open_fds(struct tapdisk_stream *s)
-{
- s->out_fd = dup(STDOUT_FILENO);
- if (s->out_fd == -1) {
- fprintf(stderr, "failed to open output: %d\n", errno);
- return errno;
- }
-
- return 0;
-}
-
-static int
-tapdisk_stream_open(struct tapdisk_stream *s, const char *path,
- int type, uint64_t count, uint64_t skip)
-{
- int err;
-
- tapdisk_stream_initialize(s);
-
- err = tapdisk_stream_open_fds(s);
- if (err)
- return err;
-
- err = tapdisk_stream_open_image(s, path, type);
- if (err)
- return err;
-
- err = tapdisk_stream_set_position(s, count, skip);
- if (err)
- return err;
-
- err = tapdisk_stream_initialize_requests(s);
- if (err)
- return err;
-
- err = tapdisk_stream_register_enqueue_event(s);
- if (err)
- return err;
-
- return 0;
-}
-
-static void
-tapdisk_stream_release(struct tapdisk_stream *s)
-{
- close(s->out_fd);
- tapdisk_stream_close_image(s);
- tapdisk_stream_unregister_enqueue_event(s);
-}
-
-static int
-tapdisk_stream_run(struct tapdisk_stream *s)
-{
- tapdisk_stream_enqueue(s->enqueue_event_id, SCHEDULER_POLL_READ_FD, s);
- tapdisk_server_run();
- return s->err;
-}
-
-int
-main(int argc, char *argv[])
-{
- int c, err, type;
- const char *params;
- const disk_info_t *info;
- const char *path;
- uint64_t count, skip;
- struct tapdisk_stream stream;
-
- err = 0;
- skip = 0;
- count = (uint64_t)-1;
- params = NULL;
-
- while ((c = getopt(argc, argv, "n:c:s:h")) != -1) {
- switch (c) {
- case 'n':
- params = optarg;
- break;
- case 'c':
- count = strtoull(optarg, NULL, 10);
- break;
- case 's':
- skip = strtoull(optarg, NULL, 10);
- break;
- default:
- err = EINVAL;
- case 'h':
- usage(argv[0], err);
- }
- }
-
- if (!params)
- usage(argv[0], EINVAL);
-
- type = tapdisk_disktype_parse_params(params, &path);
- if (type < 0) {
- err = type;
- fprintf(stderr, "invalid argument %s: %d\n", params, err);
- return err;
- }
-
- tapdisk_start_logging("tapdisk-stream");
-
- err = tapdisk_stream_open(&stream, path, type, count, skip);
- if (err)
- goto out;
-
- err = tapdisk_stream_run(&stream);
- if (err)
- goto out;
-
- err = 0;
-
-out:
- tapdisk_stream_release(&stream);
- tapdisk_stop_logging();
- return err;
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include <errno.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-#include <sys/stat.h>
-#include <sys/mman.h>
-#include <sys/ioctl.h>
-#include <sys/resource.h>
-#include <sys/utsname.h>
-#ifdef __linux__
-#include <linux/version.h>
-#endif
-
-#include "blk.h"
-#include "tapdisk.h"
-#include "blktaplib.h"
-#include "tapdisk-log.h"
-#include "tapdisk-utils.h"
-
-void
-tapdisk_start_logging(const char *name)
-{
- static char buf[128];
-
- snprintf(buf, sizeof(buf), "%s[%d]", name, getpid());
- openlog(buf, LOG_CONS | LOG_ODELAY, LOG_DAEMON);
- open_tlog("/tmp/tapdisk.log", (64 << 10), TLOG_WARN, 0);
-}
-
-void
-tapdisk_stop_logging(void)
-{
- closelog();
- close_tlog();
-}
-
-int
-tapdisk_set_resource_limits(void)
-{
- int err;
- struct rlimit rlim;
-
- rlim.rlim_cur = RLIM_INFINITY;
- rlim.rlim_max = RLIM_INFINITY;
-
- err = setrlimit(RLIMIT_MEMLOCK, &rlim);
- if (err == -1) {
- EPRINTF("RLIMIT_MEMLOCK failed: %d\n", errno);
- return -errno;
- }
-
- err = mlockall(MCL_CURRENT | MCL_FUTURE);
- if (err == -1) {
- EPRINTF("mlockall failed: %d\n", errno);
- return -errno;
- }
-
-#define CORE_DUMP
-#if defined(CORE_DUMP)
- err = setrlimit(RLIMIT_CORE, &rlim);
- if (err == -1)
- EPRINTF("RLIMIT_CORE failed: %d\n", errno);
-#endif
-
- return 0;
-}
-
-int
-tapdisk_namedup(char **dup, const char *name)
-{
- *dup = NULL;
-
- if (strnlen(name, MAX_NAME_LEN) >= MAX_NAME_LEN)
- return -ENAMETOOLONG;
-
- *dup = strdup(name);
- if (!*dup)
- return -ENOMEM;
-
- return 0;
-}
-
-/*Get Image size, secsize*/
-int
-tapdisk_get_image_size(int fd, uint64_t *_sectors, uint32_t *_sector_size)
-{
- int ret;
- struct stat stat;
- uint64_t sectors;
- uint64_t sector_size;
-
- sectors = 0;
- sector_size = 0;
- *_sectors = 0;
- *_sector_size = 0;
-
- if (fstat(fd, &stat)) {
- DPRINTF("ERROR: fstat failed, Couldn't stat image");
- return -EINVAL;
- }
-
- if (S_ISBLK(stat.st_mode)) {
- /*Accessing block device directly*/
- if (blk_getimagesize(fd, §ors) != 0)
- return -EINVAL;
-
- /*Get the sector size*/
- if (blk_getsectorsize(fd, §or_size) != 0)
- sector_size = DEFAULT_SECTOR_SIZE;
- } else {
- /*Local file? try fstat instead*/
- sectors = (stat.st_size >> SECTOR_SHIFT);
- sector_size = DEFAULT_SECTOR_SIZE;
- }
-
- if (sectors == 0) {
- sectors = 16836057ULL;
- sector_size = DEFAULT_SECTOR_SIZE;
- }
-
- return 0;
-}
-
-#ifdef __linux__
-
-int tapdisk_linux_version(void)
-{
- struct utsname uts;
- unsigned int version, patchlevel, sublevel;
- int n, err;
-
- err = uname(&uts);
- if (err)
- return -errno;
-
- n = sscanf(uts.release, "%u.%u.%u", &version, &patchlevel, &sublevel);
- if (n != 3)
- return -ENOSYS;
-
- return KERNEL_VERSION(version, patchlevel, sublevel);
-}
-
-#else
-
-int tapdisk_linux_version(void)
-{
- return -ENOSYS;
-}
-
-#endif
-int read_exact(int fd, void *data, size_t size)
-{
- size_t offset = 0;
- ssize_t len;
-
- while ( offset < size )
- {
- len = read(fd, (char *)data + offset, size - offset);
- if ( (len == -1) && (errno == EINTR) )
- continue;
- if ( len == 0 )
- errno = 0;
- if ( len <= 0 )
- return -1;
- offset += len;
- }
-
- return 0;
-}
-
-int write_exact(int fd, const void *data, size_t size)
-{
- size_t offset = 0;
- ssize_t len;
-
- while ( offset < size )
- {
- len = write(fd, (const char *)data + offset, size - offset);
- if ( (len == -1) && (errno == EINTR) )
- continue;
- if ( len <= 0 )
- return -1;
- offset += len;
- }
-
- return 0;
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#ifndef _TAPDISK_UTILS_H_
-#define _TAPDISK_UTILS_H_
-
-#include <inttypes.h>
-
-#define MAX_NAME_LEN 1000
-
-void tapdisk_start_logging(const char *);
-void tapdisk_stop_logging(void);
-int tapdisk_set_resource_limits(void);
-int tapdisk_namedup(char **, const char *);
-int tapdisk_get_image_size(int, uint64_t *, uint32_t *);
-int tapdisk_linux_version(void);
-
-int read_exact(int fd, void *data, size_t size); /* EOF => -1, errno=0 */
-int write_exact(int fd, const void *data, size_t size);
-
-#endif
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#include <stdio.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <regex.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <libgen.h>
-#include <sys/mman.h>
-#include <sys/ioctl.h>
-#ifdef MEMSHR
-#include <memshr.h>
-#endif
-
-#include "tapdisk-image.h"
-#include "tapdisk-driver.h"
-#include "tapdisk-server.h"
-#include "tapdisk-interface.h"
-#include "tapdisk-disktype.h"
-#include "tapdisk-vbd.h"
-#include "blktap2.h"
-
-#define DBG(_level, _f, _a...) tlog_write(_level, _f, ##_a)
-#define ERR(_err, _f, _a...) tlog_error(_err, _f, ##_a)
-
-#if 1
-#define ASSERT(p) \
- do { \
- if (!(p)) { \
- DPRINTF("Assertion '%s' failed, line %d, " \
- "file %s", #p, __LINE__, __FILE__); \
- abort(); \
- } \
- } while (0)
-#else
-#define ASSERT(p) ((void)0)
-#endif
-
-
-#define TD_VBD_EIO_RETRIES 10
-#define TD_VBD_EIO_SLEEP 1
-#define TD_VBD_WATCHDOG_TIMEOUT 10
-
-static void tapdisk_vbd_ring_event(event_id_t, char, void *);
-static void tapdisk_vbd_callback(void *, blkif_response_t *);
-
-/*
- * initialization
- */
-
-static inline void
-tapdisk_vbd_initialize_vreq(td_vbd_request_t *vreq)
-{
- memset(vreq, 0, sizeof(td_vbd_request_t));
- INIT_LIST_HEAD(&vreq->next);
-}
-
-void
-tapdisk_vbd_free(td_vbd_t *vbd)
-{
- if (vbd) {
- tapdisk_vbd_free_stack(vbd);
- list_del_init(&vbd->next);
- free(vbd->name);
- free(vbd);
- }
-}
-
-td_vbd_t*
-tapdisk_vbd_create(uint16_t uuid)
-{
- td_vbd_t *vbd;
- int i;
-
- vbd = calloc(1, sizeof(td_vbd_t));
- if (!vbd) {
- EPRINTF("failed to allocate tapdisk state\n");
- return NULL;
- }
-
- vbd->uuid = uuid;
- vbd->minor = -1;
- vbd->ring.fd = -1;
-
- /* default blktap ring completion */
- vbd->callback = tapdisk_vbd_callback;
- vbd->argument = vbd;
-
-#ifdef MEMSHR
- memshr_vbd_initialize();
-#endif
-
- INIT_LIST_HEAD(&vbd->driver_stack);
- INIT_LIST_HEAD(&vbd->images);
- INIT_LIST_HEAD(&vbd->new_requests);
- INIT_LIST_HEAD(&vbd->pending_requests);
- INIT_LIST_HEAD(&vbd->failed_requests);
- INIT_LIST_HEAD(&vbd->completed_requests);
- INIT_LIST_HEAD(&vbd->next);
- gettimeofday(&vbd->ts, NULL);
-
- for (i = 0; i < MAX_REQUESTS; i++)
- tapdisk_vbd_initialize_vreq(vbd->request_list + i);
-
- return vbd;
-}
-
-int
-tapdisk_vbd_initialize(uint16_t uuid)
-{
- td_vbd_t *vbd;
-
- vbd = tapdisk_server_get_vbd(uuid);
- if (vbd) {
- EPRINTF("duplicate vbds! %u\n", uuid);
- return -EEXIST;
- }
-
- vbd = tapdisk_vbd_create(uuid);
-
- tapdisk_server_add_vbd(vbd);
-
- return 0;
-}
-
-void
-tapdisk_vbd_set_callback(td_vbd_t *vbd, td_vbd_cb_t callback, void *argument)
-{
- vbd->callback = callback;
- vbd->argument = argument;
-}
-
-static int
-tapdisk_vbd_validate_chain(td_vbd_t *vbd)
-{
- int err;
- td_image_t *image, *parent, *tmp;
-
- DPRINTF("VBD CHAIN:\n");
-
- tapdisk_vbd_for_each_image(vbd, image, tmp) {
- DPRINTF("%s: %d\n", image->name, image->type);
-
- if (tapdisk_vbd_is_last_image(vbd, image))
- break;
-
- parent = tapdisk_vbd_next_image(image);
- err = td_validate_parent(image, parent);
- if (err)
- return err;
- }
-
- return 0;
-}
-
-void
-tapdisk_vbd_close_vdi(td_vbd_t *vbd)
-{
- td_image_t *image, *tmp;
-
- tapdisk_vbd_for_each_image(vbd, image, tmp) {
- td_close(image);
- tapdisk_image_free(image);
- }
-
- INIT_LIST_HEAD(&vbd->images);
- td_flag_set(vbd->state, TD_VBD_CLOSED);
-
- tapdisk_vbd_free_stack(vbd);
-}
-
-static int
-tapdisk_vbd_add_block_cache(td_vbd_t *vbd)
-{
- int err;
- td_driver_t *driver;
- td_image_t *cache, *image, *target, *tmp;
-
- target = NULL;
-
- tapdisk_vbd_for_each_image(vbd, image, tmp)
- if (td_flag_test(image->flags, TD_OPEN_RDONLY) &&
- td_flag_test(image->flags, TD_OPEN_SHAREABLE)) {
- target = image;
- break;
- }
-
- if (!target)
- return 0;
-
- cache = tapdisk_image_allocate(target->name,
- DISK_TYPE_BLOCK_CACHE,
- target->storage,
- target->flags,
- target->private);
- if (!cache)
- return -ENOMEM;
-
- /* try to load existing cache */
- err = td_load(cache);
- if (!err)
- goto done;
-
- /* hack driver to send open() correct image size */
- if (!target->driver) {
- err = -ENODEV;
- goto fail;
- }
-
- cache->driver = tapdisk_driver_allocate(cache->type,
- cache->name,
- cache->flags,
- cache->storage);
- if (!cache->driver) {
- err = -ENOMEM;
- goto fail;
- }
-
- cache->driver->info = target->driver->info;
-
- /* try to open new cache */
- err = td_open(cache);
- if (!err)
- goto done;
-
-fail:
- /* give up */
- tapdisk_image_free(target);
- return err;
-
-done:
- /* insert cache before image */
- list_add(&cache->next, target->next.prev);
- return 0;
-}
-
-static int
-tapdisk_vbd_add_dirty_log(td_vbd_t *vbd)
-{
- int err;
- td_driver_t *driver;
- td_image_t *log, *parent;
-
- driver = NULL;
- log = NULL;
-
- parent = tapdisk_vbd_first_image(vbd);
-
- log = tapdisk_image_allocate(parent->name,
- DISK_TYPE_LOG,
- parent->storage,
- parent->flags,
- vbd);
- if (!log)
- return -ENOMEM;
-
- driver = tapdisk_driver_allocate(log->type,
- log->name,
- log->flags,
- log->storage);
- if (!driver) {
- err = -ENOMEM;
- goto fail;
- }
-
- driver->info = parent->driver->info;
- log->driver = driver;
-
- err = td_open(log);
- if (err)
- goto fail;
-
- list_add(&log->next, &vbd->images);
- return 0;
-
-fail:
- tapdisk_image_free(log);
- return err;
-}
-
-static int
-tapdisk_vbd_open_level(td_vbd_t *vbd, struct list_head *head,
- const char *params, int driver_type,
- td_disk_info_t *driver_info, td_flag_t flags)
-{
- const char *name;
- int type, err;
- td_image_t *image;
- td_disk_id_t id;
- td_driver_t *driver;
-
- name = params;
- id.name = NULL;
- type = driver_type;
- INIT_LIST_HEAD(head);
-
- for (;;) {
- err = -ENOMEM;
- image = tapdisk_image_allocate(name, type,
- vbd->storage, flags, vbd);
-
- free(id.name);
-
- if (!image)
- goto out;
-
-
- /* this breaks if a driver modifies its info within a layer */
- err = __td_open(image, driver_info);
- if (err)
- goto out;
-
- /* TODO: non-sink drivers that don't care about their child
- * currently return EINVAL. Could return TD_PARENT_OK or
- * TD_ANY_PARENT */
-
- err = td_get_parent_id(image, &id);
- if (err && (err != TD_NO_PARENT && err != -EINVAL)) {
- td_close(image);
- goto out;
- }
-
- /* add this image to the end of the list */
- list_add_tail(&image->next, head);
- image = NULL;
-
- /* if the image does not have a parent we return the
- * list of images generated by this level of the stack */
- if (err == TD_NO_PARENT || err == -EINVAL) {
- err = 0;
- goto out;
- }
-
- name = id.name;
- type = id.drivertype;
-
- flags |= (TD_OPEN_RDONLY | TD_OPEN_SHAREABLE);
- }
-
-out:
- if (err) {
- if (image) {
- td_close(image);
- tapdisk_image_free(image);
- }
- while (!list_empty(head)) {
- image = list_entry(&head->next, td_image_t, next);
- td_close(image);
- tapdisk_image_free(image);
- }
- }
-
- return err;
-}
-
-static int
-__tapdisk_vbd_open_vdi(td_vbd_t *vbd, td_flag_t extra_flags)
-{
- int err;
- td_flag_t flags;
- td_image_t *tmp;
- td_vbd_driver_info_t *driver_info;
- struct list_head *images;
- td_disk_info_t *parent_info = NULL;
-
- if (list_empty(&vbd->driver_stack))
- return -ENOENT;
-
- flags = (vbd->flags & ~TD_OPEN_SHAREABLE) | extra_flags;
-
- /* loop on each user specified driver.
- * NOTE: driver_info is in reverse order. That is, the first
- * item is the 'parent' or 'sink' driver */
- list_for_each_entry(driver_info, &vbd->driver_stack, next) {
- LIST_HEAD(images);
-
- err = tapdisk_vbd_open_level(vbd, &images,
- driver_info->params,
- driver_info->type,
- parent_info, flags);
- if (err)
- goto fail;
-
- /* after each loop,
- * append the created stack to the result stack */
- list_splice(&images, &vbd->images);
-
- /* set the parent_info to the first diskinfo on the stack */
- tmp = tapdisk_vbd_first_image(vbd);
- parent_info = &tmp->info;
- }
-
- if (td_flag_test(vbd->flags, TD_OPEN_LOG_DIRTY)) {
- err = tapdisk_vbd_add_dirty_log(vbd);
- if (err)
- goto fail;
- }
-
- if (td_flag_test(vbd->flags, TD_OPEN_ADD_CACHE)) {
- err = tapdisk_vbd_add_block_cache(vbd);
- if (err)
- goto fail;
- }
-
- err = tapdisk_vbd_validate_chain(vbd);
- if (err)
- goto fail;
-
- td_flag_clear(vbd->state, TD_VBD_CLOSED);
-
- return 0;
-
-fail:
- tapdisk_vbd_close_vdi(vbd);
- return err;
-}
-
-/* this populates a vbd type based on path */
-int
-tapdisk_vbd_parse_stack(td_vbd_t *vbd, const char *path)
-{
- int err;
- char *params, *driver_str;
- td_vbd_driver_info_t *driver;
-
- err = tapdisk_namedup(¶ms, path);
- if (err)
- return err;
-
- /* tokenize params based on pipe '|' */
- driver_str = strtok(params, "|");
- while (driver_str != NULL) {
- const char *path;
- int type;
-
- /* parse driver info and add to vbd */
- driver = calloc(1, sizeof(td_vbd_driver_info_t));
- if (!driver) {
- PERROR("malloc");
- err = -errno;
- goto out;
- }
- INIT_LIST_HEAD(&driver->next);
-
- err = tapdisk_parse_disk_type(driver_str, &path, &type);
- if (err) {
- free(driver);
- goto out;
- }
-
- driver->type = type;
- driver->params = strdup(path);
- if (!driver->params) {
- err = -ENOMEM;
- free(driver);
- goto out;
- }
-
- /* build the list backwards as the last driver will be the
- * first driver to open in the stack */
- list_add(&driver->next, &vbd->driver_stack);
-
- /* get next driver string */
- driver_str = strtok(NULL, "|");
- }
-
-out:
- free(params);
- if (err)
- tapdisk_vbd_free_stack(vbd);
-
- return err;
-}
-
-void
-tapdisk_vbd_free_stack(td_vbd_t *vbd)
-{
- td_vbd_driver_info_t *driver;
-
- while (!list_empty(&vbd->driver_stack)) {
- driver = list_entry(vbd->driver_stack.next,
- td_vbd_driver_info_t, next);
- list_del(&driver->next);
- free(driver->params);
- free(driver);
- }
-}
-
-/* NOTE: driver type, etc. must be set */
-int
-tapdisk_vbd_open_stack(td_vbd_t *vbd, uint16_t storage, td_flag_t flags)
-{
- int i, err = 0;
-
- vbd->flags = flags;
- vbd->storage = storage;
-
- for (i = 0; i < TD_VBD_EIO_RETRIES; i++) {
- err = __tapdisk_vbd_open_vdi(vbd, 0);
- if (err != -EIO)
- break;
-
- sleep(TD_VBD_EIO_SLEEP);
- }
- if (err)
- goto fail;
-
- return 0;
-
- fail:
- return err;
-}
-
-int
-tapdisk_vbd_open_vdi(td_vbd_t *vbd, const char *path,
- uint16_t drivertype, uint16_t storage, td_flag_t flags)
-{
- int i, err;
- const struct tap_disk *ops;
-
- ops = tapdisk_disk_drivers[drivertype];
- if (!ops)
- return -EINVAL;
- DPRINTF("Loaded %s driver for vbd %u %s 0x%08x\n",
- ops->disk_type, vbd->uuid, path, flags);
-
- err = tapdisk_namedup(&vbd->name, path);
- if (err)
- return err;
-
- vbd->flags = flags;
- vbd->storage = storage;
-
- for (i = 0; i < TD_VBD_EIO_RETRIES; i++) {
- err = __tapdisk_vbd_open_vdi(vbd, 0);
- if (err != -EIO)
- break;
-
- sleep(TD_VBD_EIO_SLEEP);
- }
- if (err)
- goto fail;
-
- return 0;
-
-fail:
- free(vbd->name);
- vbd->name = NULL;
- return err;
-}
-
-static int
-tapdisk_vbd_register_event_watches(td_vbd_t *vbd)
-{
- event_id_t id;
-
- id = tapdisk_server_register_event(SCHEDULER_POLL_READ_FD,
- vbd->ring.fd, 0,
- tapdisk_vbd_ring_event, vbd);
- if (id < 0)
- return id;
-
- vbd->ring_event_id = id;
-
- return 0;
-}
-
-static void
-tapdisk_vbd_unregister_events(td_vbd_t *vbd)
-{
- if (vbd->ring_event_id)
- tapdisk_server_unregister_event(vbd->ring_event_id);
-}
-
-static int
-tapdisk_vbd_map_device(td_vbd_t *vbd, const char *devname)
-{
-
- int err, psize;
- td_ring_t *ring;
-
- ring = &vbd->ring;
- psize = getpagesize();
-
- ring->fd = open(devname, O_RDWR);
- if (ring->fd == -1) {
- err = -errno;
- EPRINTF("failed to open %s: %d\n", devname, err);
- goto fail;
- }
-
- ring->mem = mmap(0, psize * BLKTAP_MMAP_REGION_SIZE,
- PROT_READ | PROT_WRITE, MAP_SHARED, ring->fd, 0);
- if (ring->mem == MAP_FAILED) {
- err = -errno;
- EPRINTF("failed to mmap %s: %d\n", devname, err);
- goto fail;
- }
-
- ring->sring = (blkif_sring_t *)((unsigned long)ring->mem);
- BACK_RING_INIT(&ring->fe_ring, ring->sring, psize);
-
- ring->vstart =
- (unsigned long)ring->mem + (BLKTAP_RING_PAGES * psize);
-
- ioctl(ring->fd, BLKTAP_IOCTL_SETMODE, BLKTAP_MODE_INTERPOSE);
-
- return 0;
-
-fail:
- if (ring->mem && ring->mem != MAP_FAILED)
- munmap(ring->mem, psize * BLKTAP_MMAP_REGION_SIZE);
- if (ring->fd != -1)
- close(ring->fd);
- ring->fd = -1;
- ring->mem = NULL;
- return err;
-}
-
-static int
-tapdisk_vbd_unmap_device(td_vbd_t *vbd)
-{
- int psize;
-
- psize = getpagesize();
-
- if (vbd->ring.fd != -1)
- close(vbd->ring.fd);
- if (vbd->ring.mem > 0)
- munmap(vbd->ring.mem, psize * BLKTAP_MMAP_REGION_SIZE);
-
- return 0;
-}
-
-void
-tapdisk_vbd_detach(td_vbd_t *vbd)
-{
- tapdisk_vbd_unregister_events(vbd);
-
- tapdisk_vbd_unmap_device(vbd);
- vbd->minor = -1;
-}
-
-
-int
-tapdisk_vbd_attach(td_vbd_t *vbd, const char *devname, int minor)
-{
- int err;
-
- err = tapdisk_vbd_map_device(vbd, devname);
- if (err)
- goto fail;
-
- err = tapdisk_vbd_register_event_watches(vbd);
- if (err)
- goto fail;
-
- vbd->minor = minor;
-
- return 0;
-
-fail:
- tapdisk_vbd_detach(vbd);
-
- return err;
-}
-
-int
-tapdisk_vbd_open(td_vbd_t *vbd, const char *name, uint16_t type,
- uint16_t storage, int minor, const char *ring, td_flag_t flags)
-{
- int err;
-
- err = tapdisk_vbd_open_stack(vbd, storage, flags);
- if (err)
- goto out;
-
- err = tapdisk_vbd_attach(vbd, ring, minor);
- if (err)
- goto out;
-
- return 0;
-
-out:
- tapdisk_vbd_detach(vbd);
- tapdisk_vbd_close_vdi(vbd);
- free(vbd->name);
- vbd->name = NULL;
- return err;
-}
-
-static void
-tapdisk_vbd_queue_count(td_vbd_t *vbd, int *new,
- int *pending, int *failed, int *completed)
-{
- int n, p, f, c;
- td_vbd_request_t *vreq, *tvreq;
-
- n = 0;
- p = 0;
- f = 0;
- c = 0;
-
- tapdisk_vbd_for_each_request(vreq, tvreq, &vbd->new_requests)
- n++;
-
- tapdisk_vbd_for_each_request(vreq, tvreq, &vbd->pending_requests)
- p++;
-
- tapdisk_vbd_for_each_request(vreq, tvreq, &vbd->failed_requests)
- f++;
-
- tapdisk_vbd_for_each_request(vreq, tvreq, &vbd->completed_requests)
- c++;
-
- *new = n;
- *pending = p;
- *failed = f;
- *completed = c;
-}
-
-static int
-tapdisk_vbd_shutdown(td_vbd_t *vbd)
-{
- int new, pending, failed, completed;
-
- if (!list_empty(&vbd->pending_requests))
- return -EAGAIN;
-
- tapdisk_vbd_kick(vbd);
- tapdisk_vbd_queue_count(vbd, &new, &pending, &failed, &completed);
-
- DPRINTF("%s: state: 0x%08x, new: 0x%02x, pending: 0x%02x, "
- "failed: 0x%02x, completed: 0x%02x\n",
- vbd->name, vbd->state, new, pending, failed, completed);
- DPRINTF("last activity: %010ld.%06lld, errors: 0x%04"PRIx64", "
- "retries: 0x%04"PRIx64", received: 0x%08"PRIx64", "
- "returned: 0x%08"PRIx64", kicked: 0x%08"PRIx64"\n",
- vbd->ts.tv_sec, (unsigned long long)vbd->ts.tv_usec,
- vbd->errors, vbd->retries, vbd->received, vbd->returned,
- vbd->kicked);
-
- tapdisk_vbd_close_vdi(vbd);
- tapdisk_vbd_detach(vbd);
- tapdisk_server_remove_vbd(vbd);
- tapdisk_vbd_free(vbd);
-
- tlog_print_errors();
-
- return 0;
-}
-
-int
-tapdisk_vbd_close(td_vbd_t *vbd)
-{
- /*
- * don't close if any requests are pending in the aio layer
- */
- if (!list_empty(&vbd->pending_requests))
- goto fail;
-
- /*
- * if the queue is still active and we have more
- * requests, try to complete them before closing.
- */
- if (tapdisk_vbd_queue_ready(vbd) &&
- (!list_empty(&vbd->new_requests) ||
- !list_empty(&vbd->failed_requests) ||
- !list_empty(&vbd->completed_requests)))
- goto fail;
-
- return tapdisk_vbd_shutdown(vbd);
-
-fail:
- td_flag_set(vbd->state, TD_VBD_SHUTDOWN_REQUESTED);
- DBG(TLOG_WARN, "%s: requests pending\n", vbd->name);
- return -EAGAIN;
-}
-
-/*
- * control operations
- */
-
-void
-tapdisk_vbd_debug(td_vbd_t *vbd)
-{
- td_image_t *image, *tmp;
- int new, pending, failed, completed;
-
- tapdisk_vbd_queue_count(vbd, &new, &pending, &failed, &completed);
-
- DBG(TLOG_WARN, "%s: state: 0x%08x, new: 0x%02x, pending: 0x%02x, "
- "failed: 0x%02x, completed: 0x%02x, last activity: %010ld.%06lld, "
- "errors: 0x%04"PRIx64", retries: 0x%04"PRIx64", received: 0x%08"PRIx64", "
- "returned: 0x%08"PRIx64", kicked: 0x%08"PRIx64"\n",
- vbd->name, vbd->state, new, pending, failed, completed,
- vbd->ts.tv_sec, (unsigned long long)vbd->ts.tv_usec,
- vbd->errors, vbd->retries,
- vbd->received, vbd->returned, vbd->kicked);
-
- tapdisk_vbd_for_each_image(vbd, image, tmp)
- td_debug(image);
-}
-
-static void
-tapdisk_vbd_drop_log(td_vbd_t *vbd)
-{
- if (td_flag_test(vbd->state, TD_VBD_LOG_DROPPED))
- return;
-
- tapdisk_vbd_debug(vbd);
- tlog_flush();
- td_flag_set(vbd->state, TD_VBD_LOG_DROPPED);
-}
-
-int
-tapdisk_vbd_get_image_info(td_vbd_t *vbd, image_t *img)
-{
- td_image_t *image;
-
- memset(img, 0, sizeof(image_t));
-
- if (list_empty(&vbd->images))
- return -EINVAL;
-
- image = tapdisk_vbd_first_image(vbd);
- img->size = image->info.size;
- img->secsize = image->info.sector_size;
- img->info = image->info.info;
-
- return 0;
-}
-
-int
-tapdisk_vbd_queue_ready(td_vbd_t *vbd)
-{
- return (!td_flag_test(vbd->state, TD_VBD_DEAD) &&
- !td_flag_test(vbd->state, TD_VBD_CLOSED) &&
- !td_flag_test(vbd->state, TD_VBD_QUIESCED) &&
- !td_flag_test(vbd->state, TD_VBD_QUIESCE_REQUESTED));
-}
-
-int
-tapdisk_vbd_retry_needed(td_vbd_t *vbd)
-{
- return td_flag_test(vbd->state, TD_VBD_RETRY_NEEDED);
-}
-
-int
-tapdisk_vbd_lock(td_vbd_t *vbd)
-{
- return 0;
-}
-
-int
-tapdisk_vbd_quiesce_queue(td_vbd_t *vbd)
-{
- if (!list_empty(&vbd->pending_requests)) {
- td_flag_set(vbd->state, TD_VBD_QUIESCE_REQUESTED);
- return -EAGAIN;
- }
-
- td_flag_clear(vbd->state, TD_VBD_QUIESCE_REQUESTED);
- td_flag_set(vbd->state, TD_VBD_QUIESCED);
- return 0;
-}
-
-int
-tapdisk_vbd_start_queue(td_vbd_t *vbd)
-{
- td_flag_clear(vbd->state, TD_VBD_QUIESCED);
- td_flag_clear(vbd->state, TD_VBD_QUIESCE_REQUESTED);
- return 0;
-}
-
-int
-tapdisk_vbd_kill_queue(td_vbd_t *vbd)
-{
- tapdisk_vbd_quiesce_queue(vbd);
- td_flag_set(vbd->state, TD_VBD_DEAD);
- return 0;
-}
-
-static int
-tapdisk_vbd_open_image(td_vbd_t *vbd, td_image_t *image)
-{
- int err;
- td_image_t *parent;
-
- err = td_open(image);
- if (err)
- return err;
-
- if (!tapdisk_vbd_is_last_image(vbd, image)) {
- parent = tapdisk_vbd_next_image(image);
- err = td_validate_parent(image, parent);
- if (err) {
- td_close(image);
- return err;
- }
- }
-
- return 0;
-}
-
-static int
-tapdisk_vbd_close_and_reopen_image(td_vbd_t *vbd, td_image_t *image)
-{
- int i, err = 0;
-
- td_close(image);
-
- for (i = 0; i < TD_VBD_EIO_RETRIES; i++) {
- err = tapdisk_vbd_open_image(vbd, image);
- if (err != -EIO)
- break;
-
- sleep(TD_VBD_EIO_SLEEP);
- }
-
- if (err)
- td_flag_set(vbd->state, TD_VBD_CLOSED);
-
- return err;
-}
-
-int
-tapdisk_vbd_pause(td_vbd_t *vbd)
-{
- int err;
-
- td_flag_set(vbd->state, TD_VBD_PAUSE_REQUESTED);
-
- err = tapdisk_vbd_quiesce_queue(vbd);
- if (err)
- return err;
-
- tapdisk_vbd_close_vdi(vbd);
-
- td_flag_clear(vbd->state, TD_VBD_PAUSE_REQUESTED);
- td_flag_set(vbd->state, TD_VBD_PAUSED);
-
- return 0;
-}
-
-int
-tapdisk_vbd_resume(td_vbd_t *vbd, const char *path, uint16_t drivertype)
-{
- int i, err = 0;
-
- if (!td_flag_test(vbd->state, TD_VBD_PAUSED)) {
- EPRINTF("resume request for unpaused vbd %s\n", vbd->name);
- return -EINVAL;
- }
-
- if (path) {
- free(vbd->name);
- vbd->name = strdup(path);
- if (!vbd->name) {
- EPRINTF("copying new vbd %s name failed\n", path);
- return -EINVAL;
- }
- }
-
- for (i = 0; i < TD_VBD_EIO_RETRIES; i++) {
- err = __tapdisk_vbd_open_vdi(vbd, TD_OPEN_STRICT);
- if (err != -EIO)
- break;
-
- sleep(TD_VBD_EIO_SLEEP);
- }
-
- if (err)
- return err;
-
- tapdisk_vbd_start_queue(vbd);
- td_flag_clear(vbd->state, TD_VBD_PAUSED);
- td_flag_clear(vbd->state, TD_VBD_PAUSE_REQUESTED);
- tapdisk_vbd_check_state(vbd);
-
- return 0;
-}
-
-int
-tapdisk_vbd_kick(td_vbd_t *vbd)
-{
- int n;
- td_ring_t *ring;
-
- tapdisk_vbd_check_state(vbd);
-
- ring = &vbd->ring;
- if (!ring->sring)
- return 0;
-
- n = (ring->fe_ring.rsp_prod_pvt - ring->fe_ring.sring->rsp_prod);
- if (!n)
- return 0;
-
- vbd->kicked += n;
- RING_PUSH_RESPONSES(&ring->fe_ring);
- ioctl(ring->fd, BLKTAP_IOCTL_KICK_FE, 0);
-
- DBG(TLOG_INFO, "kicking %d: rec: 0x%08"PRIx64", ret: 0x%08"PRIx64", kicked: "
- "0x%08"PRIx64"\n", n, vbd->received, vbd->returned, vbd->kicked);
-
- return n;
-}
-
-static inline void
-tapdisk_vbd_write_response_to_ring(td_vbd_t *vbd, blkif_response_t *rsp)
-{
- td_ring_t *ring;
- blkif_response_t *rspp;
-
- ring = &vbd->ring;
- rspp = RING_GET_RESPONSE(&ring->fe_ring, ring->fe_ring.rsp_prod_pvt);
- memcpy(rspp, rsp, sizeof(blkif_response_t));
- ring->fe_ring.rsp_prod_pvt++;
-}
-
-static void
-tapdisk_vbd_callback(void *arg, blkif_response_t *rsp)
-{
- td_vbd_t *vbd = (td_vbd_t *)arg;
- tapdisk_vbd_write_response_to_ring(vbd, rsp);
-}
-
-static void
-tapdisk_vbd_make_response(td_vbd_t *vbd, td_vbd_request_t *vreq)
-{
- blkif_request_t tmp;
- blkif_response_t *rsp;
-
- tmp = vreq->req;
- rsp = (blkif_response_t *)&vreq->req;
-
- rsp->id = tmp.id;
- rsp->operation = tmp.operation;
- rsp->status = vreq->status;
-
- DBG(TLOG_DBG, "writing req %d, sec 0x%08"PRIx64", res %d to ring\n",
- (int)tmp.id, tmp.sector_number, vreq->status);
-
- if (rsp->status != BLKIF_RSP_OKAY)
- ERR(EIO, "returning BLKIF_RSP %d", rsp->status);
-
- vbd->returned++;
- vbd->callback(vbd->argument, rsp);
-}
-
-void
-tapdisk_vbd_check_state(td_vbd_t *vbd)
-{
- td_vbd_request_t *vreq, *tmp;
-
- tapdisk_vbd_for_each_request(vreq, tmp, &vbd->failed_requests)
- if (vreq->num_retries >= TD_VBD_MAX_RETRIES)
- tapdisk_vbd_complete_vbd_request(vbd, vreq);
-
- if (!list_empty(&vbd->new_requests) ||
- !list_empty(&vbd->failed_requests))
- tapdisk_vbd_issue_requests(vbd);
-
- tapdisk_vbd_for_each_request(vreq, tmp, &vbd->completed_requests) {
- tapdisk_vbd_make_response(vbd, vreq);
- list_del(&vreq->next);
- tapdisk_vbd_initialize_vreq(vreq);
- }
-
- if (td_flag_test(vbd->state, TD_VBD_QUIESCE_REQUESTED))
- tapdisk_vbd_quiesce_queue(vbd);
-
- if (td_flag_test(vbd->state, TD_VBD_PAUSE_REQUESTED))
- tapdisk_vbd_pause(vbd);
-
- if (td_flag_test(vbd->state, TD_VBD_SHUTDOWN_REQUESTED))
- tapdisk_vbd_close(vbd);
-}
-
-void
-tapdisk_vbd_check_progress(td_vbd_t *vbd)
-{
- int diff;
- struct timeval now;
-
- if (list_empty(&vbd->pending_requests))
- return;
-
- gettimeofday(&now, NULL);
- diff = now.tv_sec - vbd->ts.tv_sec;
-
- if (diff >= TD_VBD_WATCHDOG_TIMEOUT) {
- DBG(TLOG_WARN, "%s: watchdog timeout: pending requests "
- "idle for %d seconds\n", vbd->name, diff);
- tapdisk_vbd_drop_log(vbd);
- return;
- }
-
- tapdisk_server_set_max_timeout(TD_VBD_WATCHDOG_TIMEOUT - diff);
-}
-
-/*
- * request submission
- */
-
-static int
-tapdisk_vbd_check_queue(td_vbd_t *vbd)
-{
- int err;
- td_image_t *image;
-
- if (list_empty(&vbd->images))
- return -ENOSYS;
-
- if (!tapdisk_vbd_queue_ready(vbd))
- return -EAGAIN;
-
- if (!vbd->reopened) {
- if (td_flag_test(vbd->state, TD_VBD_LOCKING)) {
- err = tapdisk_vbd_lock(vbd);
- if (err)
- return err;
- }
-
- image = tapdisk_vbd_first_image(vbd);
- td_flag_set(image->flags, TD_OPEN_STRICT);
-
- if (tapdisk_vbd_close_and_reopen_image(vbd, image))
- EPRINTF("reopening disks failed\n");
- else {
- DPRINTF("reopening disks succeeded\n");
- vbd->reopened = 1;
- }
- }
-
- return 0;
-}
-
-void
-tapdisk_vbd_complete_vbd_request(td_vbd_t *vbd, td_vbd_request_t *vreq)
-{
- if (!vreq->submitting && !vreq->secs_pending) {
- if (vreq->status == BLKIF_RSP_ERROR &&
- vreq->num_retries < TD_VBD_MAX_RETRIES &&
- !td_flag_test(vbd->state, TD_VBD_DEAD) &&
- !td_flag_test(vbd->state, TD_VBD_SHUTDOWN_REQUESTED))
- tapdisk_vbd_move_request(vreq, &vbd->failed_requests);
- else
- tapdisk_vbd_move_request(vreq, &vbd->completed_requests);
- }
-}
-
-static uint64_t
-tapdisk_vbd_breq_get_sector(blkif_request_t *breq, td_request_t treq)
-{
- int seg, nsects;
- uint64_t sector_nr = breq->sector_number;
-
- for(seg=0; seg < treq.sidx; seg++) {
- nsects = breq->seg[seg].last_sect - breq->seg[seg].first_sect + 1;
- sector_nr += nsects;
- }
-
- return sector_nr;
-}
-
-static void
-__tapdisk_vbd_complete_td_request(td_vbd_t *vbd, td_vbd_request_t *vreq,
- td_request_t treq, int res)
-{
- int err;
- td_image_t *image = treq.image;
-
- err = (res <= 0 ? res : -res);
- vbd->secs_pending -= treq.secs;
- vreq->secs_pending -= treq.secs;
-
- vreq->blocked = treq.blocked;
-
- if (err) {
- vreq->status = BLKIF_RSP_ERROR;
- vreq->error = (vreq->error ? : err);
- if (err != -EBUSY) {
- vbd->errors++;
- ERR(err, "req %"PRIu64": %s 0x%04x secs to "
- "0x%08"PRIx64, vreq->req.id,
- (treq.op == TD_OP_WRITE ? "write" : "read"),
- treq.secs, treq.sec);
- }
- } else {
-#ifdef MEMSHR
- if (treq.op == TD_OP_READ
- && td_flag_test(image->flags, TD_OPEN_RDONLY)) {
- share_tuple_t hnd = treq.memshr_hnd;
- uint16_t uid = image->memshr_id;
- blkif_request_t *breq = &vreq->req;
- uint64_t sec = tapdisk_vbd_breq_get_sector(breq, treq);
- int secs = breq->seg[treq.sidx].last_sect -
- breq->seg[treq.sidx].first_sect + 1;
-
- if (hnd.handle != 0)
- memshr_vbd_complete_ro_request(hnd, uid,
- sec, secs);
- }
-#endif
- }
-
- tapdisk_vbd_complete_vbd_request(vbd, vreq);
-}
-
-static void
-__tapdisk_vbd_reissue_td_request(td_vbd_t *vbd,
- td_image_t *image, td_request_t treq)
-{
- td_image_t *parent;
- td_vbd_request_t *vreq;
-
- vreq = (td_vbd_request_t *)treq.private;
- gettimeofday(&vreq->last_try, NULL);
-
- vreq->submitting++;
-
- if (tapdisk_vbd_is_last_image(vbd, image)) {
- memset(treq.buf, 0, treq.secs << SECTOR_SHIFT);
- td_complete_request(treq, 0);
- goto done;
- }
-
- parent = tapdisk_vbd_next_image(image);
- treq.image = parent;
-
- /* return zeros for requests that extend beyond end of parent image */
- if (treq.sec + treq.secs > parent->info.size) {
- td_request_t clone = treq;
-
- if (parent->info.size > treq.sec) {
- int secs = parent->info.size - treq.sec;
- clone.sec += secs;
- clone.secs -= secs;
- clone.buf += (secs << SECTOR_SHIFT);
- treq.secs = secs;
- } else
- treq.secs = 0;
-
- memset(clone.buf, 0, clone.secs << SECTOR_SHIFT);
- td_complete_request(clone, 0);
-
- if (!treq.secs)
- goto done;
- }
-
- switch (treq.op) {
- case TD_OP_WRITE:
- td_queue_write(parent, treq);
- break;
-
- case TD_OP_READ:
-#ifdef MEMSHR
- if(td_flag_test(parent->flags, TD_OPEN_RDONLY)) {
- int ret, seg = treq.sidx;
- blkif_request_t *breq = &vreq->req;
-
- ret = memshr_vbd_issue_ro_request(treq.buf,
- breq->seg[seg].gref,
- parent->memshr_id,
- treq.sec,
- treq.secs,
- &treq.memshr_hnd);
- if(ret == 0) {
- /* Reset memshr handle. This'll prevent
- * memshr_vbd_complete_ro_request being called
- */
- treq.memshr_hnd.handle = 0;
- td_complete_request(treq, 0);
- } else
- td_queue_read(parent, treq);
- } else
-#endif
- td_queue_read(parent, treq);
- break;
- }
-
-done:
- vreq->submitting--;
- if (!vreq->secs_pending)
- tapdisk_vbd_complete_vbd_request(vbd, vreq);
-}
-
-void
-tapdisk_vbd_forward_request(td_request_t treq)
-{
- td_vbd_t *vbd;
- td_image_t *image;
- td_vbd_request_t *vreq;
-
- image = treq.image;
- vbd = (td_vbd_t *)image->private;
- vreq = (td_vbd_request_t *)treq.private;
-
- gettimeofday(&vbd->ts, NULL);
-
- if (tapdisk_vbd_queue_ready(vbd))
- __tapdisk_vbd_reissue_td_request(vbd, image, treq);
- else
- __tapdisk_vbd_complete_td_request(vbd, vreq, treq, -EIO);
-}
-
-static void
-tapdisk_vbd_complete_td_request(td_request_t treq, int res)
-{
- td_vbd_t *vbd;
- td_image_t *image;
- td_vbd_request_t *vreq;
-
- image = treq.image;
- vbd = (td_vbd_t *)image->private;
- vreq = (td_vbd_request_t *)treq.private;
-
- gettimeofday(&vbd->ts, NULL);
- DBG(TLOG_DBG, "%s: req %d seg %d sec 0x%08"PRIx64" "
- "secs 0x%04x buf %p op %d res %d\n", image->name,
- (int)treq.id, treq.sidx, treq.sec, treq.secs,
- treq.buf, (int)vreq->req.operation, res);
-
- __tapdisk_vbd_complete_td_request(vbd, vreq, treq, res);
-}
-
-static int
-tapdisk_vbd_issue_request(td_vbd_t *vbd, td_vbd_request_t *vreq)
-{
- char *page;
- td_ring_t *ring;
- td_image_t *image;
- td_request_t treq;
- uint64_t sector_nr;
- blkif_request_t *req;
- int i, err, id, nsects;
-
- req = &vreq->req;
- id = req->id;
- ring = &vbd->ring;
- sector_nr = req->sector_number;
- image = tapdisk_vbd_first_image(vbd);
-
- vreq->submitting = 1;
- gettimeofday(&vbd->ts, NULL);
- gettimeofday(&vreq->last_try, NULL);
- tapdisk_vbd_move_request(vreq, &vbd->pending_requests);
-
-#if 0
- err = tapdisk_vbd_check_queue(vbd);
- if (err)
- goto fail;
-#endif
-
- err = tapdisk_image_check_ring_request(image, req);
- if (err)
- goto fail;
-
- for (i = 0; i < req->nr_segments; i++) {
- nsects = req->seg[i].last_sect - req->seg[i].first_sect + 1;
- page = (char *)MMAP_VADDR(ring->vstart,
- (unsigned long)req->id, i);
- page += (req->seg[i].first_sect << SECTOR_SHIFT);
-
- treq.id = id;
- treq.sidx = i;
- treq.blocked = 0;
- treq.buf = page;
- treq.sec = sector_nr;
- treq.secs = nsects;
- treq.image = image;
- treq.cb = tapdisk_vbd_complete_td_request;
- treq.cb_data = NULL;
- treq.private = vreq;
-
- DBG(TLOG_DBG, "%s: req %d seg %d sec 0x%08"PRIx64" secs 0x%04x "
- "buf %p op %d\n", image->name, id, i, treq.sec, treq.secs,
- treq.buf, (int)req->operation);
-
- vreq->secs_pending += nsects;
- vbd->secs_pending += nsects;
-
- switch (req->operation) {
- case BLKIF_OP_WRITE:
- treq.op = TD_OP_WRITE;
- td_queue_write(image, treq);
- break;
-
- case BLKIF_OP_READ:
- treq.op = TD_OP_READ;
- td_queue_read(image, treq);
- break;
- }
-
- sector_nr += nsects;
- }
-
- err = 0;
-
-out:
- vreq->submitting--;
- if (!vreq->secs_pending) {
- err = (err ? : vreq->error);
- tapdisk_vbd_complete_vbd_request(vbd, vreq);
- }
-
- return err;
-
-fail:
- vreq->status = BLKIF_RSP_ERROR;
- goto out;
-}
-
-static int
-tapdisk_vbd_reissue_failed_requests(td_vbd_t *vbd)
-{
- int err;
- struct timeval now;
- td_vbd_request_t *vreq, *tmp;
-
- err = 0;
- gettimeofday(&now, NULL);
-
- tapdisk_vbd_for_each_request(vreq, tmp, &vbd->failed_requests) {
- if (vreq->secs_pending)
- continue;
-
- if (td_flag_test(vbd->state, TD_VBD_SHUTDOWN_REQUESTED))
- goto fail;
-
- if (vreq->error != -EBUSY &&
- now.tv_sec - vreq->last_try.tv_sec < TD_VBD_RETRY_INTERVAL)
- continue;
-
- if (vreq->num_retries >= TD_VBD_MAX_RETRIES) {
- fail:
- DBG(TLOG_INFO, "req %"PRIu64"retried %d times\n",
- vreq->req.id, vreq->num_retries);
- tapdisk_vbd_complete_vbd_request(vbd, vreq);
- continue;
- }
-
- /*
- * never fail due to too many retries if we are blocked on a
- * dependency
- */
- if (vreq->blocked) {
- vreq->blocked = 0;
- } else {
- vbd->retries++;
- vreq->num_retries++;
- }
- vreq->error = 0;
- vreq->status = BLKIF_RSP_OKAY;
- DBG(TLOG_DBG, "retry #%d of req %"PRIu64", "
- "sec 0x%08"PRIx64", nr_segs: %d\n", vreq->num_retries,
- vreq->req.id, vreq->req.sector_number,
- vreq->req.nr_segments);
-
- err = tapdisk_vbd_issue_request(vbd, vreq);
- if (err)
- break;
- }
-
- if (list_empty(&vbd->failed_requests))
- td_flag_clear(vbd->state, TD_VBD_RETRY_NEEDED);
- else
- td_flag_set(vbd->state, TD_VBD_RETRY_NEEDED);
-
- return err;
-}
-
-static int
-tapdisk_vbd_issue_new_requests(td_vbd_t *vbd)
-{
- int err;
- td_vbd_request_t *vreq, *tmp;
-
- tapdisk_vbd_for_each_request(vreq, tmp, &vbd->new_requests) {
- err = tapdisk_vbd_issue_request(vbd, vreq);
- if (err)
- return err;
- }
-
- return 0;
-}
-
-static int
-tapdisk_vbd_kill_requests(td_vbd_t *vbd)
-{
- td_vbd_request_t *vreq, *tmp;
-
- tapdisk_vbd_for_each_request(vreq, tmp, &vbd->new_requests) {
- vreq->status = BLKIF_RSP_ERROR;
- tapdisk_vbd_move_request(vreq, &vbd->completed_requests);
- }
-
- tapdisk_vbd_for_each_request(vreq, tmp, &vbd->failed_requests) {
- vreq->status = BLKIF_RSP_ERROR;
- tapdisk_vbd_move_request(vreq, &vbd->completed_requests);
- }
-
- return 0;
-}
-
-int
-tapdisk_vbd_issue_requests(td_vbd_t *vbd)
-{
- int err;
-
- if (td_flag_test(vbd->state, TD_VBD_DEAD))
- return tapdisk_vbd_kill_requests(vbd);
-
- if (!tapdisk_vbd_queue_ready(vbd))
- return -EAGAIN;
-
- err = tapdisk_vbd_reissue_failed_requests(vbd);
- if (err)
- return err;
-
- return tapdisk_vbd_issue_new_requests(vbd);
-}
-
-static void
-tapdisk_vbd_pull_ring_requests(td_vbd_t *vbd)
-{
- int idx;
- RING_IDX rp, rc;
- td_ring_t *ring;
- blkif_request_t *req;
- td_vbd_request_t *vreq;
-
- ring = &vbd->ring;
- if (!ring->sring)
- return;
-
- rp = ring->fe_ring.sring->req_prod;
- xen_rmb();
-
- for (rc = ring->fe_ring.req_cons; rc != rp; rc++) {
- req = RING_GET_REQUEST(&ring->fe_ring, rc);
- ++ring->fe_ring.req_cons;
-
- idx = req->id;
- vreq = &vbd->request_list[idx];
-
- ASSERT(list_empty(&vreq->next));
- ASSERT(vreq->secs_pending == 0);
-
- memcpy(&vreq->req, req, sizeof(blkif_request_t));
- vbd->received++;
- vreq->vbd = vbd;
-
- tapdisk_vbd_move_request(vreq, &vbd->new_requests);
-
- DBG(TLOG_DBG, "%s: request %d \n", vbd->name, idx);
- }
-}
-
-static int
-tapdisk_vbd_pause_ring(td_vbd_t *vbd)
-{
- int err;
-
- if (td_flag_test(vbd->state, TD_VBD_PAUSED))
- return 0;
-
- td_flag_set(vbd->state, TD_VBD_PAUSE_REQUESTED);
-
- err = tapdisk_vbd_quiesce_queue(vbd);
- if (err) {
- EPRINTF("%s: ring pause request on active queue\n", vbd->name);
- return err;
- }
-
- tapdisk_vbd_close_vdi(vbd);
-
- err = ioctl(vbd->ring.fd, BLKTAP2_IOCTL_PAUSE, 0);
- if (err)
- EPRINTF("%s: pause ioctl failed: %d\n", vbd->name, errno);
- else {
- td_flag_clear(vbd->state, TD_VBD_PAUSE_REQUESTED);
- td_flag_set(vbd->state, TD_VBD_PAUSED);
- }
-
- return err;
-}
-
-static int
-tapdisk_vbd_resume_ring(td_vbd_t *vbd)
-{
- int i, err, type;
- char message[BLKTAP2_MAX_MESSAGE_LEN];
- const char *path;
-
- memset(message, 0, sizeof(message));
-
- if (!td_flag_test(vbd->state, TD_VBD_PAUSED)) {
- EPRINTF("%s: resume message for unpaused vbd\n", vbd->name);
- return -EINVAL;
- }
-
- err = ioctl(vbd->ring.fd, BLKTAP2_IOCTL_REOPEN, &message);
- if (err) {
- EPRINTF("%s: resume ioctl failed: %d\n", vbd->name, errno);
- return err;
- }
-
- err = tapdisk_parse_disk_type(message, &path, &type);
- if (err) {
- EPRINTF("%s: invalid resume string %s\n", vbd->name, message);
- goto out;
- }
-
- free(vbd->name);
- vbd->name = strdup(path);
- if (!vbd->name) {
- EPRINTF("resume malloc failed\n");
- err = -ENOMEM;
- goto out;
- }
-
- tapdisk_vbd_start_queue(vbd);
-
- for (i = 0; i < TD_VBD_EIO_RETRIES; i++) {
- err = __tapdisk_vbd_open_vdi(vbd, TD_OPEN_STRICT);
- if (err != -EIO)
- break;
-
- sleep(TD_VBD_EIO_SLEEP);
- }
-
-out:
- if (!err) {
- image_t image;
- struct blktap2_params params;
-
- memset(¶ms, 0, sizeof(params));
- tapdisk_vbd_get_image_info(vbd, &image);
-
- params.sector_size = image.secsize;
- params.capacity = image.size;
- snprintf(params.name, sizeof(params.name),
- "%.*s", (int)sizeof(params.name) - 1, message);
-
- ioctl(vbd->ring.fd, BLKTAP2_IOCTL_SET_PARAMS, ¶ms);
- td_flag_clear(vbd->state, TD_VBD_PAUSED);
- }
-
- ioctl(vbd->ring.fd, BLKTAP2_IOCTL_RESUME, err);
- return err;
-}
-
-static int
-tapdisk_vbd_check_ring_message(td_vbd_t *vbd)
-{
- if (!vbd->ring.sring)
- return -EINVAL;
-
- switch (vbd->ring.sring->pvt.tapif_user.msg) {
- case 0:
- return 0;
-
- case BLKTAP2_RING_MESSAGE_PAUSE:
- return tapdisk_vbd_pause_ring(vbd);
-
- case BLKTAP2_RING_MESSAGE_RESUME:
- return tapdisk_vbd_resume_ring(vbd);
-
- case BLKTAP2_RING_MESSAGE_CLOSE:
- return tapdisk_vbd_close(vbd);
-
- default:
- return -EINVAL;
- }
-}
-
-static void
-tapdisk_vbd_ring_event(event_id_t id, char mode, void *private)
-{
- td_vbd_t *vbd;
-
- vbd = (td_vbd_t *)private;
-
- tapdisk_vbd_pull_ring_requests(vbd);
- tapdisk_vbd_issue_requests(vbd);
-
- /* vbd may be destroyed after this call */
- tapdisk_vbd_check_ring_message(vbd);
-}
-
-td_image_t *
-tapdisk_vbd_first_image(td_vbd_t *vbd)
-{
- return list_entry(vbd->images.next, td_image_t, next);
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#ifndef _TAPDISK_VBD_H_
-#define _TAPDISK_VBD_H_
-
-#include <sys/time.h>
-#include <xenctrl.h>
-#include <xen/io/blkif.h>
-
-#include "tapdisk.h"
-#include "scheduler.h"
-#include "tapdisk-image.h"
-
-#define TD_VBD_MAX_RETRIES 100
-#define TD_VBD_RETRY_INTERVAL 1
-
-#define TD_VBD_DEAD 0x0001
-#define TD_VBD_CLOSED 0x0002
-#define TD_VBD_QUIESCE_REQUESTED 0x0004
-#define TD_VBD_QUIESCED 0x0008
-#define TD_VBD_PAUSE_REQUESTED 0x0010
-#define TD_VBD_PAUSED 0x0020
-#define TD_VBD_SHUTDOWN_REQUESTED 0x0040
-#define TD_VBD_LOCKING 0x0080
-#define TD_VBD_RETRY_NEEDED 0x0100
-#define TD_VBD_LOG_DROPPED 0x0200
-
-typedef struct td_ring td_ring_t;
-typedef struct td_vbd_request td_vbd_request_t;
-typedef struct td_vbd_driver_info td_vbd_driver_info_t;
-typedef struct td_vbd_handle td_vbd_t;
-typedef void (*td_vbd_cb_t) (void *, blkif_response_t *);
-
-struct td_ring {
- int fd;
- char *mem;
- blkif_sring_t *sring;
- blkif_back_ring_t fe_ring;
- unsigned long vstart;
-};
-
-struct td_vbd_request {
- blkif_request_t req;
- int16_t status;
-
- int error;
- int blocked; /* blocked on a dependency */
- int submitting;
- int secs_pending;
- int num_retries;
- struct timeval last_try;
-
- td_vbd_t *vbd;
- struct list_head next;
-};
-
-struct td_vbd_driver_info {
- char *params;
- int type;
- struct list_head next;
-};
-
-struct td_vbd_handle {
- char *name;
-
- td_uuid_t uuid;
- int minor;
-
- struct list_head driver_stack;
-
- int storage;
-
- uint8_t reopened;
- uint8_t reactivated;
- td_flag_t flags;
- td_flag_t state;
-
- struct list_head images;
-
- struct list_head new_requests;
- struct list_head pending_requests;
- struct list_head failed_requests;
- struct list_head completed_requests;
-
- td_vbd_request_t request_list[MAX_REQUESTS];
-
- td_ring_t ring;
- event_id_t ring_event_id;
-
- td_vbd_cb_t callback;
- void *argument;
-
- struct list_head next;
-
- struct timeval ts;
-
- uint64_t received;
- uint64_t returned;
- uint64_t kicked;
- uint64_t secs_pending;
- uint64_t retries;
- uint64_t errors;
-};
-
-#define tapdisk_vbd_for_each_request(vreq, tmp, list) \
- list_for_each_entry_safe((vreq), (tmp), (list), next)
-
-#define tapdisk_vbd_for_each_image(vbd, image, tmp) \
- list_for_each_entry_safe((image), (tmp), &(vbd)->images, next)
-
-static inline void
-tapdisk_vbd_move_request(td_vbd_request_t *vreq, struct list_head *dest)
-{
- list_del(&vreq->next);
- INIT_LIST_HEAD(&vreq->next);
- list_add_tail(&vreq->next, dest);
-}
-
-static inline void
-tapdisk_vbd_add_image(td_vbd_t *vbd, td_image_t *image)
-{
- list_add_tail(&image->next, &vbd->images);
-}
-
-static inline int
-tapdisk_vbd_is_last_image(td_vbd_t *vbd, td_image_t *image)
-{
- return list_is_last(&image->next, &vbd->images);
-}
-
-td_image_t *
-tapdisk_vbd_first_image(td_vbd_t *vbd);
-
-static inline td_image_t *
-tapdisk_vbd_last_image(td_vbd_t *vbd)
-{
- return list_entry(vbd->images.prev, td_image_t, next);
-}
-
-static inline td_image_t *
-tapdisk_vbd_next_image(td_image_t *image)
-{
- return list_entry(image->next.next, td_image_t, next);
-}
-
-td_vbd_t *tapdisk_vbd_create(td_uuid_t);
-int tapdisk_vbd_initialize(td_uuid_t);
-void tapdisk_vbd_set_callback(td_vbd_t *, td_vbd_cb_t, void *);
-int tapdisk_vbd_parse_stack(td_vbd_t *vbd, const char *path);
-int tapdisk_vbd_open(td_vbd_t *, const char *, uint16_t,
- uint16_t, int, const char *, td_flag_t);
-int tapdisk_vbd_close(td_vbd_t *);
-void tapdisk_vbd_free(td_vbd_t *);
-void tapdisk_vbd_free_stack(td_vbd_t *);
-
-int tapdisk_vbd_open_stack(td_vbd_t *, uint16_t, td_flag_t);
-int tapdisk_vbd_open_vdi(td_vbd_t *, const char *,
- uint16_t, uint16_t, td_flag_t);
-void tapdisk_vbd_close_vdi(td_vbd_t *);
-
-int tapdisk_vbd_attach(td_vbd_t *, const char *, int);
-void tapdisk_vbd_detach(td_vbd_t *);
-
-void tapdisk_vbd_forward_request(td_request_t);
-
-int tapdisk_vbd_get_image_info(td_vbd_t *, image_t *);
-int tapdisk_vbd_queue_ready(td_vbd_t *);
-int tapdisk_vbd_retry_needed(td_vbd_t *);
-int tapdisk_vbd_quiesce_queue(td_vbd_t *);
-int tapdisk_vbd_start_queue(td_vbd_t *);
-int tapdisk_vbd_issue_requests(td_vbd_t *);
-int tapdisk_vbd_kill_queue(td_vbd_t *);
-int tapdisk_vbd_pause(td_vbd_t *);
-int tapdisk_vbd_resume(td_vbd_t *, const char *, uint16_t);
-int tapdisk_vbd_kick(td_vbd_t *);
-void tapdisk_vbd_check_state(td_vbd_t *);
-void tapdisk_vbd_check_progress(td_vbd_t *);
-void tapdisk_vbd_debug(td_vbd_t *);
-
-void tapdisk_vbd_complete_vbd_request(td_vbd_t *, td_vbd_request_t *);
-
-#endif
+++ /dev/null
-/*
- * Copyright (c) 2007, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * Some notes on the tap_disk interface:
- *
- * tap_disk aims to provide a generic interface to easily implement new
- * types of image accessors. The structure-of-function-calls is similar
- * to disk interfaces used in qemu/denali/etc, with the significant
- * difference being the expectation of asynchronous rather than synchronous
- * I/O. The asynchronous interface is intended to allow lots of requests to
- * be pipelined through a disk, without the disk requiring any of its own
- * threads of control. As such, a batch of requests is delivered to the disk
- * using:
- *
- * td_queue_[read,write]()
- *
- * and passing in a completion callback, which the disk is responsible for
- * tracking. Disks should transform these requests as necessary and return
- * the resulting iocbs to tapdisk using td_prep_[read,write]() and
- * td_queue_tiocb().
- *
- * NOTE: tapdisk uses the number of sectors submitted per request as a
- * ref count. Plugins must use the callback function to communicate the
- * completion -- or error -- of every sector submitted to them.
- *
- * td_get_parent_id returns:
- * 0 if parent id successfully retrieved
- * TD_NO_PARENT if no parent exists
- * -errno on error
- */
-
-#ifndef _TAPDISK_H_
-#define _TAPDISK_H_
-
-#include <time.h>
-#include <stdint.h>
-
-#include "list.h"
-#include "blktaplib.h"
-#include "tapdisk-log.h"
-#include "tapdisk-utils.h"
-
-#ifdef MEMSHR
-#include "memshr.h"
-#endif
-
-#define DPRINTF(_f, _a...) syslog(LOG_INFO, _f, ##_a)
-#define EPRINTF(_f, _a...) syslog(LOG_ERR, "tap-err:%s: " _f, __func__, ##_a)
-#define PERROR(_f, _a...) EPRINTF(_f ": %s", ##_a, strerror(errno))
-
-#define MAX_SEGMENTS_PER_REQ 11
-#define SECTOR_SHIFT 9
-#define DEFAULT_SECTOR_SIZE 512
-
-#define TAPDISK_DATA_REQUESTS (MAX_REQUESTS * MAX_SEGMENTS_PER_REQ)
-
-//#define BLK_NOT_ALLOCATED (-99)
-#define TD_NO_PARENT 1
-
-#define MAX_RAMDISK_SIZE 1024000 /*500MB disk limit*/
-
-#define TD_OP_READ 0
-#define TD_OP_WRITE 1
-
-#define TD_OPEN_QUIET 0x00001
-#define TD_OPEN_QUERY 0x00002
-#define TD_OPEN_RDONLY 0x00004
-#define TD_OPEN_STRICT 0x00008
-#define TD_OPEN_SHAREABLE 0x00010
-#define TD_OPEN_ADD_CACHE 0x00020
-#define TD_OPEN_VHD_INDEX 0x00040
-#define TD_OPEN_LOG_DIRTY 0x00080
-
-#define TD_CREATE_SPARSE 0x00001
-#define TD_CREATE_MULTITYPE 0x00002
-
-#define td_flag_set(word, flag) ((word) |= (flag))
-#define td_flag_clear(word, flag) ((word) &= ~(flag))
-#define td_flag_test(word, flag) ((word) & (flag))
-
-typedef uint16_t td_uuid_t;
-typedef uint32_t td_flag_t;
-typedef uint64_t td_sector_t;
-typedef struct td_disk_id td_disk_id_t;
-typedef struct td_disk_info td_disk_info_t;
-typedef struct td_request td_request_t;
-typedef struct td_driver_handle td_driver_t;
-typedef struct td_image_handle td_image_t;
-
-struct td_disk_id {
- char *name;
- int drivertype;
-};
-
-struct td_disk_info {
- td_sector_t size;
- uint64_t sector_size;
- uint32_t info;
-};
-
-struct td_request {
- int op;
- char *buf;
- td_sector_t sec;
- int secs;
-
- uint8_t blocked; /* blocked on a dependency */
-
- td_image_t *image;
-
- void * /*td_callback_t*/ cb;
- void *cb_data;
-
- uint64_t id;
- int sidx;
- void *private;
-
-#ifdef MEMSHR
- share_tuple_t memshr_hnd;
-#endif
-};
-
-/*
- * Prototype of the callback to activate as requests complete.
- */
-typedef void (*td_callback_t)(td_request_t, int);
-
-/*
- * Structure describing the interface to a virtual disk implementation.
- * See note at the top of this file describing this interface.
- */
-struct tap_disk {
- const char *disk_type;
- td_flag_t flags;
- int private_data_size;
- int (*td_open) (td_driver_t *, const char *, td_flag_t);
- int (*td_close) (td_driver_t *);
- int (*td_get_parent_id) (td_driver_t *, td_disk_id_t *);
- int (*td_validate_parent) (td_driver_t *, td_driver_t *, td_flag_t);
- void (*td_queue_read) (td_driver_t *, td_request_t);
- void (*td_queue_write) (td_driver_t *, td_request_t);
- void (*td_debug) (td_driver_t *);
-};
-
-#endif
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include <stdio.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <unistd.h>
-#ifdef MEMSHR
-#include <memshr.h>
-#endif
-
-#include "tapdisk.h"
-#include "tapdisk-utils.h"
-#include "tapdisk-server.h"
-#include "tapdisk-control.h"
-
-static void
-usage(const char *app, int err)
-{
- fprintf(stderr, "usage: %s [-D] <-u uuid> <-c control socket>\n", app);
- exit(err);
-}
-
-int
-main(int argc, char *argv[])
-{
- char *control;
- int c, err, nodaemon;
-
- control = NULL;
- nodaemon = 0;
-
- while ((c = getopt(argc, argv, "s:Dh")) != -1) {
- switch (c) {
- case 'D':
- nodaemon = 1;
- break;
- case 'h':
- usage(argv[0], 0);
- break;
- case 's':
-#ifdef MEMSHR
- memshr_set_domid(atoi(optarg));
-#else
- fprintf(stderr, "MEMSHR support not compiled in.\n");
- exit(EXIT_FAILURE);
-#endif
- break;
- default:
- usage(argv[0], EINVAL);
- }
- }
-
- if (optind != argc)
- usage(argv[0], EINVAL);
-
- if (chdir("/")) {
- DPRINTF("failed to chdir(/): %d\n", errno);
- err = 1;
- goto out;
- }
-
- tapdisk_start_logging("tapdisk2");
-
- err = tapdisk_server_init();
- if (err) {
- DPRINTF("failed to initialize server: %d\n", err);
- goto out;
- }
-
- if (!nodaemon) {
- err = daemon(0, 1);
- if (err) {
- DPRINTF("failed to daemonize: %d\n", errno);
- goto out;
- }
- }
-
- err = tapdisk_control_open(&control);
- if (err) {
- DPRINTF("failed to open control socket: %d\n", err);
- goto out;
- }
-
- fprintf(stdout, "%s\n", control);
- fflush(stdout);
-
- if (!nodaemon) {
- int fd;
-
- fd = open("/dev/null", O_RDWR);
- if (fd != -1) {
- dup2(fd, STDIN_FILENO);
- dup2(fd, STDOUT_FILENO);
- dup2(fd, STDERR_FILENO);
- if (fd > 2)
- close(fd);
- }
- }
-
- err = tapdisk_server_complete();
- if (err) {
- DPRINTF("failed to complete server: %d\n", err);
- goto out;
- }
-
- err = tapdisk_server_run();
-
-out:
- tapdisk_control_close();
- tapdisk_stop_logging();
- return err;
-}
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#include <errno.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/resource.h>
-#include <unistd.h>
-#include <string.h>
-
-#include "libvhd.h"
-#include "vhd-util.h"
-#include "tapdisk-utils.h"
-
-#if 1
-#define DFPRINTF(_f, _a...) fprintf ( stdout, _f , ## _a )
-#else
-#define DFPRINTF(_f, _a...) ((void)0)
-#endif
-
-typedef enum {
- TD_FIELD_HIDDEN = 0,
- TD_FIELD_INVALID = 1
-} td_field_t;
-
-struct vdi_field {
- char *name;
- td_field_t id;
-};
-
-static struct vdi_field td_vdi_fields[TD_FIELD_INVALID] = {
- { .id = TD_FIELD_HIDDEN, .name = "hidden" }
-};
-
-typedef enum {
- TD_CMD_CREATE = 0,
- TD_CMD_SNAPSHOT,
-/* TD_CMD_COALESCE, */
- TD_CMD_QUERY,
-/* TD_CMD_RESIZE, */
- TD_CMD_SET,
-/* TD_CMD_REPAIR, */
-/* TD_CMD_FILL, */
-/* TD_CMD_READ, */
- TD_CMD_INVALID,
-} td_command_t;
-
-struct command {
- td_command_t id;
- char *name;
- int needs_type;
-};
-
-struct command commands[TD_CMD_INVALID] = {
- { .id = TD_CMD_CREATE, .name = "create", .needs_type = 1 },
- { .id = TD_CMD_SNAPSHOT, .name = "snapshot", .needs_type = 1 },
-/* { .id = TD_CMD_COALESCE, .name = "coalesce", .needs_type = 1 }, */
- { .id = TD_CMD_QUERY, .name = "query", .needs_type = 1 },
-/* { .id = TD_CMD_RESIZE, .name = "resize", .needs_type = 1 }, */
- { .id = TD_CMD_SET, .name = "set", .needs_type = 1 },
-/* { .id = TD_CMD_REPAIR, .name = "repair", .needs_type = 1 }, */
-/* { .id = TD_CMD_FILL, .name = "fill", .needs_type = 1 }, */
-/* { .id = TD_CMD_READ, .name = "read", .needs_type = 1 }, */
-};
-
-typedef enum {
- TD_TYPE_VHD = 0,
- TD_TYPE_AIO,
- TD_TYPE_INVALID,
-} td_disk_t;
-
-const char *td_disk_types[TD_TYPE_INVALID] = {
- "vhd",
- "aio",
-};
-
-#define print_commands() \
- do { \
- int i; \
- fprintf(stderr, "COMMAND := { "); \
- fprintf(stderr, "%s", commands[0].name); \
- for (i = 1; i < TD_CMD_INVALID; i++) \
- fprintf(stderr, " | %s", commands[i].name); \
- fprintf(stderr, " }\n"); \
- } while (0)
-
-#define print_disk_types() \
- do { \
- int i; \
- fprintf(stderr, "TYPE := { "); \
- fprintf(stderr, "%s", td_disk_types[0]); \
- for (i = 1; i < TD_TYPE_INVALID; i++) \
- fprintf(stderr, " | %s", td_disk_types[i]); \
- fprintf(stderr, " }\n"); \
- } while (0);
-
-#define print_field_names() \
- do { \
- int i; \
- fprintf(stderr, "FIELD := { "); \
- fprintf(stderr, "%s", td_vdi_fields[0].name); \
- for (i = 1; i < TD_FIELD_INVALID; i++) \
- fprintf(stderr, " | %s", td_vdi_fields[i].name); \
- fprintf(stderr, " }\n"); \
- } while (0)
-
-void
-help(void)
-{
- fprintf(stderr, "Tapdisk Utilities: v1.0.0\n");
- fprintf(stderr, "usage: td-util COMMAND [TYPE] [OPTIONS]\n");
- print_commands();
- print_disk_types();
- exit(-1);
-}
-
-struct command *
-get_command(char *command)
-{
- int i;
-
- for (i = 0; i < TD_CMD_INVALID; i++)
- if (!strcmp(command, commands[i].name))
- return &commands[i];
-
- return NULL;
-}
-
-struct vdi_field *
-get_field(char *field)
-{
- int i;
-
- for (i = 0; i < TD_FIELD_INVALID; i++)
- if (!strcmp(field, td_vdi_fields[i].name))
- return &td_vdi_fields[i];
-
- return NULL;
-}
-
-int
-get_driver_type(char *type)
-{
- int i;
-
- if (strnlen(type, 25) >= 25)
- return -ENAMETOOLONG;
-
- for (i = 0; i < TD_TYPE_INVALID; i++)
- if (!strcmp(type, td_disk_types[i]))
- return i;
-
- return -TD_TYPE_INVALID;
-}
-
-int
-td_create(int type, int argc, char *argv[])
-{
- ssize_t mb;
- uint64_t size;
- char *name, *buf;
- int c, i, fd, sparse = 1, fixedsize = 0;
-
- while ((c = getopt(argc, argv, "hrb")) != -1) {
- switch(c) {
- case 'r':
- sparse = 0;
- break;
- case 'b':
- fixedsize = 1;
- break;
- default:
- fprintf(stderr, "Unknown option %c\n", (char)c);
- case 'h':
- goto usage;
- }
- }
-
- if (optind != (argc - 2))
- goto usage;
-
- mb = 1 << 20;
- size = atoi(argv[optind++]);
- size = size << 20;
- name = argv[optind];
-
- if (strnlen(name, MAX_NAME_LEN) == MAX_NAME_LEN) {
- fprintf(stderr, "Device name too long\n");
- return ENAMETOOLONG;
- }
-
- if (type == TD_TYPE_VHD) {
- int cargc = 0;
- char sbuf[32], *cargv[10];
-
- size >>= 20;
-
- memset(cargv, 0, sizeof(cargv));
- snprintf(sbuf, sizeof(sbuf) - 1, "%"PRIu64, size);
- cargv[cargc++] = "create";
- cargv[cargc++] = "-n";
- cargv[cargc++] = name;
- cargv[cargc++] = "-s";
- cargv[cargc++] = sbuf;
- if (!sparse)
- cargv[cargc++] = "-r";
- if (fixedsize)
- cargv[cargc++] = "-b";
-
- return vhd_util_create(cargc, cargv);
- }
-
- /* generic create */
- if (sparse) {
- fprintf(stderr, "Cannot create sparse %s image\n",
- td_disk_types[type]);
- return EINVAL;
- }
-
- buf = calloc(1, mb);
- if (!buf)
- return ENOMEM;
-
- fd = open(name, O_WRONLY | O_DIRECT | O_CREAT | O_TRUNC, 0644);
- if (fd == -1) {
- free(buf);
- return errno;
- }
-
- size >>= 20;
- for (i = 0; i < size; i++)
- if (write(fd, buf, mb) != mb) {
- close(fd);
- unlink(name);
- free(buf);
- return EIO;
- }
-
- close(fd);
- free(buf);
- return 0;
-
- usage:
- fprintf(stderr, "usage: td-util create %s [-h help] [-r reserve] "
- "[-b file_is_fixed_size] <SIZE(MB)> <FILENAME>\n",
- td_disk_types[type]);
- return EINVAL;
-}
-
-int
-td_snapshot(int type, int argc, char *argv[])
-{
- char *cargv[10];
- int c, err, cargc;
- struct stat stats;
- char *name, *backing, *limit = NULL;
- int fixedsize = 0, rawparent = 0;
-
- if (type != TD_TYPE_VHD) {
- fprintf(stderr, "Cannot create snapshot of %s image type\n",
- td_disk_types[type]);
- return EINVAL;
- }
-
- while ((c = getopt(argc, argv, "hbml:")) != -1) {
- switch(c) {
- case 'b':
- fixedsize = 1;
- break;
- case 'm':
- rawparent = 1;
- break;
- case 'l':
- limit = optarg;
- break;
- case 'h':
- err = 0;
- goto usage;
- default:
- err = EINVAL;
- goto usage;
- }
- }
-
- if (optind != (argc - 2)) {
- err = EINVAL;
- goto usage;
- }
-
- name = argv[optind++];
- backing = argv[optind++];
-
- if (strnlen(name, MAX_NAME_LEN) == MAX_NAME_LEN ||
- strnlen(backing, MAX_NAME_LEN) == MAX_NAME_LEN) {
- fprintf(stderr, "Device name too long\n");
- return ENAMETOOLONG;
- }
-
- if (stat(backing, &stats) == -1) {
- fprintf(stderr, "File %s not found\n", backing);
- return errno;
- }
-
- cargc = 0;
- memset(cargv, 0, sizeof(cargv));
- cargv[cargc++] = "snapshot";
- cargv[cargc++] = "-n";
- cargv[cargc++] = name;
- cargv[cargc++] = "-p";
- cargv[cargc++] = backing;
- if (fixedsize)
- cargv[cargc++] = "-b";
- if (rawparent)
- cargv[cargc++] = "-m";
- if (limit) {
- cargv[cargc++] = "-l";
- cargv[cargc++] = limit;
- }
- return vhd_util_snapshot(cargc, cargv);
-
- usage:
- fprintf(stderr, "usage: td-util snapshot %s [-h help] [-m parent_raw] "
- "[-b file_is_fixed_size] [-l snapshot depth limit] "
- "<FILENAME> <BACKING_FILENAME>\n", td_disk_types[type]);
- return err;
-}
-
-int
-td_coalesce(int type, int argc, char *argv[])
-{
- int c, ret, cargc;
- char *name, *pname, *cargv[3];
-
- if (type != TD_TYPE_VHD) {
- fprintf(stderr, "Cannot create snapshot of %s image type\n",
- td_disk_types[type]);
- return EINVAL;
- }
-
- while ((c = getopt(argc, argv, "h")) != -1) {
- switch(c) {
- default:
- fprintf(stderr, "Unknown option %c\n", (char)c);
- case 'h':
- goto usage;
- }
- }
-
- if (optind != (argc - 1))
- goto usage;
-
- name = argv[optind++];
-
- if (strnlen(name, MAX_NAME_LEN) == MAX_NAME_LEN) {
- fprintf(stderr, "Device name too long\n");
- return ENAMETOOLONG;
- }
-
- cargc = 0;
- memset(cargv, 0, sizeof(cargv));
- cargv[cargc++] = "coalesce";
- cargv[cargc++] = "-n";
- cargv[cargc++] = name;
- ret = vhd_util_coalesce(cargc, cargv);
- if (ret)
- printf("coalesce failed: %d\n", ret);
-
- return ret;
-
- usage:
- fprintf(stderr, "usage: td-util coalesce %s [-h help] "
- "<FILENAME>\n", td_disk_types[type]);
- return EINVAL;
-}
-
-int
-td_query(int type, int argc, char *argv[])
-{
- char *name;
- int c, size = 0, parent = 0, fields = 0, depth = 0, err = 0;
-
- while ((c = getopt(argc, argv, "hvpfd")) != -1) {
- switch(c) {
- case 'v':
- size = 1;
- break;
- case 'p':
- parent = 1;
- break;
- case 'f':
- fields = 1;
- break;
- case 'd':
- depth = 1;
- break;
- case 'h':
- err = 0;
- goto usage;
- default:
- err = EINVAL;
- goto usage;
- }
- }
-
- if (optind != (argc - 1)) {
- err = EINVAL;
- goto usage;
- }
-
- name = argv[optind++];
-
- if (strnlen(name, MAX_NAME_LEN) == MAX_NAME_LEN) {
- fprintf(stderr, "Device name too long\n");
- return ENAMETOOLONG;
- }
-
- if (type == TD_TYPE_VHD) {
- vhd_context_t vhd;
-
- err = vhd_open(&vhd, name, VHD_OPEN_RDONLY);
- if (err) {
- printf("failed opening %s: %d\n", name, err);
- return err;
- }
-
- if (size)
- printf("%"PRIu64"\n", vhd.footer.curr_size >> 20);
-
- if (parent) {
- if (vhd.footer.type != HD_TYPE_DIFF)
- printf("%s has no parent\n", name);
- else {
- char *pname;
-
- err = vhd_parent_locator_get(&vhd, &pname);
- if (err)
- printf("failed getting parent: %d\n",
- err);
- else {
- printf("%s\n", pname);
- free(pname);
- }
- }
- }
-
- if (fields) {
- int ret, hidden;
-
- ret = vhd_hidden(&vhd, &hidden);
- if (ret) {
- printf("failed checking 'hidden' field: %d\n",
- ret);
- err = (err ? : ret);
- } else
- printf("%s: %d\n",
- td_vdi_fields[TD_FIELD_HIDDEN].name,
- hidden);
- }
-
- if (depth) {
- int ret, length;
-
- ret = vhd_chain_depth(&vhd, &length);
- if (ret)
- printf("error checking chain depth: %d\n", ret);
- else
- printf("chain depth: %d\n", length);
-
- err = (err ? : ret);
- }
-
- vhd_close(&vhd);
-
- } else if (type == TD_TYPE_AIO) {
- if (size) {
- int fd;
- uint64_t secs;
- uint32_t ssize;
-
- fd = open(name, O_RDONLY | O_LARGEFILE);
- if (fd == -1) {
- printf("failed opening %s: %d\n", name, errno);
- return -errno;
- }
-
- err = tapdisk_get_image_size(fd, &secs, &ssize);
- close(fd);
-
- if (err) {
- printf("failed getting size for %s: %d\n:",
- name, err);
- return err;
- }
-
- printf("%"PRIu64"\n", secs >> 11);
- }
-
- if (parent)
- printf("%s has no parent\n", name);
-
- if (fields) {
- int i;
-
- for (i = 0; i < TD_FIELD_INVALID; i++)
- printf("%s: 0\n", td_vdi_fields[i].name);
- }
- }
-
- return err;
-
- usage:
- fprintf(stderr, "usage: td-util query %s [-h help] [-v virtsize] "
- "[-p parent] [-f fields] <FILENAME>\n", td_disk_types[type]);
- return err;
-}
-
-int
-td_set_field(int type, int argc, char *argv[])
-{
- int ret, i, c, cargc;
- struct vdi_field *field;
- char *name, *value, *cargv[7];
-
- if (type != TD_TYPE_VHD) {
- fprintf(stderr, "Cannot set fields of %s images\n",
- td_disk_types[type]);
- return EINVAL;
- }
-
- while ((c = getopt(argc, argv, "h")) != -1) {
- switch(c) {
- default:
- fprintf(stderr, "Unknown option %c\n", (char)c);
- case 'h':
- goto usage;
- }
- }
-
- if (optind != (argc - 3))
- goto usage;
-
- name = argv[optind++];
-
- field = get_field(argv[optind]);
- if (!field || field->id != TD_FIELD_HIDDEN) {
- fprintf(stderr, "Invalid field %s\n", argv[optind]);
- goto usage;
- }
-
- value = argv[++optind];
-
- cargc = 0;
- memset(cargv, 0, sizeof(cargv));
- cargv[cargc++] = "set";
- cargv[cargc++] = "-n";
- cargv[cargc++] = name;
- cargv[cargc++] = "-f";
- cargv[cargc++] = field->name;
- cargv[cargc++] = "-v";
- cargv[cargc++] = value;
- return vhd_util_set_field(cargc, cargv);
-
- usage:
- fprintf(stderr, "usage: td-util set %s [-h help] "
- "<FILENAME> <FIELD> <VALUE>\n", td_disk_types[type]);
- print_field_names();
- return EINVAL;
-}
-
-int
-main(int argc, char *argv[])
-{
- char **cargv;
- struct command *cmd;
- int cargc, i, type = -1, ret = 0;
-
-#ifdef CORE_DUMP
- struct rlimit rlim;
- rlim.rlim_cur = RLIM_INFINITY;
- rlim.rlim_max = RLIM_INFINITY;
- if (setrlimit(RLIMIT_CORE, &rlim) < 0)
- fprintf(stderr, "setrlimit failed: %d\n", errno);
-#endif
-
- if (argc < 2)
- help();
-
- cargc = argc - 1;
- cmd = get_command(argv[1]);
- if (!cmd) {
- fprintf(stderr, "invalid COMMAND %s\n", argv[1]);
- help();
- }
-
- if (cmd->needs_type) {
- if (argc < 3) {
- fprintf(stderr, "td-util %s requires a TYPE\n",
- cmd->name);
- print_disk_types();
- exit(-1);
- }
-
- type = get_driver_type(argv[2]);
- if (type < 0) {
- fprintf(stderr, "invalid TYPE '%s'.\n", argv[2]);
- print_disk_types();
- exit(-1);
- }
- --cargc;
- }
-
- cargv = malloc(sizeof(char *) * cargc);
- if (!cargv)
- exit(ENOMEM);
-
- cargv[0] = cmd->name;
- for (i = 1; i < cargc; i++)
- cargv[i] = argv[i + (argc - cargc)];
-
- switch(cmd->id) {
- case TD_CMD_CREATE:
- ret = td_create(type, cargc, cargv);
- break;
- case TD_CMD_SNAPSHOT:
- ret = td_snapshot(type, cargc, cargv);
- break;
-/*
- case TD_CMD_COALESCE:
- ret = td_coalesce(type, cargc, cargv);
- break;
-*/
- case TD_CMD_QUERY:
- ret = td_query(type, cargc, cargv);
- break;
-/*
- case TD_CMD_RESIZE:
- ret = td_resize(type, cargc, cargv);
- break;
-*/
- case TD_CMD_SET:
- ret = td_set_field(type, cargc, cargv);
- break;
-/*
- case TD_CMD_REPAIR:
- ret = td_repair(type, cargc, cargv);
- break;
- case TD_CMD_FILL:
- ret = td_fill(type, cargc, cargv);
- break;
- case TD_CMD_READ:
- ret = td_read(type, cargc, cargv);
- break;
-*/
- default:
- case TD_CMD_INVALID:
- ret = EINVAL;
- break;
- }
-
- free(cargv);
-
- return (ret >= 0 ? ret : -ret);
-}
+++ /dev/null
-#!/bin/bash
-
-usage () { echo "USAGE: xmsnap <VM ID> <Backing File>"; }
-
-#
-# Check Usage
-#
-if [ -n "$1" ]
-then
- vmid=$1
-else
- usage
- exit 1
-fi
-
-if [ -n "$2" ]
-then
- target=$2
-else
- usage
- exit 1
-fi
-
-if [ -e "$target" ]
-then
- echo "Creating snapshot of file $target for VM $vmid."
-else
- usage
- echo "File $target not found."
- exit 1
-fi
-
-#
-# Find the snapshot name
-#
-directory=`dirname "$target"`
-target=`basename "$target"`
-
-let maxidx=0
-if [ -e $directory/${target}.snap1 ]
-then
- for idx in $(ls $directory/${target}.snap*)
- do
- let idx=${idx#$directory/${target}.snap}
- if [ "$idx" -gt "$maxidx" ]
- then
- let maxidx=$idx
- fi
- done
-fi
-
-snap=${target}.snap`expr $maxidx + 1`
-
-#
-# Pause VM
-#
-xm pause $vmid
-if [ "$?" -ne "0" ]; then
- exit 1
-fi
-
-
-#
-# Snap and reposition the files
-#
-mv $directory/$target $directory/$snap
-if [ "$?" -ne "0" ]; then
- exit 1
-fi
-
-qcow-create 0 $directory/$target $directory/$snap
-
-#
-# Unpause
-#
-xm unpause $vmid
-
-exit
\ No newline at end of file
+++ /dev/null
-XEN_ROOT := $(CURDIR)/../../..
-include $(XEN_ROOT)/tools/Rules.mk
-
-.PHONY: all
-all:
-
-.PHONY: install
-install:
- $(INSTALL_DIR) -p $(DESTDIR)$(includedir)
-
-.PHONY: uninstall
-.uninstall:
-
-.PHONY: clean
-clean:
- @:
-
-.PHONY: distclean
-distclean: clean
+++ /dev/null
-/* $OpenBSD: atomicio.h,v 1.6 2005/05/24 17:32:43 avsm Exp $ */
-
-/*
- * Copyright (c) 1995,1999 Theo de Raadt. All rights reserved.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include <sys/types.h>
-
-/*
- * Ensure all of data on socket comes through. f==read || f==vwrite
- */
-size_t atomicio(ssize_t (*)(int, void *, size_t), int, void *, size_t);
-
-#define vwrite (ssize_t (*)(int, void *, size_t))write
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#ifndef _BLKTAP_2_H_
-#define _BLKTAP_2_H_
-
-#define BLKTAP2_MAX_MESSAGE_LEN 256
-
-#define BLKTAP2_RING_MESSAGE_PAUSE 1
-#define BLKTAP2_RING_MESSAGE_RESUME 2
-#define BLKTAP2_RING_MESSAGE_CLOSE 3
-
-#define BLKTAP2_IOCTL_KICK_FE 1
-#define BLKTAP2_IOCTL_ALLOC_TAP 200
-#define BLKTAP2_IOCTL_FREE_TAP 201
-#define BLKTAP2_IOCTL_CREATE_DEVICE 202
-#define BLKTAP2_IOCTL_SET_PARAMS 203
-#define BLKTAP2_IOCTL_PAUSE 204
-#define BLKTAP2_IOCTL_REOPEN 205
-#define BLKTAP2_IOCTL_RESUME 206
-
-#define BLKTAP2_SYSFS_DIR "/sys/class/blktap2"
-#define BLKTAP2_CONTROL_NAME "blktap-control"
-#define BLKTAP2_CONTROL_DIR "/var/run/"BLKTAP2_CONTROL_NAME
-#define BLKTAP2_CONTROL_SOCKET "ctl"
-#define BLKTAP2_DIRECTORY "/dev/xen/blktap-2"
-#define BLKTAP2_CONTROL_DEVICE BLKTAP2_DIRECTORY"/control"
-#define BLKTAP2_RING_DEVICE BLKTAP2_DIRECTORY"/blktap"
-#define BLKTAP2_IO_DEVICE BLKTAP2_DIRECTORY"/tapdev"
-
-struct blktap2_handle {
- unsigned int ring;
- unsigned int device;
- unsigned int minor;
-};
-
-struct blktap2_params {
- char name[BLKTAP2_MAX_MESSAGE_LEN];
- unsigned long long capacity;
- unsigned long sector_size;
-};
-
-#endif
+++ /dev/null
-/* blktaplib.h
- *
- * Blktap library userspace code.
- *
- * Copyright (c) 2007, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef __BLKTAPLIB_H__
-#define __BLKTAPLIB_H__
-
-#include <syslog.h>
-#include <sys/time.h>
-#include <xenctrl.h>
-#include <xen/io/blkif.h>
-
-#define BLK_RING_SIZE __CONST_RING_SIZE(blkif, XC_PAGE_SIZE)
-
-/* size of the extra VMA area to map in attached pages. */
-#define BLKTAP_VMA_PAGES BLK_RING_SIZE
-
-/* blktap IOCTLs: These must correspond with the blktap driver ioctls */
-#define BLKTAP_IOCTL_KICK_FE 1
-#define BLKTAP_IOCTL_KICK_BE 2
-#define BLKTAP_IOCTL_SETMODE 3
-#define BLKTAP_IOCTL_SENDPID 4
-#define BLKTAP_IOCTL_NEWINTF 5
-#define BLKTAP_IOCTL_MINOR 6
-#define BLKTAP_IOCTL_MAJOR 7
-#define BLKTAP_QUERY_ALLOC_REQS 8
-#define BLKTAP_IOCTL_FREEINTF 9
-#define BLKTAP_IOCTL_PRINT_IDXS 100
-#define BLKTAP_IOCTL_BACKDEV_SETUP 200
-
-#define PRIO_SPECIAL_IO -9999
-
-/* blktap switching modes: (Set with BLKTAP_IOCTL_SETMODE) */
-#define BLKTAP_MODE_PASSTHROUGH 0x00000000 /* default */
-#define BLKTAP_MODE_INTERCEPT_FE 0x00000001
-#define BLKTAP_MODE_INTERCEPT_BE 0x00000002
-
-#define BLKTAP_MODE_INTERPOSE \
- (BLKTAP_MODE_INTERCEPT_FE | BLKTAP_MODE_INTERCEPT_BE)
-
-static inline int BLKTAP_MODE_VALID(unsigned long arg)
-{
- return (
- ( arg == BLKTAP_MODE_PASSTHROUGH ) ||
- ( arg == BLKTAP_MODE_INTERCEPT_FE ) ||
- ( arg == BLKTAP_MODE_INTERPOSE ) );
-}
-
-#define MAX_REQUESTS BLK_RING_SIZE
-
-#define BLKTAP_IOCTL_KICK 1
-#define MAX_PENDING_REQS BLK_RING_SIZE
-#define BLKTAP_DEV_DIR "/dev/xen"
-#define BLKTAP_DEV_NAME "blktap"
-#define BACKDEV_NAME "backdev"
-#define BLKTAP_DEV_MINOR 0
-#define BLKTAP_CTRL_DIR "/var/run/tap"
-
-extern int blktap_major;
-
-#define BLKTAP_RING_PAGES 1 /* Front */
-#define BLKTAP_MMAP_REGION_SIZE (BLKTAP_RING_PAGES + MMAP_PAGES)
-
-struct blkif;
-struct blkif_info;
-
-typedef struct {
- blkif_request_t req;
- int submitting;
- int secs_pending;
- int16_t status;
- int num_retries;
- struct timeval last_try;
-} pending_req_t;
-
-typedef struct blkif {
- domid_t domid;
- long int handle;
-
- long int pdev;
- long int readonly;
-
- enum { DISCONNECTED, DISCONNECTING, CONNECTED } state;
-
- struct blkif_ops *ops;
- struct blkif *hash_next;
-
- void *prv; /* device-specific data */
- struct blkif_info *info; /*Image parameter passing */
- pending_req_t pending_list[MAX_REQUESTS];
- int devnum;
- int fds[2];
- int be_id;
- char *backend_path;
- int major;
- int minor;
- pid_t tappid;
- int drivertype;
- uint16_t cookie;
- int err;
-} blkif_t;
-
-typedef struct blkif_info {
- char *params;
- int readonly;
- int storage;
-} blkif_info_t;
-
-typedef struct tapdev_info {
- int fd;
- char *mem;
- blkif_sring_t *sring;
- blkif_back_ring_t fe_ring;
- unsigned long vstart;
- blkif_t *blkif;
-} tapdev_info_t;
-
-typedef struct domid_translate {
- unsigned short domid;
- unsigned short busid;
-} domid_translate_t ;
-
-typedef struct image {
- unsigned long long size;
- unsigned long secsize;
- unsigned int info;
-} image_t;
-
-typedef struct msg_hdr {
- uint16_t type;
- uint16_t len;
- uint16_t drivertype;
- uint16_t cookie;
-} msg_hdr_t;
-
-typedef struct msg_params {
- uint8_t readonly;
- int path_off;
- int path_len;
- int storage;
-} msg_params_t;
-
-typedef struct msg_newdev {
- uint8_t devnum;
- uint16_t domid;
-} msg_newdev_t;
-
-typedef struct msg_pid {
- pid_t pid;
-} msg_pid_t;
-
-typedef struct msg_cp {
- int cp_uuid_off;
- int cp_uuid_len;
- int cp_drivertype;
-} msg_cp_t;
-
-typedef struct msg_lock {
- int ro;
- int enforce;
- int uuid_off;
- int uuid_len;
-} msg_lock_t;
-
-#define READ 0
-#define WRITE 1
-
-/*Control Messages between manager and tapdev*/
-#define CTLMSG_PARAMS 1
-#define CTLMSG_IMG 2
-#define CTLMSG_IMG_FAIL 3
-#define CTLMSG_NEWDEV 4
-#define CTLMSG_NEWDEV_RSP 5
-#define CTLMSG_NEWDEV_FAIL 6
-#define CTLMSG_CLOSE 7
-#define CTLMSG_CLOSE_RSP 8
-#define CTLMSG_PID 9
-#define CTLMSG_PID_RSP 10
-#define CTLMSG_CHECKPOINT 11
-#define CTLMSG_CHECKPOINT_RSP 12
-#define CTLMSG_LOCK 13
-#define CTLMSG_LOCK_RSP 14
-#define CTLMSG_PAUSE 15
-#define CTLMSG_PAUSE_RSP 16
-#define CTLMSG_RESUME 17
-#define CTLMSG_RESUME_RSP 18
-
-#define TAPDISK_STORAGE_TYPE_NFS 1
-#define TAPDISK_STORAGE_TYPE_EXT 2
-#define TAPDISK_STORAGE_TYPE_LVM 3
-#define TAPDISK_STORAGE_TYPE_DEFAULT TAPDISK_STORAGE_TYPE_EXT
-
-/* Abitrary values, must match the underlying driver... */
-#define MAX_TAP_DEV 256
-
-/* Accessing attached data page mappings */
-#define MMAP_PAGES \
- (MAX_PENDING_REQS * BLKIF_MAX_SEGMENTS_PER_REQUEST)
-#define MMAP_VADDR(_vstart,_req,_seg) \
- ((_vstart) + \
- ((_req) * BLKIF_MAX_SEGMENTS_PER_REQUEST * getpagesize()) + \
- ((_seg) * getpagesize()))
-
-/* Defines that are only used by library clients */
-
-#ifndef __COMPILING_BLKTAP_LIB
-
-static char *blkif_op_name[] = {
- [BLKIF_OP_READ] = "READ",
- [BLKIF_OP_WRITE] = "WRITE",
-};
-
-#endif /* __COMPILING_BLKTAP_LIB */
-
-#endif /* __BLKTAPLIB_H__ */
+++ /dev/null
-/* Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#ifndef _VHD_JOURNAL_H_
-#define _VHD_JOURNAL_H_
-
-#include <inttypes.h>
-
-#include "libvhd.h"
-
-#define VHD_JOURNAL_METADATA 0x01
-#define VHD_JOURNAL_DATA 0x02
-
-#define VHD_JOURNAL_HEADER_COOKIE "vjournal"
-#define VHD_JOURNAL_ENTRY_COOKIE 0xaaaa12344321aaaa
-
-typedef struct vhd_journal_header {
- char cookie[8];
- vhd_uuid_t uuid;
- uint64_t vhd_footer_offset;
- uint32_t journal_data_entries;
- uint32_t journal_metadata_entries;
- uint64_t journal_data_offset;
- uint64_t journal_metadata_offset;
- uint64_t journal_eof;
- char pad[448];
-} vhd_journal_header_t;
-
-typedef struct vhd_journal {
- char *jname;
- int jfd;
- int is_block; /* is jfd a block device */
- vhd_journal_header_t header;
- vhd_context_t vhd;
-} vhd_journal_t;
-
-int vhd_journal_create(vhd_journal_t *, const char *file, const char *jfile);
-int vhd_journal_open(vhd_journal_t *, const char *file, const char *jfile);
-int vhd_journal_add_block(vhd_journal_t *, uint32_t block, char mode);
-int vhd_journal_commit(vhd_journal_t *);
-int vhd_journal_revert(vhd_journal_t *);
-int vhd_journal_close(vhd_journal_t *);
-int vhd_journal_remove(vhd_journal_t *);
-
-#endif
+++ /dev/null
-/* Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#ifndef _VHD_LIB_H_
-#define _VHD_LIB_H_
-
-#include <string.h>
-#if defined(__linux__)
-#include <endian.h>
-#include <byteswap.h>
-#elif defined(__NetBSD__)
-#include <sys/endian.h>
-#include <sys/bswap.h>
-#endif
-
-#include "vhd-uuid.h"
-#include "vhd.h"
-
-#ifndef O_LARGEFILE
-#define O_LARGEFILE 0
-#endif
-
-#if BYTE_ORDER == LITTLE_ENDIAN
-#if defined(__linux__)
- #define BE16_IN(foo) (*(foo)) = bswap_16(*(foo))
- #define BE32_IN(foo) (*(foo)) = bswap_32(*(foo))
- #define BE64_IN(foo) (*(foo)) = bswap_64(*(foo))
- #define BE16_OUT(foo) (*(foo)) = bswap_16(*(foo))
- #define BE32_OUT(foo) (*(foo)) = bswap_32(*(foo))
- #define BE64_OUT(foo) (*(foo)) = bswap_64(*(foo))
-#elif defined(__NetBSD__)
- #define BE16_IN(foo) (*(foo)) = bswap16(*(foo))
- #define BE32_IN(foo) (*(foo)) = bswap32(*(foo))
- #define BE64_IN(foo) (*(foo)) = bswap64(*(foo))
- #define BE16_OUT(foo) (*(foo)) = bswap16(*(foo))
- #define BE32_OUT(foo) (*(foo)) = bswap32(*(foo))
- #define BE64_OUT(foo) (*(foo)) = bswap64(*(foo))
-#endif
-#else
- #define BE16_IN(foo)
- #define BE32_IN(foo)
- #define BE64_IN(foo)
- #define BE32_OUT(foo)
- #define BE32_OUT(foo)
- #define BE64_OUT(foo)
-#endif
-
-#define MIN(a, b) (((a) < (b)) ? (a) : (b))
-#define MAX(a, b) (((a) > (b)) ? (a) : (b))
-
-#define VHD_MAX_NAME_LEN 1024
-
-#define VHD_BLOCK_SHIFT 21
-#define VHD_BLOCK_SIZE (1ULL << VHD_BLOCK_SHIFT)
-
-#define UTF_16 "UTF-16"
-#define UTF_16LE "UTF-16LE"
-#define UTF_16BE "UTF-16BE"
-
-#define VHD_OPEN_RDONLY 0x00001
-#define VHD_OPEN_RDWR 0x00002
-#define VHD_OPEN_FAST 0x00004
-#define VHD_OPEN_STRICT 0x00008
-#define VHD_OPEN_IGNORE_DISABLED 0x00010
-
-#define VHD_FLAG_CREAT_PARENT_RAW 0x00001
-
-#define vhd_flag_set(word, flag) ((word) |= (flag))
-#define vhd_flag_clear(word, flag) ((word) &= ~(flag))
-#define vhd_flag_test(word, flag) ((word) & (flag))
-
-
-#define ENABLE_FAILURE_TESTING
-#define FAIL_REPARENT_BEGIN 0
-#define FAIL_REPARENT_LOCATOR 1
-#define FAIL_REPARENT_END 2
-#define FAIL_RESIZE_BEGIN 3
-#define FAIL_RESIZE_DATA_MOVED 4
-#define FAIL_RESIZE_METADATA_MOVED 5
-#define FAIL_RESIZE_END 6
-#define NUM_FAIL_TESTS 7
-
-#ifdef ENABLE_FAILURE_TESTING
-#define TEST_FAIL_AT(point) \
- if (TEST_FAIL[point]) { \
- printf("Failing at %s\n", ENV_VAR_FAIL[point]); exit(EINVAL); }
-#define TEST_FAIL_EXTERN_VARS \
- extern const char* ENV_VAR_FAIL[]; \
- extern int TEST_FAIL[];
-#else
-#define TEST_FAIL_AT(point)
-#define TEST_FAIL_EXTERN_VARS
-#endif // ENABLE_FAILURE_TESTING
-
-
-static const char VHD_POISON_COOKIE[] = "v_poison";
-
-typedef struct hd_ftr vhd_footer_t;
-typedef struct dd_hdr vhd_header_t;
-typedef struct vhd_bat vhd_bat_t;
-typedef struct vhd_batmap vhd_batmap_t;
-typedef struct dd_batmap_hdr vhd_batmap_header_t;
-typedef struct prt_loc vhd_parent_locator_t;
-typedef struct vhd_context vhd_context_t;
-typedef uint32_t vhd_flag_creat_t;
-
-struct vhd_bat {
- uint32_t spb;
- uint32_t entries;
- uint32_t *bat;
-};
-
-struct vhd_batmap {
- vhd_batmap_header_t header;
- char *map;
-};
-
-struct vhd_context {
- int fd;
- char *file;
- int oflags;
- int is_block;
-
- uint32_t spb;
- uint32_t bm_secs;
-
- vhd_header_t header;
- vhd_footer_t footer;
- vhd_bat_t bat;
- vhd_batmap_t batmap;
-};
-
-static inline uint32_t
-secs_round_up(uint64_t bytes)
-{
- return ((bytes + (VHD_SECTOR_SIZE - 1)) >> VHD_SECTOR_SHIFT);
-}
-
-static inline uint32_t
-secs_round_up_no_zero(uint64_t bytes)
-{
- return (secs_round_up(bytes) ? : 1);
-}
-
-static inline uint64_t
-vhd_sectors_to_bytes(uint64_t sectors)
-{
- return sectors << VHD_SECTOR_SHIFT;
-}
-
-static inline uint64_t
-vhd_bytes_padded(uint64_t bytes)
-{
- return vhd_sectors_to_bytes(secs_round_up_no_zero(bytes));
-}
-
-static inline int
-vhd_type_dynamic(vhd_context_t *ctx)
-{
- return (ctx->footer.type == HD_TYPE_DYNAMIC ||
- ctx->footer.type == HD_TYPE_DIFF);
-}
-
-static inline int
-vhd_creator_tapdisk(vhd_context_t *ctx)
-{
- return !strncmp(ctx->footer.crtr_app, "tap", 3);
-}
-
-static inline int
-vhd_disabled(vhd_context_t *ctx)
-{
- return (!memcmp(ctx->footer.cookie,
- VHD_POISON_COOKIE, sizeof(ctx->footer.cookie)));
-}
-
-static inline size_t
-vhd_parent_locator_size(vhd_parent_locator_t *loc)
-{
- /*
- * MICROSOFT_COMPAT
- * data_space *should* be in sectors,
- * but sometimes we find it in bytes
- */
- if (loc->data_space < 512)
- return vhd_sectors_to_bytes(loc->data_space);
- else if (loc->data_space % 512 == 0)
- return loc->data_space;
- else
- return 0;
-}
-
-static inline int
-vhd_parent_raw(vhd_context_t *ctx)
-{
- return vhd_uuid_is_nil(&ctx->header.prt_uuid);
-}
-
-void libvhd_set_log_level(int);
-
-int vhd_test_file_fixed(const char *, int *);
-
-uint32_t vhd_time(time_t time);
-size_t vhd_time_to_string(uint32_t timestamp, char *target);
-uint32_t vhd_chs(uint64_t size);
-
-uint32_t vhd_checksum_footer(vhd_footer_t *);
-uint32_t vhd_checksum_header(vhd_header_t *);
-uint32_t vhd_checksum_batmap(vhd_batmap_t *);
-
-void vhd_footer_in(vhd_footer_t *);
-void vhd_footer_out(vhd_footer_t *);
-void vhd_header_in(vhd_header_t *);
-void vhd_header_out(vhd_header_t *);
-void vhd_bat_in(vhd_bat_t *);
-void vhd_bat_out(vhd_bat_t *);
-void vhd_batmap_header_in(vhd_batmap_t *);
-void vhd_batmap_header_out(vhd_batmap_t *);
-
-int vhd_validate_footer(vhd_footer_t *footer);
-int vhd_validate_header(vhd_header_t *header);
-int vhd_validate_batmap_header(vhd_batmap_t *batmap);
-int vhd_validate_batmap(vhd_batmap_t *batmap);
-int vhd_validate_platform_code(uint32_t code);
-
-int vhd_open(vhd_context_t *, const char *file, int flags);
-void vhd_close(vhd_context_t *);
-int vhd_create(const char *name, uint64_t bytes, int type, vhd_flag_creat_t);
-/* vhd_snapshot: the bytes parameter is optional and can be 0 if the snapshot
- * is to have the same size as the (first non-empty) parent */
-int vhd_snapshot(const char *snapshot, uint64_t bytes, const char *parent,
- vhd_flag_creat_t);
-
-int vhd_hidden(vhd_context_t *, int *);
-int vhd_chain_depth(vhd_context_t *, int *);
-
-off_t vhd_position(vhd_context_t *);
-int vhd_seek(vhd_context_t *, off_t, int);
-int vhd_read(vhd_context_t *, void *, size_t);
-int vhd_write(vhd_context_t *, void *, size_t);
-
-int vhd_offset(vhd_context_t *, uint32_t, uint32_t *);
-
-int vhd_end_of_headers(vhd_context_t *ctx, off_t *off);
-int vhd_end_of_data(vhd_context_t *ctx, off_t *off);
-int vhd_batmap_header_offset(vhd_context_t *ctx, off_t *off);
-
-int vhd_get_header(vhd_context_t *);
-int vhd_get_footer(vhd_context_t *);
-int vhd_get_bat(vhd_context_t *);
-int vhd_get_batmap(vhd_context_t *);
-
-void vhd_put_header(vhd_context_t *);
-void vhd_put_footer(vhd_context_t *);
-void vhd_put_bat(vhd_context_t *);
-void vhd_put_batmap(vhd_context_t *);
-
-int vhd_has_batmap(vhd_context_t *);
-int vhd_batmap_test(vhd_context_t *, vhd_batmap_t *, uint32_t);
-void vhd_batmap_set(vhd_context_t *, vhd_batmap_t *, uint32_t);
-void vhd_batmap_clear(vhd_context_t *, vhd_batmap_t *, uint32_t);
-
-int vhd_get_phys_size(vhd_context_t *, off_t *);
-int vhd_set_phys_size(vhd_context_t *, off_t);
-
-int vhd_bitmap_test(vhd_context_t *, char *, uint32_t);
-void vhd_bitmap_set(vhd_context_t *, char *, uint32_t);
-void vhd_bitmap_clear(vhd_context_t *, char *, uint32_t);
-
-int vhd_parent_locator_count(vhd_context_t *);
-int vhd_parent_locator_get(vhd_context_t *, char **);
-int vhd_parent_locator_read(vhd_context_t *, vhd_parent_locator_t *, char **);
-int vhd_find_parent(vhd_context_t *, const char *, char **);
-int vhd_parent_locator_write_at(vhd_context_t *, const char *,
- off_t, uint32_t, size_t,
- vhd_parent_locator_t *);
-
-int vhd_header_decode_parent(vhd_context_t *, vhd_header_t *, char **);
-int vhd_change_parent(vhd_context_t *, char *parent_path, int raw);
-
-int vhd_read_footer(vhd_context_t *, vhd_footer_t *);
-int vhd_read_footer_at(vhd_context_t *, vhd_footer_t *, off_t);
-int vhd_read_footer_strict(vhd_context_t *, vhd_footer_t *);
-int vhd_read_header(vhd_context_t *, vhd_header_t *);
-int vhd_read_header_at(vhd_context_t *, vhd_header_t *, off_t);
-int vhd_read_bat(vhd_context_t *, vhd_bat_t *);
-int vhd_read_batmap(vhd_context_t *, vhd_batmap_t *);
-int vhd_read_bitmap(vhd_context_t *, uint32_t block, char **bufp);
-int vhd_read_block(vhd_context_t *, uint32_t block, char **bufp);
-
-int vhd_write_footer(vhd_context_t *, vhd_footer_t *);
-int vhd_write_footer_at(vhd_context_t *, vhd_footer_t *, off_t);
-int vhd_write_header(vhd_context_t *, vhd_header_t *);
-int vhd_write_header_at(vhd_context_t *, vhd_header_t *, off_t);
-int vhd_write_bat(vhd_context_t *, vhd_bat_t *);
-int vhd_write_batmap(vhd_context_t *, vhd_batmap_t *);
-int vhd_write_bitmap(vhd_context_t *, uint32_t block, char *bitmap);
-int vhd_write_block(vhd_context_t *, uint32_t block, char *data);
-
-int vhd_io_read(vhd_context_t *, char *, uint64_t, uint32_t);
-int vhd_io_write(vhd_context_t *, char *, uint64_t, uint32_t);
-
-#endif
+++ /dev/null
-/*
- * list.h
- *
- * This is a subset of linux's list.h intended to be used in user-space.
- * XXX The namespace conflicts with NetBSD's <sys/queue.h>
- *
- */
-
-#ifndef __LIST_H__
-#define __LIST_H__
-
-#define LIST_POISON1 ((void *) 0x00100100)
-#define LIST_POISON2 ((void *) 0x00200200)
-
-struct list_head {
- struct list_head *next, *prev;
-};
-
-/* XXX workaround for conflicts. The list API should use its own
- * namespace prefix, i.e. BLK_
- */
-#ifdef LIST_HEAD_INIT
-#undef LIST_HEAD_INIT
-#endif
-#ifndef LIST_HEAD
-#undef LIST_HEAD
-#endif
-
-#define LIST_HEAD_INIT(name) { &(name), &(name) }
-
-#define LIST_HEAD(name) \
- struct list_head name = LIST_HEAD_INIT(name)
-
-static inline void INIT_LIST_HEAD(struct list_head *list)
-{
- list->next = list;
- list->prev = list;
-}
-
-static inline void __list_add(struct list_head *new,
- struct list_head *prev,
- struct list_head *next)
-{
- next->prev = new;
- new->next = next;
- new->prev = prev;
- prev->next = new;
-}
-
-static inline void list_add(struct list_head *new, struct list_head *head)
-{
- __list_add(new, head, head->next);
-}
-
-static inline void list_add_tail(struct list_head *new, struct list_head *head)
-{
- __list_add(new, head->prev, head);
-}
-
-static inline void __list_del(struct list_head * prev, struct list_head * next)
-{
- next->prev = prev;
- prev->next = next;
-}
-
-static inline void list_del(struct list_head *entry)
-{
- __list_del(entry->prev, entry->next);
- entry->next = LIST_POISON1;
- entry->prev = LIST_POISON2;
-}
-
-static inline void list_del_init(struct list_head *entry)
-{
- __list_del(entry->prev, entry->next);
- INIT_LIST_HEAD(entry);
-}
-
-static inline int list_empty(const struct list_head *head)
-{
- return head->next == head;
-}
-
-static inline int list_is_last(const struct list_head *list,
- const struct list_head *head)
-{
- return list->next == head;
-}
-
-static inline void __list_splice(const struct list_head *list,
- struct list_head *prev,
- struct list_head *next)
-{
- struct list_head *first = list->next;
- struct list_head *last = list->prev;
-
- first->prev = prev;
- prev->next = first;
-
- last->next = next;
- next->prev = last;
-}
-
-static inline void list_splice(const struct list_head *list,
- struct list_head *head)
-{
- if (!list_empty(list))
- __list_splice(list, head, head->next);
-}
-
-#define list_entry(ptr, type, member) \
- ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
-
-#define list_for_each_entry(pos, head, member) \
- for (pos = list_entry((head)->next, typeof(*pos), member); \
- &pos->member != (head); \
- pos = list_entry(pos->member.next, typeof(*pos), member))
-
-#define list_for_each_entry_safe(pos, n, head, member) \
- for (pos = list_entry((head)->next, typeof(*pos), member), \
- n = list_entry(pos->member.next, typeof(*pos), member); \
- &pos->member != (head); \
- pos = n, n = list_entry(n->member.next, typeof(*n), member))
-
-#endif /* __LIST_H__ */
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#ifndef _LVM_UTIL_H_
-#define _LVM_UTIL_H_
-
-#include <inttypes.h>
-
-#define MAX_NAME_SIZE 256
-
-#define LVM_SEG_TYPE_LINEAR 1
-#define LVM_SEG_TYPE_UNKNOWN 2
-
-struct lv_segment {
- uint8_t type;
- char device[MAX_NAME_SIZE];
- uint64_t pe_start;
- uint64_t pe_size;
-};
-
-struct lv {
- char name[MAX_NAME_SIZE];
- uint64_t size;
- uint32_t segments;
- struct lv_segment first_segment;
-};
-
-struct pv {
- char name[MAX_NAME_SIZE];
- uint64_t start;
-};
-
-struct vg {
- char name[MAX_NAME_SIZE];
- uint64_t extent_size;
-
- int pv_cnt;
- struct pv *pvs;
-
- int lv_cnt;
- struct lv *lvs;
-};
-
-int lvm_scan_vg(const char *vg_name, struct vg *vg);
-void lvm_free_vg(struct vg *vg);
-
-#endif
+++ /dev/null
-/* Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#ifndef _RELATIVE_PATH_H_
-#define _RELATIVE_PATH_H_
-
-#include <syslog.h>
-
-#define DELIMITER '/'
-#define MAX_NAME_LEN 1000
-
-#define EPRINTF(_f, _a...) syslog(LOG_ERR, "tap-err:%s: " _f, __func__, ##_a)
-
-/*
- * returns a relative path from @src to @dest
- * result should be freed
- */
-char *relative_path_to(char *src, char *dest, int *err);
-
-#endif
+++ /dev/null
-/* Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#ifndef _TAPDISK_MESSAGE_H_
-#define _TAPDISK_MESSAGE_H_
-
-#include <inttypes.h>
-#include <sys/types.h>
-
-#define TAPDISK_MESSAGE_MAX_PATH_LENGTH 256
-#define TAPDISK_MESSAGE_STRING_LENGTH 256
-
-#define TAPDISK_MESSAGE_MAX_MINORS \
- ((TAPDISK_MESSAGE_MAX_PATH_LENGTH / sizeof(int)) - 1)
-
-#define TAPDISK_MESSAGE_FLAG_SHARED 0x01
-#define TAPDISK_MESSAGE_FLAG_RDONLY 0x02
-#define TAPDISK_MESSAGE_FLAG_ADD_CACHE 0x04
-#define TAPDISK_MESSAGE_FLAG_VHD_INDEX 0x08
-#define TAPDISK_MESSAGE_FLAG_LOG_DIRTY 0x10
-
-typedef struct tapdisk_message tapdisk_message_t;
-typedef uint8_t tapdisk_message_flag_t;
-typedef struct tapdisk_message_image tapdisk_message_image_t;
-typedef struct tapdisk_message_params tapdisk_message_params_t;
-typedef struct tapdisk_message_string tapdisk_message_string_t;
-typedef struct tapdisk_message_response tapdisk_message_response_t;
-typedef struct tapdisk_message_minors tapdisk_message_minors_t;
-typedef struct tapdisk_message_list tapdisk_message_list_t;
-
-struct tapdisk_message_params {
- tapdisk_message_flag_t flags;
-
- uint8_t storage;
- uint32_t devnum;
- uint32_t domid;
- uint16_t path_len;
- char path[TAPDISK_MESSAGE_MAX_PATH_LENGTH];
-};
-
-struct tapdisk_message_image {
- uint64_t sectors;
- uint32_t sector_size;
- uint32_t info;
-};
-
-struct tapdisk_message_string {
- char text[TAPDISK_MESSAGE_STRING_LENGTH];
-};
-
-struct tapdisk_message_response {
- int error;
- char message[TAPDISK_MESSAGE_STRING_LENGTH];
-};
-
-struct tapdisk_message_minors {
- int count;
- int list[TAPDISK_MESSAGE_MAX_MINORS];
-};
-
-struct tapdisk_message_list {
- int count;
- int minor;
- int state;
- char path[TAPDISK_MESSAGE_MAX_PATH_LENGTH];
-};
-
-struct tapdisk_message {
- uint16_t type;
- uint16_t cookie;
-
- union {
- pid_t tapdisk_pid;
- tapdisk_message_image_t image;
- tapdisk_message_params_t params;
- tapdisk_message_string_t string;
- tapdisk_message_minors_t minors;
- tapdisk_message_response_t response;
- tapdisk_message_list_t list;
- } u;
-};
-
-enum tapdisk_message_id {
- TAPDISK_MESSAGE_ERROR = 1,
- TAPDISK_MESSAGE_RUNTIME_ERROR,
- TAPDISK_MESSAGE_PID,
- TAPDISK_MESSAGE_PID_RSP,
- TAPDISK_MESSAGE_ATTACH,
- TAPDISK_MESSAGE_ATTACH_RSP,
- TAPDISK_MESSAGE_OPEN,
- TAPDISK_MESSAGE_OPEN_RSP,
- TAPDISK_MESSAGE_PAUSE,
- TAPDISK_MESSAGE_PAUSE_RSP,
- TAPDISK_MESSAGE_RESUME,
- TAPDISK_MESSAGE_RESUME_RSP,
- TAPDISK_MESSAGE_CLOSE,
- TAPDISK_MESSAGE_CLOSE_RSP,
- TAPDISK_MESSAGE_DETACH,
- TAPDISK_MESSAGE_DETACH_RSP,
- TAPDISK_MESSAGE_LIST_MINORS,
- TAPDISK_MESSAGE_LIST_MINORS_RSP,
- TAPDISK_MESSAGE_LIST,
- TAPDISK_MESSAGE_LIST_RSP,
- TAPDISK_MESSAGE_FORCE_SHUTDOWN,
- TAPDISK_MESSAGE_EXIT,
-};
-
-static inline char *
-tapdisk_message_name(enum tapdisk_message_id id)
-{
- switch (id) {
- case TAPDISK_MESSAGE_ERROR:
- return "error";
-
- case TAPDISK_MESSAGE_PID:
- return "pid";
-
- case TAPDISK_MESSAGE_PID_RSP:
- return "pid response";
-
- case TAPDISK_MESSAGE_OPEN:
- return "open";
-
- case TAPDISK_MESSAGE_OPEN_RSP:
- return "open response";
-
- case TAPDISK_MESSAGE_PAUSE:
- return "pause";
-
- case TAPDISK_MESSAGE_PAUSE_RSP:
- return "pause response";
-
- case TAPDISK_MESSAGE_RESUME:
- return "resume";
-
- case TAPDISK_MESSAGE_RESUME_RSP:
- return "resume response";
-
- case TAPDISK_MESSAGE_CLOSE:
- return "close";
-
- case TAPDISK_MESSAGE_FORCE_SHUTDOWN:
- return "force shutdown";
-
- case TAPDISK_MESSAGE_CLOSE_RSP:
- return "close response";
-
- case TAPDISK_MESSAGE_ATTACH:
- return "attach";
-
- case TAPDISK_MESSAGE_ATTACH_RSP:
- return "attach response";
-
- case TAPDISK_MESSAGE_DETACH:
- return "detach";
-
- case TAPDISK_MESSAGE_DETACH_RSP:
- return "detach response";
-
- case TAPDISK_MESSAGE_LIST_MINORS:
- return "list minors";
-
- case TAPDISK_MESSAGE_LIST_MINORS_RSP:
- return "list minors response";
-
- case TAPDISK_MESSAGE_LIST:
- return "list";
-
- case TAPDISK_MESSAGE_LIST_RSP:
- return "list response";
-
- case TAPDISK_MESSAGE_EXIT:
- return "exit";
-
- default:
- return "unknown";
- }
-}
-
-#endif
+++ /dev/null
-/* Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#ifndef _VHD_UTIL_H_
-#define _VHD_UTIL_H_
-
-int vhd_util_create(int argc, char **argv);
-int vhd_util_snapshot(int argc, char **argv);
-int vhd_util_query(int argc, char **argv);
-int vhd_util_read(int argc, char **argv);
-int vhd_util_set_field(int argc, char **argv);
-int vhd_util_repair(int argc, char **argv);
-int vhd_util_fill(int argc, char **argv);
-int vhd_util_resize(int argc, char **argv);
-int vhd_util_coalesce(int argc, char **argv);
-int vhd_util_modify(int argc, char **argv);
-int vhd_util_scan(int argc, char **argv);
-int vhd_util_check(int argc, char **argv);
-int vhd_util_revert(int argc, char **argv);
-
-#endif
+++ /dev/null
-/* Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#ifndef __BLKTAP2_VHD_UUID_H__
-#define __BLKTAP2_VHD_UUID_H__
-
-#if defined(__linux__)
-
-#include <uuid/uuid.h>
-typedef struct {
- uuid_t uuid;
-} vhd_uuid_t;
-
-#elif defined(__NetBSD__)
-
-#include <uuid.h>
-
-typedef uuid_t vhd_uuid_t;
-
-#else
-
-#error "Please update vhd-uuid.h for your OS"
-
-#endif
-
-int vhd_uuid_is_nil(vhd_uuid_t *uuid);
-
-void vhd_uuid_generate(vhd_uuid_t *uuid);
-
-void vhd_uuid_to_string(vhd_uuid_t *uuid, char *out, size_t size);
-
-void vhd_uuid_from_string(vhd_uuid_t *uuid, const char *in);
-
-void vhd_uuid_copy(vhd_uuid_t *dst, vhd_uuid_t *src);
-
-void vhd_uuid_clear(vhd_uuid_t *uuid);
-
-int vhd_uuid_compare(vhd_uuid_t *uuid1, vhd_uuid_t *uuid2);
-
-#endif /* __BLKTAP2_VHD_UUID_H__ */
+++ /dev/null
-/* Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#ifndef __VHD_H__
-#define __VHD_H__
-
-#include <inttypes.h>
-
-typedef uint32_t u32;
-typedef uint64_t u64;
-
-#define DEBUG 1
-
-/* ---------------------------------------------------------------------- */
-/* General definitions. */
-/* ---------------------------------------------------------------------- */
-
-#define VHD_SECTOR_SIZE 512
-#define VHD_SECTOR_SHIFT 9
-
-/* ---------------------------------------------------------------------- */
-/* This is the generic disk footer, used by all disks. */
-/* ---------------------------------------------------------------------- */
-
-struct hd_ftr {
- char cookie[8]; /* Identifies original creator of the disk */
- u32 features; /* Feature Support -- see below */
- u32 ff_version; /* (major,minor) version of disk file */
- u64 data_offset; /* Abs. offset from SOF to next structure */
- u32 timestamp; /* Creation time. secs since 1/1/2000GMT */
- char crtr_app[4]; /* Creator application */
- u32 crtr_ver; /* Creator version (major,minor) */
- u32 crtr_os; /* Creator host OS */
- u64 orig_size; /* Size at creation (bytes) */
- u64 curr_size; /* Current size of disk (bytes) */
- u32 geometry; /* Disk geometry */
- u32 type; /* Disk type */
- u32 checksum; /* 1's comp sum of this struct. */
- vhd_uuid_t uuid; /* Unique disk ID, used for naming parents */
- char saved; /* one-bit -- is this disk/VM in a saved state? */
- char hidden; /* tapdisk-specific field: is this vdi hidden? */
- char reserved[426]; /* padding */
-};
-
-/* VHD cookie string. */
-static const char HD_COOKIE[9] = "conectix";
-
-/* Feature fields in hd_ftr */
-#define HD_NO_FEATURES 0x00000000
-#define HD_TEMPORARY 0x00000001 /* disk can be deleted on shutdown */
-#define HD_RESERVED 0x00000002 /* NOTE: must always be set */
-
-/* Version field in hd_ftr */
-#define HD_FF_VERSION 0x00010000
-
-/* Known creator OS type fields in hd_ftr.crtr_os */
-#define HD_CR_OS_WINDOWS 0x5769326B /* (Wi2k) */
-#define HD_CR_OS_MACINTOSH 0x4D616320 /* (Mac ) */
-
-/*
- * version 0.1: little endian bitmaps
- * version 1.1: big endian bitmaps; batmap
- * version 1.2: libvhd
- * version 1.3: batmap version bump to 1.2
- */
-#define VHD_VERSION(major, minor) (((major) << 16) | ((minor) & 0x0000FFFF))
-#define VHD_CURRENT_VERSION VHD_VERSION(1, 3)
-
-/* Disk geometry accessor macros. */
-/* Geometry is a triple of (cylinders (2 bytes), tracks (1 byte), and
- * secotrs-per-track (1 byte))
- */
-#define GEOM_GET_CYLS(_g) (((_g) >> 16) & 0xffff)
-#define GEOM_GET_HEADS(_g) (((_g) >> 8) & 0xff)
-#define GEOM_GET_SPT(_g) ((_g) & 0xff)
-
-#define GEOM_ENCODE(_c, _h, _s) (((_c) << 16) | ((_h) << 8) | (_s))
-
-/* type field in hd_ftr */
-#define HD_TYPE_NONE 0
-#define HD_TYPE_FIXED 2 /* fixed-allocation disk */
-#define HD_TYPE_DYNAMIC 3 /* dynamic disk */
-#define HD_TYPE_DIFF 4 /* differencing disk */
-
-/* String table for hd.type */
-static const char *HD_TYPE_STR[7] = {
- "None", /* 0 */
- "Reserved (deprecated)", /* 1 */
- "Fixed hard disk", /* 2 */
- "Dynamic hard disk", /* 3 */
- "Differencing hard disk", /* 4 */
- "Reserved (deprecated)", /* 5 */
- "Reserved (deprecated)" /* 6 */
-};
-
-#define HD_TYPE_MAX 6
-
-struct prt_loc {
- u32 code; /* Platform code -- see defines below. */
- u32 data_space; /* Number of 512-byte sectors to store locator */
- u32 data_len; /* Actual length of parent locator in bytes */
- u32 res; /* Must be zero */
- u64 data_offset; /* Absolute offset of locator data (bytes) */
-};
-
-/* Platform Codes */
-#define PLAT_CODE_NONE 0x0
-#define PLAT_CODE_WI2R 0x57693272 /* deprecated */
-#define PLAT_CODE_WI2K 0x5769326B /* deprecated */
-#define PLAT_CODE_W2RU 0x57327275 /* Windows relative path (UTF-16) */
-#define PLAT_CODE_W2KU 0x57326B75 /* Windows absolute path (UTF-16) */
-#define PLAT_CODE_MAC 0x4D616320 /* MacOS alias stored as a blob. */
-#define PLAT_CODE_MACX 0x4D616358 /* File URL (UTF-8), see RFC 2396. */
-
-/* ---------------------------------------------------------------------- */
-/* This is the dynamic disk header. */
-/* ---------------------------------------------------------------------- */
-
-struct dd_hdr {
- char cookie[8]; /* Should contain "cxsparse" */
- u64 data_offset; /* Byte offset of next record. (Unused) 0xffs */
- u64 table_offset; /* Absolute offset to the BAT. */
- u32 hdr_ver; /* Version of the dd_hdr (major,minor) */
- u32 max_bat_size; /* Maximum number of entries in the BAT */
- u32 block_size; /* Block size in bytes. Must be power of 2. */
- u32 checksum; /* Header checksum. 1's comp of all fields. */
- vhd_uuid_t prt_uuid; /* ID of the parent disk. */
- u32 prt_ts; /* Modification time of the parent disk */
- u32 res1; /* Reserved. */
- char prt_name[512]; /* Parent unicode name. */
- struct prt_loc loc[8]; /* Parent locator entries. */
- char res2[256]; /* Reserved. */
-};
-
-/* VHD cookie string. */
-static const char DD_COOKIE[9] = "cxsparse";
-
-/* Version field in hd_ftr */
-#define DD_VERSION 0x00010000
-
-/* Default blocksize is 2 meg. */
-#define DD_BLOCKSIZE_DEFAULT 0x00200000
-
-#define DD_BLK_UNUSED 0xFFFFFFFF
-
-struct dd_batmap_hdr {
- char cookie[8]; /* should contain "tdbatmap" */
- u64 batmap_offset; /* byte offset to batmap */
- u32 batmap_size; /* batmap size in sectors */
- u32 batmap_version; /* version of batmap */
- u32 checksum; /* batmap checksum -- 1's complement of batmap */
-};
-
-static const char VHD_BATMAP_COOKIE[9] = "tdbatmap";
-
-/*
- * version 1.1: signed char checksum
- */
-#define VHD_BATMAP_VERSION(major, minor) (((major) << 16) | ((minor) & 0x0000FFFF))
-#define VHD_BATMAP_CURRENT_VERSION VHD_BATMAP_VERSION(1, 2)
-
-/* Layout of a dynamic disk:
- *
- * +-------------------------------------------------+
- * | Mirror image of HD footer (hd_ftr) (512 bytes) |
- * +-------------------------------------------------+
- * | Sparse drive header (dd_hdr) (1024 bytes) |
- * +-------------------------------------------------+
- * | BAT (Block allocation table) |
- * | - Array of absolute sector offsets into the |
- * | file (u32). |
- * | - Rounded up to a sector boundary. |
- * | - Unused entries are marked as 0xFFFFFFFF |
- * | - max entries in dd_hdr->max_bat_size |
- * +-------------------------------------------------+
- * | Data Block 0 |
- * | Bitmap (padded to 512 byte sector boundary) |
- * | - each bit indicates whether the associated |
- * | sector within this block is used. |
- * | Data |
- * | - power-of-two multiple of sectors. |
- * | - default 2MB (4096 * 512) |
- * | - Any entries with zero in bitmap should be |
- * | zero on disk |
- * +-------------------------------------------------+
- * | Data Block 1 |
- * +-------------------------------------------------+
- * | ... |
- * +-------------------------------------------------+
- * | Data Block n |
- * +-------------------------------------------------+
- * | HD Footer (511 bytes) |
- * +-------------------------------------------------+
- */
-
-#endif
+++ /dev/null
-XEN_ROOT = $(CURDIR)/../../..
-BLKTAP_ROOT := ..
-include $(XEN_ROOT)/tools/Rules.mk
-
-ifeq ($(LVM_UTIL_TEST),y)
-TEST := lvm-util
-endif
-
-CFLAGS += -Werror
-CFLAGS += -Wno-unused
-CFLAGS += -I../include
-CFLAGS += -D_GNU_SOURCE
-
-ifeq ($(CONFIG_X86_64),y)
-CFLAGS += -fPIC
-endif
-
-LVM-OBJS := lvm-util.o
-
-all: build
-
-build: $(TEST) $(LVM-OBJS)
-
-install: all
-
-uninstall:
-
-lvm-util: lvm-util.o
- $(CC) -DLVM_UTIL $(LDFLAGS) -o lvm-util lvm-util.c
-
-clean:
- rm -rf *.o *.opic *~ $(DEPS_RM) $(IBIN)
-
-distclean: clean
-
-.PHONY: all build clean distclean install lvm-util uninstall
-
--include $(DEPS_INCLUDE)
+++ /dev/null
-/*
- * Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include <stdio.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "lvm-util.h"
-
-#define _NAME "%255s"
-static char line[1024];
-
-static inline int
-lvm_read_line(FILE *scan)
-{
- memset(line, 0, sizeof(line));
- return (fscanf(scan, "%1023[^\n]", line) != 1);
-}
-
-static inline int
-lvm_next_line(FILE *scan)
-{
- return (fscanf(scan, "%1023[\n]", line) != 1);
-}
-
-static int
-lvm_copy_name(char *dst, const char *src, size_t size)
-{
- if (strnlen(src, size) == size)
- return -ENAMETOOLONG;
-
- strcpy(dst, src);
- return 0;
-}
-
-static int
-lvm_parse_pv(struct vg *vg, const char *name, int pvs, uint64_t start)
-{
- int i, err;
- struct pv *pv;
-
- pv = NULL;
-
- if (!vg->pvs) {
- vg->pvs = calloc(pvs, sizeof(struct pv));
- if (!vg->pvs)
- return -ENOMEM;
- }
-
- for (i = 0; i < pvs; i++) {
- pv = vg->pvs + i;
-
- if (!pv->name[0])
- break;
-
- if (!strcmp(pv->name, name))
- return -EEXIST;
- }
-
- if (!pv)
- return -ENOENT;
-
- if (i == pvs)
- return -ENOMEM;
-
- err = lvm_copy_name(pv->name, name, sizeof(pv->name) - 1);
- if (err)
- return err;
-
- pv->start = start;
- return 0;
-}
-
-static int
-lvm_open_vg(const char *vgname, struct vg *vg)
-{
- FILE *scan;
- int i, err, pvs, lvs;
- char *cmd, pvname[256];
- uint64_t size, pv_start;
-
- memset(vg, 0, sizeof(*vg));
-
- err = asprintf(&cmd, "/usr/sbin/vgs %s --noheadings --nosuffix --units=b "
- "--options=vg_name,vg_extent_size,lv_count,pv_count,"
- "pv_name,pe_start --unbuffered 2> /dev/null", vgname);
- if (err == -1)
- return -ENOMEM;
-
- errno = 0;
- scan = popen(cmd, "r");
- if (!scan) {
- err = (errno ? -errno : ENOMEM);
- goto out;
- }
-
- for (;;) {
- if (lvm_read_line(scan))
- break;
-
- err = -EINVAL;
- if (sscanf(line, _NAME" %"SCNu64" %d %d "_NAME" %"SCNu64,
- vg->name, &size, &lvs, &pvs, pvname, &pv_start) != 6)
- goto out;
-
- if (strcmp(vg->name, vgname))
- goto out;
-
- err = lvm_parse_pv(vg, pvname, pvs, pv_start);
- if (err)
- goto out;
-
- if (lvm_next_line(scan))
- break;
- }
-
- err = -EINVAL;
- if (strcmp(vg->name, vgname))
- goto out;
-
- for (i = 0; i < pvs; i++)
- if (!vg->pvs[i].name[0])
- goto out;
-
- err = -ENOMEM;
- vg->lvs = calloc(lvs, sizeof(struct lv));
- if (!vg->lvs)
- goto out;
-
- err = 0;
- vg->lv_cnt = lvs;
- vg->pv_cnt = pvs;
- vg->extent_size = size;
-
-out:
- if (scan)
- pclose(scan);
- if (err)
- lvm_free_vg(vg);
- free(cmd);
- return err;
-}
-
-static int
-lvm_parse_lv_devices(struct vg *vg, struct lv_segment *seg, char *devices)
-{
- int i;
- uint64_t start, pe_start;
-
- for (i = 0; i < strlen(devices); i++)
- if (strchr(",()", devices[i]))
- devices[i] = ' ';
-
- if (sscanf(devices, _NAME" %"SCNu64, seg->device, &start) != 2)
- return -EINVAL;
-
- pe_start = -1;
- for (i = 0; i < vg->pv_cnt; i++)
- if (!strcmp(vg->pvs[i].name, seg->device)) {
- pe_start = vg->pvs[i].start;
- break;
- }
-
- if (pe_start == -1)
- return -EINVAL;
-
- seg->pe_start = (start * vg->extent_size) + pe_start;
- return 0;
-}
-
-static int
-lvm_scan_lvs(struct vg *vg)
-{
- char *cmd;
- FILE *scan;
- int i, err;
-
- err = asprintf(&cmd, "/usr/sbin/lvs %s --noheadings --nosuffix --units=b "
- "--options=lv_name,lv_size,segtype,seg_count,seg_start,"
- "seg_size,devices --unbuffered 2> /dev/null", vg->name);
- if (err == -1)
- return -ENOMEM;
-
- errno = 0;
- scan = popen(cmd, "r");
- if (!scan) {
- err = (errno ? -errno : -ENOMEM);
- goto out;
- }
-
- for (i = 0;;) {
- int segs;
- struct lv *lv;
- struct lv_segment seg;
- uint64_t size, seg_start;
- char type[32], name[256], dev[256], devices[1024];
-
- if (i >= vg->lv_cnt)
- break;
-
- if (lvm_read_line(scan)) {
- vg->lv_cnt = i;
- break;
- }
-
- err = -EINVAL;
- lv = vg->lvs + i;
-
- if (sscanf(line, _NAME" %"SCNu64" %31s %u %"SCNu64" %"SCNu64" %1023s",
- name, &size, type, &segs, &seg_start,
- &seg.pe_size, devices) != 7)
- goto out;
-
- if (seg_start)
- goto next;
-
- if (!strcmp(type, "linear"))
- seg.type = LVM_SEG_TYPE_LINEAR;
- else
- seg.type = LVM_SEG_TYPE_UNKNOWN;
-
- if (lvm_parse_lv_devices(vg, &seg, devices))
- goto out;
-
- i++;
- lv->size = size;
- lv->segments = segs;
- lv->first_segment = seg;
-
- err = lvm_copy_name(lv->name, name, sizeof(lv->name) - 1);
- if (err)
- goto out;
- err = -EINVAL;
-
- next:
- if (lvm_next_line(scan))
- goto out;
- }
-
- err = 0;
-
-out:
- if (scan)
- pclose(scan);
- free(cmd);
- return err;
-}
-
-void
-lvm_free_vg(struct vg *vg)
-{
- free(vg->lvs);
- free(vg->pvs);
- memset(vg, 0, sizeof(*vg));
-}
-
-int
-lvm_scan_vg(const char *vg_name, struct vg *vg)
-{
- int err;
-
- memset(vg, 0, sizeof(*vg));
-
- err = lvm_open_vg(vg_name, vg);
- if (err)
- return err;
-
- err = lvm_scan_lvs(vg);
- if (err) {
- lvm_free_vg(vg);
- return err;
- }
-
- return 0;
-}
-
-#ifdef LVM_UTIL
-static int
-usage(void)
-{
- printf("usage: lvm-util <vgname>\n");
- exit(EINVAL);
-}
-
-int
-main(int argc, char **argv)
-{
- int i, err;
- struct vg vg;
- struct pv *pv;
- struct lv *lv;
- struct lv_segment *seg;
-
- if (argc != 2)
- usage();
-
- err = lvm_scan_vg(argv[1], &vg);
- if (err) {
- printf("scan failed: %d\n", err);
- return (err >= 0 ? err : -err);
- }
-
-
- printf("vg %s: extent_size: %"PRIu64", pvs: %d, lvs: %d\n",
- vg.name, vg.extent_size, vg.pv_cnt, vg.lv_cnt);
-
- for (i = 0; i < vg.pv_cnt; i++) {
- pv = vg.pvs + i;
- printf("pv %s: start %"PRIu64"\n", pv->name, pv->start);
- }
-
- for (i = 0; i < vg.lv_cnt; i++) {
- lv = vg.lvs + i;
- seg = &lv->first_segment;
- printf("lv %s: size: %"PRIu64", segments: %u, type: %u, "
- "dev: %s, pe_start: %"PRIu64", pe_size: %"PRIu64"\n",
- lv->name, lv->size, lv->segments, seg->type,
- seg->device, seg->pe_start, seg->pe_size);
- }
-
- lvm_free_vg(&vg);
- return 0;
-}
-#endif
+++ /dev/null
-XEN_ROOT=$(CURDIR)/../../..
-BLKTAP_ROOT := ..
-include $(XEN_ROOT)/tools/Rules.mk
-
-SUBDIRS-y :=
-SUBDIRS-y += lib
-
-IBIN = vhd-util vhd-update
-INST_DIR = $(sbindir)
-
-CFLAGS += -Werror
-CFLAGS += -Wno-unused
-CFLAGS += -I../include
-CFLAGS += -D_GNU_SOURCE
-
-ifeq ($(CONFIG_X86_64),y)
-CFLAGS += -fPIC
-endif
-
-ifeq ($(VHD_STATIC),y)
-CFLAGS += -static
-endif
-
-LIBS := -Llib -lvhd
-
-all: subdirs-all build
-
-build: $(IBIN)
-
-LIBS_DEPENDS := lib/libvhd.so lib/vhd.a
-$(LIBS_DEPENDS):subdirs-all
-
-vhd-util: vhd-util.o $(LIBS_DEPENDS)
- $(CC) $(LDFLAGS) -o vhd-util vhd-util.o $(LIBS) $(APPEND_LDFLAGS)
-
-vhd-update: vhd-update.o $(LIBS_DEPENDS)
- $(CC) $(LDFLAGS) -o vhd-update vhd-update.o $(LIBS) $(APPEND_LDFLAGS)
-
-install: all
- $(MAKE) subdirs-install
- $(INSTALL_DIR) -p $(DESTDIR)$(INST_DIR)
- $(INSTALL_PROG) $(IBIN) $(DESTDIR)$(INST_DIR)
-
-uninstall:
- $(MAKE) subdirs-uninstall
- rm -f $(addprefix $(DESTDIR)$(INST_DIR)/, $(IBIN))
-
-clean: subdirs-clean
- rm -rf *.o *~ $(DEPS_RM) $(IBIN)
-
-distclean: clean
-
-.PHONY: all build clean distclean install uninstall vhd-util vhd-update
-
--include $(DEPS_INCLUDE)
+++ /dev/null
-XEN_ROOT=$(CURDIR)/../../../..
-BLKTAP_ROOT := ../..
-include $(XEN_ROOT)/tools/Rules.mk
-
-LIBVHD-MAJOR = 1.0
-LIBVHD-MINOR = 0
-LIBVHD-SONAME = libvhd.so.$(LIBVHD-MAJOR)
-
-LVM-UTIL-OBJ := $(BLKTAP_ROOT)/lvm/lvm-util.o
-
-LIBVHD-BUILD := libvhd.a
-
-INST-DIR = $(libdir)
-
-CFLAGS += -Werror
-CFLAGS += -Wno-unused
-CFLAGS += -I../../include
-CFLAGS += -D_GNU_SOURCE
-CFLAGS += -fPIC
-
-ifeq ($(CONFIG_Linux),y)
-LIBS := -luuid
-endif
-
-ifeq ($(CONFIG_LIBICONV),y)
-LIBS += -liconv
-endif
-
-LIB-SRCS := libvhd.c
-LIB-SRCS += libvhd-journal.c
-LIB-SRCS += vhd-util-coalesce.c
-LIB-SRCS += vhd-util-create.c
-LIB-SRCS += vhd-util-fill.c
-LIB-SRCS += vhd-util-modify.c
-LIB-SRCS += vhd-util-query.c
-LIB-SRCS += vhd-util-read.c
-LIB-SRCS += vhd-util-repair.c
-LIB-SRCS += vhd-util-resize.c
-LIB-SRCS += vhd-util-revert.c
-LIB-SRCS += vhd-util-set-field.c
-LIB-SRCS += vhd-util-snapshot.c
-LIB-SRCS += vhd-util-scan.c
-LIB-SRCS += vhd-util-check.c
-LIB-SRCS += vhd-util-uuid.c
-LIB-SRCS += relative-path.c
-LIB-SRCS += atomicio.c
-
-LIB-OBJS = $(patsubst %.c,%.o,$(LIB-SRCS))
-LIB-OBJS += $(LVM-UTIL-OBJ)
-
-LIB-PICOBJS = $(patsubst %.o,%.opic,$(LIB-OBJS))
-
-LIBVHD = libvhd.a libvhd.so.$(LIBVHD-MAJOR).$(LIBVHD-MINOR)
-
-all: build
-
-build: libvhd.a libvhd.so.$(LIBVHD-MAJOR).$(LIBVHD-MINOR)
-
-libvhd.a: $(LIB-OBJS)
- $(AR) rc $@ $^
-
-libvhd.so.$(LIBVHD-MAJOR).$(LIBVHD-MINOR): $(LIB-PICOBJS)
- $(CC) -Wl,$(SONAME_LDFLAG),$(LIBVHD-SONAME) $(SHLIB_LDFLAGS) \
- $(LDFLAGS) -o libvhd.so.$(LIBVHD-MAJOR).$(LIBVHD-MINOR) $^ $(LIBS)
- ln -sf libvhd.so.$(LIBVHD-MAJOR).$(LIBVHD-MINOR) libvhd.so.$(LIBVHD-MAJOR)
- ln -sf libvhd.so.$(LIBVHD-MAJOR) libvhd.so
-
-install: all
- $(INSTALL_DIR) -p $(DESTDIR)$(INST-DIR)
- $(INSTALL_DATA) libvhd.a $(DESTDIR)$(INST-DIR)
- $(INSTALL_PROG) libvhd.so.$(LIBVHD-MAJOR).$(LIBVHD-MINOR) $(DESTDIR)$(INST-DIR)
- ln -sf libvhd.so.$(LIBVHD-MAJOR).$(LIBVHD-MINOR) $(DESTDIR)$(INST-DIR)/libvhd.so.$(LIBVHD-MAJOR)
- ln -sf libvhd.so.$(LIBVHD-MAJOR) $(DESTDIR)$(INST-DIR)/libvhd.so
-
-uninstall:
- rm -f $(DESTDIR)$(INST-DIR)/libvhd.so
- rm -f $(DESTDIR)$(INST-DIR)/libvhd.so.$(LIBVHD-MAJOR)
- rm -f $(DESTDIR)$(INST-DIR)/libvhd.so.$(LIBVHD-MAJOR).$(LIBVHD-MINOR)
- rm -f $(DESTDIR)$(INST-DIR)/libvhd.a
-
-clean:
- rm -rf *.a *.so* *.o *.opic *~ $(DEPS_RM) $(LIBVHD)
-
-distclean: clean
-
-.PHONY: all build clean distclean install libvhd uninstall
-
--include $(DEPS_INCLUDE)
+++ /dev/null
-/*
- * Copyright (c) 2005 Anil Madhavapeddy. All rights reserved.
- * Copyright (c) 1995,1999 Theo de Raadt. All rights reserved.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include <stdlib.h>
-#include <errno.h>
-#include "atomicio.h"
-
-/*
- * ensure all of data on socket comes through. f==read || f==vwrite
- */
-size_t
-atomicio(f, fd, _s, n)
- ssize_t (*f) (int, void *, size_t);
- int fd;
- void *_s;
- size_t n;
-{
- char *s = _s;
- size_t pos = 0;
- ssize_t res;
-
- while (n > pos) {
- res = (f) (fd, s + pos, n - pos);
- switch (res) {
- case -1:
- if (errno == EINTR || errno == EAGAIN)
- continue;
- return 0;
- case 0:
- errno = EPIPE;
- return pos;
- default:
- pos += (size_t)res;
- }
- }
- return (pos);
-}
-
+++ /dev/null
-/* Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#include <stdio.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-
-#include "atomicio.h"
-#include "libvhd-journal.h"
-
-#define VHD_JOURNAL_ENTRY_TYPE_FOOTER_P 1
-#define VHD_JOURNAL_ENTRY_TYPE_FOOTER_C 2
-#define VHD_JOURNAL_ENTRY_TYPE_HEADER 3
-#define VHD_JOURNAL_ENTRY_TYPE_LOCATOR 4
-#define VHD_JOURNAL_ENTRY_TYPE_BAT 5
-#define VHD_JOURNAL_ENTRY_TYPE_BATMAP_H 6
-#define VHD_JOURNAL_ENTRY_TYPE_BATMAP_M 7
-#define VHD_JOURNAL_ENTRY_TYPE_DATA 8
-
-typedef struct vhd_journal_entry {
- uint64_t cookie;
- uint32_t type;
- uint32_t size;
- uint64_t offset;
- uint32_t checksum;
-} vhd_journal_entry_t;
-
-static inline int
-vhd_journal_seek(vhd_journal_t *j, off_t offset, int whence)
-{
- off_t off;
-
- off = lseek(j->jfd, offset, whence);
- if (off == (off_t)-1)
- return -errno;
-
- return 0;
-}
-
-static inline off_t
-vhd_journal_position(vhd_journal_t *j)
-{
- return lseek(j->jfd, 0, SEEK_CUR);
-}
-
-static inline int
-vhd_journal_read(vhd_journal_t *j, void *buf, size_t size)
-{
- ssize_t ret;
-
- errno = 0;
-
- ret = atomicio(read, j->jfd, buf, size);
- if (ret != size)
- return (errno ? -errno : -EIO);
-
- return 0;
-}
-
-static inline int
-vhd_journal_write(vhd_journal_t *j, void *buf, size_t size)
-{
- ssize_t ret;
-
- errno = 0;
-
- ret = atomicio(vwrite, j->jfd, buf, size);
- if (ret != size)
- return (errno ? -errno : -EIO);
-
- return 0;
-}
-
-static inline int
-vhd_journal_truncate(vhd_journal_t *j, off_t length)
-{
- int err;
-
- err = ftruncate(j->jfd, length);
- if (err == -1)
- return -errno;
-
- return 0;
-}
-
-static inline int
-vhd_journal_sync(vhd_journal_t *j)
-{
- int err;
-
- err = fdatasync(j->jfd);
- if (err)
- return -errno;
-
- return 0;
-}
-
-static inline void
-vhd_journal_header_in(vhd_journal_header_t *header)
-{
- BE64_IN(&header->vhd_footer_offset);
- BE32_IN(&header->journal_data_entries);
- BE32_IN(&header->journal_metadata_entries);
- BE64_IN(&header->journal_data_offset);
- BE64_IN(&header->journal_metadata_offset);
-}
-
-static inline void
-vhd_journal_header_out(vhd_journal_header_t *header)
-{
- BE64_OUT(&header->vhd_footer_offset);
- BE32_OUT(&header->journal_data_entries);
- BE32_OUT(&header->journal_metadata_entries);
- BE64_OUT(&header->journal_data_offset);
- BE64_OUT(&header->journal_metadata_offset);
-}
-
-static int
-vhd_journal_validate_header(vhd_journal_t *j, vhd_journal_header_t *header)
-{
- int err;
- off_t eof;
-
- if (memcmp(header->cookie,
- VHD_JOURNAL_HEADER_COOKIE, sizeof(header->cookie)))
- return -EINVAL;
-
- err = vhd_journal_seek(j, j->header.journal_eof, SEEK_SET);
- if (err)
- return err;
-
- eof = vhd_journal_position(j);
- if (eof == (off_t)-1)
- return -errno;
-
- if (j->header.journal_data_offset > j->header.journal_eof)
- return -EINVAL;
-
- if (j->header.journal_metadata_offset > j->header.journal_eof)
- return -EINVAL;
-
- return 0;
-}
-
-static int
-vhd_journal_read_journal_header(vhd_journal_t *j, vhd_journal_header_t *header)
-{
- int err;
- size_t size;
-
- size = sizeof(vhd_journal_header_t);
- err = vhd_journal_seek(j, 0, SEEK_SET);
- if (err)
- return err;
-
- err = vhd_journal_read(j, header, size);
- if (err)
- return err;
-
- vhd_journal_header_in(header);
-
- return vhd_journal_validate_header(j, header);
-}
-
-static int
-vhd_journal_write_header(vhd_journal_t *j, vhd_journal_header_t *header)
-{
- int err;
- size_t size;
- vhd_journal_header_t h;
-
- memcpy(&h, header, sizeof(vhd_journal_header_t));
-
- err = vhd_journal_validate_header(j, &h);
- if (err)
- return err;
-
- vhd_journal_header_out(&h);
- size = sizeof(vhd_journal_header_t);
-
- err = vhd_journal_seek(j, 0, SEEK_SET);
- if (err)
- return err;
-
- err = vhd_journal_write(j, &h, size);
- if (err)
- return err;
-
- return 0;
-}
-
-static int
-vhd_journal_add_journal_header(vhd_journal_t *j)
-{
- int err;
- off_t off;
- vhd_context_t *vhd;
-
- vhd = &j->vhd;
- memset(&j->header, 0, sizeof(vhd_journal_header_t));
-
- err = vhd_seek(vhd, 0, SEEK_END);
- if (err)
- return err;
-
- off = vhd_position(vhd);
- if (off == (off_t)-1)
- return -errno;
-
- err = vhd_get_footer(vhd);
- if (err)
- return err;
-
- vhd_uuid_copy(&j->header.uuid, &vhd->footer.uuid);
- memcpy(j->header.cookie,
- VHD_JOURNAL_HEADER_COOKIE, sizeof(j->header.cookie));
- j->header.vhd_footer_offset = off - sizeof(vhd_footer_t);
- j->header.journal_eof = sizeof(vhd_journal_header_t);
-
- return vhd_journal_write_header(j, &j->header);
-}
-
-static void
-vhd_journal_entry_in(vhd_journal_entry_t *entry)
-{
- BE32_IN(&entry->type);
- BE32_IN(&entry->size);
- BE64_IN(&entry->offset);
- BE64_IN(&entry->cookie);
- BE32_IN(&entry->checksum);
-}
-
-static void
-vhd_journal_entry_out(vhd_journal_entry_t *entry)
-{
- BE32_OUT(&entry->type);
- BE32_OUT(&entry->size);
- BE64_OUT(&entry->offset);
- BE64_OUT(&entry->cookie);
- BE32_OUT(&entry->checksum);
-}
-
-static uint32_t
-vhd_journal_checksum_entry(vhd_journal_entry_t *entry, char *buf, size_t size)
-{
- int i;
- unsigned char *blob;
- uint32_t checksum, tmp;
-
- checksum = 0;
- tmp = entry->checksum;
- entry->checksum = 0;
-
- blob = (unsigned char *)entry;
- for (i = 0; i < sizeof(vhd_journal_entry_t); i++)
- checksum += blob[i];
-
- blob = (unsigned char *)buf;
- for (i = 0; i < size; i++)
- checksum += blob[i];
-
- entry->checksum = tmp;
- return ~checksum;
-}
-
-static int
-vhd_journal_validate_entry(vhd_journal_entry_t *entry)
-{
- if (entry->size == 0)
- return -EINVAL;
-
- if (entry->size & (VHD_SECTOR_SIZE - 1))
- return -EINVAL;
-
- if (entry->cookie != VHD_JOURNAL_ENTRY_COOKIE)
- return -EINVAL;
-
- return 0;
-}
-
-static int
-vhd_journal_read_entry(vhd_journal_t *j, vhd_journal_entry_t *entry)
-{
- int err;
-
- err = vhd_journal_read(j, entry, sizeof(vhd_journal_entry_t));
- if (err)
- return err;
-
- vhd_journal_entry_in(entry);
- return vhd_journal_validate_entry(entry);
-}
-
-static int
-vhd_journal_write_entry(vhd_journal_t *j, vhd_journal_entry_t *entry)
-{
- int err;
- vhd_journal_entry_t e;
-
- err = vhd_journal_validate_entry(entry);
- if (err)
- return err;
-
- memcpy(&e, entry, sizeof(vhd_journal_entry_t));
- vhd_journal_entry_out(&e);
-
- err = vhd_journal_write(j, &e, sizeof(vhd_journal_entry_t));
- if (err)
- return err;
-
- return 0;
-}
-
-static int
-vhd_journal_validate_entry_data(vhd_journal_entry_t *entry, char *buf)
-{
- int err;
- uint32_t checksum;
-
- err = 0;
- checksum = vhd_journal_checksum_entry(entry, buf, entry->size);
-
- if (checksum != entry->checksum)
- return -EINVAL;
-
- return err;
-}
-
-static int
-vhd_journal_update(vhd_journal_t *j, off_t offset,
- char *buf, size_t size, uint32_t type)
-{
- int err;
- off_t eof;
- uint64_t *off, off_bak;
- uint32_t *entries;
- vhd_journal_entry_t entry;
-
- entry.type = type;
- entry.size = size;
- entry.offset = offset;
- entry.cookie = VHD_JOURNAL_ENTRY_COOKIE;
- entry.checksum = vhd_journal_checksum_entry(&entry, buf, size);
-
- err = vhd_journal_seek(j, j->header.journal_eof, SEEK_SET);
- if (err)
- return err;
-
- err = vhd_journal_write_entry(j, &entry);
- if (err)
- goto fail;
-
- err = vhd_journal_write(j, buf, size);
- if (err)
- goto fail;
-
- if (type == VHD_JOURNAL_ENTRY_TYPE_DATA) {
- off = &j->header.journal_data_offset;
- entries = &j->header.journal_data_entries;
- } else {
- off = &j->header.journal_metadata_offset;
- entries = &j->header.journal_metadata_entries;
- }
-
- off_bak = *off;
- if (!(*entries)++)
- *off = j->header.journal_eof;
- j->header.journal_eof += (size + sizeof(vhd_journal_entry_t));
-
- err = vhd_journal_write_header(j, &j->header);
- if (err) {
- if (!--(*entries))
- *off = off_bak;
- j->header.journal_eof -= (size + sizeof(vhd_journal_entry_t));
- goto fail;
- }
-
- return 0;
-
-fail:
- if (!j->is_block)
- vhd_journal_truncate(j, j->header.journal_eof);
- return err;
-}
-
-static int
-vhd_journal_add_footer(vhd_journal_t *j)
-{
- int err;
- off_t off;
- vhd_context_t *vhd;
- vhd_footer_t footer;
-
- vhd = &j->vhd;
-
- err = vhd_seek(vhd, 0, SEEK_END);
- if (err)
- return err;
-
- off = vhd_position(vhd);
- if (off == (off_t)-1)
- return -errno;
-
- err = vhd_read_footer_at(vhd, &footer, off - sizeof(vhd_footer_t));
- if (err)
- return err;
-
- vhd_footer_out(&footer);
- err = vhd_journal_update(j, off - sizeof(vhd_footer_t),
- (char *)&footer,
- sizeof(vhd_footer_t),
- VHD_JOURNAL_ENTRY_TYPE_FOOTER_P);
- if (err)
- return err;
-
- if (!vhd_type_dynamic(vhd))
- return 0;
-
- err = vhd_read_footer_at(vhd, &footer, 0);
- if (err)
- return err;
-
- vhd_footer_out(&footer);
- err = vhd_journal_update(j, 0,
- (char *)&footer,
- sizeof(vhd_footer_t),
- VHD_JOURNAL_ENTRY_TYPE_FOOTER_C);
-
- return err;
-}
-
-static int
-vhd_journal_add_header(vhd_journal_t *j)
-{
- int err;
- off_t off;
- vhd_context_t *vhd;
- vhd_header_t header;
-
- vhd = &j->vhd;
-
- err = vhd_read_header(vhd, &header);
- if (err)
- return err;
-
- off = vhd->footer.data_offset;
-
- vhd_header_out(&header);
- err = vhd_journal_update(j, off,
- (char *)&header,
- sizeof(vhd_header_t),
- VHD_JOURNAL_ENTRY_TYPE_HEADER);
-
- return err;
-}
-
-static int
-vhd_journal_add_locators(vhd_journal_t *j)
-{
- int i, n, err;
- vhd_context_t *vhd;
-
- vhd = &j->vhd;
-
- err = vhd_get_header(vhd);
- if (err)
- return err;
-
- n = sizeof(vhd->header.loc) / sizeof(vhd_parent_locator_t);
- for (i = 0; i < n; i++) {
- char *buf;
- off_t off;
- size_t size;
- vhd_parent_locator_t *loc;
-
- loc = vhd->header.loc + i;
- err = vhd_validate_platform_code(loc->code);
- if (err)
- return err;
-
- if (loc->code == PLAT_CODE_NONE)
- continue;
-
- off = loc->data_offset;
- size = vhd_parent_locator_size(loc);
-
- err = posix_memalign((void **)&buf, VHD_SECTOR_SIZE, size);
- if (err)
- return -err;
-
- err = vhd_seek(vhd, off, SEEK_SET);
- if (err)
- goto end;
-
- err = vhd_read(vhd, buf, size);
- if (err)
- goto end;
-
- err = vhd_journal_update(j, off, buf, size,
- VHD_JOURNAL_ENTRY_TYPE_LOCATOR);
- if (err)
- goto end;
-
- err = 0;
-
- end:
- free(buf);
- if (err)
- break;
- }
-
- return err;
-}
-
-static int
-vhd_journal_add_bat(vhd_journal_t *j)
-{
- int err;
- off_t off;
- size_t size;
- vhd_bat_t bat;
- vhd_context_t *vhd;
-
- vhd = &j->vhd;
-
- err = vhd_get_header(vhd);
- if (err)
- return err;
-
- err = vhd_read_bat(vhd, &bat);
- if (err)
- return err;
-
- off = vhd->header.table_offset;
- size = vhd_bytes_padded(bat.entries * sizeof(uint32_t));
-
- vhd_bat_out(&bat);
- err = vhd_journal_update(j, off, (char *)bat.bat, size,
- VHD_JOURNAL_ENTRY_TYPE_BAT);
-
- free(bat.bat);
- return err;
-}
-
-static int
-vhd_journal_add_batmap(vhd_journal_t *j)
-{
- int err;
- off_t off;
- size_t size;
- vhd_context_t *vhd;
- vhd_batmap_t batmap;
-
- vhd = &j->vhd;
-
- err = vhd_batmap_header_offset(vhd, &off);
- if (err)
- return err;
-
- err = vhd_read_batmap(vhd, &batmap);
- if (err)
- return err;
-
- size = vhd_bytes_padded(sizeof(struct dd_batmap_hdr));
-
- vhd_batmap_header_out(&batmap);
- err = vhd_journal_update(j, off, (char *)&batmap.header, size,
- VHD_JOURNAL_ENTRY_TYPE_BATMAP_H);
- if (err)
- goto out;
-
- vhd_batmap_header_in(&batmap);
- off = batmap.header.batmap_offset;
- size = vhd_sectors_to_bytes(batmap.header.batmap_size);
-
- err = vhd_journal_update(j, off, batmap.map, size,
- VHD_JOURNAL_ENTRY_TYPE_BATMAP_M);
-
-out:
- free(batmap.map);
- return err;
-}
-
-static int
-vhd_journal_add_metadata(vhd_journal_t *j)
-{
- int err;
- off_t eof;
- vhd_context_t *vhd;
-
- vhd = &j->vhd;
-
- err = vhd_journal_add_footer(j);
- if (err)
- return err;
-
- if (!vhd_type_dynamic(vhd))
- return 0;
-
- err = vhd_journal_add_header(j);
- if (err)
- return err;
-
- err = vhd_journal_add_locators(j);
- if (err)
- return err;
-
- err = vhd_journal_add_bat(j);
- if (err)
- return err;
-
- if (vhd_has_batmap(vhd)) {
- err = vhd_journal_add_batmap(j);
- if (err)
- return err;
- }
-
- j->header.journal_data_offset = j->header.journal_eof;
- return vhd_journal_write_header(j, &j->header);
-}
-
-static int
-__vhd_journal_read_footer(vhd_journal_t *j,
- vhd_footer_t *footer, uint32_t type)
-{
- int err;
- vhd_journal_entry_t entry;
-
- err = vhd_journal_read_entry(j, &entry);
- if (err)
- return err;
-
- if (entry.type != type)
- return -EINVAL;
-
- if (entry.size != sizeof(vhd_footer_t))
- return -EINVAL;
-
- err = vhd_journal_read(j, footer, entry.size);
- if (err)
- return err;
-
- vhd_footer_in(footer);
- return vhd_validate_footer(footer);
-}
-
-static int
-vhd_journal_read_footer(vhd_journal_t *j, vhd_footer_t *footer)
-{
- return __vhd_journal_read_footer(j, footer,
- VHD_JOURNAL_ENTRY_TYPE_FOOTER_P);
-}
-
-static int
-vhd_journal_read_footer_copy(vhd_journal_t *j, vhd_footer_t *footer)
-{
- return __vhd_journal_read_footer(j, footer,
- VHD_JOURNAL_ENTRY_TYPE_FOOTER_C);
-}
-
-static int
-vhd_journal_read_header(vhd_journal_t *j, vhd_header_t *header)
-{
- int err;
- vhd_journal_entry_t entry;
-
- err = vhd_journal_read_entry(j, &entry);
- if (err)
- return err;
-
- if (entry.type != VHD_JOURNAL_ENTRY_TYPE_HEADER)
- return -EINVAL;
-
- if (entry.size != sizeof(vhd_header_t))
- return -EINVAL;
-
- err = vhd_journal_read(j, header, entry.size);
- if (err)
- return err;
-
- vhd_header_in(header);
- return vhd_validate_header(header);
-}
-
-static int
-vhd_journal_read_locators(vhd_journal_t *j, char ***locators, int *locs)
-{
- int err, n, _locs;
- char **_locators, *buf;
- off_t pos;
- vhd_journal_entry_t entry;
-
- _locs = 0;
- *locs = 0;
- *locators = NULL;
-
- n = sizeof(j->vhd.header.loc) / sizeof(vhd_parent_locator_t);
- _locators = calloc(n, sizeof(char *));
- if (!_locators)
- return -ENOMEM;
-
- for (;;) {
- buf = NULL;
-
- pos = vhd_journal_position(j);
- err = vhd_journal_read_entry(j, &entry);
- if (err)
- goto fail;
-
- if (entry.type != VHD_JOURNAL_ENTRY_TYPE_LOCATOR) {
- err = vhd_journal_seek(j, pos, SEEK_SET);
- if (err)
- goto fail;
- break;
- }
-
- if (_locs >= n) {
- err = -EINVAL;
- goto fail;
- }
-
- err = posix_memalign((void **)&buf,
- VHD_SECTOR_SIZE, entry.size);
- if (err) {
- err = -err;
- buf = NULL;
- goto fail;
- }
-
- err = vhd_journal_read(j, buf, entry.size);
- if (err)
- goto fail;
-
- _locators[_locs++] = buf;
- err = 0;
- }
-
-
- *locs = _locs;
- *locators = _locators;
-
- return 0;
-
-fail:
- if (_locators) {
- for (n = 0; n < _locs; n++)
- free(_locators[n]);
- free(_locators);
- }
- return err;
-}
-
-static int
-vhd_journal_read_bat(vhd_journal_t *j, vhd_bat_t *bat)
-{
- int err;
- size_t size;
- vhd_context_t *vhd;
- vhd_journal_entry_t entry;
-
- vhd = &j->vhd;
-
- size = vhd_bytes_padded(vhd->header.max_bat_size * sizeof(uint32_t));
-
- err = vhd_journal_read_entry(j, &entry);
- if (err)
- return err;
-
- if (entry.type != VHD_JOURNAL_ENTRY_TYPE_BAT)
- return -EINVAL;
-
- if (entry.size != size)
- return -EINVAL;
-
- if (entry.offset != vhd->header.table_offset)
- return -EINVAL;
-
- err = posix_memalign((void **)&bat->bat, VHD_SECTOR_SIZE, size);
- if (err)
- return -err;
-
- err = vhd_journal_read(j, bat->bat, entry.size);
- if (err)
- goto fail;
-
- bat->spb = vhd->header.block_size >> VHD_SECTOR_SHIFT;
- bat->entries = vhd->header.max_bat_size;
- vhd_bat_in(bat);
-
- return 0;
-
-fail:
- free(bat->bat);
- bat->bat = NULL;
- return err;
-}
-
-static int
-vhd_journal_read_batmap_header(vhd_journal_t *j, vhd_batmap_t *batmap)
-{
- int err;
- char *buf;
- size_t size;
- vhd_journal_entry_t entry;
-
- size = vhd_bytes_padded(sizeof(struct dd_batmap_hdr));
-
- err = vhd_journal_read_entry(j, &entry);
- if (err)
- return err;
-
- if (entry.type != VHD_JOURNAL_ENTRY_TYPE_BATMAP_H)
- return -EINVAL;
-
- if (entry.size != size)
- return -EINVAL;
-
- err = posix_memalign((void **)&buf, VHD_SECTOR_SIZE, size);
- if (err)
- return err;
-
- err = vhd_journal_read(j, buf, entry.size);
- if (err) {
- free(buf);
- return err;
- }
-
- memcpy(&batmap->header, buf, sizeof(batmap->header));
-
- vhd_batmap_header_in(batmap);
- return vhd_validate_batmap_header(batmap);
-}
-
-static int
-vhd_journal_read_batmap_map(vhd_journal_t *j, vhd_batmap_t *batmap)
-{
- int err;
- vhd_journal_entry_t entry;
-
- err = vhd_journal_read_entry(j, &entry);
- if (err)
- return err;
-
- if (entry.type != VHD_JOURNAL_ENTRY_TYPE_BATMAP_M)
- return -EINVAL;
-
- if (entry.size != vhd_sectors_to_bytes(batmap->header.batmap_size))
- return -EINVAL;
-
- if (entry.offset != batmap->header.batmap_offset)
- return -EINVAL;
-
- err = posix_memalign((void **)&batmap->map,
- VHD_SECTOR_SIZE, entry.size);
- if (err)
- return -err;
-
- err = vhd_journal_read(j, batmap->map, entry.size);
- if (err) {
- free(batmap->map);
- batmap->map = NULL;
- return err;
- }
-
- return 0;
-}
-
-static int
-vhd_journal_read_batmap(vhd_journal_t *j, vhd_batmap_t *batmap)
-{
- int err;
-
- err = vhd_journal_read_batmap_header(j, batmap);
- if (err)
- return err;
-
- err = vhd_journal_read_batmap_map(j, batmap);
- if (err)
- return err;
-
- err = vhd_validate_batmap(batmap);
- if (err) {
- free(batmap->map);
- batmap->map = NULL;
- return err;
- }
-
- return 0;
-}
-
-static int
-vhd_journal_restore_footer(vhd_journal_t *j, vhd_footer_t *footer)
-{
- return vhd_write_footer_at(&j->vhd, footer,
- j->header.vhd_footer_offset);
-}
-
-static int
-vhd_journal_restore_footer_copy(vhd_journal_t *j, vhd_footer_t *footer)
-{
- return vhd_write_footer_at(&j->vhd, footer, 0);
-}
-
-static int
-vhd_journal_restore_header(vhd_journal_t *j, vhd_header_t *header)
-{
- off_t off;
- vhd_context_t *vhd;
-
- vhd = &j->vhd;
- off = vhd->footer.data_offset;
-
- return vhd_write_header_at(&j->vhd, header, off);
-}
-
-static int
-vhd_journal_restore_locators(vhd_journal_t *j, char **locators, int locs)
-{
- size_t size;
- vhd_context_t *vhd;
- int i, n, lidx, err;
- vhd_parent_locator_t *loc;
-
- lidx = 0;
- vhd = &j->vhd;
-
- n = sizeof(vhd->header.loc) / sizeof(vhd_parent_locator_t);
-
- for (i = 0; i < n && lidx < locs; i++) {
- loc = vhd->header.loc + i;
- if (loc->code == PLAT_CODE_NONE)
- continue;
-
- err = vhd_seek(vhd, loc->data_offset, SEEK_SET);
- if (err)
- return err;
-
- size = vhd_parent_locator_size(loc);
- err = vhd_write(vhd, locators[lidx++], size);
- if (err)
- return err;
- }
-
- return 0;
-}
-
-static int
-vhd_journal_restore_bat(vhd_journal_t *j, vhd_bat_t *bat)
-{
- return vhd_write_bat(&j->vhd, bat);
-}
-
-static int
-vhd_journal_restore_batmap(vhd_journal_t *j, vhd_batmap_t *batmap)
-{
- return vhd_write_batmap(&j->vhd, batmap);
-}
-
-static int
-vhd_journal_restore_metadata(vhd_journal_t *j)
-{
- off_t off;
- char **locators;
- vhd_footer_t copy;
- vhd_context_t *vhd;
- int i, locs, hlocs, err;
-
- vhd = &j->vhd;
- locs = 0;
- hlocs = 0;
- locators = NULL;
-
- err = vhd_journal_seek(j, sizeof(vhd_journal_header_t), SEEK_SET);
- if (err)
- return err;
-
- err = vhd_journal_read_footer(j, &vhd->footer);
- if (err)
- return err;
-
- if (!vhd_type_dynamic(vhd))
- goto restore;
-
- err = vhd_journal_read_footer_copy(j, ©);
- if (err)
- return err;
-
- err = vhd_journal_read_header(j, &vhd->header);
- if (err)
- return err;
-
- for (hlocs = 0, i = 0; i < vhd_parent_locator_count(vhd); i++) {
- if (vhd_validate_platform_code(vhd->header.loc[i].code))
- return err;
-
- if (vhd->header.loc[i].code != PLAT_CODE_NONE)
- hlocs++;
- }
-
- if (hlocs) {
- err = vhd_journal_read_locators(j, &locators, &locs);
- if (err)
- return err;
-
- if (hlocs != locs) {
- err = -EINVAL;
- goto out;
- }
- }
-
- err = vhd_journal_read_bat(j, &vhd->bat);
- if (err)
- goto out;
-
- if (vhd_has_batmap(vhd)) {
- err = vhd_journal_read_batmap(j, &vhd->batmap);
- if (err)
- goto out;
- }
-
-restore:
- off = vhd_journal_position(j);
- if (off == (off_t)-1)
- return -errno;
-
- if (j->header.journal_data_offset != off)
- return -EINVAL;
-
- err = vhd_journal_restore_footer(j, &vhd->footer);
- if (err)
- goto out;
-
- if (!vhd_type_dynamic(vhd))
- goto out;
-
- err = vhd_journal_restore_footer_copy(j, ©);
- if (err)
- goto out;
-
- err = vhd_journal_restore_header(j, &vhd->header);
- if (err)
- goto out;
-
- if (locs) {
- err = vhd_journal_restore_locators(j, locators, locs);
- if (err)
- goto out;
- }
-
- err = vhd_journal_restore_bat(j, &vhd->bat);
- if (err)
- goto out;
-
- if (vhd_has_batmap(vhd)) {
- err = vhd_journal_restore_batmap(j, &vhd->batmap);
- if (err)
- goto out;
- }
-
- err = 0;
-
-out:
- if (locators) {
- for (i = 0; i < locs; i++)
- free(locators[i]);
- free(locators);
- }
-
- if (!err && !vhd->is_block)
- err = ftruncate(vhd->fd,
- j->header.vhd_footer_offset +
- sizeof(vhd_footer_t));
-
- return err;
-}
-
-static int
-vhd_journal_disable_vhd(vhd_journal_t *j)
-{
- int err;
- vhd_context_t *vhd;
-
- vhd = &j->vhd;
-
- err = vhd_get_footer(vhd);
- if (err)
- return err;
-
- memcpy(&vhd->footer.cookie,
- VHD_POISON_COOKIE, sizeof(vhd->footer.cookie));
- vhd->footer.checksum = vhd_checksum_footer(&vhd->footer);
-
- err = vhd_write_footer(vhd, &vhd->footer);
- if (err)
- return err;
-
- return 0;
-}
-
-static int
-vhd_journal_enable_vhd(vhd_journal_t *j)
-{
- int err;
- vhd_context_t *vhd;
-
- vhd = &j->vhd;
-
- err = vhd_get_footer(vhd);
- if (err)
- return err;
-
- if (!vhd_disabled(vhd))
- return 0;
-
- memcpy(&vhd->footer.cookie, HD_COOKIE, sizeof(vhd->footer.cookie));
- vhd->footer.checksum = vhd_checksum_footer(&vhd->footer);
-
- err = vhd_write_footer(vhd, &vhd->footer);
- if (err)
- return err;
-
- return 0;
-}
-
-int
-vhd_journal_close(vhd_journal_t *j)
-{
- if (j->jfd)
- close(j->jfd);
-
- vhd_close(&j->vhd);
- free(j->jname);
-
- return 0;
-}
-
-int
-vhd_journal_remove(vhd_journal_t *j)
-{
- int err;
-
- err = vhd_journal_enable_vhd(j);
- if (err)
- return err;
-
- if (j->jfd) {
- close(j->jfd);
- if (!j->is_block)
- unlink(j->jname);
- }
-
- vhd_close(&j->vhd);
- free(j->jname);
-
- return 0;
-}
-
-int
-vhd_journal_open(vhd_journal_t *j, const char *file, const char *jfile)
-{
- int err;
- vhd_context_t *vhd;
-
- memset(j, 0, sizeof(vhd_journal_t));
-
- j->jfd = -1;
- vhd = &j->vhd;
-
- j->jname = strdup(jfile);
- if (j->jname == NULL)
- return -ENOMEM;
-
- j->jfd = open(j->jname, O_LARGEFILE | O_RDWR);
- if (j->jfd == -1) {
- err = -errno;
- goto fail;
- }
-
- err = vhd_test_file_fixed(j->jname, &j->is_block);
- if (err)
- goto fail;
-
- vhd->fd = open(file, O_LARGEFILE | O_RDWR | O_DIRECT);
- if (vhd->fd == -1) {
- err = -errno;
- goto fail;
- }
-
- err = vhd_test_file_fixed(file, &vhd->is_block);
- if (err)
- goto fail;
-
- err = vhd_journal_read_journal_header(j, &j->header);
- if (err)
- goto fail;
-
- err = vhd_journal_restore_metadata(j);
- if (err)
- goto fail;
-
- close(vhd->fd);
- free(vhd->bat.bat);
- free(vhd->batmap.map);
-
- err = vhd_open(vhd, file, VHD_OPEN_RDWR);
- if (err)
- goto fail;
-
- err = vhd_get_bat(vhd);
- if (err)
- goto fail;
-
- if (vhd_has_batmap(vhd)) {
- err = vhd_get_batmap(vhd);
- if (err)
- goto fail;
- }
-
- err = vhd_journal_disable_vhd(j);
- if (err)
- goto fail;
-
- return 0;
-
-fail:
- vhd_journal_close(j);
- return err;
-}
-
-int
-vhd_journal_create(vhd_journal_t *j, const char *file, const char *jfile)
-{
- char *buf;
- int i, err;
- size_t size;
- off_t off;
-
- memset(j, 0, sizeof(vhd_journal_t));
- j->jfd = -1;
-
- j->jname = strdup(jfile);
- if (j->jname == NULL) {
- err = -ENOMEM;
- goto fail1;
- }
-
- if (access(j->jname, F_OK) == 0) {
- err = vhd_test_file_fixed(j->jname, &j->is_block);
- if (err)
- goto fail1;
-
- if (!j->is_block) {
- err = -EEXIST;
- goto fail1;
- }
- }
-
- if (j->is_block)
- j->jfd = open(j->jname, O_LARGEFILE | O_RDWR, 0644);
- else
- j->jfd = open(j->jname,
- O_CREAT | O_TRUNC | O_LARGEFILE | O_RDWR, 0644);
- if (j->jfd == -1) {
- err = -errno;
- goto fail1;
- }
-
- err = vhd_open(&j->vhd, file, VHD_OPEN_RDWR | VHD_OPEN_STRICT);
- if (err)
- goto fail1;
-
- err = vhd_get_bat(&j->vhd);
- if (err)
- goto fail2;
-
- if (vhd_has_batmap(&j->vhd)) {
- err = vhd_get_batmap(&j->vhd);
- if (err)
- goto fail2;
- }
-
- err = vhd_journal_add_journal_header(j);
- if (err)
- goto fail2;
-
- err = vhd_journal_add_metadata(j);
- if (err)
- goto fail2;
-
- err = vhd_journal_disable_vhd(j);
- if (err)
- goto fail2;
-
- err = vhd_journal_sync(j);
- if (err)
- goto fail2;
-
- return 0;
-
-fail1:
- if (j->jfd != -1) {
- close(j->jfd);
- if (!j->is_block)
- unlink(j->jname);
- }
- free(j->jname);
- memset(j, 0, sizeof(vhd_journal_t));
-
- return err;
-
-fail2:
- vhd_journal_remove(j);
- return err;
-}
-
-int
-vhd_journal_add_block(vhd_journal_t *j, uint32_t block, char mode)
-{
- int err;
- char *buf;
- off_t off;
- size_t size;
- uint64_t blk;
- vhd_context_t *vhd;
-
- buf = NULL;
- vhd = &j->vhd;
-
- if (!vhd_type_dynamic(vhd))
- return -EINVAL;
-
- err = vhd_get_bat(vhd);
- if (err)
- return err;
-
- if (block >= vhd->bat.entries)
- return -ERANGE;
-
- blk = vhd->bat.bat[block];
- if (blk == DD_BLK_UNUSED)
- return 0;
-
- off = vhd_sectors_to_bytes(blk);
-
- if (mode & VHD_JOURNAL_METADATA) {
- size = vhd_sectors_to_bytes(vhd->bm_secs);
-
- err = vhd_read_bitmap(vhd, block, &buf);
- if (err)
- return err;
-
- err = vhd_journal_update(j, off, buf, size,
- VHD_JOURNAL_ENTRY_TYPE_DATA);
-
- free(buf);
-
- if (err)
- return err;
- }
-
- if (mode & VHD_JOURNAL_DATA) {
- off += vhd_sectors_to_bytes(vhd->bm_secs);
- size = vhd_sectors_to_bytes(vhd->spb);
-
- err = vhd_read_block(vhd, block, &buf);
- if (err)
- return err;
-
- err = vhd_journal_update(j, off, buf, size,
- VHD_JOURNAL_ENTRY_TYPE_DATA);
- free(buf);
-
- if (err)
- return err;
- }
-
- return vhd_journal_sync(j);
-}
-
-/*
- * commit indicates the transaction completed
- * successfully and we can remove the undo log
- */
-int
-vhd_journal_commit(vhd_journal_t *j)
-{
- int err;
-
- j->header.journal_data_entries = 0;
- j->header.journal_metadata_entries = 0;
- j->header.journal_data_offset = 0;
- j->header.journal_metadata_offset = 0;
-
- err = vhd_journal_write_header(j, &j->header);
- if (err)
- return err;
-
- if (!j->is_block)
- err = vhd_journal_truncate(j, sizeof(vhd_journal_header_t));
- if (err)
- return -errno;
-
- return 0;
-}
-
-/*
- * revert indicates the transaction failed
- * and we should revert any changes via the undo log
- */
-int
-vhd_journal_revert(vhd_journal_t *j)
-{
- int i, err;
- char *buf, *file;
- vhd_context_t *vhd;
- vhd_journal_entry_t entry;
-
- err = 0;
- vhd = &j->vhd;
- buf = NULL;
-
- file = strdup(vhd->file);
- if (!file)
- return -ENOMEM;
-
- vhd_close(&j->vhd);
- j->vhd.fd = open(file, O_RDWR | O_DIRECT | O_LARGEFILE);
- if (j->vhd.fd == -1) {
- free(file);
- return -errno;
- }
-
- err = vhd_test_file_fixed(file, &vhd->is_block);
- if (err) {
- free(file);
- return err;
- }
-
- err = vhd_journal_restore_metadata(j);
- if (err) {
- free(file);
- return err;
- }
-
- close(vhd->fd);
- free(vhd->bat.bat);
- free(vhd->batmap.map);
-
- err = vhd_open(vhd, file, VHD_OPEN_RDWR);
- free(file);
- if (err)
- return err;
-
- err = vhd_journal_seek(j, j->header.journal_data_offset, SEEK_SET);
- if (err)
- return err;
-
- for (i = 0; i < j->header.journal_data_entries; i++) {
- err = vhd_journal_read_entry(j, &entry);
- if (err)
- goto end;
-
- err = posix_memalign((void **)&buf,
- VHD_SECTOR_SIZE, entry.size);
- if (err) {
- err = -err;
- buf = NULL;
- goto end;
- }
-
- err = vhd_journal_read(j, buf, entry.size);
- if (err)
- goto end;
-
- err = vhd_journal_validate_entry_data(&entry, buf);
- if (err)
- goto end;
-
- err = vhd_seek(vhd, entry.offset, SEEK_SET);
- if (err)
- goto end;
-
- err = vhd_write(vhd, buf, entry.size);
- if (err)
- goto end;
-
- err = 0;
-
- end:
- free(buf);
- buf = NULL;
- if (err)
- break;
- }
-
- if (err)
- return err;
-
- if (!vhd->is_block) {
- err = ftruncate(vhd->fd, j->header.vhd_footer_offset +
- sizeof(vhd_footer_t));
- if (err)
- return -errno;
- }
-
- return vhd_journal_sync(j);
-}
+++ /dev/null
-/* Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE
-#endif
-#include <stdio.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <libgen.h>
-#include <iconv.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <langinfo.h>
-
-#include "libvhd.h"
-#include "relative-path.h"
-
-/* VHD uses an epoch of 12:00AM, Jan 1, 2000. This is the Unix timestamp for
- * the start of the VHD epoch. */
-#define VHD_EPOCH_START 946684800
-
-static int libvhd_dbg = 0;
-
-void
-libvhd_set_log_level(int level)
-{
- if (level)
- libvhd_dbg = 1;
-}
-
-#define VHDLOG(_f, _a...) \
- do { \
- if (libvhd_dbg) \
- syslog(LOG_INFO, "libvhd::%s: "_f, \
- __func__, ##_a); \
- } while (0)
-
-#define BIT_MASK 0x80
-
-#ifdef ENABLE_FAILURE_TESTING
-const char* ENV_VAR_FAIL[NUM_FAIL_TESTS] = {
- "VHD_UTIL_TEST_FAIL_REPARENT_BEGIN",
- "VHD_UTIL_TEST_FAIL_REPARENT_LOCATOR",
- "VHD_UTIL_TEST_FAIL_REPARENT_END",
- "VHD_UTIL_TEST_FAIL_RESIZE_BEGIN",
- "VHD_UTIL_TEST_FAIL_RESIZE_DATA_MOVED",
- "VHD_UTIL_TEST_FAIL_RESIZE_METADATA_MOVED",
- "VHD_UTIL_TEST_FAIL_RESIZE_END"
-};
-int TEST_FAIL[NUM_FAIL_TESTS];
-#endif // ENABLE_FAILURE_TESTING
-
-static inline int
-test_bit (volatile char *addr, int nr)
-{
- return ((addr[nr >> 3] << (nr & 7)) & BIT_MASK) != 0;
-}
-
-static inline void
-set_bit (volatile char *addr, int nr)
-{
- addr[nr >> 3] |= (BIT_MASK >> (nr & 7));
-}
-
-static inline void
-clear_bit (volatile char *addr, int nr)
-{
- addr[nr >> 3] &= ~(BIT_MASK >> (nr & 7));
-}
-
-static inline int
-old_test_bit(volatile char *addr, int nr)
-{
- return (((uint32_t *)addr)[nr >> 5] >> (nr & 31)) & 1;
-}
-
-static inline void
-old_set_bit(volatile char *addr, int nr)
-{
- ((uint32_t *)addr)[nr >> 5] |= (1 << (nr & 31));
-}
-
-static inline void
-old_clear_bit(volatile char *addr, int nr)
-{
- ((uint32_t *)addr)[nr >> 5] &= ~(1 << (nr & 31));
-}
-
-void
-vhd_footer_in(vhd_footer_t *footer)
-{
- BE32_IN(&footer->features);
- BE32_IN(&footer->ff_version);
- BE64_IN(&footer->data_offset);
- BE32_IN(&footer->timestamp);
- BE32_IN(&footer->crtr_ver);
- BE32_IN(&footer->crtr_os);
- BE64_IN(&footer->orig_size);
- BE64_IN(&footer->curr_size);
- BE32_IN(&footer->geometry);
- BE32_IN(&footer->type);
- BE32_IN(&footer->checksum);
-}
-
-void
-vhd_footer_out(vhd_footer_t *footer)
-{
- BE32_OUT(&footer->features);
- BE32_OUT(&footer->ff_version);
- BE64_OUT(&footer->data_offset);
- BE32_OUT(&footer->timestamp);
- BE32_OUT(&footer->crtr_ver);
- BE32_OUT(&footer->crtr_os);
- BE64_OUT(&footer->orig_size);
- BE64_OUT(&footer->curr_size);
- BE32_OUT(&footer->geometry);
- BE32_OUT(&footer->type);
- BE32_OUT(&footer->checksum);
-}
-
-void
-vhd_header_in(vhd_header_t *header)
-{
- int i, n;
-
- BE64_IN(&header->data_offset);
- BE64_IN(&header->table_offset);
- BE32_IN(&header->hdr_ver);
- BE32_IN(&header->max_bat_size);
- BE32_IN(&header->block_size);
- BE32_IN(&header->checksum);
- BE32_IN(&header->prt_ts);
-
- n = sizeof(header->loc) / sizeof(vhd_parent_locator_t);
-
- for (i = 0; i < n; i++) {
- BE32_IN(&header->loc[i].code);
- BE32_IN(&header->loc[i].data_space);
- BE32_IN(&header->loc[i].data_len);
- BE64_IN(&header->loc[i].data_offset);
- }
-}
-
-void
-vhd_header_out(vhd_header_t *header)
-{
- int i, n;
-
- BE64_OUT(&header->data_offset);
- BE64_OUT(&header->table_offset);
- BE32_OUT(&header->hdr_ver);
- BE32_OUT(&header->max_bat_size);
- BE32_OUT(&header->block_size);
- BE32_OUT(&header->checksum);
- BE32_OUT(&header->prt_ts);
-
- n = sizeof(header->loc) / sizeof(vhd_parent_locator_t);
-
- for (i = 0; i < n; i++) {
- BE32_OUT(&header->loc[i].code);
- BE32_OUT(&header->loc[i].data_space);
- BE32_OUT(&header->loc[i].data_len);
- BE64_OUT(&header->loc[i].data_offset);
- }
-}
-
-void
-vhd_batmap_header_in(vhd_batmap_t *batmap)
-{
- BE64_IN(&batmap->header.batmap_offset);
- BE32_IN(&batmap->header.batmap_size);
- BE32_IN(&batmap->header.batmap_version);
- BE32_IN(&batmap->header.checksum);
-}
-
-void
-vhd_batmap_header_out(vhd_batmap_t *batmap)
-{
- BE64_OUT(&batmap->header.batmap_offset);
- BE32_OUT(&batmap->header.batmap_size);
- BE32_OUT(&batmap->header.batmap_version);
- BE32_OUT(&batmap->header.checksum);
-}
-
-void
-vhd_bat_in(vhd_bat_t *bat)
-{
- int i;
-
- for (i = 0; i < bat->entries; i++)
- BE32_IN(&bat->bat[i]);
-}
-
-void
-vhd_bat_out(vhd_bat_t *bat)
-{
- int i;
-
- for (i = 0; i < bat->entries; i++)
- BE32_OUT(&bat->bat[i]);
-}
-
-uint32_t
-vhd_checksum_footer(vhd_footer_t *footer)
-{
- int i;
- unsigned char *blob;
- uint32_t checksum, tmp;
-
- checksum = 0;
- tmp = footer->checksum;
- footer->checksum = 0;
-
- blob = (unsigned char *)footer;
- for (i = 0; i < sizeof(vhd_footer_t); i++)
- checksum += (uint32_t)blob[i];
-
- footer->checksum = tmp;
- return ~checksum;
-}
-
-int
-vhd_validate_footer(vhd_footer_t *footer)
-{
- int csize;
- uint32_t checksum;
-
- csize = sizeof(footer->cookie);
- if (memcmp(footer->cookie, HD_COOKIE, csize) != 0 &&
- memcmp(footer->cookie, VHD_POISON_COOKIE, csize) != 0) {
- char buf[9];
- strncpy(buf, footer->cookie, sizeof(buf));
- buf[sizeof(buf)-1]= '\0';
- VHDLOG("invalid footer cookie: %s\n", buf);
- return -EINVAL;
- }
-
- checksum = vhd_checksum_footer(footer);
- if (checksum != footer->checksum) {
- /*
- * early td-util did not re-calculate
- * checksum when marking vhds 'hidden'
- */
- if (footer->hidden &&
- !strncmp(footer->crtr_app, "tap", 3) &&
- (footer->crtr_ver == VHD_VERSION(0, 1) ||
- footer->crtr_ver == VHD_VERSION(1, 1))) {
- char tmp = footer->hidden;
- footer->hidden = 0;
- checksum = vhd_checksum_footer(footer);
- footer->hidden = tmp;
-
- if (checksum == footer->checksum)
- return 0;
- }
-
- VHDLOG("invalid footer checksum: "
- "footer = 0x%08x, calculated = 0x%08x\n",
- footer->checksum, checksum);
- return -EINVAL;
- }
-
- return 0;
-}
-
-uint32_t
-vhd_checksum_header(vhd_header_t *header)
-{
- int i;
- unsigned char *blob;
- uint32_t checksum, tmp;
-
- checksum = 0;
- tmp = header->checksum;
- header->checksum = 0;
-
- blob = (unsigned char *)header;
- for (i = 0; i < sizeof(vhd_header_t); i++)
- checksum += (uint32_t)blob[i];
-
- header->checksum = tmp;
- return ~checksum;
-}
-
-int
-vhd_validate_header(vhd_header_t *header)
-{
- int i, n;
- uint32_t checksum;
-
- if (memcmp(header->cookie, DD_COOKIE, 8) != 0) {
- char buf[9];
- strncpy(buf, header->cookie, sizeof(buf));
- buf[sizeof(buf)-1]= '\0';
- VHDLOG("invalid header cookie: %s\n", buf);
- return -EINVAL;
- }
-
- if (header->hdr_ver != 0x00010000) {
- VHDLOG("invalid header version 0x%08x\n", header->hdr_ver);
- return -EINVAL;
- }
-
- if (header->data_offset != 0xFFFFFFFFFFFFFFFF) {
- VHDLOG("invalid header data_offset 0x%016"PRIx64"\n",
- header->data_offset);
- return -EINVAL;
- }
-
- n = sizeof(header->loc) / sizeof(vhd_parent_locator_t);
- for (i = 0; i < n; i++)
- if (vhd_validate_platform_code(header->loc[i].code))
- return -EINVAL;
-
- checksum = vhd_checksum_header(header);
- if (checksum != header->checksum) {
- VHDLOG("invalid header checksum: "
- "header = 0x%08x, calculated = 0x%08x\n",
- header->checksum, checksum);
- return -EINVAL;
- }
-
- return 0;
-}
-
-static inline int
-vhd_validate_bat(vhd_bat_t *bat)
-{
- if (!bat->bat)
- return -EINVAL;
-
- return 0;
-}
-
-uint32_t
-vhd_checksum_batmap(vhd_batmap_t *batmap)
-{
- int i, n;
- char *blob;
- uint32_t checksum;
-
- blob = batmap->map;
- checksum = 0;
-
- n = vhd_sectors_to_bytes(batmap->header.batmap_size);
-
- for (i = 0; i < n; i++) {
- if (batmap->header.batmap_version == VHD_BATMAP_VERSION(1, 1))
- checksum += (uint32_t)blob[i];
- else
- checksum += (uint32_t)(unsigned char)blob[i];
- }
-
- return ~checksum;
-}
-
-int
-vhd_validate_batmap_header(vhd_batmap_t *batmap)
-{
- if (memcmp(batmap->header.cookie, VHD_BATMAP_COOKIE, 8))
- return -EINVAL;
-
- if (batmap->header.batmap_version > VHD_BATMAP_CURRENT_VERSION)
- return -EINVAL;
-
- return 0;
-}
-
-int
-vhd_validate_batmap(vhd_batmap_t *batmap)
-{
- uint32_t checksum;
-
- if (!batmap->map)
- return -EINVAL;
-
- checksum = vhd_checksum_batmap(batmap);
- if (checksum != batmap->header.checksum)
- return -EINVAL;
-
- return 0;
-}
-
-int
-vhd_batmap_header_offset(vhd_context_t *ctx, off_t *_off)
-{
- off_t off;
- size_t bat;
-
- *_off = 0;
-
- off = ctx->header.table_offset;
- bat = ctx->header.max_bat_size * sizeof(uint32_t);
- off += vhd_bytes_padded(bat);
-
- *_off = off;
- return 0;
-}
-
-int
-vhd_validate_platform_code(uint32_t code)
-{
- switch (code) {
- case PLAT_CODE_NONE:
- case PLAT_CODE_WI2R:
- case PLAT_CODE_WI2K:
- case PLAT_CODE_W2RU:
- case PLAT_CODE_W2KU:
- case PLAT_CODE_MAC:
- case PLAT_CODE_MACX:
- return 0;
- default:
- VHDLOG("invalid parent locator code %u\n", code);
- return -EINVAL;
- }
-}
-
-int
-vhd_parent_locator_count(vhd_context_t *ctx)
-{
- return (sizeof(ctx->header.loc) / sizeof(vhd_parent_locator_t));
-}
-
-int
-vhd_hidden(vhd_context_t *ctx, int *hidden)
-{
- int err;
-
- *hidden = 0;
-
- if (vhd_type_dynamic(ctx) && vhd_creator_tapdisk(ctx) &&
- (ctx->footer.crtr_ver == VHD_VERSION(0, 1) ||
- ctx->footer.crtr_ver == VHD_VERSION(1, 1))) {
- vhd_footer_t copy;
-
- err = vhd_read_footer_at(ctx, ©, 0);
- if (err) {
- VHDLOG("error reading backup footer of %s: %d\n",
- ctx->file, err);
- return err;
- }
- *hidden = copy.hidden;
- } else
- *hidden = ctx->footer.hidden;
-
- return 0;
-}
-
-int
-vhd_chain_depth(vhd_context_t *ctx, int *depth)
-{
- char *file;
- int err, cnt;
- vhd_context_t vhd, *cur;
-
- err = 0;
- cnt = 0;
- *depth = 0;
- file = NULL;
- cur = ctx;
-
- for (;;) {
- cnt++;
-
- if (cur->footer.type != HD_TYPE_DIFF)
- break;
-
- if (vhd_parent_raw(cur)) {
- cnt++;
- break;
- }
-
- err = vhd_parent_locator_get(cur, &file);
- if (err) {
- file = NULL;
- break;
- }
-
- if (cur != ctx) {
- vhd_close(cur);
- cur = NULL;
- }
-
- err = vhd_open(&vhd, file, VHD_OPEN_RDONLY);
- if (err)
- break;
-
- cur = &vhd;
- free(file);
- file = NULL;
- }
-
- free(file);
- if (cur && cur != ctx)
- vhd_close(cur);
-
- if (!err)
- *depth = cnt;
-
- return err;
-}
-
-int
-vhd_batmap_test(vhd_context_t *ctx, vhd_batmap_t *batmap, uint32_t block)
-{
- if (!vhd_has_batmap(ctx) || !batmap->map)
- return 0;
-
- if (block >= (batmap->header.batmap_size << (VHD_SECTOR_SHIFT + 3)))
- return 0;
-
- return test_bit(batmap->map, block);
-}
-
-void
-vhd_batmap_set(vhd_context_t *ctx, vhd_batmap_t *batmap, uint32_t block)
-{
- if (!vhd_has_batmap(ctx) || !batmap->map)
- return;
-
- if (block >= (batmap->header.batmap_size << (VHD_SECTOR_SHIFT + 3)))
- return;
-
- set_bit(batmap->map, block);
-}
-
-void
-vhd_batmap_clear(vhd_context_t *ctx, vhd_batmap_t *batmap, uint32_t block)
-{
- if (!vhd_has_batmap(ctx) || !batmap->map)
- return;
-
- if (block >= (batmap->header.batmap_size << (VHD_SECTOR_SHIFT + 3)))
- return;
-
- clear_bit(batmap->map, block);
-}
-
-int
-vhd_bitmap_test(vhd_context_t *ctx, char *map, uint32_t block)
-{
- if (vhd_creator_tapdisk(ctx) &&
- ctx->footer.crtr_ver == 0x00000001)
- return old_test_bit(map, block);
-
- return test_bit(map, block);
-}
-
-void
-vhd_bitmap_set(vhd_context_t *ctx, char *map, uint32_t block)
-{
- if (vhd_creator_tapdisk(ctx) &&
- ctx->footer.crtr_ver == 0x00000001)
- return old_set_bit(map, block);
-
- return set_bit(map, block);
-}
-
-void
-vhd_bitmap_clear(vhd_context_t *ctx, char *map, uint32_t block)
-{
- if (vhd_creator_tapdisk(ctx) &&
- ctx->footer.crtr_ver == 0x00000001)
- return old_clear_bit(map, block);
-
- return clear_bit(map, block);
-}
-
-/*
- * returns absolute offset of the first
- * byte of the file which is not vhd metadata
- */
-int
-vhd_end_of_headers(vhd_context_t *ctx, off_t *end)
-{
- int err, i, n;
- uint32_t bat_bytes;
- off_t eom, bat_end;
- vhd_parent_locator_t *loc;
-
- *end = 0;
-
- if (!vhd_type_dynamic(ctx))
- return 0;
-
- eom = ctx->footer.data_offset + sizeof(vhd_header_t);
-
- bat_bytes = vhd_bytes_padded(ctx->header.max_bat_size * sizeof(uint32_t));
- bat_end = ctx->header.table_offset + bat_bytes;
-
- eom = MAX(eom, bat_end);
-
- if (vhd_has_batmap(ctx)) {
- off_t hdr_end, hdr_secs, map_end, map_secs;
-
- err = vhd_get_batmap(ctx);
- if (err)
- return err;
-
- hdr_secs = secs_round_up_no_zero(sizeof(vhd_batmap_header_t));
- err = vhd_batmap_header_offset(ctx, &hdr_end);
- if (err)
- return err;
-
- hdr_end += vhd_sectors_to_bytes(hdr_secs);
- eom = MAX(eom, hdr_end);
-
- map_secs = ctx->batmap.header.batmap_size;
- map_end = (ctx->batmap.header.batmap_offset +
- vhd_sectors_to_bytes(map_secs));
- eom = MAX(eom, map_end);
- }
-
- /* parent locators */
- n = sizeof(ctx->header.loc) / sizeof(vhd_parent_locator_t);
-
- for (i = 0; i < n; i++) {
- off_t loc_end;
-
- loc = &ctx->header.loc[i];
- if (loc->code == PLAT_CODE_NONE)
- continue;
-
- loc_end = loc->data_offset + vhd_parent_locator_size(loc);
- eom = MAX(eom, loc_end);
- }
-
- *end = eom;
- return 0;
-}
-
-int
-vhd_end_of_data(vhd_context_t *ctx, off_t *end)
-{
- int i, err;
- off_t max;
- uint64_t blk;
-
- if (!vhd_type_dynamic(ctx)) {
- err = vhd_seek(ctx, 0, SEEK_END);
- if (err)
- return err;
-
- max = vhd_position(ctx);
- if (max == (off_t)-1)
- return -errno;
-
- *end = max - sizeof(vhd_footer_t);
- return 0;
- }
-
- err = vhd_end_of_headers(ctx, &max);
- if (err)
- return err;
-
- err = vhd_get_bat(ctx);
- if (err)
- return err;
-
- max >>= VHD_SECTOR_SHIFT;
-
- for (i = 0; i < ctx->bat.entries; i++) {
- blk = ctx->bat.bat[i];
-
- if (blk != DD_BLK_UNUSED) {
- blk += ctx->spb + ctx->bm_secs;
- max = MAX(blk, max);
- }
- }
-
- *end = vhd_sectors_to_bytes(max);
- return 0;
-}
-
-uint32_t inline
-vhd_time(time_t time)
-{
- return (uint32_t)(time - VHD_EPOCH_START);
-}
-
-/*
- * Stringify the VHD timestamp for printing.
- * As with ctime_r, target must be >=26 bytes.
- */
-size_t
-vhd_time_to_string(uint32_t timestamp, char *target)
-{
- char *cr;
- time_t unix_timestamp;
-
- unix_timestamp = (time_t)timestamp + VHD_EPOCH_START;
- ctime_r(&unix_timestamp, target);
-
- /* handle mad ctime_r newline appending. */
- if ((cr = strchr(target, '\n')) != NULL)
- *cr = '\0';
-
- return (strlen(target));
-}
-
-/*
- * nabbed from vhd specs.
- */
-uint32_t
-vhd_chs(uint64_t size)
-{
- uint32_t secs, cylinders, heads, spt, cth;
-
- secs = secs_round_up_no_zero(size);
-
- if (secs > 65535 * 16 * 255)
- secs = 65535 * 16 * 255;
-
- if (secs >= 65535 * 16 * 63) {
- spt = 255;
- cth = secs / spt;
- heads = 16;
- } else {
- spt = 17;
- cth = secs / spt;
- heads = (cth + 1023) / 1024;
-
- if (heads < 4)
- heads = 4;
-
- if (cth >= (heads * 1024) || heads > 16) {
- spt = 31;
- cth = secs / spt;
- heads = 16;
- }
-
- if (cth >= heads * 1024) {
- spt = 63;
- cth = secs / spt;
- heads = 16;
- }
- }
-
- cylinders = cth / heads;
-
- return GEOM_ENCODE(cylinders, heads, spt);
-}
-
-int
-vhd_get_footer(vhd_context_t *ctx)
-{
- if (!vhd_validate_footer(&ctx->footer))
- return 0;
-
- return vhd_read_footer(ctx, &ctx->footer);
-}
-
-int
-vhd_get_header(vhd_context_t *ctx)
-{
- if (!vhd_type_dynamic(ctx))
- return -EINVAL;
-
- if (!vhd_validate_header(&ctx->header))
- return 0;
-
- return vhd_read_header(ctx, &ctx->header);
-}
-
-int
-vhd_get_bat(vhd_context_t *ctx)
-{
- if (!vhd_type_dynamic(ctx))
- return -EINVAL;
-
- if (!vhd_validate_bat(&ctx->bat))
- return 0;
-
- vhd_put_bat(ctx);
- return vhd_read_bat(ctx, &ctx->bat);
-}
-
-int
-vhd_get_batmap(vhd_context_t *ctx)
-{
- if (!vhd_has_batmap(ctx))
- return -EINVAL;
-
- if (!vhd_validate_batmap(&ctx->batmap))
- return 0;
-
- vhd_put_batmap(ctx);
- return vhd_read_batmap(ctx, &ctx->batmap);
-}
-
-void
-vhd_put_footer(vhd_context_t *ctx)
-{
- memset(&ctx->footer, 0, sizeof(vhd_footer_t));
-}
-
-void
-vhd_put_header(vhd_context_t *ctx)
-{
- memset(&ctx->header, 0, sizeof(vhd_header_t));
-}
-
-void
-vhd_put_bat(vhd_context_t *ctx)
-{
- if (!vhd_type_dynamic(ctx))
- return;
-
- free(ctx->bat.bat);
- memset(&ctx->bat, 0, sizeof(vhd_bat_t));
-}
-
-void
-vhd_put_batmap(vhd_context_t *ctx)
-{
- if (!vhd_type_dynamic(ctx))
- return;
-
- if (!vhd_has_batmap(ctx))
- return;
-
- free(ctx->batmap.map);
- memset(&ctx->batmap, 0, sizeof(vhd_batmap_t));
-}
-
-/*
- * look for 511 byte footer at end of file
- */
-int
-vhd_read_short_footer(vhd_context_t *ctx, vhd_footer_t *footer)
-{
- int err;
- char *buf;
- off_t eof;
-
- buf = NULL;
-
- err = vhd_seek(ctx, 0, SEEK_END);
- if (err)
- goto out;
-
- eof = vhd_position(ctx);
- if (eof == (off_t)-1) {
- err = -errno;
- goto out;
- }
-
- err = vhd_seek(ctx, eof - 511, SEEK_SET);
- if (err)
- goto out;
-
- err = posix_memalign((void **)&buf,
- VHD_SECTOR_SIZE, sizeof(vhd_footer_t));
- if (err) {
- buf = NULL;
- err = -err;
- goto out;
- }
-
- memset(buf, 0, sizeof(vhd_footer_t));
-
- /*
- * expecting short read here
- */
- vhd_read(ctx, buf, sizeof(vhd_footer_t));
-
- memcpy(footer, buf, sizeof(vhd_footer_t));
-
- vhd_footer_in(footer);
- err = vhd_validate_footer(footer);
-
-out:
- if (err)
- VHDLOG("%s: failed reading short footer: %d\n",
- ctx->file, err);
- free(buf);
- return err;
-}
-
-int
-vhd_read_footer_at(vhd_context_t *ctx, vhd_footer_t *footer, off_t off)
-{
- int err;
- char *buf;
-
- buf = NULL;
-
- err = vhd_seek(ctx, off, SEEK_SET);
- if (err)
- goto out;
-
- err = posix_memalign((void **)&buf,
- VHD_SECTOR_SIZE, sizeof(vhd_footer_t));
- if (err) {
- buf = NULL;
- err = -err;
- goto out;
- }
-
- err = vhd_read(ctx, buf, sizeof(vhd_footer_t));
- if (err)
- goto out;
-
- memcpy(footer, buf, sizeof(vhd_footer_t));
-
- vhd_footer_in(footer);
- err = vhd_validate_footer(footer);
-
-out:
- if (err)
- VHDLOG("%s: reading footer at 0x%08"PRIx64" failed: %d\n",
- ctx->file, off, err);
- free(buf);
- return err;
-}
-
-int
-vhd_read_footer(vhd_context_t *ctx, vhd_footer_t *footer)
-{
- int err;
- off_t off;
-
- err = vhd_seek(ctx, 0, SEEK_END);
- if (err)
- return err;
-
- off = vhd_position(ctx);
- if (off == (off_t)-1)
- return -errno;
-
- err = vhd_read_footer_at(ctx, footer, off - 512);
- if (err != -EINVAL)
- return err;
-
- err = vhd_read_short_footer(ctx, footer);
- if (err != -EINVAL)
- return err;
-
- if (ctx->oflags & VHD_OPEN_STRICT)
- return -EINVAL;
-
- return vhd_read_footer_at(ctx, footer, 0);
-}
-
-int
-vhd_read_header_at(vhd_context_t *ctx, vhd_header_t *header, off_t off)
-{
- int err;
- char *buf;
-
- buf = NULL;
-
- if (!vhd_type_dynamic(ctx)) {
- err = -EINVAL;
- goto out;
- }
-
- err = vhd_seek(ctx, off, SEEK_SET);
- if (err)
- goto out;
-
- err = posix_memalign((void **)&buf,
- VHD_SECTOR_SIZE, sizeof(vhd_header_t));
- if (err) {
- buf = NULL;
- err = -err;
- goto out;
- }
-
- err = vhd_read(ctx, buf, sizeof(vhd_header_t));
- if (err)
- goto out;
-
- memcpy(header, buf, sizeof(vhd_header_t));
-
- vhd_header_in(header);
- err = vhd_validate_header(header);
-
-out:
- if (err)
- VHDLOG("%s: reading header at 0x%08"PRIx64" failed: %d\n",
- ctx->file, off, err);
- free(buf);
- return err;
-}
-
-int
-vhd_read_header(vhd_context_t *ctx, vhd_header_t *header)
-{
- int err;
- off_t off;
-
- if (!vhd_type_dynamic(ctx)) {
- VHDLOG("%s is not dynamic!\n", ctx->file);
- return -EINVAL;
- }
-
- off = ctx->footer.data_offset;
- return vhd_read_header_at(ctx, header, off);
-}
-
-int
-vhd_read_bat(vhd_context_t *ctx, vhd_bat_t *bat)
-{
- int err;
- char *buf;
- off_t off;
- size_t size;
-
- buf = NULL;
-
- if (!vhd_type_dynamic(ctx)) {
- err = -EINVAL;
- goto fail;
- }
-
- off = ctx->header.table_offset;
- size = vhd_bytes_padded(ctx->header.max_bat_size * sizeof(uint32_t));
-
- err = posix_memalign((void **)&buf, VHD_SECTOR_SIZE, size);
- if (err) {
- buf = NULL;
- err = -err;
- goto fail;
- }
-
- err = vhd_seek(ctx, off, SEEK_SET);
- if (err)
- goto fail;
-
- err = vhd_read(ctx, buf, size);
- if (err)
- goto fail;
-
- bat->spb = ctx->header.block_size >> VHD_SECTOR_SHIFT;
- bat->entries = ctx->header.max_bat_size;
- bat->bat = (uint32_t *)buf;
-
- vhd_bat_in(bat);
-
- return 0;
-
-fail:
- free(buf);
- memset(bat, 0, sizeof(vhd_bat_t));
- VHDLOG("%s: failed to read bat: %d\n", ctx->file, err);
- return err;
-}
-
-static int
-vhd_read_batmap_header(vhd_context_t *ctx, vhd_batmap_t *batmap)
-{
- int err;
- char *buf;
- off_t off;
- size_t size;
-
- buf = NULL;
-
- err = vhd_batmap_header_offset(ctx, &off);
- if (err)
- goto fail;
-
- err = vhd_seek(ctx, off, SEEK_SET);
- if (err)
- goto fail;
-
- size = vhd_bytes_padded(sizeof(vhd_batmap_header_t));
- err = posix_memalign((void **)&buf, VHD_SECTOR_SIZE, size);
- if (err) {
- buf = NULL;
- err = -err;
- goto fail;
- }
-
- err = vhd_read(ctx, buf, size);
- if (err)
- goto fail;
-
- memcpy(&batmap->header, buf, sizeof(vhd_batmap_header_t));
- free(buf);
- buf = NULL;
-
- vhd_batmap_header_in(batmap);
-
- return 0;
-
-fail:
- free(buf);
- memset(&batmap->header, 0, sizeof(vhd_batmap_header_t));
- VHDLOG("%s: failed to read batmap header: %d\n", ctx->file, err);
- return err;
-}
-
-static int
-vhd_read_batmap_map(vhd_context_t *ctx, vhd_batmap_t *batmap)
-{
- int err;
- char *buf;
- off_t off;
- size_t map_size;
-
- map_size = vhd_sectors_to_bytes(batmap->header.batmap_size);
-
- err = posix_memalign((void **)&buf, VHD_SECTOR_SIZE, map_size);
- if (err) {
- buf = NULL;
- err = -err;
- goto fail;
- }
-
- off = batmap->header.batmap_offset;
- err = vhd_seek(ctx, off, SEEK_SET);
- if (err)
- goto fail;
-
- err = vhd_read(ctx, buf, map_size);
- if (err)
- goto fail;
-
- batmap->map = buf;
- return 0;
-
-fail:
- free(buf);
- batmap->map = NULL;
- VHDLOG("%s: failed to read batmap: %d\n", ctx->file, err);
- return err;
-}
-
-int
-vhd_read_batmap(vhd_context_t *ctx, vhd_batmap_t *batmap)
-{
- int err;
-
- if (!vhd_has_batmap(ctx))
- return -EINVAL;
-
- memset(batmap, 0, sizeof(vhd_batmap_t));
-
- err = vhd_read_batmap_header(ctx, batmap);
- if (err)
- return err;
-
- err = vhd_validate_batmap_header(batmap);
- if (err)
- return err;
-
- err = vhd_read_batmap_map(ctx, batmap);
- if (err)
- return err;
-
- err = vhd_validate_batmap(batmap);
- if (err)
- goto fail;
-
- return 0;
-
-fail:
- free(batmap->map);
- memset(batmap, 0, sizeof(vhd_batmap_t));
- return err;
-}
-
-int
-vhd_has_batmap(vhd_context_t *ctx)
-{
- if (!vhd_type_dynamic(ctx))
- return 0;
-
- if (!vhd_creator_tapdisk(ctx))
- return 0;
-
- if (ctx->footer.crtr_ver <= VHD_VERSION(0, 1))
- return 0;
-
- if (ctx->footer.crtr_ver >= VHD_VERSION(1, 2))
- return 1;
-
- /*
- * VHDs of version 1.1 probably have a batmap, but may not
- * if they were updated from version 0.1 via vhd-update.
- */
- if (!vhd_validate_batmap_header(&ctx->batmap))
- return 1;
-
- if (vhd_read_batmap_header(ctx, &ctx->batmap))
- return 0;
-
- return (!vhd_validate_batmap_header(&ctx->batmap));
-}
-
-/*
- * Is this a block device (with a fixed size)? This affects whether the file
- * can be truncated and where the footer is written for VHDs.
- */
-int
-vhd_test_file_fixed(const char *file, int *is_block)
-{
- int err;
- struct stat stats;
-
- err = stat(file, &stats);
- if (err == -1)
- return -errno;
-
- *is_block = !!(S_ISBLK(stats.st_mode));
- return err;
-}
-
-int
-vhd_find_parent(vhd_context_t *ctx, const char *parent, char **_location)
-{
- int err;
- char *location, *cpath, *cdir, *path;
-
- err = 0;
- path = NULL;
- cpath = NULL;
- location = NULL;
- *_location = NULL;
-
- if (!parent)
- return -EINVAL;
-
- if (parent[0] == '/') {
- if (!access(parent, R_OK)) {
- path = strdup(parent);
- if (!path)
- return -ENOMEM;
- *_location = path;
- return 0;
- }
- }
-
- /* check parent path relative to child's directory */
- cpath = realpath(ctx->file, NULL);
- if (!cpath) {
- err = -errno;
- goto out;
- }
-
- cdir = dirname(cpath);
- if (asprintf(&location, "%s/%s", cdir, parent) == -1) {
- err = -errno;
- location = NULL;
- goto out;
- }
-
- if (!access(location, R_OK)) {
- path = realpath(location, NULL);
- if (path) {
- *_location = path;
- return 0;
- }
- }
- err = -errno;
-
-out:
- free(location);
- free(cpath);
- return err;
-}
-
-static int
-vhd_macx_encode_location(char *name, char **out, int *outlen)
-{
- iconv_t cd;
- int len, err;
- size_t ibl, obl;
- char *uri, *uri_utf8, *uri_utf8p, *ret;
- const char *urip;
- char *codeset;
-
- err = 0;
- ret = NULL;
- *out = NULL;
- *outlen = 0;
- len = strlen(name) + strlen("file://");
-
- ibl = len;
- obl = len * 2;
-
- urip = uri = malloc(ibl + 1);
- uri_utf8 = uri_utf8p = malloc(obl);
-
- if (!uri || !uri_utf8)
- return -ENOMEM;
-
- codeset = nl_langinfo(CODESET);
- cd = iconv_open("UTF-8", codeset);
- if (cd == (iconv_t)-1) {
- err = -errno;
- goto out;
- }
-
- snprintf(uri, ibl+1, "file://%s", name);
-
- if (iconv(cd,
-#ifdef __linux__
- (char **)
-#endif
- &urip, &ibl, &uri_utf8p, &obl) == (size_t)-1 ||
- ibl) {
- err = (errno ? -errno : -EIO);
- goto out;
- }
-
- ret = malloc(len);
- if (!ret) {
- err = -ENOMEM;
- goto out;
- }
-
- memcpy(ret, uri_utf8, len);
- *outlen = len;
- *out = ret;
-
- out:
- free(uri);
- free(uri_utf8);
- if (cd != (iconv_t)-1)
- iconv_close(cd);
-
- return err;
-}
-
-static int
-vhd_w2u_encode_location(char *name, char **out, int *outlen)
-{
- iconv_t cd;
- int len, err;
- size_t ibl, obl;
- char *uri, *uri_utf16, *uri_utf16p, *tmp, *ret;
- const char *urip;
- char *codeset;
-
- err = 0;
- ret = NULL;
- *out = NULL;
- *outlen = 0;
- cd = (iconv_t) -1;
-
- /*
- * MICROSOFT_COMPAT
- * relative paths must start with ".\"
- */
- if (name[0] != '/') {
- tmp = strstr(name, "./");
- if (tmp == name)
- tmp += strlen("./");
- else
- tmp = name;
-
- err = asprintf(&uri, ".\\%s", tmp);
- } else
- err = asprintf(&uri, "%s", name);
-
- if (err == -1)
- return -ENOMEM;
-
- tmp = uri;
- while (*tmp != '\0') {
- if (*tmp == '/')
- *tmp = '\\';
- tmp++;
- }
-
- len = strlen(uri);
- ibl = len;
- obl = len * 2;
- urip = uri;
-
- uri_utf16 = uri_utf16p = malloc(obl);
- if (!uri_utf16) {
- err = -ENOMEM;
- goto out;
- }
-
- /*
- * MICROSOFT_COMPAT
- * little endian unicode here
- */
- codeset = nl_langinfo(CODESET);
- cd = iconv_open("UTF-16LE", codeset);
- if (cd == (iconv_t)-1) {
- err = -errno;
- goto out;
- }
-
- if (iconv(cd,
-#ifdef __linux__
- (char **)
-#endif
- &urip, &ibl, &uri_utf16p, &obl) == (size_t)-1 ||
- ibl) {
- err = (errno ? -errno : -EIO);
- goto out;
- }
-
- len = len * 2;
- ret = malloc(len);
- if (!ret) {
- err = -ENOMEM;
- goto out;
- }
-
- memcpy(ret, uri_utf16, len);
- *outlen = len;
- *out = ret;
- err = 0;
-
- out:
- free(uri);
- free(uri_utf16);
- if (cd != (iconv_t)-1)
- iconv_close(cd);
-
- return err;
-}
-
-static char *
-vhd_macx_decode_location(const char *in, char *out, int len)
-{
- iconv_t cd;
- char *name;
- size_t ibl, obl;
- char *codeset;
-
- name = out;
- ibl = obl = len;
-
- codeset = nl_langinfo(CODESET);
- cd = iconv_open(codeset, "UTF-8");
- if (cd == (iconv_t)-1)
- return NULL;
-
- if (iconv(cd,
-#ifdef __linux__
- (char **)
-#endif
- &in, &ibl, &out, &obl) == (size_t)-1 || ibl)
- return NULL;
-
- iconv_close(cd);
- *out = '\0';
-
- if (strstr(name, "file://") != name)
- return NULL;
-
- name += strlen("file://");
-
- return strdup(name);
-}
-
-static char *
-vhd_w2u_decode_location(const char *in, char *out, int len, char *utf_type)
-{
- iconv_t cd;
- char *name, *tmp;
- size_t ibl, obl;
- char *codeset;
-
- tmp = name = out;
- ibl = obl = len;
-
- codeset = nl_langinfo(CODESET);
- cd = iconv_open(codeset, utf_type);
- if (cd == (iconv_t)-1)
- return NULL;
-
- if (iconv(cd,
-#ifdef __linux__
- (char **)
-#endif
- &in, &ibl, &out, &obl) == (size_t)-1 || ibl)
- return NULL;
-
- iconv_close(cd);
- *out = '\0';
-
- /* TODO: spaces */
- while (tmp != out) {
- if (*tmp == '\\')
- *tmp = '/';
- tmp++;
- }
-
- if (strstr(name, "C:") == name || strstr(name, "c:") == name)
- name += strlen("c:");
-
- return strdup(name);
-}
-
-int
-vhd_header_decode_parent(vhd_context_t *ctx, vhd_header_t *header, char **buf)
-{
- char *code, out[512];
-
- if (vhd_creator_tapdisk(ctx) &&
- ctx->footer.crtr_ver == VHD_VERSION(0, 1))
- code = UTF_16;
- else
- code = UTF_16BE;
-
- *buf = vhd_w2u_decode_location(header->prt_name, out, 512, code);
- return (*buf == NULL ? -EINVAL : 0);
-}
-
-int
-vhd_parent_locator_read(vhd_context_t *ctx,
- vhd_parent_locator_t *loc, char **parent)
-{
- int err, size;
- char *raw, *out, *name;
-
- raw = NULL;
- out = NULL;
- name = NULL;
- *parent = NULL;
-
- if (ctx->footer.type != HD_TYPE_DIFF) {
- err = -EINVAL;
- goto out;
- }
-
- switch (loc->code) {
- case PLAT_CODE_MACX:
- case PLAT_CODE_W2KU:
- case PLAT_CODE_W2RU:
- break;
- default:
- err = -EINVAL;
- goto out;
- }
-
- err = vhd_seek(ctx, loc->data_offset, SEEK_SET);
- if (err)
- goto out;
-
- size = vhd_parent_locator_size(loc);
- if (size <= 0) {
- err = -EINVAL;
- goto out;
- }
-
- err = posix_memalign((void **)&raw, VHD_SECTOR_SIZE, size);
- if (err) {
- raw = NULL;
- err = -err;
- goto out;
- }
-
- err = vhd_read(ctx, raw, size);
- if (err)
- goto out;
-
- out = malloc(loc->data_len + 1);
- if (!out) {
- err = -ENOMEM;
- goto out;
- }
-
- switch (loc->code) {
- case PLAT_CODE_MACX:
- name = vhd_macx_decode_location(raw, out, loc->data_len);
- break;
- case PLAT_CODE_W2KU:
- case PLAT_CODE_W2RU:
- name = vhd_w2u_decode_location(raw, out,
- loc->data_len, UTF_16LE);
- break;
- }
-
- if (!name) {
- err = -EINVAL;
- goto out;
- }
-
- err = 0;
- *parent = name;
-
-out:
- free(raw);
- free(out);
-
- if (err) {
- VHDLOG("%s: error reading parent locator: %d\n",
- ctx->file, err);
- VHDLOG("%s: locator: code %u, space 0x%x, len 0x%x, "
- "off 0x%"PRIx64"\n", ctx->file, loc->code, loc->data_space,
- loc->data_len, loc->data_offset);
- }
-
- return err;
-}
-
-int
-vhd_parent_locator_get(vhd_context_t *ctx, char **parent)
-{
- int i, n, err;
- char *name, *location;
- vhd_parent_locator_t *loc;
-
- err = 0;
- *parent = NULL;
-
- if (ctx->footer.type != HD_TYPE_DIFF)
- return -EINVAL;
-
- n = vhd_parent_locator_count(ctx);
- for (i = 0; i < n; i++) {
- loc = ctx->header.loc + i;
- err = vhd_parent_locator_read(ctx, loc, &name);
- if (err)
- continue;
-
- err = vhd_find_parent(ctx, name, &location);
- if (err)
- VHDLOG("%s: couldn't find parent %s (%d)\n",
- ctx->file, name, err);
- free(name);
-
- if (!err) {
- *parent = location;
- return 0;
- }
- }
-
- return err;
-}
-
-int
-vhd_parent_locator_write_at(vhd_context_t *ctx,
- const char *parent, off_t off, uint32_t code,
- size_t max_bytes, vhd_parent_locator_t *loc)
-{
- struct stat stats;
- int err, len, size;
- char *absolute_path, *relative_path, *encoded, *block;
-
- memset(loc, 0, sizeof(vhd_parent_locator_t));
-
- if (ctx->footer.type != HD_TYPE_DIFF)
- return -EINVAL;
-
- absolute_path = NULL;
- relative_path = NULL;
- encoded = NULL;
- block = NULL;
- size = 0;
- len = 0;
-
- switch (code) {
- case PLAT_CODE_MACX:
- case PLAT_CODE_W2KU:
- case PLAT_CODE_W2RU:
- break;
- default:
- return -EINVAL;
- }
-
- absolute_path = realpath(parent, NULL);
- if (!absolute_path) {
- err = -errno;
- goto out;
- }
-
- err = stat(absolute_path, &stats);
- if (err) {
- err = -errno;
- goto out;
- }
-
- if (!S_ISREG(stats.st_mode) && !S_ISBLK(stats.st_mode)) {
- err = -EINVAL;
- goto out;
- }
-
- relative_path = relative_path_to(ctx->file, absolute_path, &err);
- if (!relative_path || err) {
- err = (err ? err : -EINVAL);
- goto out;
- }
-
- switch (code) {
- case PLAT_CODE_MACX:
- err = vhd_macx_encode_location(relative_path, &encoded, &len);
- break;
- case PLAT_CODE_W2KU:
- case PLAT_CODE_W2RU:
- err = vhd_w2u_encode_location(relative_path, &encoded, &len);
- break;
- default:
- err = -EINVAL;
- }
-
- if (err)
- goto out;
-
- err = vhd_seek(ctx, off, SEEK_SET);
- if (err)
- goto out;
-
- size = vhd_bytes_padded(len);
-
- if (max_bytes && size > max_bytes) {
- err = -ENAMETOOLONG;
- goto out;
- }
-
- err = posix_memalign((void **)&block, VHD_SECTOR_SIZE, size);
- if (err) {
- block = NULL;
- err = -err;
- goto out;
- }
-
- memset(block, 0, size);
- memcpy(block, encoded, len);
-
- err = vhd_write(ctx, block, size);
- if (err)
- goto out;
-
- err = 0;
-
-out:
- free(absolute_path);
- free(relative_path);
- free(encoded);
- free(block);
-
- if (!err) {
- loc->res = 0;
- loc->code = code;
- loc->data_len = len;
- /*
- * write number of bytes ('size') instead of number of sectors
- * into loc->data_space to be compatible with MSFT, even though
- * this goes against the specs
- */
- loc->data_space = size;
- loc->data_offset = off;
- }
-
- return err;
-}
-
-static int
-vhd_footer_offset_at_eof(vhd_context_t *ctx, off_t *off)
-{
- int err;
- if ((err = vhd_seek(ctx, 0, SEEK_END)))
- return errno;
- *off = vhd_position(ctx) - sizeof(vhd_footer_t);
- return 0;
-}
-
-int
-vhd_read_bitmap(vhd_context_t *ctx, uint32_t block, char **bufp)
-{
- int err;
- char *buf;
- size_t size;
- off_t off;
- uint64_t blk;
-
- buf = NULL;
- *bufp = NULL;
-
- if (!vhd_type_dynamic(ctx))
- return -EINVAL;
-
- err = vhd_get_bat(ctx);
- if (err)
- return err;
-
- if (block >= ctx->bat.entries)
- return -ERANGE;
-
- blk = ctx->bat.bat[block];
- if (blk == DD_BLK_UNUSED)
- return -EINVAL;
-
- off = vhd_sectors_to_bytes(blk);
- size = vhd_bytes_padded(ctx->spb >> 3);
-
- err = vhd_seek(ctx, off, SEEK_SET);
- if (err)
- return err;
-
- err = posix_memalign((void **)&buf, VHD_SECTOR_SIZE, size);
- if (err)
- return -err;
-
- err = vhd_read(ctx, buf, size);
- if (err)
- goto fail;
-
- *bufp = buf;
- return 0;
-
-fail:
- free(buf);
- return err;
-}
-
-int
-vhd_read_block(vhd_context_t *ctx, uint32_t block, char **bufp)
-{
- int err;
- char *buf;
- size_t size;
- uint64_t blk;
- off_t end, off;
-
- buf = NULL;
- *bufp = NULL;
-
- if (!vhd_type_dynamic(ctx))
- return -EINVAL;
-
- err = vhd_get_bat(ctx);
- if (err)
- return err;
-
- if (block >= ctx->bat.entries)
- return -ERANGE;
-
- blk = ctx->bat.bat[block];
- if (blk == DD_BLK_UNUSED)
- return -EINVAL;
-
- off = vhd_sectors_to_bytes(blk + ctx->bm_secs);
- size = vhd_sectors_to_bytes(ctx->spb);
-
- err = vhd_footer_offset_at_eof(ctx, &end);
- if (err)
- return err;
-
- err = posix_memalign((void **)&buf, VHD_SECTOR_SIZE, size);
- if (err) {
- err = -err;
- goto fail;
- }
-
- if (end < off + ctx->header.block_size) {
- size = end - off;
- memset(buf + size, 0, ctx->header.block_size - size);
- }
-
- err = vhd_seek(ctx, off, SEEK_SET);
- if (err)
- goto fail;
-
- err = vhd_read(ctx, buf, size);
- if (err)
- goto fail;
-
- *bufp = buf;
- return 0;
-
-fail:
- free(buf);
- return err;
-}
-
-int
-vhd_write_footer_at(vhd_context_t *ctx, vhd_footer_t *footer, off_t off)
-{
- int err;
- vhd_footer_t *f;
-
- f = NULL;
-
- err = posix_memalign((void **)&f,
- VHD_SECTOR_SIZE, sizeof(vhd_footer_t));
- if (err) {
- f = NULL;
- err = -err;
- goto out;
- }
-
- memcpy(f, footer, sizeof(vhd_footer_t));
- f->checksum = vhd_checksum_footer(f);
-
- err = vhd_validate_footer(f);
- if (err)
- goto out;
-
- err = vhd_seek(ctx, off, SEEK_SET);
- if (err)
- goto out;
-
- vhd_footer_out(f);
-
- err = vhd_write(ctx, f, sizeof(vhd_footer_t));
-
-out:
- if (err)
- VHDLOG("%s: failed writing footer at 0x%08"PRIx64": %d\n",
- ctx->file, off, err);
- free(f);
- return err;
-}
-
-int
-vhd_write_footer(vhd_context_t *ctx, vhd_footer_t *footer)
-{
- int err;
- off_t off;
-
- if (ctx->is_block)
- err = vhd_footer_offset_at_eof(ctx, &off);
- else
- err = vhd_end_of_data(ctx, &off);
- if (err)
- return err;
-
- err = vhd_write_footer_at(ctx, footer, off);
- if (err)
- return err;
-
- if (!vhd_type_dynamic(ctx))
- return 0;
-
- return vhd_write_footer_at(ctx, footer, 0);
-}
-
-int
-vhd_write_header_at(vhd_context_t *ctx, vhd_header_t *header, off_t off)
-{
- int err;
- vhd_header_t *h;
-
- h = NULL;
-
- if (!vhd_type_dynamic(ctx)) {
- err = -EINVAL;
- goto out;
- }
-
- err = posix_memalign((void **)&h,
- VHD_SECTOR_SIZE, sizeof(vhd_header_t));
- if (err) {
- h = NULL;
- err = -err;
- goto out;
- }
-
- memcpy(h, header, sizeof(vhd_header_t));
-
- h->checksum = vhd_checksum_header(h);
- err = vhd_validate_header(h);
- if (err)
- goto out;
-
- vhd_header_out(h);
-
- err = vhd_seek(ctx, off, SEEK_SET);
- if (err)
- goto out;
-
- err = vhd_write(ctx, h, sizeof(vhd_header_t));
-
-out:
- if (err)
- VHDLOG("%s: failed writing header at 0x%08"PRIx64": %d\n",
- ctx->file, off, err);
- free(h);
- return err;
-}
-
-int
-vhd_write_header(vhd_context_t *ctx, vhd_header_t *header)
-{
- int err;
- off_t off;
-
- if (!vhd_type_dynamic(ctx))
- return -EINVAL;
-
- off = ctx->footer.data_offset;
- return vhd_write_header_at(ctx, header, off);
-}
-
-int
-vhd_write_bat(vhd_context_t *ctx, vhd_bat_t *bat)
-{
- int err;
- off_t off;
- vhd_bat_t b;
- size_t size;
-
- if (!vhd_type_dynamic(ctx))
- return -EINVAL;
-
- err = vhd_validate_bat(&ctx->bat);
- if (err)
- return err;
-
- err = vhd_validate_bat(bat);
- if (err)
- return err;
-
- memset(&b, 0, sizeof(vhd_bat_t));
-
- off = ctx->header.table_offset;
- size = vhd_bytes_padded(bat->entries * sizeof(uint32_t));
-
- err = vhd_seek(ctx, off, SEEK_SET);
- if (err)
- return err;
-
- err = posix_memalign((void **)&b.bat, VHD_SECTOR_SIZE, size);
- if (err)
- return -err;
-
- memcpy(b.bat, bat->bat, size);
- b.spb = bat->spb;
- b.entries = bat->entries;
- vhd_bat_out(&b);
-
- err = vhd_write(ctx, b.bat, size);
- free(b.bat);
-
- return err;
-}
-
-int
-vhd_write_batmap(vhd_context_t *ctx, vhd_batmap_t *batmap)
-{
- int err;
- off_t off;
- vhd_batmap_t b;
- char *buf, *map;
- size_t size, map_size;
-
- buf = NULL;
- map = NULL;
-
- if (!vhd_has_batmap(ctx)) {
- err = -EINVAL;
- goto out;
- }
-
- b.header = batmap->header;
- b.map = batmap->map;
-
- b.header.checksum = vhd_checksum_batmap(&b);
- err = vhd_validate_batmap(&b);
- if (err)
- goto out;
-
- off = b.header.batmap_offset;
- map_size = vhd_sectors_to_bytes(b.header.batmap_size);
-
- err = vhd_seek(ctx, off, SEEK_SET);
- if (err)
- goto out;
-
- err = posix_memalign((void **)&map, VHD_SECTOR_SIZE, map_size);
- if (err) {
- map = NULL;
- err = -err;
- goto out;
- }
-
- memcpy(map, b.map, map_size);
-
- err = vhd_write(ctx, map, map_size);
- if (err)
- goto out;
-
- err = vhd_batmap_header_offset(ctx, &off);
- if (err)
- goto out;
-
- size = vhd_bytes_padded(sizeof(vhd_batmap_header_t));
-
- err = vhd_seek(ctx, off, SEEK_SET);
- if (err)
- goto out;
-
- err = posix_memalign((void **)&buf, VHD_SECTOR_SIZE, size);
- if (err) {
- err = -err;
- buf = NULL;
- goto out;
- }
-
- vhd_batmap_header_out(&b);
- memset(buf, 0, size);
- memcpy(buf, &b.header, sizeof(vhd_batmap_header_t));
-
- err = vhd_write(ctx, buf, size);
-
-out:
- if (err)
- VHDLOG("%s: failed writing batmap: %d\n", ctx->file, err);
- free(buf);
- free(map);
- return 0;
-}
-
-int
-vhd_write_bitmap(vhd_context_t *ctx, uint32_t block, char *bitmap)
-{
- int err;
- off_t off;
- uint64_t blk;
- size_t secs, size;
-
- if (!vhd_type_dynamic(ctx))
- return -EINVAL;
-
- err = vhd_validate_bat(&ctx->bat);
- if (err)
- return err;
-
- if (block >= ctx->bat.entries)
- return -ERANGE;
-
- if ((unsigned long)bitmap & (VHD_SECTOR_SIZE - 1))
- return -EINVAL;
-
- blk = ctx->bat.bat[block];
- if (blk == DD_BLK_UNUSED)
- return -EINVAL;
-
- off = vhd_sectors_to_bytes(blk);
- size = vhd_sectors_to_bytes(ctx->bm_secs);
-
- err = vhd_seek(ctx, off, SEEK_SET);
- if (err)
- return err;
-
- err = vhd_write(ctx, bitmap, size);
- if (err)
- return err;
-
- return 0;
-}
-
-int
-vhd_write_block(vhd_context_t *ctx, uint32_t block, char *data)
-{
- int err;
- off_t off;
- size_t size;
- uint64_t blk;
-
- if (!vhd_type_dynamic(ctx))
- return -EINVAL;
-
- err = vhd_validate_bat(&ctx->bat);
- if (err)
- return err;
-
- if (block >= ctx->bat.entries)
- return -ERANGE;
-
- if ((unsigned long)data & (VHD_SECTOR_SIZE -1))
- return -EINVAL;
-
- blk = ctx->bat.bat[block];
- if (blk == DD_BLK_UNUSED)
- return -EINVAL;
-
- off = vhd_sectors_to_bytes(blk + ctx->bm_secs);
- size = vhd_sectors_to_bytes(ctx->spb);
-
- err = vhd_seek(ctx, off, SEEK_SET);
- if (err)
- return err;
-
- err = vhd_write(ctx, data, size);
- if (err)
- return err;
-
- return 0;
-}
-
-static inline int
-namedup(char **dup, const char *name)
-{
- *dup = NULL;
-
- if (strnlen(name, MAX_NAME_LEN) >= MAX_NAME_LEN)
- return -ENAMETOOLONG;
-
- *dup = strdup(name);
- if (*dup == NULL)
- return -ENOMEM;
-
- return 0;
-}
-
-int
-vhd_seek(vhd_context_t *ctx, off_t offset, int whence)
-{
- off_t off;
-
- off = lseek(ctx->fd, offset, whence);
- if (off == (off_t)-1) {
- VHDLOG("%s: seek(0x%08"PRIx64", %d) failed: %d\n",
- ctx->file, offset, whence, -errno);
- return -errno;
- }
-
- return 0;
-}
-
-off_t
-vhd_position(vhd_context_t *ctx)
-{
- return lseek(ctx->fd, 0, SEEK_CUR);
-}
-
-int
-vhd_read(vhd_context_t *ctx, void *buf, size_t size)
-{
- size_t ret;
-
- errno = 0;
-
- ret = read(ctx->fd, buf, size);
- if (ret == size)
- return 0;
-
- VHDLOG("%s: read of %zu returned %zd, errno: %d\n",
- ctx->file, size, ret, -errno);
-
- return (errno ? -errno : -EIO);
-}
-
-int
-vhd_write(vhd_context_t *ctx, void *buf, size_t size)
-{
- size_t ret;
-
- errno = 0;
-
- ret = write(ctx->fd, buf, size);
- if (ret == size)
- return 0;
-
- VHDLOG("%s: write of %zu returned %zd, errno: %d\n",
- ctx->file, size, ret, -errno);
-
- return (errno ? -errno : -EIO);
-}
-
-int
-vhd_offset(vhd_context_t *ctx, uint32_t sector, uint32_t *offset)
-{
- int err;
- uint32_t block;
-
- if (!vhd_type_dynamic(ctx))
- return sector;
-
- err = vhd_get_bat(ctx);
- if (err)
- return err;
-
- block = sector / ctx->spb;
- if (ctx->bat.bat[block] == DD_BLK_UNUSED)
- *offset = DD_BLK_UNUSED;
- else
- *offset = ctx->bat.bat[block] +
- ctx->bm_secs + (sector % ctx->spb);
-
- return 0;
-}
-
-int
-vhd_open_fast(vhd_context_t *ctx)
-{
- int err;
- char *buf;
- size_t size;
-
- size = sizeof(vhd_footer_t) + sizeof(vhd_header_t);
- err = posix_memalign((void **)&buf, VHD_SECTOR_SIZE, size);
- if (err) {
- VHDLOG("failed allocating %s: %d\n", ctx->file, -err);
- return -err;
- }
-
- err = vhd_read(ctx, buf, size);
- if (err) {
- VHDLOG("failed reading %s: %d\n", ctx->file, err);
- goto out;
- }
-
- memcpy(&ctx->footer, buf, sizeof(vhd_footer_t));
- vhd_footer_in(&ctx->footer);
- err = vhd_validate_footer(&ctx->footer);
- if (err)
- goto out;
-
- if (vhd_type_dynamic(ctx)) {
- if (ctx->footer.data_offset != sizeof(vhd_footer_t))
- err = vhd_read_header(ctx, &ctx->header);
- else {
- memcpy(&ctx->header,
- buf + sizeof(vhd_footer_t),
- sizeof(vhd_header_t));
- vhd_header_in(&ctx->header);
- err = vhd_validate_header(&ctx->header);
- }
-
- if (err)
- goto out;
-
- ctx->spb = ctx->header.block_size >> VHD_SECTOR_SHIFT;
- ctx->bm_secs = secs_round_up_no_zero(ctx->spb >> 3);
- }
-
-out:
- free(buf);
- return err;
-}
-
-int
-vhd_open(vhd_context_t *ctx, const char *file, int flags)
-{
- int err, oflags;
-
- if (flags & VHD_OPEN_STRICT)
- vhd_flag_clear(flags, VHD_OPEN_FAST);
-
- memset(ctx, 0, sizeof(vhd_context_t));
- ctx->fd = -1;
- ctx->oflags = flags;
-
- err = namedup(&ctx->file, file);
- if (err)
- return err;
-
- oflags = O_DIRECT | O_LARGEFILE;
- if (flags & VHD_OPEN_RDONLY)
- oflags |= O_RDONLY;
- if (flags & VHD_OPEN_RDWR)
- oflags |= O_RDWR;
-
- ctx->fd = open(ctx->file, oflags, 0644);
- if (ctx->fd == -1) {
- err = -errno;
- VHDLOG("failed to open %s: %d\n", ctx->file, err);
- goto fail;
- }
-
- err = vhd_test_file_fixed(ctx->file, &ctx->is_block);
- if (err)
- goto fail;
-
- if (flags & VHD_OPEN_FAST) {
- err = vhd_open_fast(ctx);
- if (err)
- goto fail;
-
- return 0;
- }
-
- err = vhd_read_footer(ctx, &ctx->footer);
- if (err)
- goto fail;
-
- if (!(flags & VHD_OPEN_IGNORE_DISABLED) && vhd_disabled(ctx)) {
- err = -EINVAL;
- goto fail;
- }
-
- if (vhd_type_dynamic(ctx)) {
- err = vhd_read_header(ctx, &ctx->header);
- if (err)
- goto fail;
-
- ctx->spb = ctx->header.block_size >> VHD_SECTOR_SHIFT;
- ctx->bm_secs = secs_round_up_no_zero(ctx->spb >> 3);
- }
-
- return 0;
-
-fail:
- if (ctx->fd != -1)
- close(ctx->fd);
- free(ctx->file);
- memset(ctx, 0, sizeof(vhd_context_t));
- return err;
-}
-
-void
-vhd_close(vhd_context_t *ctx)
-{
- if (ctx->file)
- close(ctx->fd);
- free(ctx->file);
- free(ctx->bat.bat);
- free(ctx->batmap.map);
- memset(ctx, 0, sizeof(vhd_context_t));
-}
-
-static inline void
-vhd_initialize_footer(vhd_context_t *ctx, int type, uint64_t size)
-{
- memset(&ctx->footer, 0, sizeof(vhd_footer_t));
- memcpy(ctx->footer.cookie, HD_COOKIE, sizeof(ctx->footer.cookie));
- ctx->footer.features = HD_RESERVED;
- ctx->footer.ff_version = HD_FF_VERSION;
- ctx->footer.timestamp = vhd_time(time(NULL));
- ctx->footer.crtr_ver = VHD_CURRENT_VERSION;
- ctx->footer.crtr_os = 0x00000000;
- ctx->footer.orig_size = size;
- ctx->footer.curr_size = size;
- ctx->footer.geometry = vhd_chs(size);
- ctx->footer.type = type;
- ctx->footer.saved = 0;
- ctx->footer.data_offset = 0xFFFFFFFFFFFFFFFF;
- strcpy(ctx->footer.crtr_app, "tap");
- vhd_uuid_generate(&ctx->footer.uuid);
-}
-
-static int
-vhd_initialize_header_parent_name(vhd_context_t *ctx, const char *parent_path)
-{
- int err;
- iconv_t cd;
- size_t ibl, obl;
- char *ppath, *dst;
- const char *pname;
- char *codeset;
-
- err = 0;
- pname = NULL;
- ppath = NULL;
-
- /*
- * MICROSOFT_COMPAT
- * big endian unicode here
- */
- codeset = nl_langinfo(CODESET);
- cd = iconv_open(UTF_16BE, codeset);
- if (cd == (iconv_t)-1) {
- err = -errno;
- goto out;
- }
-
- ppath = strdup(parent_path);
- if (!ppath) {
- err = -ENOMEM;
- goto out;
- }
-
- pname = basename(ppath);
- if (!strcmp(pname, "")) {
- err = -EINVAL;
- goto out;
- }
-
- ibl = strlen(pname);
- obl = sizeof(ctx->header.prt_name);
- dst = ctx->header.prt_name;
-
- memset(dst, 0, obl);
-
- if (iconv(cd,
-#ifdef __linux__
- (char **)
-#endif
- &pname, &ibl, &dst, &obl) == (size_t)-1 || ibl)
- err = (errno ? -errno : -EINVAL);
-
-out:
- iconv_close(cd);
- free(ppath);
- return err;
-}
-
-static off_t
-get_file_size(const char *name)
-{
- int fd;
- off_t end;
-
- fd = open(name, O_LARGEFILE | O_RDONLY);
- if (fd == -1) {
- VHDLOG("unable to open '%s': %d\n", name, errno);
- return -errno;
- }
- end = lseek(fd, 0, SEEK_END);
- close(fd);
- return end;
-}
-
-static int
-vhd_initialize_header(vhd_context_t *ctx, const char *parent_path,
- uint64_t size, int raw)
-{
- int err;
- struct stat stats;
- vhd_context_t parent;
-
- if (!vhd_type_dynamic(ctx))
- return -EINVAL;
-
- memset(&ctx->header, 0, sizeof(vhd_header_t));
- memcpy(ctx->header.cookie, DD_COOKIE, sizeof(ctx->header.cookie));
- ctx->header.data_offset = (uint64_t)-1;
- ctx->header.table_offset = VHD_SECTOR_SIZE * 3; /* 1 ftr + 2 hdr */
- ctx->header.hdr_ver = DD_VERSION;
- ctx->header.block_size = VHD_BLOCK_SIZE;
- ctx->header.prt_ts = 0;
- ctx->header.res1 = 0;
- ctx->header.max_bat_size = (ctx->footer.curr_size +
- VHD_BLOCK_SIZE - 1) >> VHD_BLOCK_SHIFT;
-
- ctx->footer.data_offset = VHD_SECTOR_SIZE;
-
- if (ctx->footer.type == HD_TYPE_DYNAMIC)
- return 0;
-
- err = stat(parent_path, &stats);
- if (err == -1)
- return -errno;
-
- if (raw) {
- ctx->header.prt_ts = vhd_time(stats.st_mtime);
- if (!size)
- size = get_file_size(parent_path);
- }
- else {
- err = vhd_open(&parent, parent_path, VHD_OPEN_RDONLY);
- if (err)
- return err;
-
- ctx->header.prt_ts = vhd_time(stats.st_mtime);
- vhd_uuid_copy(&ctx->header.prt_uuid, &parent.footer.uuid);
- if (!size)
- size = parent.footer.curr_size;
- vhd_close(&parent);
- }
- ctx->footer.orig_size = size;
- ctx->footer.curr_size = size;
- ctx->footer.geometry = vhd_chs(size);
- ctx->header.max_bat_size =
- (size + VHD_BLOCK_SIZE - 1) >> VHD_BLOCK_SHIFT;
-
- return vhd_initialize_header_parent_name(ctx, parent_path);
-}
-
-static int
-vhd_write_parent_locators(vhd_context_t *ctx, const char *parent)
-{
- int i, err;
- off_t off;
- uint32_t code;
-
- code = PLAT_CODE_NONE;
-
- if (ctx->footer.type != HD_TYPE_DIFF)
- return -EINVAL;
-
- off = ctx->batmap.header.batmap_offset +
- vhd_sectors_to_bytes(ctx->batmap.header.batmap_size);
- if (off & (VHD_SECTOR_SIZE - 1))
- off = vhd_bytes_padded(off);
-
- for (i = 0; i < 3; i++) {
- switch (i) {
- case 0:
- code = PLAT_CODE_MACX;
- break;
- case 1:
- code = PLAT_CODE_W2KU;
- break;
- case 2:
- code = PLAT_CODE_W2RU;
- break;
- }
-
- err = vhd_parent_locator_write_at(ctx, parent, off, code,
- 0, ctx->header.loc + i);
- if (err)
- return err;
-
- off += vhd_parent_locator_size(ctx->header.loc + i);
- }
-
- return 0;
-}
-
-int
-vhd_change_parent(vhd_context_t *child, char *parent_path, int raw)
-{
- int i, err;
- char *ppath;
- struct stat stats;
- vhd_context_t parent;
-
- ppath = realpath(parent_path, NULL);
- if (!ppath) {
- VHDLOG("error resolving parent path %s for %s: %d\n",
- parent_path, child->file, errno);
- return -errno;
- }
-
- err = stat(ppath, &stats);
- if (err == -1) {
- err = -errno;
- goto out;
- }
-
- if (!S_ISREG(stats.st_mode) && !S_ISBLK(stats.st_mode)) {
- err = -EINVAL;
- goto out;
- }
-
- if (raw) {
- vhd_uuid_clear(&child->header.prt_uuid);
- } else {
- err = vhd_open(&parent, ppath, VHD_OPEN_RDONLY);
- if (err) {
- VHDLOG("error opening parent %s for %s: %d\n",
- ppath, child->file, err);
- goto out;
- }
- vhd_uuid_copy(&child->header.prt_uuid, &parent.footer.uuid);
- vhd_close(&parent);
- }
-
- vhd_initialize_header_parent_name(child, ppath);
- child->header.prt_ts = vhd_time(stats.st_mtime);
-
- for (i = 0; i < vhd_parent_locator_count(child); i++) {
- vhd_parent_locator_t *loc = child->header.loc + i;
- size_t max = vhd_parent_locator_size(loc);
-
- switch (loc->code) {
- case PLAT_CODE_MACX:
- case PLAT_CODE_W2KU:
- case PLAT_CODE_W2RU:
- break;
- default:
- continue;
- }
-
- err = vhd_parent_locator_write_at(child, ppath,
- loc->data_offset,
- loc->code, max, loc);
- if (err) {
- VHDLOG("error writing parent locator %d for %s: %d\n",
- i, child->file, err);
- goto out;
- }
- }
-
- TEST_FAIL_AT(FAIL_REPARENT_LOCATOR);
-
- err = vhd_write_header(child, &child->header);
- if (err) {
- VHDLOG("error writing header for %s: %d\n", child->file, err);
- goto out;
- }
-
- err = 0;
-
-out:
- free(ppath);
- return err;
-}
-
-static int
-vhd_create_batmap(vhd_context_t *ctx)
-{
- off_t off;
- int err, map_bytes;
- vhd_batmap_header_t *header;
-
- if (!vhd_type_dynamic(ctx))
- return -EINVAL;
-
- map_bytes = (ctx->header.max_bat_size + 7) >> 3;
- header = &ctx->batmap.header;
-
- memset(header, 0, sizeof(vhd_batmap_header_t));
- memcpy(header->cookie, VHD_BATMAP_COOKIE, sizeof(header->cookie));
-
- err = vhd_batmap_header_offset(ctx, &off);
- if (err)
- return err;
-
- header->batmap_offset = off +
- vhd_bytes_padded(sizeof(vhd_batmap_header_t));
- header->batmap_size = secs_round_up_no_zero(map_bytes);
- header->batmap_version = VHD_BATMAP_CURRENT_VERSION;
-
- map_bytes = vhd_sectors_to_bytes(header->batmap_size);
-
- err = posix_memalign((void **)&ctx->batmap.map,
- VHD_SECTOR_SIZE, map_bytes);
- if (err) {
- ctx->batmap.map = NULL;
- return -err;
- }
-
- memset(ctx->batmap.map, 0, map_bytes);
-
- return vhd_write_batmap(ctx, &ctx->batmap);
-}
-
-static int
-vhd_create_bat(vhd_context_t *ctx)
-{
- int i, err;
- size_t size;
-
- if (!vhd_type_dynamic(ctx))
- return -EINVAL;
-
- size = vhd_bytes_padded(ctx->header.max_bat_size * sizeof(uint32_t));
- err = posix_memalign((void **)&ctx->bat.bat, VHD_SECTOR_SIZE, size);
- if (err) {
- ctx->bat.bat = NULL;
- return err;
- }
-
- memset(ctx->bat.bat, 0, size);
- for (i = 0; i < ctx->header.max_bat_size; i++)
- ctx->bat.bat[i] = DD_BLK_UNUSED;
-
- err = vhd_seek(ctx, ctx->header.table_offset, SEEK_SET);
- if (err)
- return err;
-
- ctx->bat.entries = ctx->header.max_bat_size;
- ctx->bat.spb = ctx->header.block_size >> VHD_SECTOR_SHIFT;
-
- return vhd_write_bat(ctx, &ctx->bat);
-}
-
-static int
-vhd_initialize_fixed_disk(vhd_context_t *ctx)
-{
- char *buf;
- int i, err;
-
- if (ctx->footer.type != HD_TYPE_FIXED)
- return -EINVAL;
-
- err = vhd_seek(ctx, 0, SEEK_SET);
- if (err)
- return err;
-
- buf = mmap(0, VHD_BLOCK_SIZE, PROT_READ,
- MAP_SHARED | MAP_ANON, -1, 0);
- if (buf == MAP_FAILED)
- return -errno;
-
- for (i = 0; i < ctx->footer.curr_size >> VHD_BLOCK_SHIFT; i++) {
- err = vhd_write(ctx, buf, VHD_BLOCK_SIZE);
- if (err)
- goto out;
- }
-
- err = 0;
-
-out:
- munmap(buf, VHD_BLOCK_SIZE);
- return err;
-}
-
-int
-vhd_get_phys_size(vhd_context_t *ctx, off_t *size)
-{
- int err;
-
- if ((err = vhd_end_of_data(ctx, size)))
- return err;
- *size += sizeof(vhd_footer_t);
- return 0;
-}
-
-int
-vhd_set_phys_size(vhd_context_t *ctx, off_t size)
-{
- off_t phys_size;
- int err;
-
- err = vhd_get_phys_size(ctx, &phys_size);
- if (err)
- return err;
- if (size < phys_size) {
- // would result in data loss
- VHDLOG("ERROR: new size (%"PRIu64") < phys size (%"PRIu64")\n",
- size, phys_size);
- return -EINVAL;
- }
- return vhd_write_footer_at(ctx, &ctx->footer,
- size - sizeof(vhd_footer_t));
-}
-
-static int
-__vhd_create(const char *name, const char *parent, uint64_t bytes, int type,
- vhd_flag_creat_t flags)
-{
- int err;
- off_t off;
- vhd_context_t ctx;
- vhd_footer_t *footer;
- vhd_header_t *header;
- uint64_t size, blks;
-
- switch (type) {
- case HD_TYPE_DIFF:
- if (!parent)
- return -EINVAL;
- case HD_TYPE_FIXED:
- case HD_TYPE_DYNAMIC:
- break;
- default:
- return -EINVAL;
- }
-
- if (strnlen(name, VHD_MAX_NAME_LEN - 1) == VHD_MAX_NAME_LEN - 1)
- return -ENAMETOOLONG;
-
- memset(&ctx, 0, sizeof(vhd_context_t));
- footer = &ctx.footer;
- header = &ctx.header;
- blks = (bytes + VHD_BLOCK_SIZE - 1) >> VHD_BLOCK_SHIFT;
- size = blks << VHD_BLOCK_SHIFT;
-
- ctx.fd = open(name, O_WRONLY | O_CREAT |
- O_TRUNC | O_LARGEFILE | O_DIRECT, 0644);
- if (ctx.fd == -1)
- return -errno;
-
- ctx.file = strdup(name);
- if (!ctx.file) {
- err = -ENOMEM;
- goto out;
- }
-
- err = vhd_test_file_fixed(ctx.file, &ctx.is_block);
- if (err)
- goto out;
-
- vhd_initialize_footer(&ctx, type, size);
-
- if (type == HD_TYPE_FIXED) {
- err = vhd_initialize_fixed_disk(&ctx);
- if (err)
- goto out;
- } else {
- int raw = vhd_flag_test(flags, VHD_FLAG_CREAT_PARENT_RAW);
- err = vhd_initialize_header(&ctx, parent, size, raw);
- if (err)
- goto out;
-
- err = vhd_write_footer_at(&ctx, &ctx.footer, 0);
- if (err)
- goto out;
-
- err = vhd_write_header_at(&ctx, &ctx.header, VHD_SECTOR_SIZE);
- if (err)
- goto out;
-
- err = vhd_create_batmap(&ctx);
- if (err)
- goto out;
-
- err = vhd_create_bat(&ctx);
- if (err)
- goto out;
-
- if (type == HD_TYPE_DIFF) {
- err = vhd_write_parent_locators(&ctx, parent);
- if (err)
- goto out;
- }
-
- /* write header again since it may have changed */
- err = vhd_write_header_at(&ctx, &ctx.header, VHD_SECTOR_SIZE);
- if (err)
- goto out;
- }
-
- err = vhd_seek(&ctx, 0, SEEK_END);
- if (err)
- goto out;
-
- off = vhd_position(&ctx);
- if (off == (off_t)-1) {
- err = -errno;
- goto out;
- }
-
- if (ctx.is_block)
- off -= sizeof(vhd_footer_t);
-
- err = vhd_write_footer_at(&ctx, &ctx.footer, off);
- if (err)
- goto out;
-
- err = 0;
-
-out:
- vhd_close(&ctx);
- if (err && !ctx.is_block)
- unlink(name);
- return err;
-}
-
-int
-vhd_create(const char *name, uint64_t bytes, int type, vhd_flag_creat_t flags)
-{
- return __vhd_create(name, NULL, bytes, type, flags);
-}
-
-int
-vhd_snapshot(const char *name, uint64_t bytes, const char *parent,
- vhd_flag_creat_t flags)
-{
- return __vhd_create(name, parent, bytes, HD_TYPE_DIFF, flags);
-}
-
-static int
-__vhd_io_fixed_read(vhd_context_t *ctx,
- char *buf, uint64_t sec, uint32_t secs)
-{
- int err;
-
- err = vhd_seek(ctx, vhd_sectors_to_bytes(sec), SEEK_SET);
- if (err)
- return err;
-
- return vhd_read(ctx, buf, vhd_sectors_to_bytes(secs));
-}
-
-static void
-__vhd_io_dynamic_copy_data(vhd_context_t *ctx,
- char *map, int map_off,
- char *bitmap, int bitmap_off,
- char *dst, char *src, int secs)
-{
- int i;
-
- for (i = 0; i < secs; i++) {
- if (test_bit(map, map_off + i))
- goto next;
-
- if (ctx && !vhd_bitmap_test(ctx, bitmap, bitmap_off + i))
- goto next;
-
- memcpy(dst, src, VHD_SECTOR_SIZE);
- set_bit(map, map_off + i);
-
- next:
- src += VHD_SECTOR_SIZE;
- dst += VHD_SECTOR_SIZE;
- }
-}
-
-static int
-__vhd_io_dynamic_read_link(vhd_context_t *ctx, char *map,
- char *buf, uint64_t sector, uint32_t secs)
-{
- off_t off;
- uint32_t blk, sec;
- int err, cnt, map_off;
- char *bitmap, *data, *src;
-
- map_off = 0;
-
- do {
- blk = sector / ctx->spb;
- sec = sector % ctx->spb;
- off = ctx->bat.bat[blk];
- data = NULL;
- bitmap = NULL;
-
- if (off == DD_BLK_UNUSED) {
- cnt = MIN(secs, ctx->spb);
- goto next;
- }
-
- err = vhd_read_bitmap(ctx, blk, &bitmap);
- if (err)
- return err;
-
- err = vhd_read_block(ctx, blk, &data);
- if (err) {
- free(bitmap);
- return err;
- }
-
- cnt = MIN(secs, ctx->spb - sec);
- src = data + vhd_sectors_to_bytes(sec);
-
- __vhd_io_dynamic_copy_data(ctx,
- map, map_off,
- bitmap, sec,
- buf, src, cnt);
-
- next:
- free(data);
- free(bitmap);
-
- secs -= cnt;
- sector += cnt;
- map_off += cnt;
- buf += vhd_sectors_to_bytes(cnt);
-
- } while (secs);
-
- return 0;
-}
-
-static int
-__raw_read_link(char *filename,
- char *map, char *buf, uint64_t sec, uint32_t secs)
-{
- int fd, err;
- off_t off;
- uint64_t size;
- char *data;
-
- err = 0;
- errno = 0;
- fd = open(filename, O_RDONLY | O_DIRECT | O_LARGEFILE);
- if (fd == -1) {
- VHDLOG("%s: failed to open: %d\n", filename, -errno);
- return -errno;
- }
-
- off = lseek(fd, vhd_sectors_to_bytes(sec), SEEK_SET);
- if (off == (off_t)-1) {
- VHDLOG("%s: seek(0x%08"PRIx64") failed: %d\n",
- filename, vhd_sectors_to_bytes(sec), -errno);
- err = -errno;
- goto close;
- }
-
- size = vhd_sectors_to_bytes(secs);
- err = posix_memalign((void **)&data, VHD_SECTOR_SIZE, size);
- if (err)
- goto close;
-
- err = read(fd, data, size);
- if (err != size) {
- VHDLOG("%s: reading of %"PRIu64" returned %d, errno: %d\n",
- filename, size, err, -errno);
- free(data);
- err = errno ? -errno : -EIO;
- goto close;
- }
- __vhd_io_dynamic_copy_data(NULL, map, 0, NULL, 0, buf, data, secs);
- free(data);
- err = 0;
-
-close:
- close(fd);
- return err;
-}
-
-static int
-__vhd_io_dynamic_read(vhd_context_t *ctx,
- char *buf, uint64_t sec, uint32_t secs)
-{
- int err;
- uint32_t i, done;
- char *map, *next;
- vhd_context_t parent, *vhd;
-
- err = vhd_get_bat(ctx);
- if (err)
- return err;
-
- vhd = ctx;
- next = NULL;
- map = calloc(1, secs << (VHD_SECTOR_SHIFT - 3));
- if (!map)
- return -ENOMEM;
-
- memset(buf, 0, vhd_sectors_to_bytes(secs));
-
- for (;;) {
- err = __vhd_io_dynamic_read_link(vhd, map, buf, sec, secs);
- if (err)
- goto close;
-
- for (done = 0, i = 0; i < secs; i++)
- if (test_bit(map, i))
- done++;
-
- if (done == secs) {
- err = 0;
- goto close;
- }
-
- if (vhd->footer.type == HD_TYPE_DIFF) {
- err = vhd_parent_locator_get(vhd, &next);
- if (err)
- goto close;
- if (vhd_parent_raw(vhd)) {
- err = __raw_read_link(next, map, buf, sec,
- secs);
- goto close;
- }
- } else {
- err = 0;
- goto close;
- }
-
- if (vhd != ctx)
- vhd_close(vhd);
- vhd = &parent;
-
- err = vhd_open(vhd, next, VHD_OPEN_RDONLY);
- if (err)
- goto out;
-
- err = vhd_get_bat(vhd);
- if (err)
- goto close;
-
- free(next);
- next = NULL;
- }
-
-close:
- if (vhd != ctx)
- vhd_close(vhd);
-out:
- free(map);
- free(next);
- return err;
-}
-
-int
-vhd_io_read(vhd_context_t *ctx, char *buf, uint64_t sec, uint32_t secs)
-{
- if (vhd_sectors_to_bytes(sec + secs) > ctx->footer.curr_size)
- return -ERANGE;
-
- if (!vhd_type_dynamic(ctx))
- return __vhd_io_fixed_read(ctx, buf, sec, secs);
-
- return __vhd_io_dynamic_read(ctx, buf, sec, secs);
-}
-
-static int
-__vhd_io_fixed_write(vhd_context_t *ctx,
- char *buf, uint64_t sec, uint32_t secs)
-{
- int err;
-
- err = vhd_seek(ctx, vhd_sectors_to_bytes(sec), SEEK_SET);
- if (err)
- return err;
-
- return vhd_write(ctx, buf, vhd_sectors_to_bytes(secs));
-}
-
-static int
-__vhd_io_allocate_block(vhd_context_t *ctx, uint32_t block)
-{
- char *buf;
- size_t size;
- off_t off, max;
- int i, err, gap, spp;
-
- spp = getpagesize() >> VHD_SECTOR_SHIFT;
-
- err = vhd_end_of_data(ctx, &max);
- if (err)
- return err;
-
- gap = 0;
- off = max;
- max >>= VHD_SECTOR_SHIFT;
-
- /* data region of segment should begin on page boundary */
- if ((max + ctx->bm_secs) % spp) {
- gap = (spp - ((max + ctx->bm_secs) % spp));
- max += gap;
- }
-
- err = vhd_seek(ctx, off, SEEK_SET);
- if (err)
- return err;
-
- size = vhd_sectors_to_bytes(ctx->spb + ctx->bm_secs + gap);
- buf = mmap(0, size, PROT_READ, MAP_SHARED | MAP_ANON, -1, 0);
- if (buf == MAP_FAILED)
- return -errno;
-
- err = vhd_write(ctx, buf, size);
- if (err)
- goto out;
-
- ctx->bat.bat[block] = max;
- err = vhd_write_bat(ctx, &ctx->bat);
- if (err)
- goto out;
-
- err = 0;
-
-out:
- munmap(buf, size);
- return err;
-}
-
-static int
-__vhd_io_dynamic_write(vhd_context_t *ctx,
- char *buf, uint64_t sector, uint32_t secs)
-{
- char *map;
- off_t off;
- uint32_t blk, sec;
- int i, err, cnt, ret;
-
- if (vhd_sectors_to_bytes(sector + secs) > ctx->footer.curr_size)
- return -ERANGE;
-
- err = vhd_get_bat(ctx);
- if (err)
- return err;
-
- if (vhd_has_batmap(ctx)) {
- err = vhd_get_batmap(ctx);
- if (err)
- return err;
- }
-
- do {
- blk = sector / ctx->spb;
- sec = sector % ctx->spb;
-
- off = ctx->bat.bat[blk];
- if (off == DD_BLK_UNUSED) {
- err = __vhd_io_allocate_block(ctx, blk);
- if (err)
- return err;
-
- off = ctx->bat.bat[blk];
- }
-
- off += ctx->bm_secs + sec;
- err = vhd_seek(ctx, vhd_sectors_to_bytes(off), SEEK_SET);
- if (err)
- return err;
-
- cnt = MIN(secs, ctx->spb - sec);
- err = vhd_write(ctx, buf, vhd_sectors_to_bytes(cnt));
- if (err)
- return err;
-
- if (vhd_has_batmap(ctx) &&
- vhd_batmap_test(ctx, &ctx->batmap, blk))
- goto next;
-
- err = vhd_read_bitmap(ctx, blk, &map);
- if (err)
- return err;
-
- for (i = 0; i < cnt; i++)
- vhd_bitmap_set(ctx, map, sec + i);
-
- err = vhd_write_bitmap(ctx, blk, map);
- if (err)
- goto fail;
-
- if (vhd_has_batmap(ctx)) {
- for (i = 0; i < ctx->spb; i++)
- if (!vhd_bitmap_test(ctx, map, i)) {
- free(map);
- goto next;
- }
-
- vhd_batmap_set(ctx, &ctx->batmap, blk);
- err = vhd_write_batmap(ctx, &ctx->batmap);
- if (err)
- goto fail;
- }
-
- free(map);
- map = NULL;
-
- next:
- secs -= cnt;
- sector += cnt;
- buf += vhd_sectors_to_bytes(cnt);
- } while (secs);
-
- err = 0;
-
-out:
- ret = vhd_write_footer(ctx, &ctx->footer);
- return (err ? err : ret);
-
-fail:
- free(map);
- goto out;
-}
-
-int
-vhd_io_write(vhd_context_t *ctx, char *buf, uint64_t sec, uint32_t secs)
-{
- if (vhd_sectors_to_bytes(sec + secs) > ctx->footer.curr_size)
- return -ERANGE;
-
- if (!vhd_type_dynamic(ctx))
- return __vhd_io_fixed_write(ctx, buf, sec, secs);
-
- return __vhd_io_dynamic_write(ctx, buf, sec, secs);
-}
+++ /dev/null
-/* Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#include <stdio.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "relative-path.h"
-
-#define sfree(ptr) \
-do { \
- free(ptr); \
- ptr = NULL; \
-} while (0)
-
-/*
- * count number of tokens between DELIMETER characters
- */
-static int
-count_nodes(char *path)
-{
- int i;
- char *tmp;
-
- if (!path)
- return 0;
-
- for (i = 0, tmp = path; *tmp != '\0'; tmp++)
- if (*tmp == DELIMITER)
- i++;
-
- return i;
-}
-
-/*
- * return copy of next node in @path, or NULL
- * @path is moved to the end of the next node
- * @err is set to -errno on failure
- * copy should be freed
- */
-static char *
-next_node(char **path, int *err)
-{
- int ret;
- char *tmp, *start;
-
- if (!path || !*path) {
- *err = -EINVAL;
- return NULL;
- }
-
- *err = 0;
- start = *path;
-
- for (tmp = *path; *tmp != '\0'; tmp++)
- if (*tmp == DELIMITER) {
- int size;
- char *node;
-
- size = tmp - start + 1;
- node = malloc(size);
- if (!node) {
- *err = -ENOMEM;
- return NULL;
- }
-
- ret = snprintf(node, size, "%s", start);
- if (ret < 0) {
- free(node);
- *err = -EINVAL;
- return NULL;
- }
-
- *path = tmp;
- return node;
- }
-
- return NULL;
-}
-
-/*
- * count number of nodes in common betwee @to and @from
- * returns number of common nodes, or -errno on failure
- */
-static int
-count_common_nodes(char *to, char *from)
-{
- int err, common;
- char *to_node, *from_node;
-
- if (!to || !from)
- return -EINVAL;
-
- err = 0;
- common = 0;
- to_node = NULL;
- from_node = NULL;
-
- do {
- to_node = next_node(&to, &err);
- if (err || !to_node)
- break;
-
- from_node = next_node(&from, &err);
- if (err || !from_node)
- break;
-
- if (strncmp(to_node, from_node, MAX_NAME_LEN))
- break;
-
- ++to;
- ++from;
- ++common;
- sfree(to_node);
- sfree(from_node);
-
- } while (1);
-
- sfree(to_node);
- sfree(from_node);
-
- if (err)
- return err;
-
- return common;
-}
-
-/*
- * construct path of @count '../', './' if @count is zero, or NULL on error
- * result should be freed
- */
-static char *
-up_nodes(int count)
-{
- char *path, *tmp;
- int i, ret, len, size;
-
- if (!count)
- return strdup("./");
-
- len = strlen("../");
- size = len * count;
- if (size >= MAX_NAME_LEN)
- return NULL;
-
- path = malloc(size + 1);
- if (!path)
- return NULL;
-
- tmp = path;
- for (i = 0; i < count; i++) {
- ret = sprintf(tmp, "../");
- if (ret < 0 || ret != len) {
- free(path);
- return NULL;
- }
- tmp += ret;
- }
-
- return path;
-}
-
-/*
- * return pointer to @offset'th node of path or NULL on error
- */
-static char *
-node_offset(char *from, int offset)
-{
- char *path;
-
- if (!from || !offset)
- return NULL;
-
- for (path = from; *path != '\0'; path++) {
- if (*path == DELIMITER)
- if (--offset == 0)
- return path + 1;
- }
-
- return NULL;
-}
-
-/*
- * return a relative path from @from to @to
- * result should be freed
- */
-char *
-relative_path_to(char *from, char *to, int *err)
-{
- int from_nodes, common;
- char *to_absolute, *from_absolute;
- char *up, *common_target_path, *relative_path;
-
- *err = 0;
- up = NULL;
- to_absolute = NULL;
- from_absolute = NULL;
- relative_path = NULL;
-
- if (strnlen(to, MAX_NAME_LEN) == MAX_NAME_LEN ||
- strnlen(from, MAX_NAME_LEN) == MAX_NAME_LEN) {
- EPRINTF("invalid input; max path length is %d\n",
- MAX_NAME_LEN);
- *err = -ENAMETOOLONG;
- return NULL;
- }
-
- to_absolute = realpath(to, NULL);
- if (!to_absolute) {
- EPRINTF("failed to get absolute path of %s\n", to);
- *err = -errno;
- goto out;
- }
-
- from_absolute = realpath(from, NULL);
- if (!from_absolute) {
- EPRINTF("failed to get absolute path of %s\n", from);
- *err = -errno;
- goto out;
- }
-
- if (strnlen(to_absolute, MAX_NAME_LEN) == MAX_NAME_LEN ||
- strnlen(from_absolute, MAX_NAME_LEN) == MAX_NAME_LEN) {
- EPRINTF("invalid input; max path length is %d\n",
- MAX_NAME_LEN);
- *err = -ENAMETOOLONG;
- goto out;
- }
-
- /* count nodes in source path */
- from_nodes = count_nodes(from_absolute);
-
- /* count nodes in common */
- common = count_common_nodes(to_absolute + 1, from_absolute + 1);
- if (common < 0) {
- EPRINTF("failed to count common nodes of %s and %s: %d\n",
- to_absolute, from_absolute, common);
- *err = common;
- goto out;
- }
-
- /* move up to common node */
- up = up_nodes(from_nodes - common - 1);
- if (!up) {
- EPRINTF("failed to allocate relative path for %s: %d\n",
- from_absolute, -ENOMEM);
- *err = -ENOMEM;
- goto out;
- }
-
- /* get path from common node to target */
- common_target_path = node_offset(to_absolute, common + 1);
- if (!common_target_path) {
- EPRINTF("failed to find common target path to %s: %d\n",
- to_absolute, -EINVAL);
- *err = -EINVAL;
- goto out;
- }
-
- /* get relative path */
- if (asprintf(&relative_path, "%s%s", up, common_target_path) == -1) {
- EPRINTF("failed to construct final path %s%s: %d\n",
- up, common_target_path, -ENOMEM);
- relative_path = NULL;
- *err = -ENOMEM;
- goto out;
- }
-
-out:
- sfree(up);
- sfree(to_absolute);
- sfree(from_absolute);
-
- return relative_path;
-}
+++ /dev/null
-/* Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#include <time.h>
-#include <stdio.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <libgen.h>
-#include <inttypes.h>
-#include <sys/stat.h>
-
-#include "libvhd.h"
-#include "vhd-util.h"
-
-// allow the VHD timestamp to be at most this many seconds into the future to
-// account for time skew with NFS servers
-#define TIMESTAMP_MAX_SLACK 1800
-
-static int
-vhd_util_check_zeros(void *buf, size_t size)
-{
- int i;
- char *p;
-
- p = buf;
- for (i = 0; i < size; i++)
- if (p[i])
- return i;
-
- return 0;
-}
-
-static int
-vhd_util_check_footer_opened(vhd_footer_t *footer)
-{
- int i, n;
- uint32_t *buf;
-
- buf = (uint32_t *)footer;
- n = sizeof(*footer) / sizeof(uint32_t);
-
- for (i = 0; i < n; i++)
- if (buf[i] != 0xc7c7c7c7)
- return 0;
-
- return 1;
-}
-
-static char *
-vhd_util_check_validate_footer(vhd_footer_t *footer)
-{
- int size;
- uint32_t checksum, now;
-
- size = sizeof(footer->cookie);
- if (memcmp(footer->cookie, HD_COOKIE, size))
- return "invalid cookie";
-
- checksum = vhd_checksum_footer(footer);
- if (checksum != footer->checksum) {
- if (footer->hidden &&
- !strncmp(footer->crtr_app, "tap", 3) &&
- (footer->crtr_ver == VHD_VERSION(0, 1) ||
- footer->crtr_ver == VHD_VERSION(1, 1))) {
- char tmp = footer->hidden;
- footer->hidden = 0;
- checksum = vhd_checksum_footer(footer);
- footer->hidden = tmp;
-
- if (checksum == footer->checksum)
- goto ok;
- }
-
- return "invalid checksum";
- }
-
-ok:
- if (!(footer->features & HD_RESERVED))
- return "invalid 'reserved' feature";
-
- if (footer->features & ~(HD_TEMPORARY | HD_RESERVED))
- return "invalid extra features";
-
- if (footer->ff_version != HD_FF_VERSION)
- return "invalid file format version";
-
- if (footer->type != HD_TYPE_DYNAMIC &&
- footer->type != HD_TYPE_DIFF &&
- footer->data_offset != ~(0ULL))
- return "invalid data offset";
-
- now = vhd_time(time(NULL));
- if (footer->timestamp > now + TIMESTAMP_MAX_SLACK)
- return "creation time in future";
-
- if (!strncmp(footer->crtr_app, "tap", 3) &&
- footer->crtr_ver > VHD_CURRENT_VERSION)
- return "unsupported tap creator version";
-
- if (vhd_chs(footer->curr_size) < footer->geometry)
- return "geometry too large";
-
- if (footer->type != HD_TYPE_FIXED &&
- footer->type != HD_TYPE_DYNAMIC &&
- footer->type != HD_TYPE_DIFF)
- return "invalid type";
-
- if (footer->saved && footer->saved != 1)
- return "invalid 'saved' state";
-
- if (footer->hidden && footer->hidden != 1)
- return "invalid 'hidden' state";
-
- if (vhd_util_check_zeros(footer->reserved,
- sizeof(footer->reserved)))
- return "invalid 'reserved' bits";
-
- return NULL;
-}
-
-static char *
-vhd_util_check_validate_header(int fd, vhd_header_t *header)
-{
- off_t eof;
- int i, cnt, size;
- uint32_t checksum;
-
- size = sizeof(header->cookie);
- if (memcmp(header->cookie, DD_COOKIE, size))
- return "invalid cookie";
-
- checksum = vhd_checksum_header(header);
- if (checksum != header->checksum)
- return "invalid checksum";
-
- if (header->hdr_ver != 0x00010000)
- return "invalid header version";
-
- if (header->data_offset != ~(0ULL))
- return "invalid data offset";
-
- eof = lseek(fd, 0, SEEK_END);
- if (eof == (off_t)-1)
- return "error finding eof";
-
- if (header->table_offset <= 0 ||
- header->table_offset % 512 ||
- (header->table_offset +
- (header->max_bat_size * sizeof(uint32_t)) >
- eof - sizeof(vhd_footer_t)))
- return "invalid table offset";
-
- for (cnt = 0, i = 0; i < sizeof(header->block_size) * 8; i++)
- if ((header->block_size >> i) & 1)
- cnt++;
-
- if (cnt != 1)
- return "invalid block size";
-
- if (header->res1)
- return "invalid reserved bits";
-
- if (vhd_util_check_zeros(header->res2, sizeof(header->res2)))
- return "invalid reserved bits";
-
- return NULL;
-}
-
-static char *
-vhd_util_check_validate_differencing_header(vhd_context_t *vhd)
-{
- vhd_header_t *header;
-
- header = &vhd->header;
-
- if (vhd->footer.type == HD_TYPE_DIFF) {
- char *parent;
- uint32_t now;
-
- now = vhd_time(time(NULL));
- if (header->prt_ts > now + TIMESTAMP_MAX_SLACK)
- return "parent creation time in future";
-
- if (vhd_header_decode_parent(vhd, header, &parent))
- return "invalid parent name";
-
- free(parent);
- } else {
- if (vhd_util_check_zeros(header->prt_name,
- sizeof(header->prt_name)))
- return "invalid non-null parent name";
-
- if (vhd_util_check_zeros(header->loc, sizeof(header->loc)))
- return "invalid non-null parent locators";
-
- if (!vhd_uuid_is_nil(&header->prt_uuid))
- return "invalid non-null parent uuid";
-
- if (header->prt_ts)
- return "invalid non-zero parent timestamp";
- }
-
- return NULL;
-}
-
-static char *
-vhd_util_check_validate_batmap(vhd_context_t *vhd, vhd_batmap_t *batmap)
-{
- int size;
- off_t eof;
- uint32_t checksum;
-
- size = sizeof(batmap->header.cookie);
- if (memcmp(batmap->header.cookie, VHD_BATMAP_COOKIE, size))
- return "invalid cookie";
-
- if (batmap->header.batmap_version > VHD_BATMAP_CURRENT_VERSION)
- return "unsupported batmap version";
-
- checksum = vhd_checksum_batmap(batmap);
- if (checksum != batmap->header.checksum)
- return "invalid checksum";
-
- if (!batmap->header.batmap_size)
- return "invalid size zero";
-
- eof = lseek(vhd->fd, 0, SEEK_END);
- if (eof == (off_t)-1)
- return "error finding eof";
-
- if (!batmap->header.batmap_offset ||
- batmap->header.batmap_offset % 512)
- return "invalid batmap offset";
-
- if ((batmap->header.batmap_offset +
- vhd_sectors_to_bytes(batmap->header.batmap_size)) >
- eof - sizeof(vhd_footer_t))
- return "invalid batmap size";
-
- return NULL;
-}
-
-static char *
-vhd_util_check_validate_parent_locator(vhd_context_t *vhd,
- vhd_parent_locator_t *loc)
-{
- off_t eof;
-
- if (vhd_validate_platform_code(loc->code))
- return "invalid platform code";
-
- if (loc->code == PLAT_CODE_NONE) {
- if (vhd_util_check_zeros(loc, sizeof(*loc)))
- return "non-zero locator";
-
- return NULL;
- }
-
- if (!loc->data_offset)
- return "invalid data offset";
-
- if (!loc->data_space)
- return "invalid data space";
-
- if (!loc->data_len)
- return "invalid data length";
-
- eof = lseek(vhd->fd, 0, SEEK_END);
- if (eof == (off_t)-1)
- return "error finding eof";
-
- if (loc->data_offset + vhd_parent_locator_size(loc) >
- eof - sizeof(vhd_footer_t))
- return "invalid size";
-
- if (loc->res)
- return "invalid reserved bits";
-
- return NULL;
-}
-
-static const char *
-vhd_util_check_validate_parent(vhd_context_t *vhd, const char *ppath)
-{
- const char *msg;
- vhd_context_t parent;
- uint32_t status;
-
- msg = NULL;
-
- if (vhd_parent_raw(vhd))
- return msg;
-
- if (vhd_open(&parent, ppath,
- VHD_OPEN_RDONLY | VHD_OPEN_IGNORE_DISABLED))
- return "error opening parent";
-
- if (vhd_uuid_compare(&vhd->header.prt_uuid, &parent.footer.uuid)) {
- msg = "invalid parent uuid";
- goto out;
- }
-
-out:
- vhd_close(&parent);
- return msg;
-}
-
-static int
-vhd_util_check_footer(int fd, vhd_footer_t *footer, int ignore)
-{
- size_t size;
- int err, opened;
- char *msg, *buf = NULL;
- off_t eof, off;
- vhd_footer_t primary, backup;
-
- memset(&primary, 0, sizeof(primary));
- memset(&backup, 0, sizeof(backup));
-
- err = posix_memalign((void **)&buf, VHD_SECTOR_SIZE, sizeof(primary));
- if (err) {
- printf("error allocating buffer: %d\n", err);
- return -err;
- }
-
- memset(buf, 0, sizeof(primary));
-
- eof = lseek(fd, 0, SEEK_END);
- if (eof == (off_t)-1) {
- err = -errno;
- printf("error calculating end of file: %d\n", err);
- goto out;
- }
-
- size = ((eof % 512) ? 511 : 512);
- eof = lseek(fd, eof - size, SEEK_SET);
- if (eof == (off_t)-1) {
- err = -errno;
- printf("error calculating end of file: %d\n", err);
- goto out;
- }
-
- err = read(fd, buf, 512);
- if (err != size) {
- err = (errno ? -errno : -EIO);
- printf("error reading primary footer: %d\n", err);
- goto out;
- }
-
- memcpy(&primary, buf, sizeof(primary));
- opened = vhd_util_check_footer_opened(&primary);
- vhd_footer_in(&primary);
-
- msg = vhd_util_check_validate_footer(&primary);
- if (msg) {
- if (opened && ignore)
- goto check_backup;
-
- err = -EINVAL;
- printf("primary footer invalid: %s\n", msg);
- goto out;
- }
-
- if (primary.type == HD_TYPE_FIXED) {
- err = 0;
- goto out;
- }
-
-check_backup:
- off = lseek(fd, 0, SEEK_SET);
- if (off == (off_t)-1) {
- err = -errno;
- printf("error seeking to backup footer: %d\n", err);
- goto out;
- }
-
- size = 512;
- memset(buf, 0, sizeof(primary));
-
- err = read(fd, buf, size);
- if (err != size) {
- err = (errno ? -errno : -EIO);
- printf("error reading backup footer: %d\n", err);
- goto out;
- }
-
- memcpy(&backup, buf, sizeof(backup));
- vhd_footer_in(&backup);
-
- msg = vhd_util_check_validate_footer(&backup);
- if (msg) {
- err = -EINVAL;
- printf("backup footer invalid: %s\n", msg);
- goto out;
- }
-
- if (memcmp(&primary, &backup, sizeof(primary))) {
- if (opened && ignore) {
- memcpy(&primary, &backup, sizeof(primary));
- goto ok;
- }
-
- if (backup.hidden &&
- !strncmp(backup.crtr_app, "tap", 3) &&
- (backup.crtr_ver == VHD_VERSION(0, 1) ||
- backup.crtr_ver == VHD_VERSION(1, 1))) {
- char cmp, tmp = backup.hidden;
- backup.hidden = 0;
- cmp = memcmp(&primary, &backup, sizeof(primary));
- backup.hidden = tmp;
- if (!cmp)
- goto ok;
- }
-
- err = -EINVAL;
- printf("primary and backup footers do not match\n");
- goto out;
- }
-
-ok:
- err = 0;
- memcpy(footer, &primary, sizeof(primary));
-
-out:
- free(buf);
- return err;
-}
-
-static int
-vhd_util_check_header(int fd, vhd_footer_t *footer)
-{
- int err;
- off_t off;
- char *msg, *buf;
- vhd_header_t header;
-
- err = posix_memalign((void **)&buf, VHD_SECTOR_SIZE, sizeof(header));
- if (err) {
- printf("error allocating header: %d\n", err);
- return err;
- }
-
- off = footer->data_offset;
- off = lseek(fd, off, SEEK_SET);
- if (off == (off_t)-1) {
- err = -errno;
- printf("error seeking to header: %d\n", err);
- goto out;
- }
-
- err = read(fd, buf, sizeof(header));
- if (err != sizeof(header)) {
- err = (errno ? -errno : -EIO);
- printf("error reading header: %d\n", err);
- goto out;
- }
-
- memcpy(&header, buf, sizeof(header));
- vhd_header_in(&header);
-
- msg = vhd_util_check_validate_header(fd, &header);
- if (msg) {
- err = -EINVAL;
- printf("header is invalid: %s\n", msg);
- goto out;
- }
-
- err = 0;
-
-out:
- free(buf);
- return err;
-}
-
-static int
-vhd_util_check_differencing_header(vhd_context_t *vhd)
-{
- char *msg;
-
- msg = vhd_util_check_validate_differencing_header(vhd);
- if (msg) {
- printf("differencing header is invalid: %s\n", msg);
- return -EINVAL;
- }
-
- return 0;
-}
-
-static int
-vhd_util_check_bat(vhd_context_t *vhd)
-{
- off_t eof, eoh;
- int i, j, err, block_size;
-
- err = vhd_seek(vhd, 0, SEEK_END);
- if (err) {
- printf("error calculating eof: %d\n", err);
- return err;
- }
-
- eof = vhd_position(vhd);
- if (eof == (off_t)-1) {
- printf("error calculating eof: %d\n", -errno);
- return -errno;
- }
-
- /* adjust eof for vhds with short footers */
- if (eof % 512) {
- if (eof % 512 != 511) {
- printf("invalid file size: 0x%"PRIx64"\n", eof);
- return -EINVAL;
- }
-
- eof++;
- }
-
- err = vhd_get_bat(vhd);
- if (err) {
- printf("error reading bat: %d\n", err);
- return err;
- }
-
- err = vhd_end_of_headers(vhd, &eoh);
- if (err) {
- printf("error calculating end of metadata: %d\n", err);
- return err;
- }
-
- eof -= sizeof(vhd_footer_t);
- eof >>= VHD_SECTOR_SHIFT;
- eoh >>= VHD_SECTOR_SHIFT;
- block_size = vhd->spb + vhd->bm_secs;
-
- for (i = 0; i < vhd->header.max_bat_size; i++) {
- uint32_t off = vhd->bat.bat[i];
- if (off == DD_BLK_UNUSED)
- continue;
-
- if (off < eoh) {
- printf("block %d (offset 0x%x) clobbers headers\n",
- i, off);
- return -EINVAL;
- }
-
- if (off + block_size > eof) {
- printf("block %d (offset 0x%x) clobbers footer\n",
- i, off);
- return -EINVAL;
- }
-
- for (j = 0; j < vhd->header.max_bat_size; j++) {
- uint32_t joff = vhd->bat.bat[j];
-
- if (i == j)
- continue;
-
- if (joff == DD_BLK_UNUSED)
- continue;
-
- if (off == joff)
- err = -EINVAL;
-
- if (off > joff && off < joff + block_size)
- err = -EINVAL;
-
- if (off + block_size > joff &&
- off + block_size < joff + block_size)
- err = -EINVAL;
-
- if (err) {
- printf("block %d (offset 0x%x) clobbers "
- "block %d (offset 0x%x)\n",
- i, off, j, joff);
- return err;
- }
- }
- }
-
- return 0;
-}
-
-static int
-vhd_util_check_batmap(vhd_context_t *vhd)
-{
- char *msg;
- int i, err;
-
- err = vhd_get_bat(vhd);
- if (err) {
- printf("error reading bat: %d\n", err);
- return err;
- }
-
- err = vhd_get_batmap(vhd);
- if (err) {
- printf("error reading batmap: %d\n", err);
- return err;
- }
-
- msg = vhd_util_check_validate_batmap(vhd, &vhd->batmap);
- if (msg) {
- printf("batmap is invalid: %s\n", msg);
- return -EINVAL;
- }
-
- for (i = 0; i < vhd->header.max_bat_size; i++) {
- if (!vhd_batmap_test(vhd, &vhd->batmap, i))
- continue;
-
- if (vhd->bat.bat[i] == DD_BLK_UNUSED) {
- printf("batmap shows unallocated block %d full\n", i);
- return -EINVAL;
- }
- }
-
- return 0;
-}
-
-static int
-vhd_util_check_parent_locators(vhd_context_t *vhd)
-{
- int i, n, err;
- vhd_parent_locator_t *loc;
- char *file, *ppath, *location, *pname;
- const char *msg;
- int mac, macx, w2ku, w2ru, wi2r, wi2k, found;
-
- mac = 0;
- macx = 0;
- w2ku = 0;
- w2ru = 0;
- wi2r = 0;
- wi2k = 0;
- found = 0;
- pname = NULL;
- ppath = NULL;
- location = NULL;
-
- err = vhd_header_decode_parent(vhd, &vhd->header, &pname);
- if (err) {
- printf("error decoding parent name: %d\n", err);
- return err;
- }
-
- n = sizeof(vhd->header.loc) / sizeof(vhd->header.loc[0]);
- for (i = 0; i < n; i++) {
- ppath = NULL;
- location = NULL;
- loc = vhd->header.loc + i;
-
- msg = vhd_util_check_validate_parent_locator(vhd, loc);
- if (msg) {
- err = -EINVAL;
- printf("invalid parent locator %d: %s\n", i, msg);
- goto out;
- }
-
- if (loc->code == PLAT_CODE_NONE)
- continue;
-
- switch (loc->code) {
- case PLAT_CODE_MACX:
- if (macx++)
- goto dup;
- break;
-
- case PLAT_CODE_MAC:
- if (mac++)
- goto dup;
- break;
-
- case PLAT_CODE_W2KU:
- if (w2ku++)
- goto dup;
- break;
-
- case PLAT_CODE_W2RU:
- if (w2ru++)
- goto dup;
- break;
-
- case PLAT_CODE_WI2R:
- if (wi2r++)
- goto dup;
- break;
-
- case PLAT_CODE_WI2K:
- if (wi2k++)
- goto dup;
- break;
-
- default:
- err = -EINVAL;
- printf("invalid platform code for locator %d\n", i);
- goto out;
- }
-
- if (loc->code != PLAT_CODE_MACX &&
- loc->code != PLAT_CODE_W2RU &&
- loc->code != PLAT_CODE_W2KU)
- continue;
-
- err = vhd_parent_locator_read(vhd, loc, &ppath);
- if (err) {
- printf("error reading parent locator %d: %d\n", i, err);
- goto out;
- }
-
- file = basename(ppath);
- if (strcmp(pname, file)) {
- err = -EINVAL;
- printf("parent locator %d name (%s) does not match "
- "header name (%s)\n", i, file, pname);
- goto out;
- }
-
- err = vhd_find_parent(vhd, ppath, &location);
- if (err) {
- printf("error resolving %s: %d\n", ppath, err);
- goto out;
- }
-
- err = access(location, R_OK);
- if (err && loc->code == PLAT_CODE_MACX) {
- err = -errno;
- printf("parent locator %d points to missing file %s "
- "(resolved to %s)\n", i, ppath, location);
- goto out;
- }
-
- msg = vhd_util_check_validate_parent(vhd, location);
- if (msg) {
- err = -EINVAL;
- printf("invalid parent %s: %s\n", location, msg);
- goto out;
- }
-
- found++;
- free(ppath);
- free(location);
- ppath = NULL;
- location = NULL;
-
- continue;
-
- dup:
- printf("duplicate platform code in locator %d: 0x%x\n",
- i, loc->code);
- err = -EINVAL;
- goto out;
- }
-
- if (!found) {
- err = -EINVAL;
- printf("could not find parent %s\n", pname);
- goto out;
- }
-
- err = 0;
-
-out:
- free(pname);
- free(ppath);
- free(location);
- return err;
-}
-
-static void
-vhd_util_dump_headers(const char *name)
-{
- char *argv[] = { "read", "-p", "-n", (char *)name };
- int argc = sizeof(argv) / sizeof(argv[0]);
-
- printf("%s appears invalid; dumping metadata\n", name);
- vhd_util_read(argc, argv);
-}
-
-static int
-vhd_util_check_vhd(const char *name, int ignore)
-{
- int fd, err;
- vhd_context_t vhd;
- struct stat stats;
- vhd_footer_t footer;
-
- fd = -1;
- memset(&vhd, 0, sizeof(vhd));
- memset(&footer, 0, sizeof(footer));
-
- err = stat(name, &stats);
- if (err == -1) {
- printf("cannot stat %s: %d\n", name, errno);
- return -errno;
- }
-
- if (!S_ISREG(stats.st_mode) && !S_ISBLK(stats.st_mode)) {
- printf("%s is not a regular file or block device\n", name);
- return -EINVAL;
- }
-
- fd = open(name, O_RDONLY | O_DIRECT | O_LARGEFILE);
- if (fd == -1) {
- printf("error opening %s\n", name);
- return -errno;
- }
-
- err = vhd_util_check_footer(fd, &footer, ignore);
- if (err)
- goto out;
-
- if (footer.type != HD_TYPE_DYNAMIC && footer.type != HD_TYPE_DIFF)
- goto out;
-
- err = vhd_util_check_header(fd, &footer);
- if (err)
- goto out;
-
- err = vhd_open(&vhd, name, VHD_OPEN_RDONLY | VHD_OPEN_IGNORE_DISABLED);
- if (err)
- goto out;
-
- err = vhd_util_check_differencing_header(&vhd);
- if (err)
- goto out;
-
- err = vhd_util_check_bat(&vhd);
- if (err)
- goto out;
-
- if (vhd_has_batmap(&vhd)) {
- err = vhd_util_check_batmap(&vhd);
- if (err)
- goto out;
- }
-
- if (vhd.footer.type == HD_TYPE_DIFF) {
- err = vhd_util_check_parent_locators(&vhd);
- if (err)
- goto out;
- }
-
- err = 0;
- printf("%s is valid\n", name);
-
-out:
- if (err)
- vhd_util_dump_headers(name);
- if (fd != -1)
- close(fd);
- vhd_close(&vhd);
- return err;
-}
-
-static int
-vhd_util_check_parents(const char *name, int ignore)
-{
- int err;
- vhd_context_t vhd;
- char *cur, *parent;
-
- cur = (char *)name;
-
- for (;;) {
- err = vhd_open(&vhd, cur,
- VHD_OPEN_RDONLY | VHD_OPEN_IGNORE_DISABLED);
- if (err)
- goto out;
-
- if (vhd.footer.type != HD_TYPE_DIFF || vhd_parent_raw(&vhd)) {
- vhd_close(&vhd);
- goto out;
- }
-
- err = vhd_parent_locator_get(&vhd, &parent);
- vhd_close(&vhd);
-
- if (err) {
- printf("error getting parent: %d\n", err);
- goto out;
- }
-
- if (cur != name)
- free(cur);
- cur = parent;
-
- err = vhd_util_check_vhd(cur, ignore);
- if (err)
- goto out;
- }
-
-out:
- if (err)
- printf("error checking parents: %d\n", err);
- if (cur != name)
- free(cur);
- return err;
-}
-
-int
-vhd_util_check(int argc, char **argv)
-{
- char *name;
- vhd_context_t vhd;
- int c, err, ignore, parents;
-
- if (!argc || !argv) {
- err = -EINVAL;
- goto usage;
- }
-
- ignore = 0;
- parents = 0;
- name = NULL;
-
- optind = 0;
- while ((c = getopt(argc, argv, "n:iph")) != -1) {
- switch (c) {
- case 'n':
- name = optarg;
- break;
- case 'i':
- ignore = 1;
- break;
- case 'p':
- parents = 1;
- break;
- case 'h':
- err = 0;
- goto usage;
- default:
- err = -EINVAL;
- goto usage;
- }
- }
-
- if (!name || optind != argc) {
- err = -EINVAL;
- goto usage;
- }
-
- err = vhd_util_check_vhd(name, ignore);
- if (err)
- goto out;
-
- if (parents)
- err = vhd_util_check_parents(name, ignore);
-
-out:
- return err;
-
-usage:
- printf("options: -n <file> [-i ignore missing primary footers] "
- "[-p check parents] [-h help]\n");
- return err;
-}
+++ /dev/null
-/* Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#include <errno.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-#include "libvhd.h"
-
-static int
-__raw_io_write(int fd, char* buf, uint64_t sec, uint32_t secs)
-{
- off_t off;
- size_t ret;
-
- errno = 0;
- off = lseek(fd, vhd_sectors_to_bytes(sec), SEEK_SET);
- if (off == (off_t)-1) {
- printf("raw parent: seek(0x%08"PRIx64") failed: %d\n",
- vhd_sectors_to_bytes(sec), -errno);
- return -errno;
- }
-
- ret = write(fd, buf, vhd_sectors_to_bytes(secs));
- if (ret == vhd_sectors_to_bytes(secs))
- return 0;
-
- printf("raw parent: write of 0x%"PRIx64" returned %zd, errno: %d\n",
- vhd_sectors_to_bytes(secs), ret, -errno);
- return (errno ? -errno : -EIO);
-}
-
-/*
- * Use 'parent' if the parent is VHD, and 'parent_fd' if the parent is raw
- */
-static int
-vhd_util_coalesce_block(vhd_context_t *vhd, vhd_context_t *parent,
- int parent_fd, uint64_t block)
-{
- int i, err;
- char *buf, *map;
- uint64_t sec, secs;
-
- buf = NULL;
- map = NULL;
- sec = block * vhd->spb;
-
- if (vhd->bat.bat[block] == DD_BLK_UNUSED)
- return 0;
-
- err = posix_memalign((void **)&buf, 4096, vhd->header.block_size);
- if (err)
- return -err;
-
- err = vhd_io_read(vhd, buf, sec, vhd->spb);
- if (err)
- goto done;
-
- if (vhd_has_batmap(vhd) && vhd_batmap_test(vhd, &vhd->batmap, block)) {
- if (parent->file)
- err = vhd_io_write(parent, buf, sec, vhd->spb);
- else
- err = __raw_io_write(parent_fd, buf, sec, vhd->spb);
- goto done;
- }
-
- err = vhd_read_bitmap(vhd, block, &map);
- if (err)
- goto done;
-
- for (i = 0; i < vhd->spb; i++) {
- if (!vhd_bitmap_test(vhd, map, i))
- continue;
-
- for (secs = 0; i + secs < vhd->spb; secs++)
- if (!vhd_bitmap_test(vhd, map, i + secs))
- break;
-
- if (parent->file)
- err = vhd_io_write(parent,
- buf + vhd_sectors_to_bytes(i),
- sec + i, secs);
- else
- err = __raw_io_write(parent_fd,
- buf + vhd_sectors_to_bytes(i),
- sec + i, secs);
- if (err)
- goto done;
-
- i += secs;
- }
-
- err = 0;
-
-done:
- free(buf);
- free(map);
- return err;
-}
-
-int
-vhd_util_coalesce(int argc, char **argv)
-{
- int err, c;
- uint64_t i;
- char *name, *pname;
- vhd_context_t vhd, parent;
- int parent_fd = -1;
-
- name = NULL;
- pname = NULL;
- parent.file = NULL;
-
- if (!argc || !argv)
- goto usage;
-
- optind = 0;
- while ((c = getopt(argc, argv, "n:h")) != -1) {
- switch (c) {
- case 'n':
- name = optarg;
- break;
- case 'h':
- default:
- goto usage;
- }
- }
-
- if (!name || optind != argc)
- goto usage;
-
- err = vhd_open(&vhd, name, VHD_OPEN_RDONLY);
- if (err) {
- printf("error opening %s: %d\n", name, err);
- return err;
- }
-
- err = vhd_parent_locator_get(&vhd, &pname);
- if (err) {
- printf("error finding %s parent: %d\n", name, err);
- vhd_close(&vhd);
- return err;
- }
-
- if (vhd_parent_raw(&vhd)) {
- parent_fd = open(pname, O_RDWR | O_DIRECT | O_LARGEFILE, 0644);
- if (parent_fd == -1) {
- err = -errno;
- printf("failed to open parent %s: %d\n", pname, err);
- vhd_close(&vhd);
- return err;
- }
- } else {
- err = vhd_open(&parent, pname, VHD_OPEN_RDWR);
- if (err) {
- printf("error opening %s: %d\n", pname, err);
- free(pname);
- vhd_close(&vhd);
- return err;
- }
- }
-
- err = vhd_get_bat(&vhd);
- if (err)
- goto done;
-
- if (vhd_has_batmap(&vhd)) {
- err = vhd_get_batmap(&vhd);
- if (err)
- goto done;
- }
-
- for (i = 0; i < vhd.bat.entries; i++) {
- err = vhd_util_coalesce_block(&vhd, &parent, parent_fd, i);
- if (err)
- goto done;
- }
-
- err = 0;
-
- done:
- free(pname);
- vhd_close(&vhd);
- if (parent.file)
- vhd_close(&parent);
- else
- close(parent_fd);
- return err;
-
-usage:
- printf("options: <-n name> [-h help]\n");
- return -EINVAL;
-}
+++ /dev/null
-/* Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#include <stdio.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-#include "libvhd.h"
-
-int
-vhd_util_create(int argc, char **argv)
-{
- char *name;
- uint64_t size;
- int c, sparse, err;
- vhd_flag_creat_t flags;
-
- err = -EINVAL;
- size = 0;
- sparse = 1;
- name = NULL;
- flags = 0;
-
- if (!argc || !argv)
- goto usage;
-
- optind = 0;
- while ((c = getopt(argc, argv, "n:s:rh")) != -1) {
- switch (c) {
- case 'n':
- name = optarg;
- break;
- case 's':
- err = 0;
- size = strtoull(optarg, NULL, 10);
- break;
- case 'r':
- sparse = 0;
- break;
- case 'h':
- default:
- goto usage;
- }
- }
-
- if (err || !name || optind != argc)
- goto usage;
-
- return vhd_create(name, size << 20,
- (sparse ? HD_TYPE_DYNAMIC : HD_TYPE_FIXED),
- flags);
-
-usage:
- printf("options: <-n name> <-s size (MB)> [-r reserve] [-h help]\n");
- return -EINVAL;
-}
+++ /dev/null
-/* Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#include <errno.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-#include "libvhd.h"
-
-int
-vhd_util_fill(int argc, char **argv)
-{
- int err, c;
- char *buf, *name;
- vhd_context_t vhd;
- uint64_t i, sec, secs;
-
- buf = NULL;
- name = NULL;
-
- if (!argc || !argv)
- goto usage;
-
- optind = 0;
- while ((c = getopt(argc, argv, "n:h")) != -1) {
- switch (c) {
- case 'n':
- name = optarg;
- break;
- case 'h':
- default:
- goto usage;
- }
- }
-
- if (!name || optind != argc)
- goto usage;
-
- err = vhd_open(&vhd, name, VHD_OPEN_RDWR);
- if (err) {
- printf("error opening %s: %d\n", name, err);
- return err;
- }
-
- err = vhd_get_bat(&vhd);
- if (err)
- goto done;
-
- err = posix_memalign((void **)&buf, 4096, vhd.header.block_size);
- if (err) {
- err = -err;
- goto done;
- }
-
- sec = 0;
- secs = vhd.header.block_size >> VHD_SECTOR_SHIFT;
-
- for (i = 0; i < vhd.header.max_bat_size; i++) {
- err = vhd_io_read(&vhd, buf, sec, secs);
- if (err)
- goto done;
-
- err = vhd_io_write(&vhd, buf, sec, secs);
- if (err)
- goto done;
-
- sec += secs;
- }
-
- err = 0;
-
- done:
- free(buf);
- vhd_close(&vhd);
- return err;
-
-usage:
- printf("options: <-n name> [-h help]\n");
- return -EINVAL;
-}
+++ /dev/null
-/* Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * Altering operations:
- *
- * 1. Change the parent pointer to another file.
- * 2. Change the size of the file containing the VHD image. This does NOT
- * affect the VHD disk capacity, only the physical size of the file containing
- * the VHD. Naturally, it is not possible to set the file size to be less than
- * the what VHD utilizes.
- * The operation doesn't actually change the file size, but it writes the
- * footer in the right location such that resizing the file (manually, as a
- * separate step) will produce the correct results. If the new file size is
- * greater than the current file size, the file must first be expanded and then
- * altered with this operation. If the new size is smaller than the current
- * size, the VHD must first be altered with this operation and then the file
- * must be shrunk. Failing to resize the file will result in a corrupted VHD.
- */
-
-#include <errno.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-#include "libvhd.h"
-
-TEST_FAIL_EXTERN_VARS;
-
-int
-vhd_util_modify(int argc, char **argv)
-{
- char *name;
- vhd_context_t vhd;
- int err, c, size, parent, parent_raw;
- off_t newsize = 0;
- char *newparent = NULL;
-
- name = NULL;
- size = 0;
- parent = 0;
- parent_raw = 0;
-
- optind = 0;
- while ((c = getopt(argc, argv, "n:s:p:mh")) != -1) {
- switch (c) {
- case 'n':
- name = optarg;
- break;
- case 's':
- size = 1;
- errno = 0;
- newsize = strtoll(optarg, NULL, 10);
- if (errno) {
- fprintf(stderr, "Invalid size '%s'\n", optarg);
- goto usage;
- }
- break;
- case 'p':
- parent = 1;
- newparent = optarg;
- break;
- case 'm':
- parent_raw = 1;
- break;
-
- case 'h':
- default:
- goto usage;
- }
- }
-
- if (!name || optind != argc)
- goto usage;
-
- err = vhd_open(&vhd, name, VHD_OPEN_RDWR);
- if (err) {
- printf("error opening %s: %d\n", name, err);
- return err;
- }
-
- if (size) {
- err = vhd_set_phys_size(&vhd, newsize);
- if (err)
- printf("failed to set physical size to %"PRIu64":"
- " %d\n", newsize, err);
- }
-
- if (parent) {
- TEST_FAIL_AT(FAIL_REPARENT_BEGIN);
- err = vhd_change_parent(&vhd, newparent, parent_raw);
- if (err) {
- printf("failed to set parent to '%s': %d\n",
- newparent, err);
- goto done;
- }
- TEST_FAIL_AT(FAIL_REPARENT_END);
- }
-
-done:
- vhd_close(&vhd);
- return err;
-
-usage:
- printf("*** Dangerous operations, use with care ***\n");
- printf("options: <-n name> [-p NEW_PARENT set parent [-m raw]] "
- "[-s NEW_SIZE set size] [-h help]\n");
- return -EINVAL;
-}
+++ /dev/null
-/* Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#include <errno.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-#include "libvhd.h"
-
-int
-vhd_util_query(int argc, char **argv)
-{
- char *name;
- vhd_context_t vhd;
- off_t currsize;
- int ret, err, c, size, physize, parent, fields, depth;
-
- name = NULL;
- size = 0;
- physize = 0;
- parent = 0;
- fields = 0;
- depth = 0;
-
- if (!argc || !argv) {
- err = -EINVAL;
- goto usage;
- }
-
- optind = 0;
- while ((c = getopt(argc, argv, "n:vspfdh")) != -1) {
- switch (c) {
- case 'n':
- name = optarg;
- break;
- case 'v':
- size = 1;
- break;
- case 's':
- physize = 1;
- break;
- case 'p':
- parent = 1;
- break;
- case 'f':
- fields = 1;
- break;
- case 'd':
- depth = 1;
- break;
- case 'h':
- err = 0;
- goto usage;
- default:
- err = -EINVAL;
- goto usage;
- }
- }
-
- if (!name || optind != argc) {
- err = -EINVAL;
- goto usage;
- }
-
- err = vhd_open(&vhd, name, VHD_OPEN_RDONLY | VHD_OPEN_IGNORE_DISABLED);
- if (err) {
- printf("error opening %s: %d\n", name, err);
- return err;
- }
-
- if (size)
- printf("%"PRIu64"\n", vhd.footer.curr_size >> 20);
-
- if (physize) {
- err = vhd_get_phys_size(&vhd, &currsize);
- if (err)
- printf("failed to get physical size: %d\n", err);
- else
- printf("%"PRIu64"\n", currsize);
- }
-
- if (parent) {
- ret = 0;
-
- if (vhd.footer.type != HD_TYPE_DIFF)
- printf("%s has no parent\n", name);
- else {
- char *pname;
-
- ret = vhd_parent_locator_get(&vhd, &pname);
- if (ret)
- printf("query failed\n");
- else {
- printf("%s\n", pname);
- free(pname);
- }
- }
-
- err = (err ? : ret);
- }
-
- if (fields) {
- int hidden;
-
- ret = vhd_hidden(&vhd, &hidden);
- if (ret)
- printf("error checking 'hidden' field: %d\n", ret);
- else
- printf("hidden: %d\n", hidden);
-
- err = (err ? : ret);
- }
-
- if (depth) {
- int length;
-
- ret = vhd_chain_depth(&vhd, &length);
- if (ret)
- printf("error checking chain depth: %d\n", ret);
- else
- printf("chain depth: %d\n", length);
-
- err = (err ? : ret);
- }
-
- vhd_close(&vhd);
- return err;
-
-usage:
- printf("options: <-n name> [-v print virtual size (in MB)] "
- "[-s print physical utilization (bytes)] [-p print parent] "
- "[-f print fields] [-d print chain depth] [-h help]\n");
- return err;
-}
+++ /dev/null
-/* Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#include <stdio.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <inttypes.h>
-
-#include "libvhd.h"
-#include "vhd-util.h"
-
-#define nsize 24
-static char nbuf[nsize];
-
-static inline char *
-__xconv(uint64_t num)
-{
- snprintf(nbuf, nsize, "%#" PRIx64 , num);
- return nbuf;
-}
-
-static inline char *
-__dconv(uint64_t num)
-{
- snprintf(nbuf, nsize, "%" PRIu64, num);
- return nbuf;
-}
-
-#define conv(hex, num) \
- (hex ? __xconv((uint64_t)num) : __dconv((uint64_t)num))
-
-static void
-vhd_print_header(vhd_context_t *vhd, vhd_header_t *h, int hex)
-{
- int err;
- uint32_t cksm;
- char uuid[39], time_str[26], cookie[9], out[512], *name;
-
- printf("VHD Header Summary:\n-------------------\n");
-
- snprintf(cookie, sizeof(cookie), "%s", h->cookie);
- printf("Cookie : %s\n", cookie);
-
- printf("Data offset (unusd) : %s\n", conv(hex, h->data_offset));
- printf("Table offset : %s\n", conv(hex, h->table_offset));
- printf("Header version : 0x%08x\n", h->hdr_ver);
- printf("Max BAT size : %s\n", conv(hex, h->max_bat_size));
- printf("Block size : %s ", conv(hex, h->block_size));
- printf("(%s MB)\n", conv(hex, h->block_size >> 20));
-
- err = vhd_header_decode_parent(vhd, h, &name);
- printf("Parent name : %s\n",
- (err ? "failed to read name" : name));
- free(name);
-
- vhd_uuid_to_string(&h->prt_uuid, uuid, sizeof(uuid));
- printf("Parent UUID : %s\n", uuid);
-
- vhd_time_to_string(h->prt_ts, time_str);
- printf("Parent timestamp : %s\n", time_str);
-
- cksm = vhd_checksum_header(h);
- printf("Checksum : 0x%x|0x%x (%s)\n", h->checksum, cksm,
- h->checksum == cksm ? "Good!" : "Bad!");
- printf("\n");
-}
-
-static void
-vhd_print_footer(vhd_footer_t *f, int hex)
-{
- uint64_t c, h, s;
- uint32_t ff_maj, ff_min, cr_maj, cr_min, cksm, cksm_save;
- char time_str[26], creator[5], uuid[39], cookie[9];
-
- printf("VHD Footer Summary:\n-------------------\n");
-
- snprintf(cookie, sizeof(cookie), "%s", f->cookie);
- printf("Cookie : %s\n", cookie);
-
- printf("Features : (0x%08x) %s%s\n", f->features,
- (f->features & HD_TEMPORARY) ? "<TEMP>" : "",
- (f->features & HD_RESERVED) ? "<RESV>" : "");
-
- ff_maj = f->ff_version >> 16;
- ff_min = f->ff_version & 0xffff;
- printf("File format version : Major: %d, Minor: %d\n",
- ff_maj, ff_min);
-
- printf("Data offset : %s\n", conv(hex, f->data_offset));
-
- vhd_time_to_string(f->timestamp, time_str);
- printf("Timestamp : %s\n", time_str);
-
- memcpy(creator, f->crtr_app, 4);
- creator[4] = '\0';
- printf("Creator Application : '%s'\n", creator);
-
- cr_maj = f->crtr_ver >> 16;
- cr_min = f->crtr_ver & 0xffff;
- printf("Creator version : Major: %d, Minor: %d\n",
- cr_maj, cr_min);
-
- printf("Creator OS : %s\n",
- ((f->crtr_os == HD_CR_OS_WINDOWS) ? "Windows" :
- ((f->crtr_os == HD_CR_OS_MACINTOSH) ? "Macintosh" :
- "Unknown!")));
-
- printf("Original disk size : %s MB ", conv(hex, f->orig_size >> 20));
- printf("(%s Bytes)\n", conv(hex, f->orig_size));
-
- printf("Current disk size : %s MB ", conv(hex, f->curr_size >> 20));
- printf("(%s Bytes)\n", conv(hex, f->curr_size));
-
- c = f->geometry >> 16;
- h = (f->geometry & 0x0000FF00) >> 8;
- s = f->geometry & 0x000000FF;
- printf("Geometry : Cyl: %s, ", conv(hex, c));
- printf("Hds: %s, ", conv(hex, h));
- printf("Sctrs: %s\n", conv(hex, s));
- printf(" : = %s MB ", conv(hex, (c * h * s) >> 11));
- printf("(%s Bytes)\n", conv(hex, c * h * s << 9));
-
- printf("Disk type : %s\n",
- f->type <= HD_TYPE_MAX ?
- HD_TYPE_STR[f->type] : "Unknown type!\n");
-
- cksm = vhd_checksum_footer(f);
- printf("Checksum : 0x%x|0x%x (%s)\n", f->checksum, cksm,
- f->checksum == cksm ? "Good!" : "Bad!");
-
- vhd_uuid_to_string(&f->uuid, uuid, sizeof(uuid));
- printf("UUID : %s\n", uuid);
-
- printf("Saved state : %s\n", f->saved == 0 ? "No" : "Yes");
- printf("Hidden : %d\n", f->hidden);
- printf("\n");
-}
-
-static inline char *
-code_name(uint32_t code)
-{
- switch(code) {
- case PLAT_CODE_NONE:
- return "PLAT_CODE_NONE";
- case PLAT_CODE_WI2R:
- return "PLAT_CODE_WI2R";
- case PLAT_CODE_WI2K:
- return "PLAT_CODE_WI2K";
- case PLAT_CODE_W2RU:
- return "PLAT_CODE_W2RU";
- case PLAT_CODE_W2KU:
- return "PLAT_CODE_W2KU";
- case PLAT_CODE_MAC:
- return "PLAT_CODE_MAC";
- case PLAT_CODE_MACX:
- return "PLAT_CODE_MACX";
- default:
- return "UNKOWN";
- }
-}
-
-static void
-vhd_print_parent(vhd_context_t *vhd, vhd_parent_locator_t *loc)
-{
- int err;
- char *buf;
-
- err = vhd_parent_locator_read(vhd, loc, &buf);
- if (err) {
- printf("failed to read parent name\n");
- return;
- }
-
- printf(" decoded name : %s\n", buf);
-}
-
-static void
-vhd_print_parent_locators(vhd_context_t *vhd, int hex)
-{
- int i, n;
- vhd_parent_locator_t *loc;
-
- printf("VHD Parent Locators:\n--------------------\n");
-
- n = sizeof(vhd->header.loc) / sizeof(struct prt_loc);
- for (i = 0; i < n; i++) {
- loc = &vhd->header.loc[i];
-
- if (loc->code == PLAT_CODE_NONE)
- continue;
-
- printf("locator: : %d\n", i);
- printf(" code : %s\n",
- code_name(loc->code));
- printf(" data_space : %s\n",
- conv(hex, loc->data_space));
- printf(" data_length : %s\n",
- conv(hex, loc->data_len));
- printf(" data_offset : %s\n",
- conv(hex, loc->data_offset));
- vhd_print_parent(vhd, loc);
- printf("\n");
- }
-}
-
-static void
-vhd_print_batmap_header(vhd_batmap_t *batmap, int hex)
-{
- uint32_t cksm;
-
- printf("VHD Batmap Summary:\n-------------------\n");
- printf("Batmap offset : %s\n",
- conv(hex, batmap->header.batmap_offset));
- printf("Batmap size (secs) : %s\n",
- conv(hex, batmap->header.batmap_size));
- printf("Batmap version : 0x%08x\n",
- batmap->header.batmap_version);
-
- cksm = vhd_checksum_batmap(batmap);
- printf("Checksum : 0x%x|0x%x (%s)\n",
- batmap->header.checksum, cksm,
- (batmap->header.checksum == cksm ? "Good!" : "Bad!"));
- printf("\n");
-}
-
-static inline int
-check_block_range(vhd_context_t *vhd, uint64_t block, int hex)
-{
- if (block > vhd->header.max_bat_size) {
- fprintf(stderr, "block %s past end of file\n",
- conv(hex, block));
- return -ERANGE;
- }
-
- return 0;
-}
-
-static int
-vhd_print_headers(vhd_context_t *vhd, int hex)
-{
- int err;
-
- vhd_print_footer(&vhd->footer, hex);
-
- if (vhd_type_dynamic(vhd)) {
- vhd_print_header(vhd, &vhd->header, hex);
-
- if (vhd->footer.type == HD_TYPE_DIFF)
- vhd_print_parent_locators(vhd, hex);
-
- if (vhd_has_batmap(vhd)) {
- err = vhd_get_batmap(vhd);
- if (err) {
- printf("failed to get batmap header\n");
- return err;
- }
-
- vhd_print_batmap_header(&vhd->batmap, hex);
- }
- }
-
- return 0;
-}
-
-static int
-vhd_dump_headers(const char *name, int hex)
-{
- vhd_context_t vhd;
-
- libvhd_set_log_level(1);
- memset(&vhd, 0, sizeof(vhd));
-
- printf("\n%s appears invalid; dumping headers\n\n", name);
-
- vhd.fd = open(name, O_DIRECT | O_LARGEFILE | O_RDONLY);
- if (vhd.fd == -1)
- return -errno;
-
- vhd.file = strdup(name);
-
- vhd_read_footer(&vhd, &vhd.footer);
- vhd_read_header(&vhd, &vhd.header);
-
- vhd_print_footer(&vhd.footer, hex);
- vhd_print_header(&vhd, &vhd.header, hex);
-
- close(vhd.fd);
- free(vhd.file);
-
- return 0;
-}
-
-static int
-vhd_print_logical_to_physical(vhd_context_t *vhd,
- uint64_t sector, int count, int hex)
-{
- int i;
- uint32_t blk, lsec;
- uint64_t cur, offset;
-
- if (vhd_sectors_to_bytes(sector + count) > vhd->footer.curr_size) {
- fprintf(stderr, "sector %s past end of file\n",
- conv(hex, sector + count));
- return -ERANGE;
- }
-
- for (i = 0; i < count; i++) {
- cur = sector + i;
- blk = cur / vhd->spb;
- lsec = cur % vhd->spb;
- offset = vhd->bat.bat[blk];
-
- if (offset != DD_BLK_UNUSED) {
- offset += lsec + 1;
- offset = vhd_sectors_to_bytes(offset);
- }
-
- printf("logical sector %s: ", conv(hex, cur));
- printf("block number: %s, ", conv(hex, blk));
- printf("sector offset: %s, ", conv(hex, lsec));
- printf("file offset: %s\n", (offset == DD_BLK_UNUSED ?
- "not allocated" : conv(hex, offset)));
- }
-
- return 0;
-}
-
-static int
-vhd_print_bat(vhd_context_t *vhd, uint64_t block, int count, int hex)
-{
- int i;
- uint64_t cur, offset;
-
- if (check_block_range(vhd, block + count, hex))
- return -ERANGE;
-
- for (i = 0; i < count; i++) {
- cur = block + i;
- offset = vhd->bat.bat[cur];
-
- printf("block: %s: ", conv(hex, cur));
- printf("offset: %s\n",
- (offset == DD_BLK_UNUSED ? "not allocated" :
- conv(hex, vhd_sectors_to_bytes(offset))));
- }
-
- return 0;
-}
-
-static inline void
-write_full(int fd, void* buf, size_t count)
-{
- ssize_t num_written = 0;
- if (!buf) return;
-
-
- while(count > 0) {
-
- num_written = write(fd, buf, count);
- if (num_written == -1) {
- if (errno == EINTR)
- continue;
- else
- return;
- }
-
- count -= num_written;
- buf += num_written;
- }
-}
-
-static int
-vhd_print_bitmap(vhd_context_t *vhd, uint64_t block, int count, int hex)
-{
- char *buf;
- int i, err;
- uint64_t cur;
-
- if (check_block_range(vhd, block + count, hex))
- return -ERANGE;
-
- for (i = 0; i < count; i++) {
- cur = block + i;
-
- if (vhd->bat.bat[cur] == DD_BLK_UNUSED) {
- printf("block %s not allocated\n", conv(hex, cur));
- continue;
- }
-
- err = vhd_read_bitmap(vhd, cur, &buf);
- if (err)
- goto out;
-
- write_full(STDOUT_FILENO, buf,
- vhd_sectors_to_bytes(vhd->bm_secs));
- free(buf);
- }
-
- err = 0;
-out:
- return err;
-}
-
-static int
-vhd_test_bitmap(vhd_context_t *vhd, uint64_t sector, int count, int hex)
-{
- char *buf;
- uint64_t cur;
- int i, err, bit;
- uint32_t blk, bm_blk, sec;
-
- if (vhd_sectors_to_bytes(sector + count) > vhd->footer.curr_size) {
- printf("sector %s past end of file\n", conv(hex, sector));
- return -ERANGE;
- }
-
- bm_blk = -1;
- buf = NULL;
-
- for (i = 0; i < count; i++) {
- cur = sector + i;
- blk = cur / vhd->spb;
- sec = cur % vhd->spb;
-
- if (blk != bm_blk) {
- bm_blk = blk;
- free(buf);
- buf = NULL;
-
- if (vhd->bat.bat[blk] != DD_BLK_UNUSED) {
- err = vhd_read_bitmap(vhd, blk, &buf);
- if (err)
- goto out;
- }
- }
-
- if (vhd->bat.bat[blk] == DD_BLK_UNUSED)
- bit = 0;
- else
- bit = vhd_bitmap_test(vhd, buf, blk);
-
- print:
- printf("block %s: ", conv(hex, blk));
- printf("sec: %s: %d\n", conv(hex, sec), bit);
- }
-
- err = 0;
- out:
- free(buf);
- return err;
-}
-
-static int
-vhd_print_batmap(vhd_context_t *vhd)
-{
- int err;
- size_t size;
-
- err = vhd_get_batmap(vhd);
- if (err) {
- printf("failed to read batmap: %d\n", err);
- return err;
- }
-
- size = vhd_sectors_to_bytes(vhd->batmap.header.batmap_size);
- write_full(STDOUT_FILENO, vhd->batmap.map, size);
-
- return 0;
-}
-
-static int
-vhd_test_batmap(vhd_context_t *vhd, uint64_t block, int count, int hex)
-{
- int i, err;
- uint64_t cur;
-
- if (check_block_range(vhd, block + count, hex))
- return -ERANGE;
-
- err = vhd_get_batmap(vhd);
- if (err) {
- fprintf(stderr, "failed to get batmap\n");
- return err;
- }
-
- for (i = 0; i < count; i++) {
- cur = block + i;
- fprintf(stderr, "batmap for block %s: %d\n", conv(hex, cur),
- vhd_batmap_test(vhd, &vhd->batmap, cur));
- }
-
- return 0;
-}
-
-static int
-vhd_print_data(vhd_context_t *vhd, uint64_t block, int count, int hex)
-{
- char *buf;
- int i, err;
- uint64_t cur;
-
- err = 0;
-
- if (check_block_range(vhd, block + count, hex))
- return -ERANGE;
-
- for (i = 0; i < count; i++) {
- cur = block + i;
-
- if (vhd->bat.bat[cur] == DD_BLK_UNUSED) {
- printf("block %s not allocated\n", conv(hex, cur));
- continue;
- }
-
- err = vhd_read_block(vhd, cur, &buf);
- if (err)
- break;
-
- write_full(STDOUT_FILENO, buf, vhd->header.block_size);
- free(buf);
- }
-
- return err;
-}
-
-static int
-vhd_read_data(vhd_context_t *vhd, uint64_t sec, int count, int hex)
-{
- char *buf;
- uint64_t cur;
- int err, max, secs;
-
- if (vhd_sectors_to_bytes(sec + count) > vhd->footer.curr_size)
- return -ERANGE;
-
- max = MIN(vhd_sectors_to_bytes(count), VHD_BLOCK_SIZE);
- err = posix_memalign((void **)&buf, VHD_SECTOR_SIZE, max);
- if (err)
- return -err;
-
- cur = sec;
- while (count) {
- secs = MIN((max >> VHD_SECTOR_SHIFT), count);
- err = vhd_io_read(vhd, buf, cur, secs);
- if (err)
- break;
-
- write_full(STDOUT_FILENO, buf, vhd_sectors_to_bytes(secs));
-
- cur += secs;
- count -= secs;
- }
-
- free(buf);
- return err;
-}
-
-int
-vhd_util_read(int argc, char **argv)
-{
- char *name;
- vhd_context_t vhd;
- int c, err, headers, hex;
- uint64_t bat, bitmap, tbitmap, batmap, tbatmap, data, lsec, count, read;
-
- err = 0;
- hex = 0;
- headers = 0;
- count = 1;
- bat = -1;
- bitmap = -1;
- tbitmap = -1;
- batmap = -1;
- tbatmap = -1;
- data = -1;
- lsec = -1;
- read = -1;
- name = NULL;
-
- if (!argc || !argv)
- goto usage;
-
- optind = 0;
- while ((c = getopt(argc, argv, "n:pt:b:m:i:aj:d:c:r:xh")) != -1) {
- switch(c) {
- case 'n':
- name = optarg;
- break;
- case 'p':
- headers = 1;
- break;
- case 't':
- lsec = strtoul(optarg, NULL, 10);
- break;
- case 'b':
- bat = strtoull(optarg, NULL, 10);
- break;
- case 'm':
- bitmap = strtoull(optarg, NULL, 10);
- break;
- case 'i':
- tbitmap = strtoul(optarg, NULL, 10);
- break;
- case 'a':
- batmap = 1;
- break;
- case 'j':
- tbatmap = strtoull(optarg, NULL, 10);
- break;
- case 'd':
- data = strtoull(optarg, NULL, 10);
- break;
- case 'r':
- read = strtoull(optarg, NULL, 10);
- break;
- case 'c':
- count = strtoul(optarg, NULL, 10);
- break;
- case 'x':
- hex = 1;
- break;
- case 'h':
- default:
- goto usage;
- }
- }
-
- if (!name || optind != argc)
- goto usage;
-
- err = vhd_open(&vhd, name, VHD_OPEN_RDONLY | VHD_OPEN_IGNORE_DISABLED);
- if (err) {
- printf("Failed to open %s: %d\n", name, err);
- vhd_dump_headers(name, hex);
- return err;
- }
-
- err = vhd_get_bat(&vhd);
- if (err) {
- printf("Failed to get bat for %s: %d\n", name, err);
- goto out;
- }
-
- if (headers)
- vhd_print_headers(&vhd, hex);
-
- if (lsec != -1) {
- err = vhd_print_logical_to_physical(&vhd, lsec, count, hex);
- if (err)
- goto out;
- }
-
- if (bat != -1) {
- err = vhd_print_bat(&vhd, bat, count, hex);
- if (err)
- goto out;
- }
-
- if (bitmap != -1) {
- err = vhd_print_bitmap(&vhd, bitmap, count, hex);
- if (err)
- goto out;
- }
-
- if (tbitmap != -1) {
- err = vhd_test_bitmap(&vhd, tbitmap, count, hex);
- if (err)
- goto out;
- }
-
- if (batmap != -1) {
- err = vhd_print_batmap(&vhd);
- if (err)
- goto out;
- }
-
- if (tbatmap != -1) {
- err = vhd_test_batmap(&vhd, tbatmap, count, hex);
- if (err)
- goto out;
- }
-
- if (data != -1) {
- err = vhd_print_data(&vhd, data, count, hex);
- if (err)
- goto out;
- }
-
- if (read != -1) {
- err = vhd_read_data(&vhd, read, count, hex);
- if (err)
- goto out;
- }
-
- err = 0;
-
- out:
- vhd_close(&vhd);
- return err;
-
- usage:
- printf("options:\n"
- "-h help\n"
- "-n name\n"
- "-p print VHD headers\n"
- "-t sec translate logical sector to VHD location\n"
- "-b blk print bat entry\n"
- "-m blk print bitmap\n"
- "-i sec test bitmap for logical sector\n"
- "-a print batmap\n"
- "-j blk test batmap for block\n"
- "-d blk print data\n"
- "-c num num units\n"
- "-r sec read num sectors at sec\n"
- "-x print in hex\n");
- return EINVAL;
-}
+++ /dev/null
-/* Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#include <errno.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-#include "libvhd.h"
-
-int
-vhd_util_repair(int argc, char **argv)
-{
- char *name;
- int err, c;
- off_t eof;
- vhd_context_t vhd;
-
- name = NULL;
-
- if (!argc || !argv)
- goto usage;
-
- optind = 0;
- while ((c = getopt(argc, argv, "n:h")) != -1) {
- switch (c) {
- case 'n':
- name = optarg;
- break;
- case 'h':
- default:
- goto usage;
- }
- }
-
- if (!name || optind != argc)
- goto usage;
-
- err = vhd_open(&vhd, name, VHD_OPEN_RDWR);
- if (err) {
- printf("error opening %s: %d\n", name, err);
- return err;
- }
-
- err = vhd_end_of_data(&vhd, &eof);
- if (err) {
- printf("error finding end of data: %d\n", err);
- goto done;
- }
-
- err = vhd_write_footer_at(&vhd, &vhd.footer, eof);
-
- done:
- vhd_close(&vhd);
- return err;
-
-usage:
- printf("options: <-n name> [-h help]\n");
- return -EINVAL;
-}
+++ /dev/null
-/* Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#include <errno.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <syslog.h>
-#include <inttypes.h>
-#include <sys/mman.h>
-
-#include "libvhd-journal.h"
-
-#if 1
-#define DFPRINTF(_f, _a...) fprintf(stdout, _f, ##_a)
-#else
-#define DFPRINTF(_f, _a...) ((void)0)
-#endif
-
-#define EPRINTF(_f, _a...) \
- do { \
- syslog(LOG_INFO, "%s: " _f, __func__, ##_a); \
- DFPRINTF(_f, _a); \
- } while (0)
-
-typedef struct vhd_block {
- uint32_t block;
- uint32_t offset;
-} vhd_block_t;
-
-TEST_FAIL_EXTERN_VARS;
-
-static inline uint32_t
-secs_to_blocks_down(vhd_context_t *vhd, uint64_t secs)
-{
- return secs / vhd->spb;
-}
-
-static uint32_t
-secs_to_blocks_up(vhd_context_t *vhd, uint64_t secs)
-{
- uint32_t blocks;
-
- blocks = secs / vhd->spb;
- if (secs % vhd->spb)
- blocks++;
-
- return blocks;
-}
-
-static int
-vhd_fixed_shrink(vhd_journal_t *journal, uint64_t secs)
-{
- int err;
- uint64_t new_eof;
- vhd_context_t *vhd;
-
- vhd = &journal->vhd;
-
- new_eof = vhd->footer.curr_size - vhd_sectors_to_bytes(secs);
- if (new_eof <= sizeof(vhd_footer_t))
- return -EINVAL;
-
- err = ftruncate(vhd->fd, new_eof);
- if (err)
- return errno;
-
- vhd->footer.curr_size = new_eof;
- return vhd_write_footer(vhd, &vhd->footer);
-}
-
-static int
-vhd_write_zeros(vhd_journal_t *journal, off_t off, uint64_t size)
-{
- int err;
- char *buf;
- vhd_context_t *vhd;
- uint64_t bytes, map;
-
- vhd = &journal->vhd;
- map = MIN(size, VHD_BLOCK_SIZE);
-
- err = vhd_seek(vhd, off, SEEK_SET);
- if (err)
- return err;
-
- buf = mmap(0, map, PROT_READ, MAP_SHARED | MAP_ANON, -1, 0);
- if (buf == MAP_FAILED)
- return -errno;
-
- do {
- bytes = MIN(size, map);
-
- err = vhd_write(vhd, buf, bytes);
- if (err)
- break;
-
- size -= bytes;
- } while (size);
-
- munmap(buf, map);
-
- return err;
-}
-
-static int
-vhd_fixed_grow(vhd_journal_t *journal, uint64_t secs)
-{
- int err;
- vhd_context_t *vhd;
- uint64_t size, eof, new_eof;
-
- size = vhd_sectors_to_bytes(secs);
- vhd = &journal->vhd;
-
- err = vhd_seek(vhd, 0, SEEK_END);
- if (err)
- goto out;
-
- eof = vhd_position(vhd);
- if (eof == (off_t)-1) {
- err = -errno;
- goto out;
- }
-
- err = vhd_write_zeros(journal, eof - sizeof(vhd_footer_t), size);
- if (err)
- goto out;
-
- new_eof = eof + size;
- err = vhd_seek(vhd, new_eof, SEEK_SET);
- if (err)
- goto out;
-
- vhd->footer.curr_size += size;
- err = vhd_write_footer(vhd, &vhd->footer);
- if (err)
- goto out;
-
- err = 0;
-
-out:
- return err;
-}
-
-static int
-vhd_fixed_resize(vhd_journal_t *journal, uint64_t size)
-{
- int err;
- vhd_context_t *vhd;
- uint64_t cur_secs, new_secs;
-
- vhd = &journal->vhd;
- cur_secs = vhd->footer.curr_size >> VHD_SECTOR_SHIFT;
- new_secs = size << (20 - VHD_SECTOR_SHIFT);
-
- if (cur_secs == new_secs)
- return 0;
- else if (cur_secs > new_secs)
- err = vhd_fixed_shrink(journal, cur_secs - new_secs);
- else
- err = vhd_fixed_grow(journal, new_secs - cur_secs);
-
- return err;
-}
-
-static inline void
-swap(vhd_block_t *list, int a, int b)
-{
- vhd_block_t tmp;
-
- tmp = list[a];
- list[a] = list[b];
- list[b] = tmp;
-}
-
-static int
-partition(vhd_block_t *list, int left, int right, int pidx)
-{
- int i, sidx;
- long long pval;
-
- sidx = left;
- pval = list[pidx].offset;
- swap(list, pidx, right);
-
- for (i = left; i < right; i++)
- if (list[i].offset >= pval) {
- swap(list, sidx, i);
- ++sidx;
- }
-
- swap(list, right, sidx);
- return sidx;
-}
-
-static void
-quicksort(vhd_block_t *list, int left, int right)
-{
- int pidx, new_pidx;
-
- if (right < left)
- return;
-
- pidx = left;
- new_pidx = partition(list, left, right, pidx);
- quicksort(list, left, new_pidx - 1);
- quicksort(list, new_pidx + 1, right);
-}
-
-static int
-vhd_move_block(vhd_journal_t *journal, uint32_t src, off_t offset)
-{
- int err;
- char *buf;
- size_t size;
- vhd_context_t *vhd;
- off_t off, src_off;
-
- buf = NULL;
- vhd = &journal->vhd;
- off = offset;
- size = vhd_sectors_to_bytes(vhd->bm_secs);
- src_off = vhd->bat.bat[src];
-
- if (src_off == DD_BLK_UNUSED)
- return -EINVAL;
- src_off = vhd_sectors_to_bytes(src_off);
-
- err = vhd_journal_add_block(journal, src,
- VHD_JOURNAL_DATA | VHD_JOURNAL_METADATA);
- if (err)
- goto out;
-
- err = vhd_read_bitmap(vhd, src, &buf);
- if (err)
- goto out;
-
- err = vhd_seek(vhd, off, SEEK_SET);
- if (err)
- goto out;
-
- err = vhd_write(vhd, buf, size);
- if (err)
- goto out;
-
- free(buf);
- buf = NULL;
- off += size;
- size = vhd_sectors_to_bytes(vhd->spb);
-
- err = vhd_read_block(vhd, src, &buf);
- if (err)
- goto out;
-
- err = vhd_seek(vhd, off, SEEK_SET);
- if (err)
- goto out;
-
- err = vhd_write(vhd, buf, size);
- if (err)
- goto out;
-
- vhd->bat.bat[src] = offset >> VHD_SECTOR_SHIFT;
-
- err = vhd_write_zeros(journal, src_off,
- vhd_sectors_to_bytes(vhd->bm_secs + vhd->spb));
-
-out:
- free(buf);
- return err;
-}
-
-static int
-vhd_clobber_block(vhd_journal_t *journal, uint32_t src, uint32_t dest)
-{
- int err;
- off_t off;
- vhd_context_t *vhd;
-
- vhd = &journal->vhd;
- off = vhd_sectors_to_bytes(vhd->bat.bat[dest]);
-
- err = vhd_journal_add_block(journal, dest,
- VHD_JOURNAL_DATA | VHD_JOURNAL_METADATA);
- if (err)
- return err;
-
- err = vhd_move_block(journal, src, off);
- if (err)
- return err;
-
- vhd->bat.bat[dest] = DD_BLK_UNUSED;
-
- return 0;
-}
-
-/*
- * remove a list of blocks from the vhd file
- * if a block to be removed:
- * - resides at the end of the file: simply clear its bat entry
- * - resides elsewhere: move the last block in the file into its position
- * and update the bat to reflect this
- */
-static int
-vhd_defrag_shrink(vhd_journal_t *journal,
- vhd_block_t *original_free_list, int free_cnt)
-{
- vhd_context_t *vhd;
- int i, j, free_idx, err;
- vhd_block_t *blocks, *free_list;
-
- err = 0;
- blocks = NULL;
- free_list = NULL;
- vhd = &journal->vhd;
-
- blocks = malloc(vhd->bat.entries * sizeof(vhd_block_t));
- if (!blocks) {
- err = -ENOMEM;
- goto out;
- }
-
- free_list = malloc(free_cnt * sizeof(vhd_block_t));
- if (!free_list) {
- err = -ENOMEM;
- goto out;
- }
-
- for (i = 0; i < vhd->bat.entries; i++) {
- blocks[i].block = i;
- blocks[i].offset = vhd->bat.bat[i];
- }
-
- memcpy(free_list, original_free_list,
- free_cnt * sizeof(vhd_block_t));
-
- /* sort both the to-free list and the bat list
- * in order of descending file offset */
- quicksort(free_list, 0, free_cnt - 1);
- quicksort(blocks, 0, vhd->bat.entries - 1);
-
- for (i = 0, free_idx = 0;
- i < vhd->bat.entries && free_idx < free_cnt; i++) {
- vhd_block_t *b = blocks + i;
-
- if (b->offset == DD_BLK_UNUSED)
- continue;
-
- for (j = free_idx; j < free_cnt; j++)
- if (b->block == free_list[j].block) {
- /* the last block in the file is in the list of
- * blocks to remove; no need to shuffle the
- * data -- just clear the bat entry */
- vhd->bat.bat[free_list[j].block] = DD_BLK_UNUSED;
- free_idx++;
- continue;
- }
-
- err = vhd_clobber_block(journal, b->block,
- free_list[free_idx++].block);
- if (err)
- goto out;
- }
-
- /* clear any bat entries for blocks we did not shuffle */
- for (i = free_idx; i < free_cnt; i++)
- vhd->bat.bat[free_list[i].block] = DD_BLK_UNUSED;
-
-out:
- free(blocks);
- free(free_list);
-
- return err;
-}
-
-static int
-vhd_clear_bat_entries(vhd_journal_t *journal, uint32_t entries)
-{
- int i, err;
- vhd_context_t *vhd;
- off_t orig_map_off, new_map_off;
- uint32_t orig_entries, new_entries;
-
- vhd = &journal->vhd;
- orig_entries = vhd->header.max_bat_size;
- new_entries = orig_entries - entries;
-
- if (vhd_has_batmap(vhd)) {
- err = vhd_batmap_header_offset(vhd, &orig_map_off);
- if (err)
- return err;
- }
-
- /* update header */
- vhd->header.max_bat_size = new_entries;
- err = vhd_write_header(vhd, &vhd->header);
- if (err)
- return err;
-
- /* update footer */
- vhd->footer.curr_size = (uint64_t)new_entries * vhd->header.block_size;
- vhd->footer.geometry = vhd_chs(vhd->footer.curr_size);
- err = vhd_write_footer(vhd, &vhd->footer);
- if (err)
- return err;
-
- /* update bat -- we don't reclaim space, just clear entries */
- for (i = new_entries; i < orig_entries; i++)
- vhd->bat.bat[i] = 0;
-
- err = vhd_write_bat(vhd, &vhd->bat);
- if (err)
- return err;
-
- /* update this after write_bat so the end of the bat is zeored */
- vhd->bat.entries = new_entries;
-
- if (!vhd_has_batmap(vhd))
- return 0;
-
- /* zero out old batmap header if new header has moved */
- err = vhd_batmap_header_offset(vhd, &new_map_off);
- if (err)
- return err;
-
- if (orig_map_off != new_map_off) {
- size_t size;
-
- size = vhd_bytes_padded(sizeof(struct dd_batmap_hdr));
-
- err = vhd_write_zeros(journal, orig_map_off, size);
- if (err)
- return err;
- }
-
- /* update batmap -- clear entries for freed blocks */
- for (i = new_entries; i < orig_entries; i++)
- vhd_batmap_clear(vhd, &vhd->batmap, i);
-
- err = vhd_write_batmap(vhd, &vhd->batmap);
- if (err)
- return err;
-
- return 0;
-}
-
-static int
-vhd_dynamic_shrink(vhd_journal_t *journal, uint64_t secs)
-{
- off_t eof;
- uint32_t blocks;
- vhd_context_t *vhd;
- int i, j, err, free_cnt;
- struct vhd_block *free_list;
-
- printf("dynamic shrink not fully implemented\n");
- return -ENOSYS;
-
- eof = 0;
- free_cnt = 0;
- free_list = NULL;
- vhd = &journal->vhd;
-
- blocks = secs_to_blocks_down(vhd, secs);
- if (blocks == 0)
- return 0;
-
- if (vhd_has_batmap(vhd)) {
- err = vhd_get_batmap(vhd);
- if (err)
- return err;
- }
-
- free_list = malloc(blocks * sizeof(struct vhd_block));
- if (!free_list)
- return -ENOMEM;
-
- for (i = vhd->bat.entries - 1, j = 0; i >= 0 && j < blocks; i--, j++) {
- uint32_t blk = vhd->bat.bat[i];
-
- if (blk != DD_BLK_UNUSED) {
- free_list[free_cnt].block = i;
- free_list[free_cnt].offset = blk;
- free_cnt++;
- }
- }
-
- if (free_cnt) {
- err = vhd_defrag_shrink(journal, free_list, free_cnt);
- if (err)
- goto out;
- }
-
- err = vhd_clear_bat_entries(journal, blocks);
- if (err)
- goto out;
-
- /* remove data beyond footer */
- err = vhd_end_of_data(vhd, &eof);
- if (err)
- goto out;
-
- err = ftruncate(vhd->fd, eof + sizeof(vhd_footer_t));
- if (err) {
- err = -errno;
- goto out;
- }
-
- err = 0;
-
-out:
- free(free_list);
- return err;
-}
-
-static inline void
-vhd_first_data_block(vhd_context_t *vhd, vhd_block_t *block)
-{
- int i;
- uint32_t blk;
-
- memset(block, 0, sizeof(vhd_block_t));
-
- for (i = 0; i < vhd->bat.entries; i++) {
- blk = vhd->bat.bat[i];
-
- if (blk != DD_BLK_UNUSED) {
- if (!block->offset || blk < block->offset) {
- block->block = i;
- block->offset = blk;
- }
- }
- }
-}
-
-static inline uint32_t
-vhd_next_block_offset(vhd_context_t *vhd)
-{
- int i;
- uint32_t blk, end, spp, next;
-
- next = 0;
- spp = getpagesize() >> VHD_SECTOR_SHIFT;
-
- for (i = 0; i < vhd->bat.entries; i++) {
- blk = vhd->bat.bat[i];
-
- if (blk != DD_BLK_UNUSED) {
- end = blk + vhd->spb + vhd->bm_secs;
- next = MAX(next, end);
- }
- }
-
- return next;
-}
-
-static inline int
-in_range(off_t off, off_t start, off_t size)
-{
- return (start < off && start + size > off);
-}
-
-#define SKIP_HEADER 0x01
-#define SKIP_BAT 0x02
-#define SKIP_BATMAP 0x04
-#define SKIP_PLOC 0x08
-#define SKIP_DATA 0x10
-
-static inline int
-skip_check(int mode, int type)
-{
- return mode & type;
-}
-
-static int
-vhd_check_for_clobber(vhd_context_t *vhd, off_t off, int mode)
-{
- int i, n;
- char *msg;
- size_t size;
- vhd_block_t fb;
- vhd_parent_locator_t *loc;
-
- msg = NULL;
-
- if (!vhd_type_dynamic(vhd))
- return 0;
-
- if (off < VHD_SECTOR_SIZE) {
- msg = "backup footer";
- goto fail;
- }
-
- if (!skip_check(mode, SKIP_HEADER))
- if (in_range(off,
- vhd->footer.data_offset, sizeof(vhd_header_t))) {
- msg = "header";
- goto fail;
- }
-
- if (!skip_check(mode, SKIP_BAT))
- if (in_range(off, vhd->header.table_offset,
- vhd_bytes_padded(vhd->header.max_bat_size *
- sizeof(uint32_t)))) {
- msg = "bat";
- goto fail;
- }
-
- if (!skip_check(mode, SKIP_BATMAP))
- if (vhd_has_batmap(vhd) &&
- in_range(off, vhd->batmap.header.batmap_offset,
- vhd_bytes_padded(vhd->batmap.header.batmap_size))) {
- msg = "batmap";
- goto fail;
- }
-
- if (!skip_check(mode, SKIP_PLOC)) {
- n = sizeof(vhd->header.loc) / sizeof(vhd_parent_locator_t);
- for (i = 0; i < n; i++) {
- loc = vhd->header.loc + i;
- if (loc->code == PLAT_CODE_NONE)
- continue;
-
- size = vhd_parent_locator_size(loc);
- if (in_range(off, loc->data_offset, size)) {
- msg = "parent locator";
- goto fail;
- }
- }
- }
-
- if (!skip_check(mode, SKIP_DATA)) {
- vhd_first_data_block(vhd, &fb);
- if (fb.offset && in_range(off,
- vhd_sectors_to_bytes(fb.offset),
- VHD_BLOCK_SIZE)) {
- msg = "data block";
- goto fail;
- }
- }
-
- return 0;
-
-fail:
- EPRINTF("write to 0x%08"PRIx64" would clobber %s\n", off, msg);
- return -EINVAL;
-}
-
-/*
- * take any metadata after the bat (@eob) and shift it
- */
-static int
-vhd_shift_metadata(vhd_journal_t *journal, off_t eob,
- size_t bat_needed, size_t map_needed)
-{
- int i, n, err;
- vhd_context_t *vhd;
- size_t size_needed;
- char *buf, **locators;
- vhd_parent_locator_t *loc;
-
- vhd = &journal->vhd;
- size_needed = bat_needed + map_needed;
-
- n = sizeof(vhd->header.loc) / sizeof(vhd_parent_locator_t);
-
- locators = calloc(n, sizeof(char *));
- if (!locators)
- return -ENOMEM;
-
- for (i = 0; i < n; i++) {
- size_t size;
-
- loc = vhd->header.loc + i;
- if (loc->code == PLAT_CODE_NONE)
- continue;
-
- if (loc->data_offset < eob)
- continue;
-
- size = vhd_parent_locator_size(loc);
- err = posix_memalign((void **)&buf, VHD_SECTOR_SIZE, size);
- if (err) {
- err = -err;
- buf = NULL;
- goto out;
- }
-
- err = vhd_seek(vhd, loc->data_offset, SEEK_SET);
- if (err)
- goto out;
-
- err = vhd_read(vhd, buf, size);
- if (err)
- goto out;
-
- locators[i] = buf;
- }
-
- for (i = 0; i < n; i++) {
- off_t off;
- size_t size;
-
- if (!locators[i])
- continue;
-
- loc = vhd->header.loc + i;
- off = loc->data_offset + size_needed;
- size = vhd_parent_locator_size(loc);
-
- if (vhd_check_for_clobber(vhd, off + size, SKIP_PLOC)) {
- EPRINTF("%s: shifting locator %d would clobber data\n",
- vhd->file, i);
- return -EINVAL;
- }
-
- err = vhd_seek(vhd, off, SEEK_SET);
- if (err)
- goto out;
-
- err = vhd_write(vhd, locators[i], size);
- if (err)
- goto out;
-
- free(locators[i]);
- locators[i] = NULL;
- loc->data_offset = off;
-
- /* write the new header after writing the new bat */
- }
-
- if (vhd_has_batmap(vhd) && vhd->batmap.header.batmap_offset > eob) {
- vhd->batmap.header.batmap_offset += bat_needed;
-
- /* write the new batmap after writing the new bat */
- }
-
- err = 0;
-
-out:
- for (i = 0; i < n; i++)
- free(locators[i]);
- free(locators);
-
- return err;
-}
-
-static int
-vhd_add_bat_entries(vhd_journal_t *journal, int entries)
-{
- int i, err;
- off_t off;
- vhd_bat_t new_bat;
- vhd_context_t *vhd;
- uint32_t new_entries;
- vhd_batmap_t new_batmap;
- uint64_t bat_size, new_bat_size, map_size, new_map_size;
-
- vhd = &journal->vhd;
- new_entries = vhd->header.max_bat_size + entries;
-
- bat_size = vhd_bytes_padded(vhd->header.max_bat_size *
- sizeof(uint32_t));
- new_bat_size = vhd_bytes_padded(new_entries * sizeof(uint32_t));
-
- map_size = vhd_bytes_padded((vhd->header.max_bat_size + 7) >> 3);
- new_map_size = vhd_bytes_padded((new_entries + 7) >> 3);
-
- off = vhd->header.table_offset + new_bat_size;
- if (vhd_check_for_clobber(vhd, off, SKIP_BAT | SKIP_BATMAP)) {
- EPRINTF("%s: writing new bat of 0x%"PRIx64" bytes "
- "at 0x%08"PRIx64" would clobber data\n",
- vhd->file, new_bat_size, vhd->header.table_offset);
- return -EINVAL;
- }
-
- if (vhd_has_batmap(vhd)) {
- off = vhd->batmap.header.batmap_offset + new_map_size;
- if (vhd_check_for_clobber(vhd, off, 0)) {
- EPRINTF("%s: writing new batmap of 0x%"PRIx64" bytes"
- " at 0x%08"PRIx64" would clobber data\n", vhd->file,
- new_map_size, vhd->batmap.header.batmap_offset);
- return -EINVAL;
- }
- }
-
- /* update header */
- vhd->header.max_bat_size = new_entries;
- err = vhd_write_header(vhd, &vhd->header);
- if (err)
- return err;
-
- /* update footer */
- vhd->footer.curr_size = (uint64_t)new_entries * vhd->header.block_size;
- vhd->footer.geometry = vhd_chs(vhd->footer.curr_size);
- vhd->footer.checksum = vhd_checksum_footer(&vhd->footer);
- err = vhd_write_footer(vhd, &vhd->footer);
- if (err)
- return err;
-
- /* allocate new bat */
- err = posix_memalign((void **)&new_bat.bat, VHD_SECTOR_SIZE, new_bat_size);
- if (err)
- return -err;
-
- new_bat.spb = vhd->bat.spb;
- new_bat.entries = new_entries;
- memcpy(new_bat.bat, vhd->bat.bat, bat_size);
- for (i = vhd->bat.entries; i < new_entries; i++)
- new_bat.bat[i] = DD_BLK_UNUSED;
-
- /* write new bat */
- err = vhd_write_bat(vhd, &new_bat);
- if (err) {
- free(new_bat.bat);
- return err;
- }
-
- /* update in-memory bat */
- free(vhd->bat.bat);
- vhd->bat = new_bat;
-
- if (!vhd_has_batmap(vhd))
- return 0;
-
- /* allocate new batmap */
- err = posix_memalign((void **)&new_batmap.map,
- VHD_SECTOR_SIZE, new_map_size);
- if (err)
- return err;
-
- new_batmap.header = vhd->batmap.header;
- new_batmap.header.batmap_size = secs_round_up_no_zero(new_map_size);
- memcpy(new_batmap.map, vhd->batmap.map, map_size);
- memset(new_batmap.map + map_size, 0, new_map_size - map_size);
-
- /* write new batmap */
- err = vhd_write_batmap(vhd, &new_batmap);
- if (err) {
- free(new_batmap.map);
- return err;
- }
-
- /* update in-memory batmap */
- free(vhd->batmap.map);
- vhd->batmap = new_batmap;
-
- return 0;
-}
-
-static int
-vhd_dynamic_grow(vhd_journal_t *journal, uint64_t secs)
-{
- int i, err;
- off_t eob, eom;
- vhd_context_t *vhd;
- vhd_block_t first_block;
- uint64_t blocks, size_needed;
- uint64_t bat_needed, bat_size, bat_avail, bat_bytes, bat_secs;
- uint64_t map_needed, map_size, map_avail, map_bytes, map_secs;
-
- vhd = &journal->vhd;
-
- size_needed = 0;
- bat_needed = 0;
- map_needed = 0;
-
- /* number of vhd blocks to add */
- blocks = secs_to_blocks_up(vhd, secs);
-
- /* size in bytes needed for new bat entries */
- bat_needed = blocks * sizeof(uint32_t);
- map_needed = (blocks >> 3) + 1;
-
- /* available bytes in current bat */
- bat_bytes = vhd->header.max_bat_size * sizeof(uint32_t);
- bat_secs = secs_round_up_no_zero(bat_bytes);
- bat_size = vhd_sectors_to_bytes(bat_secs);
- bat_avail = bat_size - bat_bytes;
-
- if (vhd_has_batmap(vhd)) {
- /* avaliable bytes in current batmap */
- map_bytes = (vhd->header.max_bat_size + 7) >> 3;
- map_secs = vhd->batmap.header.batmap_size;
- map_size = vhd_sectors_to_bytes(map_secs);
- map_avail = map_size - map_bytes;
- } else {
- map_needed = 0;
- map_avail = 0;
- }
-
- /* we have enough space already; just extend the bat */
- if (bat_needed <= bat_avail && map_needed <= map_avail)
- goto add_entries;
-
- /* we need to add new sectors to the bat */
- if (bat_needed > bat_avail) {
- bat_needed -= bat_avail;
- bat_needed = vhd_bytes_padded(bat_needed);
- } else
- bat_needed = 0;
-
- /* we need to add new sectors to the batmap */
- if (map_needed > map_avail) {
- map_needed -= map_avail;
- map_needed = vhd_bytes_padded(map_needed);
- } else
- map_needed = 0;
-
- /* how many additional bytes do we need? */
- size_needed = bat_needed + map_needed;
-
- /* calculate space between end of headers and beginning of data */
- err = vhd_end_of_headers(vhd, &eom);
- if (err)
- return err;
-
- eob = vhd->header.table_offset + vhd_sectors_to_bytes(bat_secs);
- vhd_first_data_block(vhd, &first_block);
-
- /* no blocks allocated; just shift post-bat metadata */
- if (!first_block.offset)
- goto shift_metadata;
-
- /*
- * not enough space --
- * move vhd data blocks to the end of the file to make room
- */
- do {
- off_t new_off, bm_size, gap_size;
-
- new_off = vhd_sectors_to_bytes(vhd_next_block_offset(vhd));
-
- /* data region of segment should begin on page boundary */
- bm_size = vhd_sectors_to_bytes(vhd->bm_secs);
- if ((new_off + bm_size) % 4096) {
- gap_size = 4096 - ((new_off + bm_size) % 4096);
-
- err = vhd_write_zeros(journal, new_off, gap_size);
- if (err)
- return err;
-
- new_off += gap_size;
- }
-
- err = vhd_move_block(journal, first_block.block, new_off);
- if (err)
- return err;
-
- vhd_first_data_block(vhd, &first_block);
-
- } while (eom + size_needed >= vhd_sectors_to_bytes(first_block.offset));
-
- TEST_FAIL_AT(FAIL_RESIZE_DATA_MOVED);
-
-shift_metadata:
- /* shift any metadata after the bat to make room for new bat sectors */
- err = vhd_shift_metadata(journal, eob, bat_needed, map_needed);
- if (err)
- return err;
-
- TEST_FAIL_AT(FAIL_RESIZE_METADATA_MOVED);
-
-add_entries:
- return vhd_add_bat_entries(journal, blocks);
-}
-
-static int
-vhd_dynamic_resize(vhd_journal_t *journal, uint64_t size)
-{
- int err;
- vhd_context_t *vhd;
- uint64_t cur_secs, new_secs;
-
- vhd = &journal->vhd;
- cur_secs = vhd->footer.curr_size >> VHD_SECTOR_SHIFT;
- new_secs = size << (20 - VHD_SECTOR_SHIFT);
-
- if (cur_secs == new_secs)
- return 0;
-
- err = vhd_get_header(vhd);
- if (err)
- return err;
-
- err = vhd_get_bat(vhd);
- if (err)
- return err;
-
- if (vhd_has_batmap(vhd)) {
- err = vhd_get_batmap(vhd);
- if (err)
- return err;
- }
-
- if (cur_secs > new_secs)
- err = vhd_dynamic_shrink(journal, cur_secs - new_secs);
- else
- err = vhd_dynamic_grow(journal, new_secs - cur_secs);
-
- return err;
-}
-
-static int
-vhd_util_resize_check_creator(const char *name)
-{
- int err;
- vhd_context_t vhd;
-
- err = vhd_open(&vhd, name, VHD_OPEN_RDONLY | VHD_OPEN_STRICT);
- if (err) {
- printf("error opening %s: %d\n", name, err);
- return err;
- }
-
- if (!vhd_creator_tapdisk(&vhd)) {
- printf("%s not created by xen; resize not supported\n", name);
- err = -EINVAL;
- }
-
- vhd_close(&vhd);
- return err;
-}
-
-int
-vhd_util_resize(int argc, char **argv)
-{
- char *name, *jname;
- uint64_t size;
- int c, err, jerr;
- vhd_journal_t journal;
- vhd_context_t *vhd;
-
- err = -EINVAL;
- size = 0;
- name = NULL;
- jname = NULL;
-
- optind = 0;
- while ((c = getopt(argc, argv, "n:j:s:h")) != -1) {
- switch (c) {
- case 'n':
- name = optarg;
- break;
- case 'j':
- jname = optarg;
- break;
- case 's':
- err = 0;
- size = strtoull(optarg, NULL, 10);
- break;
- case 'h':
- default:
- goto usage;
- }
- }
-
- if (err || !name || !jname || argc != optind)
- goto usage;
-
- err = vhd_util_resize_check_creator(name);
- if (err)
- return err;
-
- libvhd_set_log_level(1);
- err = vhd_journal_create(&journal, name, jname);
- if (err) {
- printf("creating journal failed: %d\n", err);
- return err;
- }
-
- vhd = &journal.vhd;
-
- err = vhd_get_footer(vhd);
- if (err)
- goto out;
-
- TEST_FAIL_AT(FAIL_RESIZE_BEGIN);
-
- if (vhd_type_dynamic(vhd))
- err = vhd_dynamic_resize(&journal, size);
- else
- err = vhd_fixed_resize(&journal, size);
-
- TEST_FAIL_AT(FAIL_RESIZE_END);
-
-out:
- if (err) {
- printf("resize failed: %d\n", err);
- jerr = vhd_journal_revert(&journal);
- } else
- jerr = vhd_journal_commit(&journal);
-
- if (jerr) {
- printf("closing journal failed: %d\n", jerr);
- vhd_journal_close(&journal);
- } else
- vhd_journal_remove(&journal);
-
- return (err ? : jerr);
-
-usage:
- printf("options: <-n name> <-j journal> <-s size (in MB)> [-h help]\n");
- return -EINVAL;
-}
+++ /dev/null
-/* Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * Altering operations:
- *
- * 1. Change the parent pointer to another file.
- * 2. Change the size of the file containing the VHD image. This does NOT
- * affect the VHD disk capacity, only the physical size of the file containing
- * the VHD. Naturally, it is not possible to set the file size to be less than
- * the what VHD utilizes.
- * The operation doesn't actually change the file size, but it writes the
- * footer in the right location such that resizing the file (manually, as a
- * separate step) will produce the correct results. If the new file size is
- * greater than the current file size, the file must first be expanded and then
- * altered with this operation. If the new size is smaller than the current
- * size, the VHD must first be altered with this operation and then the file
- * must be shrunk. Failing to resize the file will result in a corrupted VHD.
-*/
-
-#include <errno.h>
-//#include <fcntl.h>
-#include <stdio.h>
-//#include <stdlib.h>
-#include <unistd.h>
-
-#include "libvhd.h"
-#include "libvhd-journal.h"
-
-int
-vhd_util_revert(int argc, char **argv)
-{
- char *name, *jname;
- vhd_journal_t journal;
- int c, err;
-
- name = NULL;
- jname = NULL;
-
- optind = 0;
- while ((c = getopt(argc, argv, "n:j:h")) != -1) {
- switch (c) {
- case 'n':
- name = optarg;
- break;
- case 'j':
- jname = optarg;
- break;
- case 'h':
- default:
- goto usage;
- }
- }
-
- if (!name || !jname || argc != optind)
- goto usage;
-
- libvhd_set_log_level(1);
- err = vhd_journal_open(&journal, name, jname);
- if (err) {
- printf("opening journal failed: %d\n", err);
- return err;
- }
-
- err = vhd_journal_revert(&journal);
- if (err) {
- printf("reverting journal failed: %d\n", err);
- vhd_journal_close(&journal);
- return err;
- }
-
- err = vhd_journal_remove(&journal);
- if (err) {
- printf("removing journal failed: %d\n", err);
- vhd_journal_close(&journal);
- return err;
- }
-
- return 0;
-
-usage:
- printf("options: <-n name> <-j journal> [-h help]\n");
- return -EINVAL;
-}
+++ /dev/null
-/* Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#include <glob.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <fnmatch.h>
-#include <libgen.h> /* for basename() */
-#include <sys/stat.h>
-
-#include "list.h"
-#include "libvhd.h"
-#include "lvm-util.h"
-
-#define VHD_SCAN_FAST 0x01
-#define VHD_SCAN_PRETTY 0x02
-#define VHD_SCAN_VOLUME 0x04
-#define VHD_SCAN_NOFAIL 0x08
-#define VHD_SCAN_VERBOSE 0x10
-#define VHD_SCAN_PARENTS 0x20
-
-#define VHD_TYPE_RAW_FILE 0x01
-#define VHD_TYPE_VHD_FILE 0x02
-#define VHD_TYPE_RAW_VOLUME 0x04
-#define VHD_TYPE_VHD_VOLUME 0x08
-
-static inline int
-target_volume(uint8_t type)
-{
- return (type == VHD_TYPE_RAW_VOLUME || type == VHD_TYPE_VHD_VOLUME);
-}
-
-static inline int
-target_vhd(uint8_t type)
-{
- return (type == VHD_TYPE_VHD_FILE || type == VHD_TYPE_VHD_VOLUME);
-}
-
-struct target {
- char name[VHD_MAX_NAME_LEN];
- char device[VHD_MAX_NAME_LEN];
- uint64_t size;
- uint64_t start;
- uint64_t end;
- uint8_t type;
-};
-
-struct iterator {
- int cur;
- int cur_size;
- int max_size;
- struct target *targets;
-};
-
-struct vhd_image {
- char *name;
- char *parent;
- uint64_t capacity;
- off_t size;
- uint8_t hidden;
- int error;
- char *message;
-
- struct target *target;
-
- struct list_head sibling;
- struct list_head children;
- struct vhd_image *parent_image;
-};
-
-struct vhd_scan {
- int cur;
- int size;
-
- int lists_cur;
- int lists_size;
-
- struct vhd_image **images;
- struct vhd_image **lists;
-};
-
-static int flags;
-static struct vg vg;
-static struct vhd_scan scan;
-
-static int
-vhd_util_scan_pretty_allocate_list(int cnt)
-{
- int i;
- struct vhd_image *list;
-
- memset(&scan, 0, sizeof(scan));
-
- scan.lists_cur = 1;
- scan.lists_size = 10;
-
- scan.lists = calloc(scan.lists_size, sizeof(struct vhd_image *));
- if (!scan.lists)
- goto fail;
-
- scan.lists[0] = calloc(cnt, sizeof(struct vhd_image));
- if (!scan.lists[0])
- goto fail;
-
- scan.images = calloc(cnt, sizeof(struct vhd_image *));
- if (!scan.images)
- goto fail;
-
- for (i = 0; i < cnt; i++)
- scan.images[i] = scan.lists[0] + i;
-
- scan.cur = 0;
- scan.size = cnt;
-
- return 0;
-
-fail:
- if (scan.lists) {
- free(scan.lists[0]);
- free(scan.lists);
- }
-
- free(scan.images);
- memset(&scan, 0, sizeof(scan));
- return -ENOMEM;
-}
-
-static void
-vhd_util_scan_pretty_free_list(void)
-{
- int i;
-
- if (scan.lists) {
- for (i = 0; i < scan.lists_cur; i++)
- free(scan.lists[i]);
- free(scan.lists);
- }
-
- free(scan.images);
- memset(&scan, 0, sizeof(scan));
-}
-
-static int
-vhd_util_scan_pretty_add_image(struct vhd_image *image)
-{
- int i;
- struct vhd_image *img;
-
- for (i = 0; i < scan.cur; i++) {
- img = scan.images[i];
- if (!strcmp(img->name, image->name))
- return 0;
- }
-
- if (scan.cur >= scan.size) {
- struct vhd_image *new, **list;
-
- if (scan.lists_cur >= scan.lists_size) {
- list = realloc(scan.lists, scan.lists_size * 2 *
- sizeof(struct vhd_image *));
- if (!list)
- return -ENOMEM;
-
- scan.lists_size *= 2;
- scan.lists = list;
- }
-
- new = calloc(scan.size, sizeof(struct vhd_image));
- if (!new)
- return -ENOMEM;
-
- scan.lists[scan.lists_cur++] = new;
- scan.size *= 2;
-
- list = realloc(scan.images, scan.size *
- sizeof(struct vhd_image *));
- if (!list)
- return -ENOMEM;
-
- scan.images = list;
- for (i = 0; i + scan.cur < scan.size; i++)
- scan.images[i + scan.cur] = new + i;
- }
-
- img = scan.images[scan.cur];
- INIT_LIST_HEAD(&img->sibling);
- INIT_LIST_HEAD(&img->children);
-
- img->capacity = image->capacity;
- img->size = image->size;
- img->hidden = image->hidden;
- img->error = image->error;
- img->message = image->message;
-
- img->name = strdup(image->name);
- if (!img->name)
- goto fail;
-
- if (image->parent) {
- img->parent = strdup(image->parent);
- if (!img->parent)
- goto fail;
- }
-
- scan.cur++;
- return 0;
-
-fail:
- free(img->name);
- free(img->parent);
- memset(img, 0, sizeof(*img));
- return -ENOMEM;
-}
-
-static int
-vhd_util_scan_pretty_image_compare(const void *lhs, const void *rhs)
-{
- struct vhd_image *l, *r;
-
- l = *(struct vhd_image **)lhs;
- r = *(struct vhd_image **)rhs;
-
- return strcmp(l->name, r->name);
-}
-
-static void
-vhd_util_scan_print_image_indent(struct vhd_image *image, int tab)
-{
- char *pad, *name, *pmsg, *parent;
-
- pad = (tab ? " " : "");
- name = image->name;
- parent = (image->parent ? : "none");
-
- if ((flags & VHD_SCAN_PRETTY) && image->parent && !image->parent_image)
- pmsg = " (not found in scan)";
- else
- pmsg = "";
-
- if (!(flags & VHD_SCAN_VERBOSE)) {
- name = basename(image->name);
- if (image->parent)
- parent = basename(image->parent);
- }
-
- if (image->error)
- printf("%*svhd=%s scan-error=%d error-message='%s'\n",
- tab, pad, image->name, image->error, image->message);
- else
- printf("%*svhd=%s capacity=%"PRIu64" size=%"PRIu64" hidden=%u "
- "parent=%s%s\n", tab, pad, name, image->capacity,
- image->size, image->hidden, parent, pmsg);
-}
-
-static void
-vhd_util_scan_pretty_print_tree(struct vhd_image *image, int depth)
-{
- struct vhd_image *img, *tmp;
-
- vhd_util_scan_print_image_indent(image, depth * 3);
-
- list_for_each_entry_safe(img, tmp, &image->children, sibling)
- if (!img->hidden)
- vhd_util_scan_pretty_print_tree(img, depth + 1);
-
- list_for_each_entry_safe(img, tmp, &image->children, sibling)
- if (img->hidden)
- vhd_util_scan_pretty_print_tree(img, depth + 1);
-
- free(image->name);
- free(image->parent);
-
- image->name = NULL;
- image->parent = NULL;
-}
-
-static void
-vhd_util_scan_pretty_print_images(void)
-{
- int i;
- struct vhd_image *image, **parentp, *parent, *keyp, key;
-
- qsort(scan.images, scan.cur, sizeof(scan.images[0]),
- vhd_util_scan_pretty_image_compare);
-
- for (i = 0; i < scan.cur; i++) {
- image = scan.images[i];
-
- if (!image->parent) {
- image->parent_image = NULL;
- continue;
- }
-
- memset(&key, 0, sizeof(key));
- key.name = image->parent;
- keyp = &key;
-
- parentp = bsearch(&keyp, scan.images, scan.cur,
- sizeof(scan.images[0]),
- vhd_util_scan_pretty_image_compare);
- if (!parentp) {
- image->parent_image = NULL;
- continue;
- }
-
- parent = *parentp;
- image->parent_image = parent;
- list_add_tail(&image->sibling, &parent->children);
- }
-
- for (i = 0; i < scan.cur; i++) {
- image = scan.images[i];
-
- if (image->parent_image || !image->hidden)
- continue;
-
- vhd_util_scan_pretty_print_tree(image, 0);
- }
-
- for (i = 0; i < scan.cur; i++) {
- image = scan.images[i];
-
- if (!image->name || image->parent_image)
- continue;
-
- vhd_util_scan_pretty_print_tree(image, 0);
- }
-
- for (i = 0; i < scan.cur; i++) {
- image = scan.images[i];
-
- if (!image->name)
- continue;
-
- vhd_util_scan_pretty_print_tree(image, 0);
- }
-}
-
-static void
-vhd_util_scan_print_image(struct vhd_image *image)
-{
- int err;
-
- if (!image->error && (flags & VHD_SCAN_PRETTY)) {
- err = vhd_util_scan_pretty_add_image(image);
- if (!err)
- return;
-
- if (!image->error) {
- image->error = err;
- image->message = "allocating memory";
- }
- }
-
- vhd_util_scan_print_image_indent(image, 0);
-}
-
-static int
-vhd_util_scan_error(const char *file, int err)
-{
- struct vhd_image image;
-
- memset(&image, 0, sizeof(image));
- image.name = (char *)file;
- image.error = err;
- image.message = "failure scanning target";
-
- vhd_util_scan_print_image(&image);
-
- /*
- if (flags & VHD_SCAN_NOFAIL)
- return 0;
- */
-
- return err;
-}
-
-static vhd_parent_locator_t *
-vhd_util_scan_get_parent_locator(vhd_context_t *vhd)
-{
- int i;
- vhd_parent_locator_t *loc;
-
- loc = NULL;
-
- for (i = 0; i < 8; i++) {
- if (vhd->header.loc[i].code == PLAT_CODE_MACX) {
- loc = vhd->header.loc + i;
- break;
- }
-
- if (vhd->header.loc[i].code == PLAT_CODE_W2RU)
- loc = vhd->header.loc + i;
-
- if (!loc && vhd->header.loc[i].code != PLAT_CODE_NONE)
- loc = vhd->header.loc + i;
- }
-
- return loc;
-}
-
-static inline int
-copy_name(char *dst, const char *src)
-{
- if (snprintf(dst, VHD_MAX_NAME_LEN, "%s", src) < VHD_MAX_NAME_LEN)
- return 0;
-
- return -ENAMETOOLONG;
-}
-
-/*
- * LVHD stores realpath(parent) in parent locators, so
- * /dev/<vol-group>/<lv-name> becomes /dev/mapper/<vol--group>-<lv--name>
- */
-static int
-vhd_util_scan_extract_volume_name(char *dst, const char *src)
-{
- int err;
- char copy[VHD_MAX_NAME_LEN], *name, *s, *c;
-
- name = strrchr(src, '/');
- if (!name)
- name = (char *)src;
-
- /* convert single dashes to slashes, double dashes to single dashes */
- for (c = copy, s = name; *s != '\0'; s++, c++) {
- if (*s == '-') {
- if (s[1] != '-')
- *c = '/';
- else {
- s++;
- *c = '-';
- }
- } else
- *c = *s;
- }
-
- *c = '\0';
- c = strrchr(copy, '/');
- if (c == name) {
- /* unrecognized format */
- strcpy(dst, src);
- return -EINVAL;
- }
-
- strcpy(dst, ++c);
- return 0;
-}
-
-static int
-vhd_util_scan_get_volume_parent(vhd_context_t *vhd, struct vhd_image *image)
-{
- int err;
- char name[VHD_MAX_NAME_LEN];
- vhd_parent_locator_t *loc, copy;
-
- if (flags & VHD_SCAN_FAST) {
- err = vhd_header_decode_parent(vhd,
- &vhd->header, &image->parent);
- if (!err)
- goto found;
- }
-
- loc = vhd_util_scan_get_parent_locator(vhd);
- if (!loc)
- return -EINVAL;
-
- copy = *loc;
- copy.data_offset += image->target->start;
- err = vhd_parent_locator_read(vhd, ©, &image->parent);
- if (err)
- return err;
-
-found:
- err = vhd_util_scan_extract_volume_name(name, image->parent);
- if (!err)
- return copy_name(image->parent, name);
-
- return 0;
-}
-
-static int
-vhd_util_scan_get_parent(vhd_context_t *vhd, struct vhd_image *image)
-{
- int i, err;
- vhd_parent_locator_t *loc;
-
- if (!target_vhd(image->target->type)) {
- image->parent = NULL;
- return 0;
- }
-
- loc = NULL;
-
- if (target_volume(image->target->type))
- return vhd_util_scan_get_volume_parent(vhd, image);
-
- if (flags & VHD_SCAN_FAST) {
- err = vhd_header_decode_parent(vhd,
- &vhd->header, &image->parent);
- if (!err)
- return 0;
- } else {
- /*
- * vhd_parent_locator_get checks for the existence of the
- * parent file. if this call succeeds, all is well; if not,
- * we'll try to return whatever string we have before failing
- * outright.
- */
- err = vhd_parent_locator_get(vhd, &image->parent);
- if (!err)
- return 0;
- }
-
- loc = vhd_util_scan_get_parent_locator(vhd);
- if (!loc)
- return -EINVAL;
-
- return vhd_parent_locator_read(vhd, loc, &image->parent);
-}
-
-static int
-vhd_util_scan_get_hidden(vhd_context_t *vhd, struct vhd_image *image)
-{
- int err, hidden;
-
- err = 0;
- hidden = 0;
-
- if (target_vhd(image->target->type))
- err = vhd_hidden(vhd, &hidden);
- else
- hidden = 1;
-
- if (err)
- return err;
-
- image->hidden = hidden;
- return 0;
-}
-
-static int
-vhd_util_scan_get_size(vhd_context_t *vhd, struct vhd_image *image)
-{
- image->size = image->target->size;
-
- if (target_vhd(image->target->type))
- image->capacity = vhd->footer.curr_size;
- else
- image->capacity = image->size;
-
- return 0;
-}
-
-static int
-vhd_util_scan_open_file(vhd_context_t *vhd, struct vhd_image *image)
-{
- int err, vhd_flags;
-
- if (!target_vhd(image->target->type))
- return 0;
-
- vhd_flags = VHD_OPEN_RDONLY | VHD_OPEN_IGNORE_DISABLED;
- if (flags & VHD_SCAN_FAST)
- vhd_flags |= VHD_OPEN_FAST;
-
- err = vhd_open(vhd, image->name, vhd_flags);
- if (err) {
- vhd->file = NULL;
- image->message = "opening file";
- image->error = err;
- return image->error;
- }
-
- return 0;
-}
-
-static int
-vhd_util_scan_read_volume_headers(vhd_context_t *vhd, struct vhd_image *image)
-{
- int err;
- char *buf;
- size_t size;
- struct target *target;
-
- buf = NULL;
- target = image->target;
- size = sizeof(vhd_footer_t) + sizeof(vhd_header_t);
-
- err = posix_memalign((void **)&buf, VHD_SECTOR_SIZE, size);
- if (err) {
- buf = NULL;
- image->message = "allocating image";
- image->error = -err;
- goto out;
- }
-
- err = vhd_seek(vhd, target->start, SEEK_SET);
- if (err) {
- image->message = "seeking to headers";
- image->error = err;
- goto out;
- }
-
- err = vhd_read(vhd, buf, size);
- if (err) {
- image->message = "reading headers";
- image->error = err;
- goto out;
- }
-
- memcpy(&vhd->footer, buf, sizeof(vhd_footer_t));
- vhd_footer_in(&vhd->footer);
- err = vhd_validate_footer(&vhd->footer);
- if (err) {
- image->message = "invalid footer";
- image->error = err;
- goto out;
- }
-
- /* lvhd vhds should always be dynamic */
- if (vhd_type_dynamic(vhd)) {
- if (vhd->footer.data_offset != sizeof(vhd_footer_t))
- err = vhd_read_header_at(vhd, &vhd->header,
- vhd->footer.data_offset +
- target->start);
- else {
- memcpy(&vhd->header,
- buf + sizeof(vhd_footer_t),
- sizeof(vhd_header_t));
- vhd_header_in(&vhd->header);
- err = vhd_validate_header(&vhd->header);
- }
-
- if (err) {
- image->message = "reading header";
- image->error = err;
- goto out;
- }
-
- vhd->spb = vhd->header.block_size >> VHD_SECTOR_SHIFT;
- vhd->bm_secs = secs_round_up_no_zero(vhd->spb >> 3);
- }
-
-out:
- free(buf);
- return image->error;
-}
-
-static int
-vhd_util_scan_open_volume(vhd_context_t *vhd, struct vhd_image *image)
-{
- int err;
- struct target *target;
-
- target = image->target;
- memset(vhd, 0, sizeof(*vhd));
- vhd->oflags = VHD_OPEN_RDONLY | VHD_OPEN_FAST;
-
- if (target->end - target->start < 4096) {
- image->message = "device too small";
- image->error = -EINVAL;
- return image->error;
- }
-
- vhd->file = strdup(image->name);
- if (!vhd->file) {
- image->message = "allocating device";
- image->error = -ENOMEM;
- return image->error;
- }
-
- vhd->fd = open(target->device, O_RDONLY | O_DIRECT | O_LARGEFILE);
- if (vhd->fd == -1) {
- free(vhd->file);
- vhd->file = NULL;
-
- image->message = "opening device";
- image->error = -errno;
- return image->error;
- }
-
- if (target_vhd(target->type))
- return vhd_util_scan_read_volume_headers(vhd, image);
-
- return 0;
-}
-
-static int
-vhd_util_scan_open(vhd_context_t *vhd, struct vhd_image *image)
-{
- struct target *target;
-
- target = image->target;
-
- if (target_volume(image->target->type) || !(flags & VHD_SCAN_PRETTY))
- image->name = target->name;
- else {
- image->name = realpath(target->name, NULL);
- if (!image->name) {
- image->name = target->name;
- image->message = "resolving name";
- image->error = -errno;
- return image->error;
- }
- }
-
- if (target_volume(target->type))
- return vhd_util_scan_open_volume(vhd, image);
- else
- return vhd_util_scan_open_file(vhd, image);
-}
-
-static int
-vhd_util_scan_init_file_target(struct target *target,
- const char *file, uint8_t type)
-{
- int err;
- struct stat stats;
-
- err = stat(file, &stats);
- if (err == -1)
- return -errno;
-
- err = copy_name(target->name, file);
- if (err)
- return err;
-
- err = copy_name(target->device, file);
- if (err)
- return err;
-
- target->type = type;
- target->start = 0;
- target->size = stats.st_size;
- target->end = stats.st_size;
-
- return 0;
-}
-
-static int
-vhd_util_scan_init_volume_target(struct target *target,
- struct lv *lv, uint8_t type)
-{
- int err;
-
- if (lv->first_segment.type != LVM_SEG_TYPE_LINEAR)
- return -ENOSYS;
-
- err = copy_name(target->name, lv->name);
- if (err)
- return err;
-
- err = copy_name(target->device, lv->first_segment.device);
- if (err)
- return err;
-
- target->type = type;
- target->size = lv->size;
- target->start = lv->first_segment.pe_start;
- target->end = target->start + lv->first_segment.pe_size;
-
- return 0;
-}
-
-static int
-iterator_init(struct iterator *itr, int cnt, struct target *targets)
-{
- memset(itr, 0, sizeof(*itr));
-
- itr->targets = malloc(sizeof(struct target) * cnt);
- if (!itr->targets)
- return -ENOMEM;
-
- memcpy(itr->targets, targets, sizeof(struct target) * cnt);
-
- itr->cur = 0;
- itr->cur_size = cnt;
- itr->max_size = cnt;
-
- return 0;
-}
-
-static struct target *
-iterator_next(struct iterator *itr)
-{
- if (itr->cur == itr->cur_size)
- return NULL;
-
- return itr->targets + itr->cur++;
-}
-
-static int
-iterator_add_file(struct iterator *itr,
- struct target *target, const char *parent, uint8_t type)
-{
- int i;
- struct target *t;
- char *lname, *rname;
-
- for (i = 0; i < itr->cur_size; i++) {
- t = itr->targets + i;
- lname = basename((char *)t->name);
- rname = basename((char *)parent);
-
- if (!strcmp(lname, rname))
- return -EEXIST;
- }
-
- return vhd_util_scan_init_file_target(target, parent, type);
-}
-
-static int
-iterator_add_volume(struct iterator *itr,
- struct target *target, const char *parent, uint8_t type)
-{
- int i, err;
- struct lv *lv;
-
- lv = NULL;
- err = -ENOENT;
-
- for (i = 0; i < itr->cur_size; i++)
- if (!strcmp(parent, itr->targets[i].name))
- return -EEXIST;
-
- for (i = 0; i < vg.lv_cnt; i++) {
- err = fnmatch(parent, vg.lvs[i].name, FNM_PATHNAME);
- if (err != FNM_NOMATCH) {
- lv = vg.lvs + i;
- break;
- }
- }
-
- if (err && err != FNM_PATHNAME)
- return err;
-
- if (!lv)
- return -ENOENT;
-
- return vhd_util_scan_init_volume_target(target, lv, type);
-}
-
-static int
-iterator_add(struct iterator *itr, const char *parent, uint8_t type)
-{
- int err;
- struct target *target;
-
- if (itr->cur_size == itr->max_size) {
- struct target *new;
-
- new = realloc(itr->targets,
- sizeof(struct target) *
- itr->max_size * 2);
- if (!new)
- return -ENOMEM;
-
- itr->max_size *= 2;
- itr->targets = new;
- }
-
- target = itr->targets + itr->cur_size;
-
- if (target_volume(type))
- err = iterator_add_volume(itr, target, parent, type);
- else
- err = iterator_add_file(itr, target, parent, type);
-
- if (err)
- memset(target, 0, sizeof(*target));
- else
- itr->cur_size++;
-
- return (err == -EEXIST ? 0 : err);
-}
-
-static void
-iterator_free(struct iterator *itr)
-{
- free(itr->targets);
- memset(itr, 0, sizeof(*itr));
-}
-
-static void
-vhd_util_scan_add_parent(struct iterator *itr,
- vhd_context_t *vhd, struct vhd_image *image)
-{
- int err;
- uint8_t type;
-
- if (vhd_parent_raw(vhd))
- type = target_volume(image->target->type) ?
- VHD_TYPE_RAW_VOLUME : VHD_TYPE_RAW_FILE;
- else
- type = target_volume(image->target->type) ?
- VHD_TYPE_VHD_VOLUME : VHD_TYPE_VHD_FILE;
-
- err = iterator_add(itr, image->parent, type);
- if (err)
- vhd_util_scan_error(image->parent, err);
-}
-
-static int
-vhd_util_scan_targets(int cnt, struct target *targets)
-{
- int ret, err;
- vhd_context_t vhd;
- struct iterator itr;
- struct target *target;
- struct vhd_image image;
-
- ret = 0;
- err = 0;
-
- err = iterator_init(&itr, cnt, targets);
- if (err)
- return err;
-
- while ((target = iterator_next(&itr))) {
- memset(&vhd, 0, sizeof(vhd));
- memset(&image, 0, sizeof(image));
-
- image.target = target;
-
- err = vhd_util_scan_open(&vhd, &image);
- if (err) {
- ret = -EAGAIN;
- goto end;
- }
-
- err = vhd_util_scan_get_size(&vhd, &image);
- if (err) {
- ret = -EAGAIN;
- image.message = "getting physical size";
- image.error = err;
- goto end;
- }
-
- err = vhd_util_scan_get_hidden(&vhd, &image);
- if (err) {
- ret = -EAGAIN;
- image.message = "checking 'hidden' field";
- image.error = err;
- goto end;
- }
-
- if (vhd.footer.type == HD_TYPE_DIFF) {
- err = vhd_util_scan_get_parent(&vhd, &image);
- if (err) {
- ret = -EAGAIN;
- image.message = "getting parent";
- image.error = err;
- goto end;
- }
- }
-
- end:
- vhd_util_scan_print_image(&image);
-
- if (flags & VHD_SCAN_PARENTS && image.parent)
- vhd_util_scan_add_parent(&itr, &vhd, &image);
-
- if (vhd.file)
- vhd_close(&vhd);
- if (image.name != target->name)
- free(image.name);
- free(image.parent);
-
- if (err && !(flags & VHD_SCAN_NOFAIL))
- break;
- }
-
- iterator_free(&itr);
-
- if (flags & VHD_SCAN_NOFAIL)
- return ret;
-
- return err;
-}
-
-static int
-vhd_util_scan_targets_pretty(int cnt, struct target *targets)
-{
- int err;
-
- err = vhd_util_scan_pretty_allocate_list(cnt);
- if (err) {
- printf("scan failed: no memory\n");
- return -ENOMEM;
- }
-
- err = vhd_util_scan_targets(cnt, targets);
-
- vhd_util_scan_pretty_print_images();
- vhd_util_scan_pretty_free_list();
-
- return ((flags & VHD_SCAN_NOFAIL) ? 0 : err);
-}
-
-static int
-vhd_util_scan_find_file_targets(int cnt, char **names,
- const char *filter,
- struct target **_targets, int *_total)
-{
- glob_t g;
- struct target *targets;
- int i, globs, err, total;
-
- total = cnt;
- globs = 0;
- *_total = 0;
- *_targets = NULL;
-
- memset(&g, 0, sizeof(g));
-
- if (filter) {
- int gflags = ((flags & VHD_SCAN_FAST) ? GLOB_NOSORT : 0);
-
- errno = 0;
- err = glob(filter, gflags, vhd_util_scan_error, &g);
-
- switch (err) {
- case GLOB_NOSPACE:
- err = -ENOMEM;
- break;
- case GLOB_ABORTED:
- err = -EIO;
- break;
- case GLOB_NOMATCH:
- err = -errno;
- break;
- }
-
- if (err) {
- vhd_util_scan_error(filter, err);
- return err;
- }
-
- globs = g.gl_pathc;
- total += globs;
- }
-
- targets = calloc(total, sizeof(struct target));
- if (!targets) {
- err = -ENOMEM;
- goto out;
- }
-
- for (i = 0; i < g.gl_pathc; i++) {
- err = vhd_util_scan_init_file_target(targets + i,
- g.gl_pathv[i],
- VHD_TYPE_VHD_FILE);
- if (err) {
- vhd_util_scan_error(g.gl_pathv[i], err);
- if (!(flags & VHD_SCAN_NOFAIL))
- goto out;
- }
- }
-
- for (i = 0; i + globs < total; i++) {
- err = vhd_util_scan_init_file_target(targets + i + globs,
- names[i],
- VHD_TYPE_VHD_FILE);
- if (err) {
- vhd_util_scan_error(names[i], err);
- if (!(flags & VHD_SCAN_NOFAIL))
- goto out;
- }
- }
-
- err = 0;
- *_total = total;
- *_targets = targets;
-
-out:
- if (err)
- free(targets);
- if (filter)
- globfree(&g);
-
- return err;
-}
-
-static inline void
-swap_volume(struct lv *lvs, int dst, int src)
-{
- struct lv copy, *ldst, *lsrc;
-
- if (dst == src)
- return;
-
- lsrc = lvs + src;
- ldst = lvs + dst;
-
- memcpy(©, ldst, sizeof(copy));
- memcpy(ldst, lsrc, sizeof(*ldst));
- memcpy(lsrc, ©, sizeof(copy));
-}
-
-static int
-vhd_util_scan_sort_volumes(struct lv *lvs, int cnt,
- const char *filter, int *_matches)
-{
- struct lv *lv;
- int i, err, matches;
-
- matches = 0;
- *_matches = 0;
-
- if (!filter)
- return 0;
-
- for (i = 0; i < cnt; i++) {
- lv = lvs + i;
-
- err = fnmatch(filter, lv->name, FNM_PATHNAME);
- if (err) {
- if (err != FNM_NOMATCH) {
- vhd_util_scan_error(lv->name, err);
- if (!(flags & VHD_SCAN_NOFAIL))
- return err;
- }
-
- continue;
- }
-
- swap_volume(lvs, matches++, i);
- }
-
- *_matches = matches;
- return 0;
-}
-
-static int
-vhd_util_scan_find_volume_targets(int cnt, char **names,
- const char *volume, const char *filter,
- struct target **_targets, int *_total)
-{
- struct target *targets;
- int i, err, total, matches;
-
- *_total = 0;
- *_targets = NULL;
- targets = NULL;
-
- err = lvm_scan_vg(volume, &vg);
- if (err)
- return err;
-
- err = vhd_util_scan_sort_volumes(vg.lvs, vg.lv_cnt,
- filter, &matches);
- if (err)
- goto out;
-
- total = matches;
- for (i = 0; i < cnt; i++) {
- err = vhd_util_scan_sort_volumes(vg.lvs + total,
- vg.lv_cnt - total,
- names[i], &matches);
- if (err)
- goto out;
-
- total += matches;
- }
-
- targets = calloc(total, sizeof(struct target));
- if (!targets) {
- err = -ENOMEM;
- goto out;
- }
-
- for (i = 0; i < total; i++) {
- err = vhd_util_scan_init_volume_target(targets + i,
- vg.lvs + i,
- VHD_TYPE_VHD_VOLUME);
- if (err) {
- vhd_util_scan_error(vg.lvs[i].name, err);
- if (!(flags & VHD_SCAN_NOFAIL))
- goto out;
- }
- }
-
- err = 0;
- *_total = total;
- *_targets = targets;
-
-out:
- if (err)
- free(targets);
- return err;
-}
-
-static int
-vhd_util_scan_find_targets(int cnt, char **names,
- const char *volume, const char *filter,
- struct target **targets, int *total)
-{
- if (flags & VHD_SCAN_VOLUME)
- return vhd_util_scan_find_volume_targets(cnt, names,
- volume, filter,
- targets, total);
- return vhd_util_scan_find_file_targets(cnt, names,
- filter, targets, total);
-}
-
-int
-vhd_util_scan(int argc, char **argv)
-{
- int c, ret, err, cnt;
- char *filter, *volume;
- struct target *targets;
-
- cnt = 0;
- ret = 0;
- err = 0;
- flags = 0;
- filter = NULL;
- volume = NULL;
- targets = NULL;
-
- optind = 0;
- while ((c = getopt(argc, argv, "m:fcl:pavh")) != -1) {
- switch (c) {
- case 'm':
- filter = optarg;
- break;
- case 'f':
- flags |= VHD_SCAN_FAST;
- break;
- case 'c':
- flags |= VHD_SCAN_NOFAIL;
- break;
- case 'l':
- volume = optarg;
- flags |= VHD_SCAN_VOLUME;
- break;
- case 'p':
- flags |= VHD_SCAN_PRETTY;
- break;
- case 'a':
- flags |= VHD_SCAN_PARENTS;
- break;
- case 'v':
- flags |= VHD_SCAN_VERBOSE;
- break;
- case 'h':
- goto usage;
- default:
- err = -EINVAL;
- goto usage;
- }
- }
-
- if (!filter && argc - optind == 0) {
- err = -EINVAL;
- goto usage;
- }
-
- if (flags & VHD_SCAN_PRETTY)
- flags &= ~VHD_SCAN_FAST;
-
- err = vhd_util_scan_find_targets(argc - optind, argv + optind,
- volume, filter, &targets, &cnt);
- if (err) {
- printf("scan failed: %d\n", err);
- return err;
- }
-
- if (!cnt)
- return 0;
-
- if (flags & VHD_SCAN_PRETTY)
- err = vhd_util_scan_targets_pretty(cnt, targets);
- else
- err = vhd_util_scan_targets(cnt, targets);
-
- free(targets);
- lvm_free_vg(&vg);
-
- return ((flags & VHD_SCAN_NOFAIL) ? 0 : err);
-
-usage:
- printf("usage: [OPTIONS] FILES\n"
- "options: [-m match filter] [-f fast] [-c continue on failure] "
- "[-l LVM volume] [-p pretty print] [-a scan parents] "
- "[-v verbose] [-h help]\n");
- return err;
-}
+++ /dev/null
-/* Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#include <errno.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-#include "libvhd.h"
-
-int
-vhd_util_set_field(int argc, char **argv)
-{
- long value;
- int err, c;
- off_t eof;
- vhd_context_t vhd;
- char *name, *field;
-
- err = -EINVAL;
- value = 0;
- name = NULL;
- field = NULL;
-
- if (!argc || !argv)
- goto usage;
-
- optind = 0;
- while ((c = getopt(argc, argv, "n:f:v:h")) != -1) {
- switch (c) {
- case 'n':
- name = optarg;
- break;
- case 'f':
- field = optarg;
- break;
- case 'v':
- err = 0;
- value = strtol(optarg, NULL, 10);
- break;
- case 'h':
- default:
- goto usage;
- }
- }
-
- if (!name || !field || optind != argc || err)
- goto usage;
-
- if (strnlen(field, 25) >= 25) {
- printf("invalid field\n");
- goto usage;
- }
-
- if (strcmp(field, "hidden")) {
- printf("invalid field %s\n", field);
- goto usage;
- }
-
- if (value < 0 || value > 255) {
- printf("invalid value %ld\n", value);
- goto usage;
- }
-
- err = vhd_open(&vhd, name, VHD_OPEN_RDWR);
- if (err) {
- printf("error opening %s: %d\n", name, err);
- return err;
- }
-
- vhd.footer.hidden = (char)value;
-
- err = vhd_write_footer(&vhd, &vhd.footer);
-
- done:
- vhd_close(&vhd);
- return err;
-
-usage:
- printf("options: <-n name> <-f field> <-v value> [-h help]\n");
- return -EINVAL;
-}
+++ /dev/null
-/* Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#include <errno.h>
-#include <stdio.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-#include "libvhd.h"
-
-static int
-vhd_util_find_snapshot_target(const char *name, char **result, int *parent_raw)
-{
- int i, err;
- char *target;
- vhd_context_t vhd;
-
- *parent_raw = 0;
- *result = NULL;
-
- target = strdup(name);
- if (!target)
- return -ENOMEM;
-
- for (;;) {
- err = vhd_open(&vhd, target, VHD_OPEN_RDONLY);
- if (err)
- return err;
-
- if (vhd.footer.type != HD_TYPE_DIFF)
- goto out;
-
- err = vhd_get_bat(&vhd);
- if (err)
- goto out;
-
- for (i = 0; i < vhd.bat.entries; i++)
- if (vhd.bat.bat[i] != DD_BLK_UNUSED)
- goto out;
-
- free(target);
- err = vhd_parent_locator_get(&vhd, &target);
- if (err)
- goto out;
-
- if (vhd_parent_raw(&vhd)) {
- *parent_raw = 1;
- goto out;
- }
-
- vhd_close(&vhd);
- }
-
-out:
- vhd_close(&vhd);
- if (err)
- free(target);
- else
- *result = target;
-
- return err;
-}
-
-static int
-vhd_util_check_depth(const char *name, int *depth)
-{
- int err;
- vhd_context_t vhd;
-
- err = vhd_open(&vhd, name, VHD_OPEN_RDONLY);
- if (err)
- return err;
-
- err = vhd_chain_depth(&vhd, depth);
- vhd_close(&vhd);
-
- return err;
-}
-
-int
-vhd_util_snapshot(int argc, char **argv)
-{
- vhd_flag_creat_t flags;
- int c, err, prt_raw, limit;
- char *name, *pname, *ppath, *backing;
- uint64_t size;
- vhd_context_t vhd;
-
- name = NULL;
- pname = NULL;
- ppath = NULL;
- backing = NULL;
- size = 0;
- flags = 0;
- limit = 0;
-
- if (!argc || !argv) {
- err = -EINVAL;
- goto usage;
- }
-
- optind = 0;
- while ((c = getopt(argc, argv, "n:p:l:mh")) != -1) {
- switch (c) {
- case 'n':
- name = optarg;
- break;
- case 'p':
- pname = optarg;
- break;
- case 'l':
- limit = strtol(optarg, NULL, 10);
- break;
- case 'm':
- vhd_flag_set(flags, VHD_FLAG_CREAT_PARENT_RAW);
- break;
- case 'h':
- err = 0;
- goto usage;
- default:
- err = -EINVAL;
- goto usage;
- }
- }
-
- if (!name || !pname || optind != argc) {
- err = -EINVAL;
- goto usage;
- }
-
- ppath = realpath(pname, NULL);
- if (!ppath)
- return -errno;
-
- if (vhd_flag_test(flags, VHD_FLAG_CREAT_PARENT_RAW)) {
- backing = strdup(ppath);
- if (!backing) {
- err = -ENOMEM;
- goto out;
- }
- } else {
- err = vhd_util_find_snapshot_target(ppath, &backing, &prt_raw);
- if (err) {
- backing = NULL;
- goto out;
- }
-
- /*
- * if the sizes of the parent chain are non-uniform, we need to
- * pick the right size: that of the supplied parent
- */
- if (strcmp(ppath, backing)) {
- err = vhd_open(&vhd, ppath, VHD_OPEN_RDONLY);
- if (err)
- goto out;
- size = vhd.footer.curr_size;
- vhd_close(&vhd);
- }
-
- if (prt_raw)
- vhd_flag_set(flags, VHD_FLAG_CREAT_PARENT_RAW);
- }
-
- if (limit && !vhd_flag_test(flags, VHD_FLAG_CREAT_PARENT_RAW)) {
- int depth;
-
- err = vhd_util_check_depth(backing, &depth);
- if (err)
- printf("error checking snapshot depth: %d\n", err);
- else if (depth + 1 > limit) {
- err = -ENOSPC;
- printf("snapshot depth exceeded: "
- "current depth: %d, limit: %d\n", depth, limit);
- }
-
- if (err)
- goto out;
- }
-
- err = vhd_snapshot(name, size, backing, flags);
-
-out:
- free(ppath);
- free(backing);
-
- return err;
-
-usage:
- printf("options: <-n name> <-p parent name> [-l snapshot depth limit]"
- " [-m parent_is_raw] [-h help]\n");
- return err;
-}
+++ /dev/null
- /* Copyright (c) 2008, XenSource Inc.
- * Copyright (c) 2011, Citrix
- *
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#if defined(__linux__)
-
-#include <uuid/uuid.h>
-
-typedef struct {
- uuid_t uuid;
-} vhd_uuid_t;
-
-int vhd_uuid_is_nil(vhd_uuid_t *uuid)
-{
- return uuid_is_null(uuid->uuid);
-}
-
-void vhd_uuid_generate(vhd_uuid_t *uuid)
-{
- uuid_generate(uuid->uuid);
-}
-
-void vhd_uuid_to_string(vhd_uuid_t *uuid, char *out, size_t size)
-{
- uuid_unparse(uuid->uuid, out);
-}
-
-void vhd_uuid_from_string(vhd_uuid_t *uuid, const char *in)
-{
- uuid_parse(in, uuid->uuid);
-}
-
-void vhd_uuid_copy(vhd_uuid_t *dst, vhd_uuid_t *src)
-{
- uuid_copy(dst->uuid, src->uuid);
-}
-
-void vhd_uuid_clear(vhd_uuid_t *uuid)
-{
- uuid_clear(uuid->uuid);
-}
-
-int vhd_uuid_compare(vhd_uuid_t *uuid1, vhd_uuid_t *uuid2)
-{
- return uuid_compare(uuid1->uuid, uuid2->uuid);
-}
-
-#elif defined(__NetBSD__)
-
-#include <uuid.h>
-#include <string.h>
-#include <stdlib.h>
-
-typedef uuid_t vhd_uuid_t;
-
-int vhd_uuid_is_nil(vhd_uuid_t *uuid)
-{
- uint32_t status;
- return uuid_is_nil((uuid_t *)uuid, &status);
-}
-
-void vhd_uuid_generate(vhd_uuid_t *uuid)
-{
- uint32_t status;
- uuid_create((uuid_t *)uuid, &status);
-}
-
-void vhd_uuid_to_string(vhd_uuid_t *uuid, char *out, size_t size)
-{
- uint32_t status;
- char *_out = NULL;
- uuid_to_string((uuid_t *)uuid, &_out, &status);
- strlcpy(out, _out, size);
- free(_out);
-}
-
-void vhd_uuid_from_string(vhd_uuid_t *uuid, const char *in)
-{
- uint32_t status;
- uuid_from_string(in, (uuid_t *)uuid, &status);
-}
-
-void vhd_uuid_copy(vhd_uuid_t *dst, vhd_uuid_t *src)
-{
- memcpy((uuid_t *)dst, (uuid_t *)src, sizeof(uuid_t));
-}
-
-void vhd_uuid_clear(vhd_uuid_t *uuid)
-{
- memset((uuid_t *)uuid, 0, sizeof(uuid_t));
-}
-
-int vhd_uuid_compare(vhd_uuid_t *uuid1, vhd_uuid_t *uuid2)
-{
- uint32_t status;
- return uuid_compare((uuid_t *)uuid1, (uuid_t *)uuid2, &status);
-}
-
-#else
-
-#error "Please update vhd-util-uuid.c for your OS"
-
-#endif
+++ /dev/null
-/* Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * Before updating a VHD file, we create a journal consisting of:
- * - all data at the beginning of the file, up to and including the BAT
- * - each allocated bitmap (existing at the same offset in the journal as
- * its corresponding bitmap in the original file)
- * Updates are performed in place by writing appropriately
- * transformed versions of journaled bitmaps to the original file.
- */
-#include <stdio.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-#include "atomicio.h"
-#include "libvhd.h"
-#include "libvhd-journal.h"
-
-static void
-usage(void)
-{
- printf("usage: vhd-update <-n name> [-j existing journal] [-h]\n");
- exit(EINVAL);
-}
-
-/*
- * update vhd creator version to reflect its new bitmap ordering
- */
-static inline int
-update_creator_version(vhd_journal_t *journal)
-{
- journal->vhd.footer.crtr_ver = VHD_VERSION(1, 1);
- return vhd_write_footer(&journal->vhd, &journal->vhd.footer);
-}
-
-static int
-journal_bitmaps(vhd_journal_t *journal)
-{
- int i, err;
-
- for (i = 0; i < journal->vhd.bat.entries; i++) {
- err = vhd_journal_add_block(journal, i, VHD_JOURNAL_METADATA);
- if (err)
- return err;
- }
-
- return 0;
-}
-
-/*
- * older VHD bitmaps were little endian
- * and bits within a word were set from right to left
- */
-static inline int
-old_test_bit(int nr, volatile void * addr)
-{
- return (((unsigned long*)addr)[nr/(sizeof(unsigned long)*8)] >>
- (nr % (sizeof(unsigned long)*8))) & 1;
-}
-
-/*
- * new VHD bitmaps are big endian
- * and bits within a word are set from left to right
- */
-#define BIT_MASK 0x80
-static inline void
-new_set_bit (int nr, volatile char *addr)
-{
- addr[nr >> 3] |= (BIT_MASK >> (nr & 7));
-}
-
-static void
-convert_bitmap(char *in, char *out, int bytes)
-{
- int i;
-
- memset(out, 0, bytes);
-
- for (i = 0; i < bytes << 3; i++)
- if (old_test_bit(i, (void *)in))
- new_set_bit(i, out);
-}
-
-static int
-update_vhd(vhd_journal_t *journal, int rollback)
-{
- int i, err;
- size_t size;
- char *buf, *converted;
-
- buf = NULL;
- converted = NULL;
-
- size = vhd_bytes_padded(journal->vhd.spb / 8);
- err = posix_memalign((void **)&converted, 512, size);
- if (err) {
- converted = NULL;
- goto out;
- }
-
- for (i = 0; i < journal->vhd.bat.entries; i++) {
- if (journal->vhd.bat.bat[i] == DD_BLK_UNUSED)
- continue;
-
- err = vhd_read_bitmap(&journal->vhd, i, &buf);
- if (err)
- goto out;
-
- if (rollback)
- memcpy(converted, buf, size);
- else
- convert_bitmap(buf, converted, size);
-
- free(buf);
-
- err = vhd_write_bitmap(&journal->vhd, i, converted);
- if (err)
- goto out;
- }
-
- err = 0;
- out:
- free(converted);
- return err;
-}
-
-static int
-open_journal(vhd_journal_t *journal, const char *file, const char *jfile)
-{
- int err;
-
- err = vhd_journal_create(journal, file, jfile);
- if (err) {
- printf("error creating journal for %s: %d\n", file, err);
- return err;
- }
-
- return 0;
-}
-
-static int
-close_journal(vhd_journal_t *journal, int err)
-{
- if (err)
- err = vhd_journal_revert(journal);
- else
- err = vhd_journal_commit(journal);
-
- if (err)
- return vhd_journal_close(journal);
- else
- return vhd_journal_remove(journal);
-}
-
-int
-main(int argc, char **argv)
-{
- char *file, *jfile;
- int c, err, rollback;
- vhd_journal_t journal;
-
- file = NULL;
- jfile = NULL;
- rollback = 0;
-
- while ((c = getopt(argc, argv, "n:j:rh")) != -1) {
- switch(c) {
- case 'n':
- file = optarg;
- break;
- case 'j':
- jfile = optarg;
- err = access(jfile, R_OK);
- if (err == -1) {
- printf("invalid journal arg %s\n", jfile);
- return -errno;
- }
- break;
- case 'r':
- /* add a rollback option for debugging which
- * pushes journalled bitmaps to original file
- * without transforming them */
- rollback = 1;
- break;
- default:
- usage();
- }
- }
-
- if (!file)
- usage();
-
- if (rollback && !jfile) {
- printf("rollback requires a journal argument\n");
- usage();
- }
-
- err = open_journal(&journal, file, jfile);
- if (err)
- return err;
-
- if (!vhd_creator_tapdisk(&journal.vhd) ||
- journal.vhd.footer.crtr_ver != VHD_VERSION(0, 1) ||
- journal.vhd.footer.type == HD_TYPE_FIXED) {
- err = 0;
- goto out;
- }
-
- err = journal_bitmaps(&journal);
- if (err) {
- /* no changes to vhd file yet,
- * so close the journal and bail */
- vhd_journal_close(&journal);
- return err;
- }
-
- err = update_vhd(&journal, rollback);
- if (err) {
- printf("update failed: %d; saving journal\n", err);
- goto out;
- }
-
- err = update_creator_version(&journal);
- if (err) {
- printf("failed to udpate creator version: %d\n", err);
- goto out;
- }
-
- err = 0;
-
-out:
- err = close_journal(&journal, err);
- return err;
-}
+++ /dev/null
-/* Copyright (c) 2008, XenSource Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of XenSource Inc. nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <langinfo.h>
-#include <locale.h>
-
-#include "libvhd.h"
-#include "vhd-util.h"
-
-#if 1
-#define DFPRINTF(_f, _a...) fprintf(stdout, _f , ##_a)
-#else
-#define DFPRINTF(_f, _a...) ((void)0)
-#endif
-
-typedef int (*vhd_util_func_t) (int, char **);
-
-struct command {
- char *name;
- vhd_util_func_t func;
-};
-
-struct command commands[] = {
- { .name = "create", .func = vhd_util_create },
- { .name = "snapshot", .func = vhd_util_snapshot },
- { .name = "query", .func = vhd_util_query },
- { .name = "read", .func = vhd_util_read },
- { .name = "set", .func = vhd_util_set_field },
- { .name = "repair", .func = vhd_util_repair },
- { .name = "resize", .func = vhd_util_resize },
- { .name = "fill", .func = vhd_util_fill },
- { .name = "coalesce", .func = vhd_util_coalesce },
- { .name = "modify", .func = vhd_util_modify },
- { .name = "scan", .func = vhd_util_scan },
- { .name = "check", .func = vhd_util_check },
- { .name = "revert", .func = vhd_util_revert },
-};
-
-#define print_commands() \
- do { \
- int i, n; \
- n = sizeof(commands) / sizeof(struct command); \
- printf("COMMAND := { "); \
- printf("%s", commands[0].name); \
- for (i = 1; i < n; i++) \
- printf(" | %s", commands[i].name); \
- printf(" }\n"); \
- } while (0)
-
-TEST_FAIL_EXTERN_VARS;
-
-void
-help(void)
-{
- printf("usage: vhd-util COMMAND [OPTIONS]\n");
- print_commands();
- exit(0);
-}
-
-struct command *
-get_command(char *command)
-{
- int i, n;
-
- if (strnlen(command, 25) >= 25)
- return NULL;
-
- n = sizeof(commands) / sizeof (struct command);
-
- for (i = 0; i < n; i++)
- if (!strcmp(command, commands[i].name))
- return &commands[i];
-
- return NULL;
-}
-
-int
-main(int argc, char *argv[])
-{
- char **cargv;
- struct command *cmd;
- int cargc, i, cnt, ret;
-
-#ifdef CORE_DUMP
- #include <sys/resource.h>
- struct rlimit rlim;
- rlim.rlim_cur = RLIM_INFINITY;
- rlim.rlim_max = RLIM_INFINITY;
- if (setrlimit(RLIMIT_CORE, &rlim) < 0)
- fprintf(stderr, "setrlimit failed: %d\n", errno);
-#endif
- setlocale(LC_CTYPE, "");
-
- ret = 0;
-
- if (argc < 2)
- help();
-
- cargc = argc - 1;
- cmd = get_command(argv[1]);
- if (!cmd) {
- fprintf(stderr, "invalid COMMAND %s\n", argv[1]);
- help();
- }
-
- cargv = malloc(sizeof(char *) * cargc);
- if (!cargv)
- exit(ENOMEM);
-
- cnt = 1;
- cargv[0] = cmd->name;
- for (i = 1; i < cargc; i++) {
- char *arg = argv[i + (argc - cargc)];
-
- if (!strcmp(arg, "--debug")) {
- libvhd_set_log_level(1);
- continue;
- }
-
- cargv[cnt++] = arg;
- }
-
-#ifdef ENABLE_FAILURE_TESTING
- for (i = 0; i < NUM_FAIL_TESTS; i++) {
- TEST_FAIL[i] = 0;
- if (getenv(ENV_VAR_FAIL[i]))
- TEST_FAIL[i] = 1;
- }
-#endif // ENABLE_FAILURE_TESTING
-
- ret = cmd->func(cnt, cargv);
-
- free(cargv);
-
- return (ret >= 0 ? ret : -ret);
-}
projects / people / royger / xen.git / commitdiff