===================================================================
RCS file: /cvs/prex-old/usr/server/fs/ramfs/ramfs_vnops.c,v
retrieving revision 1.1.1.1
retrieving revision 1.1.1.1.2.1
diff -u -r1.1.1.1 -r1.1.1.1.2.1
--- prex-old/usr/server/fs/ramfs/ramfs_vnops.c	2008/06/03 10:38:51	1.1.1.1
+++ prex-old/usr/server/fs/ramfs/ramfs_vnops.c	2008/08/13 17:12:44	1.1.1.1.2.1
@@ -27,6 +27,10 @@
  * SUCH DAMAGE.
  */
 
+/*
+ * rmafs_vnops.c - vnode operations for RAM file system.
+ */
+
 #include <prex/prex.h>
 
 #include <sys/stat.h>
@@ -45,18 +49,18 @@
 
 #define ramfs_open	((vnop_open_t)vop_nullop)
 #define ramfs_close	((vnop_close_t)vop_nullop)
-static int ramfs_read(vnode_t, file_t, void *, size_t, size_t *);
-static int ramfs_write(vnode_t, file_t, void *, size_t, size_t *);
+static int ramfs_read	(vnode_t, file_t, void *, size_t, size_t *);
+static int ramfs_write	(vnode_t, file_t, void *, size_t, size_t *);
 #define ramfs_seek	((vnop_seek_t)vop_nullop)
 #define ramfs_ioctl	((vnop_ioctl_t)vop_einval)
 #define ramfs_fsync	((vnop_fsync_t)vop_nullop)
 static int ramfs_readdir(vnode_t, file_t, struct dirent *);
-static int ramfs_lookup(vnode_t, char *, vnode_t);
-static int ramfs_create(vnode_t, char *, mode_t);
-static int ramfs_remove(vnode_t, vnode_t, char *);
-static int ramfs_rename(vnode_t, vnode_t, char *, vnode_t, vnode_t, char *);
-static int ramfs_mkdir(vnode_t, char *, mode_t);
-static int ramfs_rmdir(vnode_t, vnode_t, char *);
+static int ramfs_lookup	(vnode_t, char *, vnode_t);
+static int ramfs_create	(vnode_t, char *, mode_t);
+static int ramfs_remove	(vnode_t, vnode_t, char *);
+static int ramfs_rename	(vnode_t, vnode_t, char *, vnode_t, vnode_t, char *);
+static int ramfs_mkdir	(vnode_t, char *, mode_t);
+static int ramfs_rmdir	(vnode_t, vnode_t, char *);
 #define ramfs_getattr	((vnop_getattr_t)vop_nullop)
 #define ramfs_setattr	((vnop_setattr_t)vop_nullop)
 #define ramfs_inactive	((vnop_inactive_t)vop_nullop)
@@ -94,113 +98,114 @@
 struct ramfs_node *
 ramfs_allocate_node(char *name, int type)
 {
-	struct ramfs_node *node;
+	struct ramfs_node *np;
 
-	node = malloc(sizeof(struct ramfs_node));
-	if (node == NULL)
+	np = malloc(sizeof(struct ramfs_node));
+	if (np == NULL)
 		return NULL;
-	memset(node, 0, sizeof(struct ramfs_node));
+	memset(np, 0, sizeof(struct ramfs_node));
 
-	node->namelen = strlen(name);
-	node->name = malloc(node->namelen + 1);
-	if (node->name == NULL) {
-		free(node);
+	np->rn_namelen = strlen(name);
+	np->rn_name = malloc(np->rn_namelen + 1);
+	if (np->rn_name == NULL) {
+		free(np);
 		return NULL;
 	}
-	strcpy(node->name, name);
-	node->type = type;
-	return node;
+	strcpy(np->rn_name, name);
+	np->rn_type = type;
+	return np;
 }
 
 void
-ramfs_free_node(struct ramfs_node *node)
+ramfs_free_node(struct ramfs_node *np)
 {
 
-	free(node->name);
-	free(node);
+	free(np->rn_name);
+	free(np);
 }
 
 static struct ramfs_node *
-ramfs_add_node(struct ramfs_node *dir_node, char *name, int type)
+ramfs_add_node(struct ramfs_node *dnp, char *name, int type)
 {
-	struct ramfs_node *node, *prev;
+	struct ramfs_node *np, *prev;
 
-	node = ramfs_allocate_node(name, type);
-	if (node == NULL)
+	np = ramfs_allocate_node(name, type);
+	if (np == NULL)
 		return NULL;
 
 	mutex_lock(&ramfs_lock);
 
 	/* Link to the directory list */
-	if (dir_node->child == NULL) {
-		dir_node->child = node;
+	if (dnp->rn_child == NULL) {
+		dnp->rn_child = np;
 	} else {
-		prev = dir_node->child;
-		while (prev->next != NULL)
-			prev = prev->next;
-		prev->next = node;
+		prev = dnp->rn_child;
+		while (prev->rn_next != NULL)
+			prev = prev->rn_next;
+		prev->rn_next = np;
 	}
 	mutex_unlock(&ramfs_lock);
-	return node;
+	return np;
 }
 
 static int
-ramfs_remove_node(struct ramfs_node *dir_node, struct ramfs_node *node)
+ramfs_remove_node(struct ramfs_node *dnp, struct ramfs_node *np)
 {
 	struct ramfs_node *prev;
 
-	if (dir_node->child == NULL)
+	if (dnp->rn_child == NULL)
 		return EBUSY;
 
 	mutex_lock(&ramfs_lock);
 
 	/* Unlink from the directory list */
-	if (dir_node->child == node) {
-		dir_node->child = node->next;
+	if (dnp->rn_child == np) {
+		dnp->rn_child = np->rn_next;
 	} else {
-		for (prev = dir_node->child; prev->next != node;
-		     prev = prev->next) {
-			if (prev->next == NULL) {
+		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->next = node->next;
+		prev->rn_next = np->rn_next;
 	}
-	ramfs_free_node(node);
+	ramfs_free_node(np);
 
 	mutex_unlock(&ramfs_lock);
 	return 0;
 }
 
 static int
-ramfs_rename_node(struct ramfs_node *node, char *name)
+ramfs_rename_node(struct ramfs_node *np, char *name)
 {
 	size_t len;
 	char *tmp;
 
 	len = strlen(name);
-	if (len <= node->namelen) {
+	if (len <= np->rn_namelen) {
 		/* Reuse current name buffer */
-		strcpy(node->name, name);
+		strcpy(np->rn_name, name);
 	} else {
 		/* Expand name buffer */
 		tmp = malloc(len + 1);
 		if (tmp == NULL)
 			return ENOMEM;
 		strcpy(tmp, name);
-		free(node->name);
-		node->name = tmp;
+		free(np->rn_name);
+		np->rn_name = tmp;
 	}
-	node->namelen = len;
+	np->rn_namelen = len;
 	return 0;
 }
 
 static int
 ramfs_lookup(vnode_t dvp, char *name, vnode_t vp)
 {
-	struct ramfs_node *node, *dir_node;
+	struct ramfs_node *np, *dnp;
 	size_t len;
+	int found;
 
 	if (*name == '\0')
 		return ENOENT;
@@ -208,20 +213,23 @@
 	mutex_lock(&ramfs_lock);
 
 	len = strlen(name);
-	dir_node = dvp->v_data;
-	for (node = dir_node->child; node != NULL; node = node->next) {
-		if (node->namelen == len &&
-		    memcmp(name, node->name, len) == 0)
+	dnp = 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 (node == NULL) {
+	if (found == 0) {
 		mutex_unlock(&ramfs_lock);
 		return ENOENT;
 	}
-	vp->v_data = node;
+	vp->v_data = np;
 	vp->v_mode = ALLPERMS;
-	vp->v_type = node->type;
-	vp->v_size = node->size;
+	vp->v_type = np->rn_type;
+	vp->v_size = np->rn_size;
 
 	mutex_unlock(&ramfs_lock);
 	return 0;
@@ -230,16 +238,16 @@
 static int
 ramfs_mkdir(vnode_t dvp, char *name, mode_t mode)
 {
-	struct ramfs_node *node;
+	struct ramfs_node *np;
 
-	dprintf("mkdir %s\n", name);
+	DPRINTF(("mkdir %s\n", name));
 	if (!S_ISDIR(mode))
 		return EINVAL;
 
-	node = ramfs_add_node(dvp->v_data, name, VDIR);
-	if (node == NULL)
+	np = ramfs_add_node(dvp->v_data, name, VDIR);
+	if (np == NULL)
 		return ENOMEM;
-	node->size = 0;
+	np->rn_size = 0;
 	return 0;
 }
 
@@ -255,17 +263,17 @@
 static int
 ramfs_remove(vnode_t dvp, vnode_t vp, char *name)
 {
-	struct ramfs_node *node;
+	struct ramfs_node *np;
 	int err;
 
-	dprintf("remove %s in %s\n", name, dvp->v_path);
+	DPRINTF(("remove %s in %s\n", name, dvp->v_path));
 	err = ramfs_remove_node(dvp->v_data, vp->v_data);
 	if (err)
 		return err;
 
-	node = vp->v_data;
-	if (node->buf != NULL)
-		vm_free(task_self(), node->buf);
+	np = vp->v_data;
+	if (np->rn_buf != NULL)
+		vm_free(task_self(), np->rn_buf);
 	return 0;
 }
 
@@ -273,14 +281,14 @@
 static int
 ramfs_truncate(vnode_t vp)
 {
-	struct ramfs_node *node;
+	struct ramfs_node *np;
 
-	dprintf("truncate %s\n", vp->v_path);
-	node = vp->v_data;
-	if (node->buf != NULL) {
-		vm_free(task_self(), node->buf);
-		node->buf = NULL;
-		node->bufsize = 0;
+	DPRINTF(("truncate %s\n", vp->v_path));
+	np = vp->v_data;
+	if (np->rn_buf != NULL) {
+		vm_free(task_self(), np->rn_buf);
+		np->rn_buf = NULL;
+		np->rn_bufsize = 0;
 	}
 	vp->v_size = 0;
 	return 0;
@@ -292,14 +300,14 @@
 static int
 ramfs_create(vnode_t dvp, char *name, mode_t mode)
 {
-	struct ramfs_node *node;
+	struct ramfs_node *np;
 
-	dprintf("create %s in %s\n", name, dvp->v_path);
+	DPRINTF(("create %s in %s\n", name, dvp->v_path));
 	if (!S_ISREG(mode))
 		return EINVAL;
 
-	node = ramfs_add_node(dvp->v_data, name, VREG);
-	if (node == NULL)
+	np = ramfs_add_node(dvp->v_data, name, VREG);
+	if (np == NULL)
 		return ENOMEM;
 	return 0;
 }
@@ -307,7 +315,7 @@
 static int
 ramfs_read(vnode_t vp, file_t fp, void *buf, size_t size, size_t *result)
 {
-	struct ramfs_node *node;
+	struct ramfs_node *np;
 	off_t off;
 
 	*result = 0;
@@ -323,8 +331,8 @@
 	if (vp->v_size - off < size)
 		size = vp->v_size - off;
 
-	node = vp->v_data;
-	memcpy(buf, node->buf + off, size);
+	np = vp->v_data;
+	memcpy(buf, np->rn_buf + off, size);
 
 	fp->f_offset += size;
 	*result = size;
@@ -334,7 +342,7 @@
 static int
 ramfs_write(vnode_t vp, file_t fp, void *buf, size_t size, size_t *result)
 {
-	struct ramfs_node *node;
+	struct ramfs_node *np;
 	off_t file_pos, end_pos;
 	void *new_buf;
 	size_t new_size;
@@ -346,14 +354,14 @@
 	if (vp->v_type != VREG)
 		return EINVAL;
 
-	node = vp->v_data;
+	np = vp->v_data;
 	/* Check if the file position exceeds the end of file. */
 	end_pos = vp->v_size;
 	file_pos = (fp->f_flags & O_APPEND) ? end_pos : fp->f_offset;
 	if (file_pos + size > (size_t)end_pos) {
 		/* Expand the file size before writing to it */
 		end_pos = file_pos + size;
-		if (end_pos > (off_t)node->bufsize) {
+		if (end_pos > (off_t)np->rn_bufsize) {
 			task = task_self();
 			/*
 			 * We allocate the data buffer in page boundary.
@@ -365,17 +373,17 @@
 			new_size = PAGE_ALIGN(end_pos);
 			if (vm_allocate(task, &new_buf, new_size, 1))
 				return EIO;
-			if (node->size != 0) {
-				memcpy(new_buf, node->buf, vp->v_size);
-				vm_free(task, node->buf);
+			if (np->rn_size != 0) {
+				memcpy(new_buf, np->rn_buf, vp->v_size);
+				vm_free(task, np->rn_buf);
 			}
-			node->buf = new_buf;
-			node->bufsize = new_size;
+			np->rn_buf = new_buf;
+			np->rn_bufsize = new_size;
 		}
-		node->size = end_pos;
+		np->rn_size = end_pos;
 		vp->v_size = end_pos;
 	}
-	memcpy(node->buf + file_pos, buf, size);
+	memcpy(np->rn_buf + file_pos, buf, size);
 	fp->f_offset += size;
 	*result = size;
 	return 0;
@@ -385,7 +393,7 @@
 ramfs_rename(vnode_t dvp1, vnode_t vp1, char *name1,
 	     vnode_t dvp2, vnode_t vp2, char *name2)
 {
-	struct ramfs_node *node, *old_node;
+	struct ramfs_node *np, *old_np;
 	int err;
 
 	if (vp2) {
@@ -402,16 +410,16 @@
 			return err;
 	} else {
 		/* Create new file or directory */
-		old_node = vp1->v_data;
-		node = ramfs_add_node(dvp2->v_data, name2, VREG);
-		if (node == NULL)
+		old_np = vp1->v_data;
+		np = ramfs_add_node(dvp2->v_data, name2, VREG);
+		if (np == NULL)
 			return ENOMEM;
 
 		if (vp1->v_type == VREG) {
 			/* Copy file data */
-			node->buf = old_node->buf;
-			node->size = old_node->size;
-			node->bufsize = old_node->bufsize;
+			np->rn_buf = old_np->rn_buf;
+			np->rn_size = old_np->rn_size;
+			np->rn_bufsize = old_np->rn_bufsize;
 		}
 		/* Remove source file */
 		ramfs_remove_node(dvp1->v_data, vp1->v_data);
@@ -425,7 +433,7 @@
 static int
 ramfs_readdir(vnode_t vp, file_t fp, struct dirent *dir)
 {
-	struct ramfs_node *node, *dir_node;
+	struct ramfs_node *np, *dnp;
 	int i;
 
 	mutex_lock(&ramfs_lock);
@@ -437,25 +445,25 @@
 		dir->d_type = DT_DIR;
 		strcpy((char *)&dir->d_name, "..");
 	} else {
-		dir_node = vp->v_data;
-		node = dir_node->child;
-		if (node == NULL) {
+		dnp = 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++) {
-			node = node->next;
-			if (node == NULL) {
+			np = np->rn_next;
+			if (np == NULL) {
 				mutex_unlock(&ramfs_lock);
 				return ENOENT;
 			}
 		}
-		if (node->type == VDIR)
+		if (np->rn_type == VDIR)
 			dir->d_type = DT_DIR;
 		else
 			dir->d_type = DT_REG;
-		strcpy((char *)&dir->d_name, node->name);
+		strcpy((char *)&dir->d_name, np->rn_name);
 	}
 	dir->d_fileno = fp->f_offset;
 	dir->d_namlen = strlen(dir->d_name);