X-Git-Url: http://www.aleph1.co.uk/gitweb/?p=yaffs2.git;a=blobdiff_plain;f=yaffs_vfs.c;h=b1b6840939de4426e808a56ef4e9f16cdc54d3a5;hp=acda87cee970f59fd2fb03bc21ddae2bcd737d7e;hb=9bdabdaa8467f3f56359598434e0f6f254c100e9;hpb=7396445d7d0d13469b9505791114b9dc6b76ffe4

diff --git a/yaffs_vfs.c b/yaffs_vfs.c
index acda87c..b1b6840 100644
--- a/yaffs_vfs.c
+++ b/yaffs_vfs.c
@@ -110,10 +110,10 @@ module_param(yaffs_bg_enable, uint, 0644);
 
 static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino);
 
-#define yaffs_InodeToObjectLV(iptr) ((iptr)->i_private)
-#define yaffs_InodeToObject(iptr) ((yaffs_obj_t *)(yaffs_InodeToObjectLV(iptr)))
-#define yaffs_dentry_to_obj(dptr) yaffs_InodeToObject((dptr)->d_inode)
-#define yaffs_SuperToDevice(sb)	((yaffs_dev_t *)sb->s_fs_info)
+#define yaffs_inode_to_obj_lv(iptr) ((iptr)->i_private)
+#define yaffs_inode_to_obj(iptr) ((yaffs_obj_t *)(yaffs_inode_to_obj_lv(iptr)))
+#define yaffs_dentry_to_obj(dptr) yaffs_inode_to_obj((dptr)->d_inode)
+#define yaffs_super_to_dev(sb)	((yaffs_dev_t *)sb->s_fs_info)
 
 
 #define update_dir_time(dir) do {\
@@ -297,14 +297,14 @@ static unsigned yaffs_gc_control_callback(yaffs_dev_t *dev)
 static void yaffs_gross_lock(yaffs_dev_t *dev)
 {
 	T(YAFFS_TRACE_LOCK, (TSTR("yaffs locking %p\n"), current));
-	down(&(yaffs_dev_to_lc(dev)->grossLock));
+	down(&(yaffs_dev_to_lc(dev)->gross_lock));
 	T(YAFFS_TRACE_LOCK, (TSTR("yaffs locked %p\n"), current));
 }
 
 static void yaffs_gross_unlock(yaffs_dev_t *dev)
 {
 	T(YAFFS_TRACE_LOCK, (TSTR("yaffs unlocking %p\n"), current));
-	up(&(yaffs_dev_to_lc(dev)->grossLock));
+	up(&(yaffs_dev_to_lc(dev)->gross_lock));
 }
 
 
@@ -338,7 +338,7 @@ struct dentry *yaffs2_get_parent(struct dentry *dentry)
 	yaffs_obj_t *d_obj;
 	yaffs_obj_t *parent_obj;
 
-	d_obj = yaffs_InodeToObject(dentry->d_inode);
+	d_obj = yaffs_inode_to_obj(dentry->d_inode);
 
 	if (d_obj) {
 		parent_obj = d_obj->parent;
@@ -391,34 +391,34 @@ static struct export_operations yaffs_export_ops =
  * All these functions must be called while yaffs is locked.
  */
 
-struct yaffs_SearchContext {
+struct yaffs_search_context {
 	yaffs_dev_t *dev;
-	yaffs_obj_t *dirObj;
-	yaffs_obj_t *nextReturn;
+	yaffs_obj_t *dir_obj;
+	yaffs_obj_t *next_return;
 	struct ylist_head others;
 };
 
 /*
- * yaffs_NewSearch() creates a new search context, initialises it and
+ * yaffs_new_search() creates a new search context, initialises it and
  * adds it to the device's search context list.
  *
  * Called at start of readdir.
  */
-static struct yaffs_SearchContext * yaffs_NewSearch(yaffs_obj_t *dir)
+static struct yaffs_search_context * yaffs_new_search(yaffs_obj_t *dir)
 {
 	yaffs_dev_t *dev = dir->my_dev;
-	struct yaffs_SearchContext *sc = YMALLOC(sizeof(struct yaffs_SearchContext));
+	struct yaffs_search_context *sc = YMALLOC(sizeof(struct yaffs_search_context));
 	if(sc){
-		sc->dirObj = dir;
+		sc->dir_obj = dir;
 		sc->dev = dev;
-		if( ylist_empty(&sc->dirObj->variant.dir_variant.children))
-			sc->nextReturn = NULL;
+		if( ylist_empty(&sc->dir_obj->variant.dir_variant.children))
+			sc->next_return = NULL;
 		else
-			sc->nextReturn = ylist_entry(
+			sc->next_return = ylist_entry(
                                 dir->variant.dir_variant.children.next,
 				yaffs_obj_t,siblings);
 		YINIT_LIST_HEAD(&sc->others);
-		ylist_add(&sc->others,&(yaffs_dev_to_lc(dev)->searchContexts));
+		ylist_add(&sc->others,&(yaffs_dev_to_lc(dev)->search_contexts));
 	}
 	return sc;
 }
@@ -426,7 +426,7 @@ static struct yaffs_SearchContext * yaffs_NewSearch(yaffs_obj_t *dir)
 /*
  * yaffs_search_end() disposes of a search context and cleans up.
  */
-static void yaffs_search_end(struct yaffs_SearchContext * sc)
+static void yaffs_search_end(struct yaffs_search_context * sc)
 {
 	if(sc){
 		ylist_del(&sc->others);
@@ -439,21 +439,21 @@ static void yaffs_search_end(struct yaffs_SearchContext * sc)
  * Called when the search iterates or when an object removal causes
  * the search context to be moved to the next object.
  */
-static void yaffs_search_advance(struct yaffs_SearchContext *sc)
+static void yaffs_search_advance(struct yaffs_search_context *sc)
 {
         if(!sc)
                 return;
 
-        if( sc->nextReturn == NULL ||
-                ylist_empty(&sc->dirObj->variant.dir_variant.children))
-                sc->nextReturn = NULL;
+        if( sc->next_return == NULL ||
+                ylist_empty(&sc->dir_obj->variant.dir_variant.children))
+                sc->next_return = NULL;
         else {
-                struct ylist_head *next = sc->nextReturn->siblings.next;
+                struct ylist_head *next = sc->next_return->siblings.next;
 
-                if( next == &sc->dirObj->variant.dir_variant.children)
-                        sc->nextReturn = NULL; /* end of list */
+                if( next == &sc->dir_obj->variant.dir_variant.children)
+                        sc->next_return = NULL; /* end of list */
                 else
-                        sc->nextReturn = ylist_entry(next,yaffs_obj_t,siblings);
+                        sc->next_return = ylist_entry(next,yaffs_obj_t,siblings);
         }
 }
 
@@ -466,8 +466,8 @@ static void yaffs_remove_obj_callback(yaffs_obj_t *obj)
 {
 
         struct ylist_head *i;
-        struct yaffs_SearchContext *sc;
-        struct ylist_head *search_contexts = &(yaffs_dev_to_lc(obj->my_dev)->searchContexts);
+        struct yaffs_search_context *sc;
+        struct ylist_head *search_contexts = &(yaffs_dev_to_lc(obj->my_dev)->search_contexts);
 
 
         /* Iterate through the directory search contexts.
@@ -476,8 +476,8 @@ static void yaffs_remove_obj_callback(yaffs_obj_t *obj)
          */
          ylist_for_each(i, search_contexts) {
                 if (i) {
-                        sc = ylist_entry(i, struct yaffs_SearchContext,others);
-                        if(sc->nextReturn == obj)
+                        sc = ylist_entry(i, struct yaffs_search_context,others);
+                        if(sc->next_return == obj)
                                 yaffs_search_advance(sc);
                 }
 	}
@@ -512,7 +512,7 @@ static int yaffs_readlink(struct dentry *dentry, char __user *buffer,
 static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
 	unsigned char *alias;
-	int ret;
+	void *ret;
 	yaffs_dev_t *dev = yaffs_dentry_to_obj(dentry)->my_dev;
 
 	yaffs_gross_lock(dev);
@@ -521,14 +521,14 @@ static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd)
 	yaffs_gross_unlock(dev);
 
 	if (!alias) {
-		ret = -ENOMEM;
+		ret = ERR_PTR(-ENOMEM);
 		goto out;
 	}
 
 	nd_set_link(nd, alias);
-	ret = (int)alias;
+	ret = (void *)alias;
 out:
-	return ERR_PTR(ret);
+	return ret;
 }
 
 void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias) {
@@ -548,22 +548,22 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,
 	yaffs_obj_t *obj;
 	struct inode *inode = NULL;	/* NCB 2.5/2.6 needs NULL here */
 
-	yaffs_dev_t *dev = yaffs_InodeToObject(dir)->my_dev;
+	yaffs_dev_t *dev = yaffs_inode_to_obj(dir)->my_dev;
 
-	if(current != yaffs_dev_to_lc(dev)->readdirProcess)
+	if(current != yaffs_dev_to_lc(dev)->readdir_process)
 		yaffs_gross_lock(dev);
 
 	T(YAFFS_TRACE_OS,
 		(TSTR("yaffs_lookup for %d:%s\n"),
-		yaffs_InodeToObject(dir)->obj_id, dentry->d_name.name));
+		yaffs_inode_to_obj(dir)->obj_id, dentry->d_name.name));
 
-	obj = yaffs_find_by_name(yaffs_InodeToObject(dir),
+	obj = yaffs_find_by_name(yaffs_inode_to_obj(dir),
 					dentry->d_name.name);
 
 	obj = yaffs_get_equivalent_obj(obj);	/* in case it was a hardlink */
 
 	/* Can't hold gross lock when calling yaffs_get_inode() */
-	if(current != yaffs_dev_to_lc(dev)->readdirProcess)
+	if(current != yaffs_dev_to_lc(dev)->readdir_process)
 		yaffs_gross_unlock(dev);
 
 	if (obj) {
@@ -620,7 +620,7 @@ static void yaffs_unstitch_obj(struct inode *inode, yaffs_obj_t *obj)
 	 * the yaffs_obj_t.
 	 */
 	obj->my_inode = NULL;
-	yaffs_InodeToObjectLV(inode) = NULL;
+	yaffs_inode_to_obj_lv(inode) = NULL;
 
 	/* If the object freeing was deferred, then the real
 	 * free happens now.
@@ -639,7 +639,7 @@ static void yaffs_evict_inode( struct inode *inode)
 	yaffs_dev_t *dev;
 	int deleteme = 0;
 
-	obj = yaffs_InodeToObject(inode);
+	obj = yaffs_inode_to_obj(inode);
 
 	T(YAFFS_TRACE_OS,
 		(TSTR("yaffs_evict_inode: ino %d, count %d %s\n"), (int)inode->i_ino,
@@ -764,7 +764,7 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc)
 	unsigned long end_index;
 	char *buffer;
 	yaffs_obj_t *obj;
-	int nWritten = 0;
+	int n_written = 0;
 	unsigned n_bytes;
 	loff_t i_size;
 
@@ -805,7 +805,7 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc)
 
 	buffer = kmap(page);
 
-	obj = yaffs_InodeToObject(inode);
+	obj = yaffs_inode_to_obj(inode);
 	dev = obj->my_dev;
 	yaffs_gross_lock(dev);
 
@@ -816,7 +816,7 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc)
 		(TSTR("writepag0: obj = %05x, ino = %05x\n"),
 		(int)obj->variant.file_variant.file_size, (int)inode->i_size));
 
-	nWritten = yaffs_wr_file(obj, buffer,
+	n_written = yaffs_wr_file(obj, buffer,
 			page->index << PAGE_CACHE_SHIFT, n_bytes, 0);
 
 	yaffs_touch_super(dev);
@@ -833,7 +833,7 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc)
 	end_page_writeback(page);
 	put_page(page);
 
-	return (nWritten == n_bytes) ? 0 : -ENOSPC;
+	return (n_written == n_bytes) ? 0 : -ENOSPC;
 }
 
 
@@ -1010,13 +1010,13 @@ static void yaffs_fill_inode_from_obj(struct inode *inode, yaffs_obj_t *obj)
 			break;
 		}
 
-		yaffs_InodeToObjectLV(inode) = obj;
+		yaffs_inode_to_obj_lv(inode) = obj;
 
 		obj->my_inode = inode;
 
 	} else {
 		T(YAFFS_TRACE_OS,
-			(TSTR("yaffs_FileInode invalid parameters\n")));
+			(TSTR("yaffs_fill_inode invalid parameters\n")));
 	}
 
 }
@@ -1049,7 +1049,7 @@ struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
 
 	/* NB Side effect: iget calls back to yaffs_read_inode(). */
 	/* iget also increments the inode's i_count */
-	/* NB You can't be holding grossLock or deadlock will happen! */
+	/* NB You can't be holding gross_lock or deadlock will happen! */
 
 	return inode;
 }
@@ -1058,7 +1058,7 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
 				loff_t *pos)
 {
 	yaffs_obj_t *obj;
-	int nWritten, ipos;
+	int n_written, ipos;
 	struct inode *inode;
 	yaffs_dev_t *dev;
 
@@ -1084,7 +1084,7 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
 			"to object %d at %d(%x)\n"),
 			(unsigned) n, (unsigned) n, obj->obj_id, ipos,ipos));
 
-	nWritten = yaffs_wr_file(obj, buf, ipos, n, 0);
+	n_written = yaffs_wr_file(obj, buf, ipos, n, 0);
 
 	yaffs_touch_super(dev);
 
@@ -1092,8 +1092,8 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
 		(TSTR("yaffs_file_write: %d(%x) bytes written\n"),
 		(unsigned )n,(unsigned)n));
 
-	if (nWritten > 0) {
-		ipos += nWritten;
+	if (n_written > 0) {
+		ipos += n_written;
 		*pos = ipos;
 		if (ipos > inode->i_size) {
 			inode->i_size = ipos;
@@ -1107,7 +1107,7 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
 
 	}
 	yaffs_gross_unlock(dev);
-	return (nWritten == 0) && (n > 0) ? -ENOSPC : nWritten;
+	return (n_written == 0) && (n > 0) ? -ENOSPC : n_written;
 }
 
 /* Space holding and freeing is done to ensure we have space available for write_begin/end */
@@ -1182,11 +1182,11 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
 {
 	yaffs_obj_t *obj;
 	yaffs_dev_t *dev;
-        struct yaffs_SearchContext *sc;
+        struct yaffs_search_context *sc;
 	struct inode *inode = f->f_dentry->d_inode;
 	unsigned long offset, curoffs;
 	yaffs_obj_t *l;
-        int retVal = 0;
+        int ret_val = 0;
 
 	char name[YAFFS_MAX_NAME_LENGTH + 1];
 
@@ -1195,13 +1195,13 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
 
 	yaffs_gross_lock(dev);
 
-	yaffs_dev_to_lc(dev)->readdirProcess = current;
+	yaffs_dev_to_lc(dev)->readdir_process = current;
 
 	offset = f->f_pos;
 
-        sc = yaffs_NewSearch(obj);
+        sc = yaffs_new_search(obj);
         if(!sc){
-                retVal = -ENOMEM;
+                ret_val = -ENOMEM;
                 goto out;
         }
 
@@ -1245,9 +1245,9 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
 		f->f_version = inode->i_version;
 	}
 
-	while(sc->nextReturn){
+	while(sc->next_return){
 		curoffs++;
-                l = sc->nextReturn;
+                l = sc->next_return;
 		if (curoffs >= offset) {
                         int this_inode = yaffs_get_obj_inode(l);
                         int this_type = yaffs_get_obj_type(l);
@@ -1280,10 +1280,10 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
 
 out:
 	yaffs_search_end(sc);
-	yaffs_dev_to_lc(dev)->readdirProcess = NULL;
+	yaffs_dev_to_lc(dev)->readdir_process = NULL;
 	yaffs_gross_unlock(dev);
 
-	return retVal;
+	return ret_val;
 }
 
 
@@ -1302,7 +1302,7 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
 	yaffs_obj_t *obj = NULL;
 	yaffs_dev_t *dev;
 
-	yaffs_obj_t *parent = yaffs_InodeToObject(dir);
+	yaffs_obj_t *parent = yaffs_inode_to_obj(dir);
 
 	int error = -ENOSPC;
 	uid_t uid = YCRED(current)->fsuid;
@@ -1376,10 +1376,10 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
 
 static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 {
-	int retVal;
+	int ret_val;
 	T(YAFFS_TRACE_OS, (TSTR("yaffs_mkdir\n")));
-	retVal = yaffs_mknod(dir, dentry, mode | S_IFDIR, 0);
-	return retVal;
+	ret_val = yaffs_mknod(dir, dentry, mode | S_IFDIR, 0);
+	return ret_val;
 }
 
 static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode,
@@ -1391,7 +1391,7 @@ static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode,
 
 static int yaffs_unlink(struct inode *dir, struct dentry *dentry)
 {
-	int retVal;
+	int ret_val;
 
 	yaffs_dev_t *dev;
 	yaffs_obj_t *obj;
@@ -1400,14 +1400,14 @@ static int yaffs_unlink(struct inode *dir, struct dentry *dentry)
 		(TSTR("yaffs_unlink %d:%s\n"),
 		(int)(dir->i_ino),
 		dentry->d_name.name));
-	obj = yaffs_InodeToObject(dir);
+	obj = yaffs_inode_to_obj(dir);
 	dev = obj->my_dev;
 
 	yaffs_gross_lock(dev);
 
-	retVal = yaffs_unlinker(obj, dentry->d_name.name);
+	ret_val = yaffs_unlinker(obj, dentry->d_name.name);
 
-	if (retVal == YAFFS_OK) {
+	if (ret_val == YAFFS_OK) {
 		dentry->d_inode->i_nlink--;
 		dir->i_version++;
 		yaffs_gross_unlock(dev);
@@ -1432,13 +1432,13 @@ static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
 
 	T(YAFFS_TRACE_OS, (TSTR("yaffs_link\n")));
 
-	obj = yaffs_InodeToObject(inode);
+	obj = yaffs_inode_to_obj(inode);
 	dev = obj->my_dev;
 
 	yaffs_gross_lock(dev);
 
 	if (!S_ISDIR(inode->i_mode))		/* Don't link directories */
-		link = yaffs_link_obj(yaffs_InodeToObject(dir), dentry->d_name.name,
+		link = yaffs_link_obj(yaffs_inode_to_obj(dir), dentry->d_name.name,
 			obj);
 
 	if (link) {
@@ -1471,9 +1471,9 @@ static int yaffs_symlink(struct inode *dir, struct dentry *dentry,
 
 	T(YAFFS_TRACE_OS, (TSTR("yaffs_symlink\n")));
 
-	dev = yaffs_InodeToObject(dir)->my_dev;
+	dev = yaffs_inode_to_obj(dir)->my_dev;
 	yaffs_gross_lock(dev);
-	obj = yaffs_create_symlink(yaffs_InodeToObject(dir), dentry->d_name.name,
+	obj = yaffs_create_symlink(yaffs_inode_to_obj(dir), dentry->d_name.name,
 				S_IFLNK | S_IRWXUGO, uid, gid, symname);
 	yaffs_gross_unlock(dev);
 
@@ -1520,16 +1520,16 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
 			struct inode *new_dir, struct dentry *new_dentry)
 {
 	yaffs_dev_t *dev;
-	int retVal = YAFFS_FAIL;
+	int ret_val = YAFFS_FAIL;
 	yaffs_obj_t *target;
 
 	T(YAFFS_TRACE_OS, (TSTR("yaffs_rename\n")));
-	dev = yaffs_InodeToObject(old_dir)->my_dev;
+	dev = yaffs_inode_to_obj(old_dir)->my_dev;
 
 	yaffs_gross_lock(dev);
 
 	/* Check if the target is an existing directory that is not empty. */
-	target = yaffs_find_by_name(yaffs_InodeToObject(new_dir),
+	target = yaffs_find_by_name(yaffs_inode_to_obj(new_dir),
 				new_dentry->d_name.name);
 
 
@@ -1539,19 +1539,19 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
 
 		T(YAFFS_TRACE_OS, (TSTR("target is non-empty dir\n")));
 
-		retVal = YAFFS_FAIL;
+		ret_val = YAFFS_FAIL;
 	} else {
 		/* Now does unlinking internally using shadowing mechanism */
 		T(YAFFS_TRACE_OS, (TSTR("calling yaffs_rename_obj\n")));
 
-		retVal = yaffs_rename_obj(yaffs_InodeToObject(old_dir),
+		ret_val = yaffs_rename_obj(yaffs_inode_to_obj(old_dir),
 				old_dentry->d_name.name,
-				yaffs_InodeToObject(new_dir),
+				yaffs_inode_to_obj(new_dir),
 				new_dentry->d_name.name);
 	}
 	yaffs_gross_unlock(dev);
 
-	if (retVal == YAFFS_OK) {
+	if (ret_val == YAFFS_OK) {
 		if (target) {
 			new_dentry->d_inode->i_nlink--;
 			mark_inode_dirty(new_dentry->d_inode);
@@ -1574,7 +1574,7 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr)
 
 	T(YAFFS_TRACE_OS,
 		(TSTR("yaffs_setattr of object %d\n"),
-		yaffs_InodeToObject(inode)->obj_id));
+		yaffs_inode_to_obj(inode)->obj_id));
 
 	/* Fail if a requested resize >= 2GB */		
 	if (attr->ia_valid & ATTR_SIZE &&
@@ -1593,13 +1593,13 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr)
                         	inode->i_blocks = (inode->i_size + 511) >> 9;
 			}
 		}
-		dev = yaffs_InodeToObject(inode)->my_dev;
+		dev = yaffs_inode_to_obj(inode)->my_dev;
 		if (attr->ia_valid & ATTR_SIZE){
 			T(YAFFS_TRACE_OS,(TSTR("resize to %d(%x)\n"),
 				(int)(attr->ia_size),(int)(attr->ia_size)));
 		}
 		yaffs_gross_lock(dev);
-		result = yaffs_set_attribs(yaffs_InodeToObject(inode), attr);
+		result = yaffs_set_attribs(yaffs_inode_to_obj(inode), attr);
 		if(result == YAFFS_OK) {
 			error = 0;
 		} else {
@@ -1622,7 +1622,7 @@ int yaffs_setxattr(struct dentry *dentry, const char *name,
 	struct inode *inode = dentry->d_inode;
 	int error = 0;
 	yaffs_dev_t *dev;
-	yaffs_obj_t *obj = yaffs_InodeToObject(inode);
+	yaffs_obj_t *obj = yaffs_inode_to_obj(inode);
 
 	T(YAFFS_TRACE_OS,
 		(TSTR("yaffs_setxattr of object %d\n"),
@@ -1654,7 +1654,7 @@ ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff,
 	struct inode *inode = dentry->d_inode;
 	int error = 0;
 	yaffs_dev_t *dev;
-	yaffs_obj_t *obj = yaffs_InodeToObject(inode);
+	yaffs_obj_t *obj = yaffs_inode_to_obj(inode);
 
 	T(YAFFS_TRACE_OS,
 		(TSTR("yaffs_getxattr \"%s\" from object %d\n"),
@@ -1678,7 +1678,7 @@ int yaffs_removexattr(struct dentry *dentry, const char *name)
 	struct inode *inode = dentry->d_inode;
 	int error = 0;
 	yaffs_dev_t *dev;
-	yaffs_obj_t *obj = yaffs_InodeToObject(inode);
+	yaffs_obj_t *obj = yaffs_inode_to_obj(inode);
 
 	T(YAFFS_TRACE_OS,
 		(TSTR("yaffs_removexattr of object %d\n"),
@@ -1708,7 +1708,7 @@ ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size)
 	struct inode *inode = dentry->d_inode;
 	int error = 0;
 	yaffs_dev_t *dev;
-	yaffs_obj_t *obj = yaffs_InodeToObject(inode);
+	yaffs_obj_t *obj = yaffs_inode_to_obj(inode);
 
 	T(YAFFS_TRACE_OS,
 		(TSTR("yaffs_listxattr of object %d\n"),
@@ -1747,21 +1747,21 @@ static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf)
 	if (dev->data_bytes_per_chunk & (dev->data_bytes_per_chunk - 1)) {
 		/* Do this if chunk size is not a power of 2 */
 
-		uint64_t bytesInDev;
-		uint64_t bytesFree;
+		uint64_t bytes_in_dev;
+		uint64_t bytes_free;
 
-		bytesInDev = ((uint64_t)((dev->param.end_block - dev->param.start_block + 1))) *
+		bytes_in_dev = ((uint64_t)((dev->param.end_block - dev->param.start_block + 1))) *
 			((uint64_t)(dev->param.chunks_per_block * dev->data_bytes_per_chunk));
 
-		do_div(bytesInDev, sb->s_blocksize); /* bytesInDev becomes the number of blocks */
-		buf->f_blocks = bytesInDev;
+		do_div(bytes_in_dev, sb->s_blocksize); /* bytes_in_dev becomes the number of blocks */
+		buf->f_blocks = bytes_in_dev;
 
-		bytesFree  = ((uint64_t)(yaffs_get_n_free_chunks(dev))) *
+		bytes_free  = ((uint64_t)(yaffs_get_n_free_chunks(dev))) *
 			((uint64_t)(dev->data_bytes_per_chunk));
 
-		do_div(bytesFree, sb->s_blocksize);
+		do_div(bytes_free, sb->s_blocksize);
 
-		buf->f_bfree = bytesFree;
+		buf->f_bfree = bytes_free;
 
 	} else if (sb->s_blocksize > dev->data_bytes_per_chunk) {
 
@@ -1799,7 +1799,7 @@ static void yaffs_flush_inodes(struct super_block *sb)
 	yaffs_obj_t *obj;
 	
 	list_for_each_entry(iptr,&sb->s_inodes, i_sb_list){
-		obj = yaffs_InodeToObject(iptr);
+		obj = yaffs_inode_to_obj(iptr);
 		if(obj){
 			T(YAFFS_TRACE_OS, (TSTR("flushing obj %d\n"),
 				obj->obj_id));
@@ -1811,7 +1811,7 @@ static void yaffs_flush_inodes(struct super_block *sb)
 
 static void yaffs_flush_super(struct super_block *sb, int do_checkpoint)
 {
-	yaffs_dev_t *dev = yaffs_SuperToDevice(sb);	
+	yaffs_dev_t *dev = yaffs_super_to_dev(sb);	
 	if(!dev)
 		return;
 	
@@ -1825,20 +1825,20 @@ static void yaffs_flush_super(struct super_block *sb, int do_checkpoint)
 
 static unsigned yaffs_bg_gc_urgency(yaffs_dev_t *dev)
 {
-	unsigned erasedChunks = dev->n_erased_blocks * dev->param.chunks_per_block;
-	struct yaffs_LinuxContext *context = yaffs_dev_to_lc(dev);
-	unsigned scatteredFree = 0; /* Free chunks not in an erased block */
+	unsigned erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block;
+	struct yaffs_linux_context *context = yaffs_dev_to_lc(dev);
+	unsigned scattered = 0; /* Free chunks not in an erased block */
 
-	if(erasedChunks < dev->n_free_chunks)
-		scatteredFree = (dev->n_free_chunks - erasedChunks);
+	if(erased_chunks < dev->n_free_chunks)
+		scattered = (dev->n_free_chunks - erased_chunks);
 
-	if(!context->bgRunning)
+	if(!context->bg_running)
 		return 0;
-	else if(scatteredFree < (dev->param.chunks_per_block * 2))
+	else if(scattered < (dev->param.chunks_per_block * 2))
 		return 0;
-	else if(erasedChunks > dev->n_free_chunks/2)
+	else if(erased_chunks > dev->n_free_chunks/2)
 		return 0;
-	else if(erasedChunks > dev->n_free_chunks/4)
+	else if(erased_chunks > dev->n_free_chunks/4)
 		return 1;
 	else
 		return 2;
@@ -1848,7 +1848,7 @@ static int yaffs_do_sync_fs(struct super_block *sb,
 				int request_checkpoint)
 {
 
-	yaffs_dev_t *dev = yaffs_SuperToDevice(sb);
+	yaffs_dev_t *dev = yaffs_super_to_dev(sb);
 	unsigned int oneshot_checkpoint = (yaffs_auto_checkpoint & 4);
 	unsigned gc_urgent = yaffs_bg_gc_urgency(dev);
 	int do_checkpoint;
@@ -1897,14 +1897,14 @@ void yaffs_background_waker(unsigned long data)
 static int yaffs_bg_thread_fn(void *data)
 {
 	yaffs_dev_t *dev = (yaffs_dev_t *)data;
-	struct yaffs_LinuxContext *context = yaffs_dev_to_lc(dev);
+	struct yaffs_linux_context *context = yaffs_dev_to_lc(dev);
 	unsigned long now = jiffies;
 	unsigned long next_dir_update = now;
 	unsigned long next_gc = now;
 	unsigned long expires;
 	unsigned int urgency;
 
-	int gcResult;
+	int gc_result;
 	struct timer_list timer;
 
 	T(YAFFS_TRACE_BACKGROUND,
@@ -1912,7 +1912,7 @@ static int yaffs_bg_thread_fn(void *data)
 		(void *)dev));
 
 	set_freezable();
-	while(context->bgRunning){
+	while(context->bg_running){
 		T(YAFFS_TRACE_BACKGROUND,
 			(TSTR("yaffs_background\n")));
 
@@ -1934,7 +1934,7 @@ static int yaffs_bg_thread_fn(void *data)
 		if(time_after(now,next_gc) && yaffs_bg_enable){
 			if(!dev->is_checkpointed){
 				urgency = yaffs_bg_gc_urgency(dev);
-				gcResult = yaffs_bg_gc(dev, urgency);
+				gc_result = yaffs_bg_gc(dev, urgency);
 				if(urgency > 1)
 					next_gc = now + HZ/20+1;
 				else if(urgency > 0)
@@ -1971,33 +1971,33 @@ static int yaffs_bg_thread_fn(void *data)
 static int yaffs_bg_start(yaffs_dev_t *dev)
 {
 	int retval = 0;
-	struct yaffs_LinuxContext *context = yaffs_dev_to_lc(dev);
+	struct yaffs_linux_context *context = yaffs_dev_to_lc(dev);
 
 	if(dev->read_only)
 		return -1;
 
-	context->bgRunning = 1;
+	context->bg_running = 1;
 
-	context->bgThread = kthread_run(yaffs_bg_thread_fn,
+	context->bg_thread = kthread_run(yaffs_bg_thread_fn,
 	                        (void *)dev,"yaffs-bg-%d",context->mount_id);
 
-	if(IS_ERR(context->bgThread)){
-		retval = PTR_ERR(context->bgThread);
-		context->bgThread = NULL;
-		context->bgRunning = 0;
+	if(IS_ERR(context->bg_thread)){
+		retval = PTR_ERR(context->bg_thread);
+		context->bg_thread = NULL;
+		context->bg_running = 0;
 	}
 	return retval;
 }
 
 static void yaffs_bg_stop(yaffs_dev_t *dev)
 {
-	struct yaffs_LinuxContext *ctxt = yaffs_dev_to_lc(dev);
+	struct yaffs_linux_context *ctxt = yaffs_dev_to_lc(dev);
 
-	ctxt->bgRunning = 0;
+	ctxt->bg_running = 0;
 
-	if( ctxt->bgThread){
-		kthread_stop(ctxt->bgThread);
-		ctxt->bgThread = NULL;
+	if( ctxt->bg_thread){
+		kthread_stop(ctxt->bg_thread);
+		ctxt->bg_thread = NULL;
 	}
 }
 
@@ -2032,7 +2032,7 @@ static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino)
 {
 	struct inode *inode;
 	yaffs_obj_t *obj;
-	yaffs_dev_t *dev = yaffs_SuperToDevice(sb);
+	yaffs_dev_t *dev = yaffs_super_to_dev(sb);
 
 	T(YAFFS_TRACE_OS,
 		(TSTR("yaffs_iget for %lu\n"), ino));
@@ -2065,7 +2065,7 @@ struct semaphore yaffs_context_lock;
 
 static void yaffs_put_super(struct super_block *sb)
 {
-	yaffs_dev_t *dev = yaffs_SuperToDevice(sb);
+	yaffs_dev_t *dev = yaffs_super_to_dev(sb);
 
 	T(YAFFS_TRACE_OS, (TSTR("yaffs_put_super\n")));
 
@@ -2079,8 +2079,8 @@ static void yaffs_put_super(struct super_block *sb)
 
 	yaffs_flush_super(sb,1);
 
-	if (yaffs_dev_to_lc(dev)->putSuperFunc)
-		yaffs_dev_to_lc(dev)->putSuperFunc(sb);
+	if (yaffs_dev_to_lc(dev)->put_super_fn)
+		yaffs_dev_to_lc(dev)->put_super_fn(sb);
 
 
 	yaffs_deinitialise(dev);
@@ -2088,21 +2088,21 @@ static void yaffs_put_super(struct super_block *sb)
 	yaffs_gross_unlock(dev);
 
 	down(&yaffs_context_lock);
-	ylist_del_init(&(yaffs_dev_to_lc(dev)->contextList));
+	ylist_del_init(&(yaffs_dev_to_lc(dev)->context_list));
 	up(&yaffs_context_lock);
 
-	if (yaffs_dev_to_lc(dev)->spareBuffer) {
-		YFREE(yaffs_dev_to_lc(dev)->spareBuffer);
-		yaffs_dev_to_lc(dev)->spareBuffer = NULL;
+	if (yaffs_dev_to_lc(dev)->spare_buffer) {
+		YFREE(yaffs_dev_to_lc(dev)->spare_buffer);
+		yaffs_dev_to_lc(dev)->spare_buffer = NULL;
 	}
 
 	kfree(dev);
 }
 
 
-static void yaffs_MTDPutSuper(struct super_block *sb)
+static void yaffs_mtd_put_super(struct super_block *sb)
 {
-	struct mtd_info *mtd = yaffs_dev_to_mtd(yaffs_SuperToDevice(sb));
+	struct mtd_info *mtd = yaffs_dev_to_mtd(yaffs_super_to_dev(sb));
 
 	if (mtd->sync)
 		mtd->sync(mtd);
@@ -2113,7 +2113,7 @@ static void yaffs_MTDPutSuper(struct super_block *sb)
 
 static void yaffs_touch_super(yaffs_dev_t *dev)
 {
-	struct super_block *sb = yaffs_dev_to_lc(dev)->superBlock;
+	struct super_block *sb = yaffs_dev_to_lc(dev)->super;
 
 	T(YAFFS_TRACE_OS, (TSTR("yaffs_touch_super() sb = %p\n"), sb));
 	if (sb)
@@ -2208,7 +2208,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
 	struct mtd_info *mtd;
 	int err;
 	char *data_str = (char *)data;
-	struct yaffs_LinuxContext *context = NULL;
+	struct yaffs_linux_context *context = NULL;
 	yaffs_param_t *param;
 
 	int read_only = 0;
@@ -2217,7 +2217,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
 
 	unsigned mount_id;
 	int found;
-	struct yaffs_LinuxContext *context_iterator;
+	struct yaffs_linux_context *context_iterator;
 	struct ylist_head *l;
 
 	sb->s_magic = YAFFS_MAGIC;
@@ -2371,7 +2371,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
 	}
 
 	dev = kmalloc(sizeof(yaffs_dev_t), GFP_KERNEL);
-	context = kmalloc(sizeof(struct yaffs_LinuxContext),GFP_KERNEL);
+	context = kmalloc(sizeof(struct yaffs_linux_context),GFP_KERNEL);
 	
 	if(!dev || !context ){
 		if(dev)
@@ -2392,11 +2392,11 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
 	memset(dev, 0, sizeof(yaffs_dev_t));
 	param = &(dev->param);
 
-	memset(context,0,sizeof(struct yaffs_LinuxContext));
+	memset(context,0,sizeof(struct yaffs_linux_context));
 	dev->os_context = context;
-	YINIT_LIST_HEAD(&(context->contextList));
+	YINIT_LIST_HEAD(&(context->context_list));
 	context->dev = dev;
-	context->superBlock = sb;
+	context->super = sb;
 
 	dev->read_only = read_only;
 
@@ -2458,12 +2458,12 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
 	/* ... and the functions. */
 	if (yaffs_version == 2) {
 		param->write_chunk_tags_fn =
-		    nandmtd2_WriteChunkWithTagsToNAND;
+		    nandmtd2_write_chunk_tags;
 		param->read_chunk_tags_fn =
-		    nandmtd2_ReadChunkWithTagsFromNAND;
-		param->bad_block_fn = nandmtd2_MarkNANDBlockBad;
-		param->query_block_fn = nandmtd2_QueryNANDBlock;
-		yaffs_dev_to_lc(dev)->spareBuffer = YMALLOC(mtd->oobsize);
+		    nandmtd2_read_chunk_tags;
+		param->bad_block_fn = nandmtd2_mark_block_bad;
+		param->query_block_fn = nandmtd2_query_block;
+		yaffs_dev_to_lc(dev)->spare_buffer = YMALLOC(mtd->oobsize);
 		param->is_yaffs2 = 1;
 		param->total_bytes_per_chunk = mtd->writesize;
 		param->chunks_per_block = mtd->erasesize / mtd->writesize;
@@ -2474,23 +2474,23 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
 	} else {
 		/* use the MTD interface in yaffs_mtdif1.c */
 		param->write_chunk_tags_fn =
-			nandmtd1_WriteChunkWithTagsToNAND;
+			nandmtd1_write_chunk_tags;
 		param->read_chunk_tags_fn =
-			nandmtd1_ReadChunkWithTagsFromNAND;
-		param->bad_block_fn = nandmtd1_MarkNANDBlockBad;
-		param->query_block_fn = nandmtd1_QueryNANDBlock;
+			nandmtd1_read_chunk_tags;
+		param->bad_block_fn = nandmtd1_mark_block_bad;
+		param->query_block_fn = nandmtd1_query_block;
 		param->is_yaffs2 = 0;
 	}
 	/* ... and common functions */
-	param->erase_fn = nandmtd_EraseBlockInNAND;
-	param->initialise_flash_fn = nandmtd_InitialiseNAND;
+	param->erase_fn = nandmtd_erase_block;
+	param->initialise_flash_fn = nandmtd_initialise;
 
-	yaffs_dev_to_lc(dev)->putSuperFunc = yaffs_MTDPutSuper;
+	yaffs_dev_to_lc(dev)->put_super_fn = yaffs_mtd_put_super;
 
 	param->sb_dirty_fn = yaffs_touch_super;
 	param->gc_control = yaffs_gc_control_callback;
 
-	yaffs_dev_to_lc(dev)->superBlock= sb;
+	yaffs_dev_to_lc(dev)->super= sb;
 	
 
 #ifndef CONFIG_YAFFS_DOES_ECC
@@ -2510,21 +2510,21 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
 	for(mount_id=0; ! found; mount_id++){
 		found = 1;
 		ylist_for_each(l,&yaffs_context_list){
-			context_iterator = ylist_entry(l,struct yaffs_LinuxContext,contextList);
+			context_iterator = ylist_entry(l,struct yaffs_linux_context,context_list);
 			if(context_iterator->mount_id == mount_id)
 				found = 0;
 		}
 	}
 	context->mount_id = mount_id;
 
-	ylist_add_tail(&(yaffs_dev_to_lc(dev)->contextList), &yaffs_context_list);
+	ylist_add_tail(&(yaffs_dev_to_lc(dev)->context_list), &yaffs_context_list);
 	up(&yaffs_context_lock);
 
         /* Directory search handling...*/
-        YINIT_LIST_HEAD(&(yaffs_dev_to_lc(dev)->searchContexts));
+        YINIT_LIST_HEAD(&(yaffs_dev_to_lc(dev)->search_contexts));
         param->remove_obj_fn = yaffs_remove_obj_callback;
 
-	init_MUTEX(&(yaffs_dev_to_lc(dev)->grossLock));
+	init_MUTEX(&(yaffs_dev_to_lc(dev)->gross_lock));
 
 	yaffs_gross_lock(dev);
 
@@ -2537,7 +2537,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
 	if(err == YAFFS_OK)
 		yaffs_bg_start(dev);
 		
-	if(!context->bgThread)
+	if(!context->bg_thread)
 		param->defered_dir_update = 0;
 
 
@@ -2672,7 +2672,7 @@ static char *yaffs_dump_dev_part1(char *buf, yaffs_dev_t * dev)
 	buf += sprintf(buf, "n_gc_blocks........... %u\n", dev->n_gc_blocks);
 	buf += sprintf(buf, "bg_gcs................ %u\n", dev->bg_gcs);
 	buf += sprintf(buf, "n_retired_writes...... %u\n", dev->n_retired_writes);
-	buf += sprintf(buf, "nRetireBlocks......... %u\n", dev->n_retired_blocks);
+	buf += sprintf(buf, "n_retired_blocks...... %u\n", dev->n_retired_blocks);
 	buf += sprintf(buf, "n_ecc_fixed........... %u\n", dev->n_ecc_fixed);
 	buf += sprintf(buf, "n_ecc_unfixed......... %u\n", dev->n_ecc_unfixed);
 	buf += sprintf(buf, "n_tags_ecc_fixed...... %u\n", dev->n_tags_ecc_fixed);
@@ -2715,7 +2715,7 @@ static int yaffs_proc_read(char *page,
 
 		/* Locate and print the Nth entry.  Order N-squared but N is small. */
 		ylist_for_each(item, &yaffs_context_list) {
-			struct yaffs_LinuxContext *dc = ylist_entry(item, struct yaffs_LinuxContext, contextList);
+			struct yaffs_linux_context *dc = ylist_entry(item, struct yaffs_linux_context, context_list);
 			yaffs_dev_t *dev = dc->dev;
 
 			if (n < (step & ~1)) {
@@ -2748,15 +2748,15 @@ static int yaffs_stats_proc_read(char *page,
 
 	/* Locate and print the Nth entry.  Order N-squared but N is small. */
 	ylist_for_each(item, &yaffs_context_list) {
-		struct yaffs_LinuxContext *dc = ylist_entry(item, struct yaffs_LinuxContext, contextList);
+		struct yaffs_linux_context *dc = ylist_entry(item, struct yaffs_linux_context, context_list);
 		yaffs_dev_t *dev = dc->dev;
 
-		int erasedChunks;
+		int erased_chunks;
 
-		erasedChunks = dev->n_erased_blocks * dev->param.chunks_per_block;
+		erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block;
 		
 		buf += sprintf(buf,"%d, %d, %d, %u, %u, %u, %u\n",
-				n, dev->n_free_chunks, erasedChunks,
+				n, dev->n_free_chunks, erased_chunks,
 				dev->bg_gcs, dev->oldest_dirty_gc_count,
 				dev->n_obj, dev->n_tnodes);
 	}