[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Minios-devel] [UNIKRAFT PATCH v3 2/6] lib/ramfs: tabify imported ramfs code



To comply with Unikraft coding style, indents must be tabs, not
spaces. Imported code was a mixture of both.

Signed-off-by: Yuri Volchkov <yuri.volchkov@xxxxxxxxx>
Reviewed-by: Simon Kuenzer <simon.kuenzer@xxxxxxxxx>
---
 lib/ramfs/ramfs.h        |  26 +-
 lib/ramfs/ramfs_vfsops.c |  32 +-
 lib/ramfs/ramfs_vnops.c  | 916 +++++++++++++++++++--------------------
 3 files changed, 487 insertions(+), 487 deletions(-)

diff --git a/lib/ramfs/ramfs.h b/lib/ramfs/ramfs.h
index 88ccbe72..e4eeb65f 100644
--- a/lib/ramfs/ramfs.h
+++ b/lib/ramfs/ramfs.h
@@ -46,19 +46,19 @@
  * File/directory node for RAMFS
  */
 struct ramfs_node {
-    struct ramfs_node *rn_next;   /* next node in the same directory */
-    struct ramfs_node *rn_child;  /* first child node */
-    int rn_type;    /* file or directory */
-    char *rn_name;    /* name (null-terminated) */
-    size_t rn_namelen;    /* length of name not including terminator */
-    size_t rn_size;    /* file size */
-    char *rn_buf;    /* buffer to the file data */
-    size_t rn_bufsize;    /* allocated buffer size */
-    struct timespec rn_ctime;
-    struct timespec rn_atime;
-    struct timespec rn_mtime;
-    int rn_mode;
-    bool rn_owns_buf;
+       struct ramfs_node *rn_next;   /* next node in the same directory */
+       struct ramfs_node *rn_child;  /* first child node */
+       int rn_type;    /* file or directory */
+       char *rn_name;    /* name (null-terminated) */
+       size_t rn_namelen;    /* length of name not including terminator */
+       size_t rn_size;    /* file size */
+       char *rn_buf;    /* buffer to the file data */
+       size_t rn_bufsize;    /* allocated buffer size */
+       struct timespec rn_ctime;
+       struct timespec rn_atime;
+       struct timespec rn_mtime;
+       int rn_mode;
+       bool rn_owns_buf;
 };
 
 struct ramfs_node *ramfs_allocate_node(const char *name, int type);
diff --git a/lib/ramfs/ramfs_vfsops.c b/lib/ramfs/ramfs_vfsops.c
index 72fe7edb..53ae758a 100644
--- a/lib/ramfs/ramfs_vfsops.c
+++ b/lib/ramfs/ramfs_vfsops.c
@@ -49,12 +49,12 @@ static int ramfs_unmount(struct mount *mp, int flags);
  * File system operations
  */
 struct vfsops ramfs_vfsops = {
-        ramfs_mount,       /* mount */
-        ramfs_unmount,     /* unmount */
-        ramfs_sync,        /* sync */
-        ramfs_vget,        /* vget */
-        ramfs_statfs,      /* statfs */
-        &ramfs_vnops,      /* vnops */
+               ramfs_mount,       /* mount */
+               ramfs_unmount,     /* unmount */
+               ramfs_sync,        /* sync */
+               ramfs_vget,        /* vget */
+               ramfs_statfs,      /* statfs */
+               &ramfs_vnops,      /* vnops */
 };
 
 /*
@@ -63,16 +63,16 @@ struct vfsops ramfs_vfsops = {
 static int
 ramfs_mount(struct mount *mp, const char *dev, int flags, const void *data)
 {
-    struct ramfs_node *np;
+       struct ramfs_node *np;
 
-    DPRINTF(("ramfs_mount: dev=%s\n", dev));
+       DPRINTF(("ramfs_mount: dev=%s\n", dev));
 
-    /* Create a root node */
-    np = ramfs_allocate_node("/", VDIR);
-    if (np == NULL)
-        return ENOMEM;
-    mp->m_root->d_vnode->v_data = np;
-    return 0;
+       /* Create a root node */
+       np = ramfs_allocate_node("/", VDIR);
+       if (np == NULL)
+               return ENOMEM;
+       mp->m_root->d_vnode->v_data = np;
+       return 0;
 }
 
 /*
@@ -85,6 +85,6 @@ ramfs_mount(struct mount *mp, const char *dev, int flags, 
const void *data)
 static int
 ramfs_unmount(struct mount *mp, int flags)
 {
-    release_mp_dentries(mp);
-    return 0;
+       release_mp_dentries(mp);
+       return 0;
 }
diff --git a/lib/ramfs/ramfs_vnops.c b/lib/ramfs/ramfs_vnops.c
index 9291a4ec..8b586f88 100644
--- a/lib/ramfs/ramfs_vnops.c
+++ b/lib/ramfs/ramfs_vnops.c
@@ -54,313 +54,313 @@ static uint64_t inode_count = 1; /* inode 0 is reserved 
to root */
 static void
 set_times_to_now(struct timespec *time1, struct timespec *time2 = nullptr, 
struct timespec *time3 = nullptr)
 {
-    struct timespec now;
-    clock_gettime(CLOCK_REALTIME, &now);
-    if (time1) {
-        memcpy(time1, &now, sizeof(struct timespec));
-    }
-    if (time2) {
-        memcpy(time2, &now, sizeof(struct timespec));
-    }
-    if (time3) {
-        memcpy(time3, &now, sizeof(struct timespec));
-    }
+       struct timespec now;
+       clock_gettime(CLOCK_REALTIME, &now);
+       if (time1) {
+               memcpy(time1, &now, sizeof(struct timespec));
+       }
+       if (time2) {
+               memcpy(time2, &now, sizeof(struct timespec));
+       }
+       if (time3) {
+               memcpy(time3, &now, sizeof(struct timespec));
+       }
 }
 
 struct ramfs_node *
 ramfs_allocate_node(const char *name, int type)
 {
-    struct ramfs_node *np;
-
-    np = (ramfs_node *) malloc(sizeof(struct ramfs_node));
-    if (np == NULL)
-        return NULL;
-    memset(np, 0, sizeof(struct ramfs_node));
-
-    np->rn_namelen = strlen(name);
-    np->rn_name = (char *) malloc(np->rn_namelen + 1);
-    if (np->rn_name == NULL) {
-        free(np);
-        return NULL;
-    }
-    strlcpy(np->rn_name, name, np->rn_namelen + 1);
-    np->rn_type = type;
-
-    if (type == VDIR)
-        np->rn_mode = S_IFDIR|0777;
-    else if (type == VLNK)
-        np->rn_mode = S_IFLNK|0777;
-    else
-        np->rn_mode = S_IFREG|0777;
-
-    set_times_to_now(&(np->rn_ctime), &(np->rn_atime), &(np->rn_mtime));
-    np->rn_owns_buf = true;
-
-    return np;
+       struct ramfs_node *np;
+
+       np = (ramfs_node *) malloc(sizeof(struct ramfs_node));
+       if (np == NULL)
+               return NULL;
+       memset(np, 0, sizeof(struct ramfs_node));
+
+       np->rn_namelen = strlen(name);
+       np->rn_name = (char *) malloc(np->rn_namelen + 1);
+       if (np->rn_name == NULL) {
+               free(np);
+               return NULL;
+       }
+       strlcpy(np->rn_name, name, np->rn_namelen + 1);
+       np->rn_type = type;
+
+       if (type == VDIR)
+               np->rn_mode = S_IFDIR|0777;
+       else if (type == VLNK)
+               np->rn_mode = S_IFLNK|0777;
+       else
+               np->rn_mode = S_IFREG|0777;
+
+       set_times_to_now(&(np->rn_ctime), &(np->rn_atime), &(np->rn_mtime));
+       np->rn_owns_buf = true;
+
+       return np;
 }
 
 void
 ramfs_free_node(struct ramfs_node *np)
 {
-    if (np->rn_buf != NULL && np->rn_owns_buf)
-        free(np->rn_buf);
+       if (np->rn_buf != NULL && np->rn_owns_buf)
+               free(np->rn_buf);
 
-    free(np->rn_name);
-    free(np);
+       free(np->rn_name);
+       free(np);
 }
 
 static struct ramfs_node *
 ramfs_add_node(struct ramfs_node *dnp, char *name, int type)
 {
-    struct ramfs_node *np, *prev;
+       struct ramfs_node *np, *prev;
 
-    np = ramfs_allocate_node(name, type);
-    if (np == NULL)
-        return NULL;
+       np = ramfs_allocate_node(name, type);
+       if (np == NULL)
+               return NULL;
 
-    mutex_lock(&ramfs_lock);
+       mutex_lock(&ramfs_lock);
 
-    /* Link to the directory list */
-    if (dnp->rn_child == NULL) {
-        dnp->rn_child = np;
-    } else {
-        prev = dnp->rn_child;
-        while (prev->rn_next != NULL)
-            prev = prev->rn_next;
-        prev->rn_next = np;
-    }
+       /* Link to the directory list */
+       if (dnp->rn_child == NULL) {
+               dnp->rn_child = np;
+       } else {
+               prev = dnp->rn_child;
+               while (prev->rn_next != NULL)
+                       prev = prev->rn_next;
+               prev->rn_next = np;
+       }
 
-    set_times_to_now(&(dnp->rn_mtime), &(dnp->rn_ctime));
+       set_times_to_now(&(dnp->rn_mtime), &(dnp->rn_ctime));
 
-    mutex_unlock(&ramfs_lock);
-    return np;
+       mutex_unlock(&ramfs_lock);
+       return np;
 }
 
 static int
 ramfs_remove_node(struct ramfs_node *dnp, struct ramfs_node *np)
 {
-    struct ramfs_node *prev;
-
-    if (dnp->rn_child == NULL)
-        return EBUSY;
-
-    mutex_lock(&ramfs_lock);
-
-    /* Unlink from the directory list */
-    if (dnp->rn_child == np) {
-        dnp->rn_child = np->rn_next;
-    } else {
-        for (prev = dnp->rn_child; prev->rn_next != np;
-             prev = prev->rn_next) {
-            if (prev->rn_next == NULL) {
-                mutex_unlock(&ramfs_lock);
-                return ENOENT;
-            }
-        }
-        prev->rn_next = np->rn_next;
-    }
-    ramfs_free_node(np);
-
-    set_times_to_now(&(dnp->rn_mtime), &(dnp->rn_ctime));
-
-    mutex_unlock(&ramfs_lock);
-    return 0;
+       struct ramfs_node *prev;
+
+       if (dnp->rn_child == NULL)
+               return EBUSY;
+
+       mutex_lock(&ramfs_lock);
+
+       /* Unlink from the directory list */
+       if (dnp->rn_child == np) {
+               dnp->rn_child = np->rn_next;
+       } else {
+               for (prev = dnp->rn_child; prev->rn_next != np;
+                        prev = prev->rn_next) {
+                       if (prev->rn_next == NULL) {
+                               mutex_unlock(&ramfs_lock);
+                               return ENOENT;
+                       }
+               }
+               prev->rn_next = np->rn_next;
+       }
+       ramfs_free_node(np);
+
+       set_times_to_now(&(dnp->rn_mtime), &(dnp->rn_ctime));
+
+       mutex_unlock(&ramfs_lock);
+       return 0;
 }
 
 static int
 ramfs_rename_node(struct ramfs_node *np, char *name)
 {
-    size_t len;
-    char *tmp;
-
-    len = strlen(name);
-    if (len > NAME_MAX) {
-        return ENAMETOOLONG;
-    }
-    if (len <= np->rn_namelen) {
-        /* Reuse current name buffer */
-        strlcpy(np->rn_name, name, np->rn_namelen + 1);
-    } else {
-        /* Expand name buffer */
-        tmp = (char *) malloc(len + 1);
-        if (tmp == NULL)
-            return ENOMEM;
-        strlcpy(tmp, name, len + 1);
-        free(np->rn_name);
-        np->rn_name = tmp;
-    }
-    np->rn_namelen = len;
-    set_times_to_now(&(np->rn_ctime));
-    return 0;
+       size_t len;
+       char *tmp;
+
+       len = strlen(name);
+       if (len > NAME_MAX) {
+               return ENAMETOOLONG;
+       }
+       if (len <= np->rn_namelen) {
+               /* Reuse current name buffer */
+               strlcpy(np->rn_name, name, np->rn_namelen + 1);
+       } else {
+               /* Expand name buffer */
+               tmp = (char *) malloc(len + 1);
+               if (tmp == NULL)
+                       return ENOMEM;
+               strlcpy(tmp, name, len + 1);
+               free(np->rn_name);
+               np->rn_name = tmp;
+       }
+       np->rn_namelen = len;
+       set_times_to_now(&(np->rn_ctime));
+       return 0;
 }
 
 static int
 ramfs_lookup(struct vnode *dvp, char *name, struct vnode **vpp)
 {
-    struct ramfs_node *np, *dnp;
-    struct vnode *vp;
-    size_t len;
-    int found;
-
-    *vpp = NULL;
-
-    if (*name == '\0')
-        return ENOENT;
-
-    mutex_lock(&ramfs_lock);
-
-    len = strlen(name);
-    dnp = (ramfs_node *) dvp->v_data;
-    found = 0;
-    for (np = dnp->rn_child; np != NULL; np = np->rn_next) {
-        if (np->rn_namelen == len &&
-            memcmp(name, np->rn_name, len) == 0) {
-            found = 1;
-            break;
-        }
-    }
-    if (found == 0) {
-        mutex_unlock(&ramfs_lock);
-        return ENOENT;
-    }
-    if (vget(dvp->v_mount, inode_count++, &vp)) {
-        /* found in cache */
-        *vpp = vp;
-        mutex_unlock(&ramfs_lock);
-        return 0;
-    }
-    if (!vp) {
-        mutex_unlock(&ramfs_lock);
-        return ENOMEM;
-    }
-    vp->v_data = np;
-    vp->v_mode = ALLPERMS;
-    vp->v_type = np->rn_type;
-    vp->v_size = np->rn_size;
-
-    mutex_unlock(&ramfs_lock);
-
-    *vpp = vp;
-
-    return 0;
+       struct ramfs_node *np, *dnp;
+       struct vnode *vp;
+       size_t len;
+       int found;
+
+       *vpp = NULL;
+
+       if (*name == '\0')
+               return ENOENT;
+
+       mutex_lock(&ramfs_lock);
+
+       len = strlen(name);
+       dnp = (ramfs_node *) dvp->v_data;
+       found = 0;
+       for (np = dnp->rn_child; np != NULL; np = np->rn_next) {
+               if (np->rn_namelen == len &&
+                       memcmp(name, np->rn_name, len) == 0) {
+                       found = 1;
+                       break;
+               }
+       }
+       if (found == 0) {
+               mutex_unlock(&ramfs_lock);
+               return ENOENT;
+       }
+       if (vget(dvp->v_mount, inode_count++, &vp)) {
+               /* found in cache */
+               *vpp = vp;
+               mutex_unlock(&ramfs_lock);
+               return 0;
+       }
+       if (!vp) {
+               mutex_unlock(&ramfs_lock);
+               return ENOMEM;
+       }
+       vp->v_data = np;
+       vp->v_mode = ALLPERMS;
+       vp->v_type = np->rn_type;
+       vp->v_size = np->rn_size;
+
+       mutex_unlock(&ramfs_lock);
+
+       *vpp = vp;
+
+       return 0;
 }
 
 static int
 ramfs_mkdir(struct vnode *dvp, char *name, mode_t mode)
 {
-    struct ramfs_node *np;
+       struct ramfs_node *np;
 
-    DPRINTF(("mkdir %s\n", name));
-    if (strlen(name) > NAME_MAX) {
-        return ENAMETOOLONG;
-    }
+       DPRINTF(("mkdir %s\n", name));
+       if (strlen(name) > NAME_MAX) {
+               return ENAMETOOLONG;
+       }
 
-    if (!S_ISDIR(mode))
-        return EINVAL;
+       if (!S_ISDIR(mode))
+               return EINVAL;
 
-    np = (ramfs_node *) ramfs_add_node((ramfs_node *) dvp->v_data, name, VDIR);
-    if (np == NULL)
-        return ENOMEM;
-    np->rn_size = 0;
+       np = (ramfs_node *) ramfs_add_node((ramfs_node *) dvp->v_data, name, 
VDIR);
+       if (np == NULL)
+               return ENOMEM;
+       np->rn_size = 0;
 
-    return 0;
+       return 0;
 }
 
 static int
 ramfs_symlink(struct vnode *dvp, char *name, char *link)
 {
-    if (strlen(name) > NAME_MAX) {
-        return ENAMETOOLONG;
-    }
-    auto np = ramfs_add_node((ramfs_node *) dvp->v_data, name, VLNK);
-    if (np == NULL)
-        return ENOMEM;
-    // Save the link target without the final null, as readlink() wants it.
-    size_t len = strlen(link);
-    np->rn_buf = strndup(link, len);
-    np->rn_bufsize = np->rn_size = len;
-
-    return 0;
+       if (strlen(name) > NAME_MAX) {
+               return ENAMETOOLONG;
+       }
+       auto np = ramfs_add_node((ramfs_node *) dvp->v_data, name, VLNK);
+       if (np == NULL)
+               return ENOMEM;
+       // Save the link target without the final null, as readlink() wants it.
+       size_t len = strlen(link);
+       np->rn_buf = strndup(link, len);
+       np->rn_bufsize = np->rn_size = len;
+
+       return 0;
 }
 
 static int
 ramfs_readlink(struct vnode *vp, struct uio *uio)
 {
-    struct ramfs_node *np = (ramfs_node *) vp->v_data;
-    size_t len;
-
-    if (vp->v_type != VLNK) {
-        return EINVAL;
-    }
-    if (uio->uio_offset < 0) {
-        return EINVAL;
-    }
-    if (uio->uio_resid == 0) {
-        return 0;
-    }
-    if (uio->uio_offset >= (off_t) vp->v_size)
-        return 0;
-    if (vp->v_size - uio->uio_offset < uio->uio_resid)
-        len = vp->v_size - uio->uio_offset;
-    else
-        len = uio->uio_resid;
-
-    set_times_to_now( &(np->rn_atime));
-    return uiomove(np->rn_buf + uio->uio_offset, len, uio);
+       struct ramfs_node *np = (ramfs_node *) vp->v_data;
+       size_t len;
+
+       if (vp->v_type != VLNK) {
+               return EINVAL;
+       }
+       if (uio->uio_offset < 0) {
+               return EINVAL;
+       }
+       if (uio->uio_resid == 0) {
+               return 0;
+       }
+       if (uio->uio_offset >= (off_t) vp->v_size)
+               return 0;
+       if (vp->v_size - uio->uio_offset < uio->uio_resid)
+               len = vp->v_size - uio->uio_offset;
+       else
+               len = uio->uio_resid;
+
+       set_times_to_now( &(np->rn_atime));
+       return uiomove(np->rn_buf + uio->uio_offset, len, uio);
 }
 
 /* Remove a directory */
 static int
 ramfs_rmdir(struct vnode *dvp, struct vnode *vp, char *name)
 {
-    return ramfs_remove_node((ramfs_node *) dvp->v_data, (ramfs_node *) 
vp->v_data);
+       return ramfs_remove_node((ramfs_node *) dvp->v_data, (ramfs_node *) 
vp->v_data);
 }
 
 /* Remove a file */
 static int
 ramfs_remove(struct vnode *dvp, struct vnode *vp, char *name)
 {
-    DPRINTF(("remove %s in %s\n", name, dvp->v_path));
-    return ramfs_remove_node((ramfs_node *) dvp->v_data, (ramfs_node *) 
vp->v_data);
+       DPRINTF(("remove %s in %s\n", name, dvp->v_path));
+       return ramfs_remove_node((ramfs_node *) dvp->v_data, (ramfs_node *) 
vp->v_data);
 }
 
 /* Truncate file */
 static int
 ramfs_truncate(struct vnode *vp, off_t length)
 {
-    struct ramfs_node *np;
-    void *new_buf;
-    size_t new_size;
-
-    DPRINTF(("truncate %s length=%d\n", vp->v_path, length));
-    np = (ramfs_node *) vp->v_data;
-
-    if (length == 0) {
-        if (np->rn_buf != NULL) {
-            if(np->rn_owns_buf)
-                free(np->rn_buf);
-            np->rn_buf = NULL;
-            np->rn_bufsize = 0;
-        }
-    } else if (size_t(length) > np->rn_bufsize) {
-        // XXX: this could use a page level allocator
-        new_size = round_page(length);
-        new_buf = malloc(new_size);
-        if (!new_buf)
-            return EIO;
-        if (np->rn_size != 0) {
-            memcpy(new_buf, np->rn_buf, vp->v_size);
-            if(np->rn_owns_buf)
-                free(np->rn_buf);
-        }
-        np->rn_buf = (char *) new_buf;
-        np->rn_bufsize = new_size;
-        np->rn_owns_buf = true;
-    }
-    np->rn_size = length;
-    vp->v_size = length;
-    set_times_to_now(&(np->rn_mtime), &(np->rn_ctime));
-    return 0;
+       struct ramfs_node *np;
+       void *new_buf;
+       size_t new_size;
+
+       DPRINTF(("truncate %s length=%d\n", vp->v_path, length));
+       np = (ramfs_node *) vp->v_data;
+
+       if (length == 0) {
+               if (np->rn_buf != NULL) {
+                       if(np->rn_owns_buf)
+                               free(np->rn_buf);
+                       np->rn_buf = NULL;
+                       np->rn_bufsize = 0;
+               }
+       } else if (size_t(length) > np->rn_bufsize) {
+               // XXX: this could use a page level allocator
+               new_size = round_page(length);
+               new_buf = malloc(new_size);
+               if (!new_buf)
+                       return EIO;
+               if (np->rn_size != 0) {
+                       memcpy(new_buf, np->rn_buf, vp->v_size);
+                       if(np->rn_owns_buf)
+                               free(np->rn_buf);
+               }
+               np->rn_buf = (char *) new_buf;
+               np->rn_bufsize = new_size;
+               np->rn_owns_buf = true;
+       }
+       np->rn_size = length;
+       vp->v_size = length;
+       set_times_to_now(&(np->rn_mtime), &(np->rn_ctime));
+       return 0;
 }
 
 /*
@@ -369,165 +369,165 @@ ramfs_truncate(struct vnode *vp, off_t length)
 static int
 ramfs_create(struct vnode *dvp, char *name, mode_t mode)
 {
-    struct ramfs_node *np;
+       struct ramfs_node *np;
 
-    if (strlen(name) > NAME_MAX) {
-        return ENAMETOOLONG;
-    }
+       if (strlen(name) > NAME_MAX) {
+               return ENAMETOOLONG;
+       }
 
-    DPRINTF(("create %s in %s\n", name, dvp->v_path));
-    if (!S_ISREG(mode))
-        return EINVAL;
+       DPRINTF(("create %s in %s\n", name, dvp->v_path));
+       if (!S_ISREG(mode))
+               return EINVAL;
 
-    np = ramfs_add_node((ramfs_node *) dvp->v_data, name, VREG);
-    if (np == NULL)
-        return ENOMEM;
-    return 0;
+       np = ramfs_add_node((ramfs_node *) dvp->v_data, name, VREG);
+       if (np == NULL)
+               return ENOMEM;
+       return 0;
 }
 
 static int
 ramfs_read(struct vnode *vp, struct file *fp, struct uio *uio, int ioflag)
 {
-    struct ramfs_node *np = (ramfs_node *) vp->v_data;
-    size_t len;
-
-    if (vp->v_type == VDIR) {
-        return EISDIR;
-    }
-    if (vp->v_type != VREG) {
-        return EINVAL;
-    }
-    if (uio->uio_offset < 0) {
-        return EINVAL;
-    }
-    if (uio->uio_resid == 0) {
-        return 0;
-    }
-
-    if (uio->uio_offset >= (off_t) vp->v_size)
-        return 0;
-
-    if (vp->v_size - uio->uio_offset < uio->uio_resid)
-        len = vp->v_size - uio->uio_offset;
-    else
-        len = uio->uio_resid;
-
-    set_times_to_now(&(np->rn_atime));
-
-    return uiomove(np->rn_buf + uio->uio_offset, len, uio);
+       struct ramfs_node *np = (ramfs_node *) vp->v_data;
+       size_t len;
+
+       if (vp->v_type == VDIR) {
+               return EISDIR;
+       }
+       if (vp->v_type != VREG) {
+               return EINVAL;
+       }
+       if (uio->uio_offset < 0) {
+               return EINVAL;
+       }
+       if (uio->uio_resid == 0) {
+               return 0;
+       }
+
+       if (uio->uio_offset >= (off_t) vp->v_size)
+               return 0;
+
+       if (vp->v_size - uio->uio_offset < uio->uio_resid)
+               len = vp->v_size - uio->uio_offset;
+       else
+               len = uio->uio_resid;
+
+       set_times_to_now(&(np->rn_atime));
+
+       return uiomove(np->rn_buf + uio->uio_offset, len, uio);
 }
 
 int
 ramfs_set_file_data(struct vnode *vp, const void *data, size_t size)
 {
-    struct ramfs_node *np = (ramfs_node *) vp->v_data;
-
-    if (vp->v_type == VDIR) {
-        return EISDIR;
-    }
-    if (vp->v_type != VREG) {
-        return EINVAL;
-    }
-    if (np->rn_buf) {
-        return EINVAL;
-    }
-
-    np->rn_buf = (char *) data;
-    np->rn_bufsize = size;
-    np->rn_size = size;
-    vp->v_size = size;
-    np->rn_owns_buf = false;
-
-    return 0;
+       struct ramfs_node *np = (ramfs_node *) vp->v_data;
+
+       if (vp->v_type == VDIR) {
+               return EISDIR;
+       }
+       if (vp->v_type != VREG) {
+               return EINVAL;
+       }
+       if (np->rn_buf) {
+               return EINVAL;
+       }
+
+       np->rn_buf = (char *) data;
+       np->rn_bufsize = size;
+       np->rn_size = size;
+       vp->v_size = size;
+       np->rn_owns_buf = false;
+
+       return 0;
 }
 
 static int
 ramfs_write(struct vnode *vp, struct uio *uio, int ioflag)
 {
-    struct ramfs_node *np = (ramfs_node *) vp->v_data;
-
-    if (vp->v_type == VDIR) {
-        return EISDIR;
-    }
-    if (vp->v_type != VREG) {
-        return EINVAL;
-    }
-    if (uio->uio_offset < 0) {
-        return EINVAL;
-    }
-    if (uio->uio_offset >= LONG_MAX) {
-        return EFBIG;
-    }
-    if (uio->uio_resid == 0) {
-        return 0;
-    }
-
-    if (ioflag & IO_APPEND)
-        uio->uio_offset = np->rn_size;
-
-    if (size_t(uio->uio_offset + uio->uio_resid) > (size_t) vp->v_size) {
-        /* Expand the file size before writing to it */
-        off_t end_pos = uio->uio_offset + uio->uio_resid;
-        if (end_pos > (off_t) np->rn_bufsize) {
-            // XXX: this could use a page level allocator
-            size_t new_size = round_page(end_pos);
-            void *new_buf = malloc(new_size);
-            if (!new_buf)
-                return EIO;
-            if (np->rn_size != 0) {
-                memcpy(new_buf, np->rn_buf, vp->v_size);
-                if(np->rn_owns_buf)
-                    free(np->rn_buf);
-            }
-            np->rn_buf = (char *) new_buf;
-            np->rn_bufsize = new_size;
-        }
-        np->rn_size = end_pos;
-        vp->v_size = end_pos;
-        np->rn_owns_buf = true;
-    }
-
-    set_times_to_now(&(np->rn_mtime), &(np->rn_ctime));
-    return uiomove(np->rn_buf + uio->uio_offset, uio->uio_resid, uio);
+       struct ramfs_node *np = (ramfs_node *) vp->v_data;
+
+       if (vp->v_type == VDIR) {
+               return EISDIR;
+       }
+       if (vp->v_type != VREG) {
+               return EINVAL;
+       }
+       if (uio->uio_offset < 0) {
+               return EINVAL;
+       }
+       if (uio->uio_offset >= LONG_MAX) {
+               return EFBIG;
+       }
+       if (uio->uio_resid == 0) {
+               return 0;
+       }
+
+       if (ioflag & IO_APPEND)
+               uio->uio_offset = np->rn_size;
+
+       if (size_t(uio->uio_offset + uio->uio_resid) > (size_t) vp->v_size) {
+               /* Expand the file size before writing to it */
+               off_t end_pos = uio->uio_offset + uio->uio_resid;
+               if (end_pos > (off_t) np->rn_bufsize) {
+                       // XXX: this could use a page level allocator
+                       size_t new_size = round_page(end_pos);
+                       void *new_buf = malloc(new_size);
+                       if (!new_buf)
+                               return EIO;
+                       if (np->rn_size != 0) {
+                               memcpy(new_buf, np->rn_buf, vp->v_size);
+                               if(np->rn_owns_buf)
+                                       free(np->rn_buf);
+                       }
+                       np->rn_buf = (char *) new_buf;
+                       np->rn_bufsize = new_size;
+               }
+               np->rn_size = end_pos;
+               vp->v_size = end_pos;
+               np->rn_owns_buf = true;
+       }
+
+       set_times_to_now(&(np->rn_mtime), &(np->rn_ctime));
+       return uiomove(np->rn_buf + uio->uio_offset, uio->uio_resid, uio);
 }
 
 static int
 ramfs_rename(struct vnode *dvp1, struct vnode *vp1, char *name1,
-             struct vnode *dvp2, struct vnode *vp2, char *name2)
+                        struct vnode *dvp2, struct vnode *vp2, char *name2)
 {
-    struct ramfs_node *np, *old_np;
-    int error;
-
-    if (vp2) {
-        /* Remove destination file, first */
-        error = ramfs_remove_node((ramfs_node *) dvp2->v_data, (ramfs_node *) 
vp2->v_data);
-        if (error)
-            return error;
-    }
-    /* Same directory ? */
-    if (dvp1 == dvp2) {
-        /* Change the name of existing file */
-        error = ramfs_rename_node((ramfs_node *) vp1->v_data, name2);
-        if (error)
-            return error;
-    } else {
-        /* Create new file or directory */
-        old_np = (ramfs_node *) vp1->v_data;
-        np = ramfs_add_node((ramfs_node *) dvp2->v_data, name2, 
old_np->rn_type);
-        if (np == NULL)
-            return ENOMEM;
-
-        if (old_np->rn_buf) {
-            /* Copy file data */
-            np->rn_buf = old_np->rn_buf;
-            np->rn_size = old_np->rn_size;
-            np->rn_bufsize = old_np->rn_bufsize;
-            old_np->rn_buf = NULL;
-        }
-        /* Remove source file */
-        ramfs_remove_node((ramfs_node *) dvp1->v_data, (ramfs_node *) 
vp1->v_data);
-    }
-    return 0;
+       struct ramfs_node *np, *old_np;
+       int error;
+
+       if (vp2) {
+               /* Remove destination file, first */
+               error = ramfs_remove_node((ramfs_node *) dvp2->v_data, 
(ramfs_node *) vp2->v_data);
+               if (error)
+                       return error;
+       }
+       /* Same directory ? */
+       if (dvp1 == dvp2) {
+               /* Change the name of existing file */
+               error = ramfs_rename_node((ramfs_node *) vp1->v_data, name2);
+               if (error)
+                       return error;
+       } else {
+               /* Create new file or directory */
+               old_np = (ramfs_node *) vp1->v_data;
+               np = ramfs_add_node((ramfs_node *) dvp2->v_data, name2, 
old_np->rn_type);
+               if (np == NULL)
+                       return ENOMEM;
+
+               if (old_np->rn_buf) {
+                       /* Copy file data */
+                       np->rn_buf = old_np->rn_buf;
+                       np->rn_size = old_np->rn_size;
+                       np->rn_bufsize = old_np->rn_bufsize;
+                       old_np->rn_buf = NULL;
+               }
+               /* Remove source file */
+               ramfs_remove_node((ramfs_node *) dvp1->v_data, (ramfs_node *) 
vp1->v_data);
+       }
+       return 0;
 }
 
 /*
@@ -536,97 +536,97 @@ ramfs_rename(struct vnode *dvp1, struct vnode *vp1, char 
*name1,
 static int
 ramfs_readdir(struct vnode *vp, struct file *fp, struct dirent *dir)
 {
-    struct ramfs_node *np, *dnp;
-    int i;
-
-    mutex_lock(&ramfs_lock);
-
-    set_times_to_now(&(((ramfs_node *) vp->v_data)->rn_atime));
-
-    if (fp->f_offset == 0) {
-        dir->d_type = DT_DIR;
-        strlcpy((char *) &dir->d_name, ".", sizeof(dir->d_name));
-    } else if (fp->f_offset == 1) {
-        dir->d_type = DT_DIR;
-        strlcpy((char *) &dir->d_name, "..", sizeof(dir->d_name));
-    } else {
-        dnp = (ramfs_node *) vp->v_data;
-        np = dnp->rn_child;
-        if (np == NULL) {
-            mutex_unlock(&ramfs_lock);
-            return ENOENT;
-        }
-
-        for (i = 0; i != (fp->f_offset - 2); i++) {
-            np = np->rn_next;
-            if (np == NULL) {
-                mutex_unlock(&ramfs_lock);
-                return ENOENT;
-            }
-        }
-        if (np->rn_type == VDIR)
-            dir->d_type = DT_DIR;
-        else if (np->rn_type == VLNK)
-            dir->d_type = DT_LNK;
-        else
-            dir->d_type = DT_REG;
-        strlcpy((char *) &dir->d_name, np->rn_name,
-                sizeof(dir->d_name));
-    }
-    dir->d_fileno = fp->f_offset;
+       struct ramfs_node *np, *dnp;
+       int i;
+
+       mutex_lock(&ramfs_lock);
+
+       set_times_to_now(&(((ramfs_node *) vp->v_data)->rn_atime));
+
+       if (fp->f_offset == 0) {
+               dir->d_type = DT_DIR;
+               strlcpy((char *) &dir->d_name, ".", sizeof(dir->d_name));
+       } else if (fp->f_offset == 1) {
+               dir->d_type = DT_DIR;
+               strlcpy((char *) &dir->d_name, "..", sizeof(dir->d_name));
+       } else {
+               dnp = (ramfs_node *) vp->v_data;
+               np = dnp->rn_child;
+               if (np == NULL) {
+                       mutex_unlock(&ramfs_lock);
+                       return ENOENT;
+               }
+
+               for (i = 0; i != (fp->f_offset - 2); i++) {
+                       np = np->rn_next;
+                       if (np == NULL) {
+                               mutex_unlock(&ramfs_lock);
+                               return ENOENT;
+                       }
+               }
+               if (np->rn_type == VDIR)
+                       dir->d_type = DT_DIR;
+               else if (np->rn_type == VLNK)
+                       dir->d_type = DT_LNK;
+               else
+                       dir->d_type = DT_REG;
+               strlcpy((char *) &dir->d_name, np->rn_name,
+                               sizeof(dir->d_name));
+       }
+       dir->d_fileno = fp->f_offset;
 //     dir->d_namelen = strlen(dir->d_name);
 
-    fp->f_offset++;
+       fp->f_offset++;
 
-    mutex_unlock(&ramfs_lock);
-    return 0;
+       mutex_unlock(&ramfs_lock);
+       return 0;
 }
 
 int
 ramfs_init(void)
 {
-    return 0;
+       return 0;
 }
 
 static int
 ramfs_getattr(struct vnode *vnode, struct vattr *attr)
 {
-    attr->va_nodeid = vnode->v_ino;
-    attr->va_size = vnode->v_size;
+       attr->va_nodeid = vnode->v_ino;
+       attr->va_size = vnode->v_size;
 
-    struct ramfs_node *np = (ramfs_node *) vnode->v_data;
-    attr->va_type = (vtype) np->rn_type;
+       struct ramfs_node *np = (ramfs_node *) vnode->v_data;
+       attr->va_type = (vtype) np->rn_type;
 
-    memcpy(&(attr->va_atime), &(np->rn_atime), sizeof(struct timespec));
-    memcpy(&(attr->va_ctime), &(np->rn_ctime), sizeof(struct timespec));
-    memcpy(&(attr->va_mtime), &(np->rn_mtime), sizeof(struct timespec));
+       memcpy(&(attr->va_atime), &(np->rn_atime), sizeof(struct timespec));
+       memcpy(&(attr->va_ctime), &(np->rn_ctime), sizeof(struct timespec));
+       memcpy(&(attr->va_mtime), &(np->rn_mtime), sizeof(struct timespec));
 
-    attr->va_mode = np->rn_mode;
+       attr->va_mode = np->rn_mode;
 
-    return 0;
+       return 0;
 }
 
 static int
 ramfs_setattr(struct vnode *vnode, struct vattr *attr) {
-    struct ramfs_node *np = (ramfs_node *) vnode->v_data;
+       struct ramfs_node *np = (ramfs_node *) vnode->v_data;
 
-    if (attr->va_mask & AT_ATIME) {
-        memcpy(&(np->rn_atime), &(attr->va_atime), sizeof(struct timespec));
-    }
+       if (attr->va_mask & AT_ATIME) {
+               memcpy(&(np->rn_atime), &(attr->va_atime), sizeof(struct 
timespec));
+       }
 
-    if (attr->va_mask & AT_CTIME) {
-        memcpy(&(np->rn_ctime), &(attr->va_ctime), sizeof(struct timespec));
-    }
+       if (attr->va_mask & AT_CTIME) {
+               memcpy(&(np->rn_ctime), &(attr->va_ctime), sizeof(struct 
timespec));
+       }
 
-    if (attr->va_mask & AT_MTIME) {
-        memcpy(&(np->rn_mtime), &(attr->va_mtime), sizeof(struct timespec));
-    }
+       if (attr->va_mask & AT_MTIME) {
+               memcpy(&(np->rn_mtime), &(attr->va_mtime), sizeof(struct 
timespec));
+       }
 
-    if (attr->va_mask & AT_MODE) {
-        np->rn_mode = attr->va_mode;
-    }
+       if (attr->va_mask & AT_MODE) {
+               np->rn_mode = attr->va_mode;
+       }
 
-    return 0;
+       return 0;
 }
 
 #define ramfs_open      ((vnop_open_t)vop_nullop)
@@ -642,28 +642,28 @@ ramfs_setattr(struct vnode *vnode, struct vattr *attr) {
  * vnode operations
  */
 struct vnops ramfs_vnops = {
-        ramfs_open,             /* open */
-        ramfs_close,            /* close */
-        ramfs_read,             /* read */
-        ramfs_write,            /* write */
-        ramfs_seek,             /* seek */
-        ramfs_ioctl,            /* ioctl */
-        ramfs_fsync,            /* fsync */
-        ramfs_readdir,          /* readdir */
-        ramfs_lookup,           /* lookup */
-        ramfs_create,           /* create */
-        ramfs_remove,           /* remove */
-        ramfs_rename,           /* remame */
-        ramfs_mkdir,            /* mkdir */
-        ramfs_rmdir,            /* rmdir */
-        ramfs_getattr,          /* getattr */
-        ramfs_setattr,          /* setattr */
-        ramfs_inactive,         /* inactive */
-        ramfs_truncate,         /* truncate */
-        ramfs_link,             /* link */
-        (vnop_cache_t) nullptr, /* arc */
-        ramfs_fallocate,        /* fallocate */
-        ramfs_readlink,         /* read link */
-        ramfs_symlink,          /* symbolic link */
+               ramfs_open,             /* open */
+               ramfs_close,            /* close */
+               ramfs_read,             /* read */
+               ramfs_write,            /* write */
+               ramfs_seek,             /* seek */
+               ramfs_ioctl,            /* ioctl */
+               ramfs_fsync,            /* fsync */
+               ramfs_readdir,          /* readdir */
+               ramfs_lookup,           /* lookup */
+               ramfs_create,           /* create */
+               ramfs_remove,           /* remove */
+               ramfs_rename,           /* remame */
+               ramfs_mkdir,            /* mkdir */
+               ramfs_rmdir,            /* rmdir */
+               ramfs_getattr,          /* getattr */
+               ramfs_setattr,          /* setattr */
+               ramfs_inactive,         /* inactive */
+               ramfs_truncate,         /* truncate */
+               ramfs_link,             /* link */
+               (vnop_cache_t) nullptr, /* arc */
+               ramfs_fallocate,        /* fallocate */
+               ramfs_readlink,         /* read link */
+               ramfs_symlink,          /* symbolic link */
 };
 
-- 
2.19.2


_______________________________________________
Minios-devel mailing list
Minios-devel@xxxxxxxxxxxxxxxxxxxx
https://lists.xenproject.org/mailman/listinfo/minios-devel

 


Rackspace

Lists.xenproject.org is hosted with RackSpace, monitoring our
servers 24x7x365 and backed by RackSpace's Fanatical Support®.