Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 378 insertions, 0 deletions

diff --git a/arch/um/drivers/cow_user.c b/arch/um/drivers/cow_user.c
new file mode 100644
index 000000000000..a8ce6fc3ef26
--- /dev/null
+++ b/arch/um/drivers/cow_user.c
@@ -0,0 +1,378 @@
+#include <stddef.h>
+#include <string.h>
+#include <errno.h>
+/* _XOPEN_SOURCE is needed for pread, but we define _GNU_SOURCE, which defines
+ * that.
+ */
+#include <unistd.h>
+#include <byteswap.h>
+#include <sys/time.h>
+#include <sys/param.h>
+#include <sys/user.h>
+#include <netinet/in.h>
+
+#include "os.h"
+
+#include "cow.h"
+#include "cow_sys.h"
+
+#define PATH_LEN_V1 256
+
+struct cow_header_v1 {
+        int magic;
+        int version;
+        char backing_file[PATH_LEN_V1];
+        time_t mtime;
+        __u64 size;
+        int sectorsize;
+};
+
+#define PATH_LEN_V2 MAXPATHLEN
+
+struct cow_header_v2 {
+        __u32 magic;
+        __u32 version;
+        char backing_file[PATH_LEN_V2];
+        time_t mtime;
+        __u64 size;
+        int sectorsize;
+};
+
+/* Define PATH_LEN_V3 as the usual value of MAXPATHLEN, just hard-code it in
+ * case other systems have different values for MAXPATHLEN
+ */
+#define PATH_LEN_V3 4096
+
+/* Changes from V2 -
+ *      PATH_LEN_V3 as described above
+ *      Explicitly specify field bit lengths for systems with different
+ *              lengths for the usual C types.  Not sure whether char or
+ *              time_t should be changed, this can be changed later without
+ *              breaking compatibility
+ *      Add alignment field so that different alignments can be used for the
+ *              bitmap and data
+ *      Add cow_format field to allow for the possibility of different ways
+ *              of specifying the COW blocks.  For now, the only value is 0,
+ *              for the traditional COW bitmap.
+ *      Move the backing_file field to the end of the header.  This allows
+ *              for the possibility of expanding it into the padding required
+ *              by the bitmap alignment.
+ *      The bitmap and data portions of the file will be aligned as specified
+ *              by the alignment field.  This is to allow COW files to be
+ *              put on devices with restrictions on access alignments, such as
+ *              /dev/raw, with a 512 byte alignment restriction.  This also
+ *              allows the data to be more aligned more strictly than on
+ *              sector boundaries.  This is needed for ubd-mmap, which needs
+ *              the data to be page aligned.
+ *      Fixed (finally!) the rounding bug
+ */
+
+struct cow_header_v3 {
+        __u32 magic;
+        __u32 version;
+        __u32 mtime;
+        __u64 size;
+        __u32 sectorsize;
+        __u32 alignment;
+        __u32 cow_format;
+        char backing_file[PATH_LEN_V3];
+};
+
+/* COW format definitions - for now, we have only the usual COW bitmap */
+#define COW_BITMAP 0
+
+union cow_header {
+        struct cow_header_v1 v1;
+        struct cow_header_v2 v2;
+        struct cow_header_v3 v3;
+};
+
+#define COW_MAGIC 0x4f4f4f4d  /* MOOO */
+#define COW_VERSION 3
+
+#define DIV_ROUND(x, len) (((x) + (len) - 1) / (len))
+#define ROUND_UP(x, align) DIV_ROUND(x, align) * (align)
+
+void cow_sizes(int version, __u64 size, int sectorsize, int align,
+               int bitmap_offset, unsigned long *bitmap_len_out,
+               int *data_offset_out)
+{
+        if(version < 3){
+                *bitmap_len_out = (size + sectorsize - 1) / (8 * sectorsize);
+
+                *data_offset_out = bitmap_offset + *bitmap_len_out;
+                *data_offset_out = (*data_offset_out + sectorsize - 1) /
+                        sectorsize;
+                *data_offset_out *= sectorsize;
+        }
+        else {
+                *bitmap_len_out = DIV_ROUND(size, sectorsize);
+                *bitmap_len_out = DIV_ROUND(*bitmap_len_out, 8);
+
+                *data_offset_out = bitmap_offset + *bitmap_len_out;
+                *data_offset_out = ROUND_UP(*data_offset_out, align);
+        }
+}
+
+static int absolutize(char *to, int size, char *from)
+{
+        char save_cwd[256], *slash;
+        int remaining;
+
+        if(getcwd(save_cwd, sizeof(save_cwd)) == NULL) {
+                cow_printf("absolutize : unable to get cwd - errno = %d\n",
+                           errno);
+                return(-1);
+        }
+        slash = strrchr(from, '/');
+        if(slash != NULL){
+                *slash = '\0';
+                if(chdir(from)){
+                        *slash = '/';
+                        cow_printf("absolutize : Can't cd to '%s' - "
+                                   "errno = %d\n", from, errno);
+                        return(-1);
+                }
+                *slash = '/';
+                if(getcwd(to, size) == NULL){
+                        cow_printf("absolutize : unable to get cwd of '%s' - "
+                               "errno = %d\n", from, errno);
+                        return(-1);
+                }
+                remaining = size - strlen(to);
+                if(strlen(slash) + 1 > remaining){
+                        cow_printf("absolutize : unable to fit '%s' into %d "
+                               "chars\n", from, size);
+                        return(-1);
+                }
+                strcat(to, slash);
+        }
+        else {
+                if(strlen(save_cwd) + 1 + strlen(from) + 1 > size){
+                        cow_printf("absolutize : unable to fit '%s' into %d "
+                               "chars\n", from, size);
+                        return(-1);
+                }
+                strcpy(to, save_cwd);
+                strcat(to, "/");
+                strcat(to, from);
+        }
+        chdir(save_cwd);
+        return(0);
+}
+
+int write_cow_header(char *cow_file, int fd, char *backing_file,
+                     int sectorsize, int alignment, unsigned long long *size)
+{
+        struct cow_header_v3 *header;
+        unsigned long modtime;
+        int err;
+
+        err = cow_seek_file(fd, 0);
+        if(err < 0){
+                cow_printf("write_cow_header - lseek failed, err = %d\n", -err);
+                goto out;
+        }
+
+        err = -ENOMEM;
+        header = cow_malloc(sizeof(*header));
+        if(header == NULL){
+                cow_printf("Failed to allocate COW V3 header\n");
+                goto out;
+        }
+        header->magic = htonl(COW_MAGIC);
+        header->version = htonl(COW_VERSION);
+
+        err = -EINVAL;
+        if(strlen(backing_file) > sizeof(header->backing_file) - 1){
+                cow_printf("Backing file name \"%s\" is too long - names are "
+                           "limited to %d characters\n", backing_file,
+                           sizeof(header->backing_file) - 1);
+                goto out_free;
+        }
+
+        if(absolutize(header->backing_file, sizeof(header->backing_file),
+                      backing_file))
+                goto out_free;
+
+        err = os_file_modtime(header->backing_file, &modtime);
+        if(err < 0){
+                cow_printf("Backing file '%s' mtime request failed, "
+                           "err = %d\n", header->backing_file, -err);
+                goto out_free;
+        }
+
+        err = cow_file_size(header->backing_file, size);
+        if(err < 0){
+                cow_printf("Couldn't get size of backing file '%s', "
+                           "err = %d\n", header->backing_file, -err);
+                goto out_free;
+        }
+
+        header->mtime = htonl(modtime);
+        header->size = htonll(*size);
+        header->sectorsize = htonl(sectorsize);
+        header->alignment = htonl(alignment);
+        header->cow_format = COW_BITMAP;
+
+        err = os_write_file(fd, header, sizeof(*header));
+        if(err != sizeof(*header)){
+                cow_printf("Write of header to new COW file '%s' failed, "
+                           "err = %d\n", cow_file, -err);
+                goto out_free;
+        }
+        err = 0;
+ out_free:
+        cow_free(header);
+ out:
+        return(err);
+}
+
+int file_reader(__u64 offset, char *buf, int len, void *arg)
+{
+        int fd = *((int *) arg);
+
+        return(pread(fd, buf, len, offset));
+}
+
+/* XXX Need to sanity-check the values read from the header */
+
+int read_cow_header(int (*reader)(__u64, char *, int, void *), void *arg,
+                    __u32 *version_out, char **backing_file_out,
+                    time_t *mtime_out, unsigned long long *size_out,
+                    int *sectorsize_out, __u32 *align_out,
+                    int *bitmap_offset_out)
+{
+        union cow_header *header;
+        char *file;
+        int err, n;
+        unsigned long version, magic;
+
+        header = cow_malloc(sizeof(*header));
+        if(header == NULL){
+                cow_printf("read_cow_header - Failed to allocate header\n");
+                return(-ENOMEM);
+        }
+        err = -EINVAL;
+        n = (*reader)(0, (char *) header, sizeof(*header), arg);
+        if(n < offsetof(typeof(header->v1), backing_file)){
+                cow_printf("read_cow_header - short header\n");
+                goto out;
+        }
+
+        magic = header->v1.magic;
+        if(magic == COW_MAGIC) {
+                version = header->v1.version;
+        }
+        else if(magic == ntohl(COW_MAGIC)){
+                version = ntohl(header->v1.version);
+        }
+        /* No error printed because the non-COW case comes through here */
+        else goto out;
+
+        *version_out = version;
+
+        if(version == 1){
+                if(n < sizeof(header->v1)){
+                        cow_printf("read_cow_header - failed to read V1 "
+                                   "header\n");
+                        goto out;
+                }
+                *mtime_out = header->v1.mtime;
+                *size_out = header->v1.size;
+                *sectorsize_out = header->v1.sectorsize;
+                *bitmap_offset_out = sizeof(header->v1);
+                *align_out = *sectorsize_out;
+                file = header->v1.backing_file;
+        }
+        else if(version == 2){
+                if(n < sizeof(header->v2)){
+                        cow_printf("read_cow_header - failed to read V2 "
+                                   "header\n");
+                        goto out;
+                }
+                *mtime_out = ntohl(header->v2.mtime);
+                *size_out = ntohll(header->v2.size);
+                *sectorsize_out = ntohl(header->v2.sectorsize);
+                *bitmap_offset_out = sizeof(header->v2);
+                *align_out = *sectorsize_out;
+                file = header->v2.backing_file;
+        }
+        else if(version == 3){
+                if(n < sizeof(header->v3)){
+                        cow_printf("read_cow_header - failed to read V2 "
+                                   "header\n");
+                        goto out;
+                }
+                *mtime_out = ntohl(header->v3.mtime);
+                *size_out = ntohll(header->v3.size);
+                *sectorsize_out = ntohl(header->v3.sectorsize);
+                *align_out = ntohl(header->v3.alignment);
+                *bitmap_offset_out = ROUND_UP(sizeof(header->v3), *align_out);
+                file = header->v3.backing_file;
+        }
+        else {
+                cow_printf("read_cow_header - invalid COW version\n");
+                goto out;
+        }
+        err = -ENOMEM;
+        *backing_file_out = cow_strdup(file);
+        if(*backing_file_out == NULL){
+                cow_printf("read_cow_header - failed to allocate backing "
+                           "file\n");
+                goto out;
+        }
+        err = 0;
+ out:
+        cow_free(header);
+        return(err);
+}
+
+int init_cow_file(int fd, char *cow_file, char *backing_file, int sectorsize,
+                  int alignment, int *bitmap_offset_out,
+                  unsigned long *bitmap_len_out, int *data_offset_out)
+{
+        unsigned long long size, offset;
+        char zero = 0;
+        int err;
+
+        err = write_cow_header(cow_file, fd, backing_file, sectorsize,
+                               alignment, &size);
+        if(err)
+                goto out;
+
+        *bitmap_offset_out = ROUND_UP(sizeof(struct cow_header_v3), alignment);
+        cow_sizes(COW_VERSION, size, sectorsize, alignment, *bitmap_offset_out,
+                  bitmap_len_out, data_offset_out);
+
+        offset = *data_offset_out + size - sizeof(zero);
+        err = cow_seek_file(fd, offset);
+        if(err < 0){
+                cow_printf("cow bitmap lseek failed : err = %d\n", -err);
+                goto out;
+        }
+
+        /* does not really matter how much we write it is just to set EOF
+         * this also sets the entire COW bitmap
+         * to zero without having to allocate it
+         */
+        err = cow_write_file(fd, &zero, sizeof(zero));
+        if(err != sizeof(zero)){
+                cow_printf("Write of bitmap to new COW file '%s' failed, "
+                           "err = %d\n", cow_file, -err);
+                err = -EINVAL;
+                goto out;
+        }
+
+        return(0);
+
+ out:
+        return(err);
+}
+
+/*
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */