From b4d5215f18486403d16f2e776000e43eba052f40 Mon Sep 17 00:00:00 2001
From: Charles Manning <cdhmanning@gmail.com>
Date: Thu, 7 Jul 2016 09:30:35 +1200
Subject: [PATCH] Compilation clean up

Signed-off-by: Charles Manning <cdhmanning@gmail.com>
---
 direct/test-framework/FrameworkRules.mk    |   2 +-
 direct/test-framework/nanddrv.c            |   5 +-
 direct/test-framework/nandsim.c            |  16 ++-
 direct/test-framework/tests/nor_stress.c   |   1 +
 direct/test-framework/tests/yaffs_fsx.c    |  49 +++++----
 direct/test-framework/yaffs_fileem.c       |  89 +++++++--------
 direct/test-framework/yaffs_fileem2k.c     |  11 +-
 direct/test-framework/yaffs_m18_drv.c      |   4 +-
 direct/test-framework/yaffs_nand_drv.c     |   6 +-
 direct/test-framework/yaffs_nandsim_file.c |   2 +-
 direct/test-framework/yaffs_nandsim_file.h |   6 +-
 direct/test-framework/yaffs_nor_drv.c      |   4 +-
 direct/test-framework/yaffs_osglue.c       |   5 +
 direct/test-framework/yaffs_ramdisk.c      |  84 +++++++-------
 direct/test-framework/yaffs_ramem2k.c      |  32 +-----
 direct/test-framework/yaffscfg2k.c         |   1 +
 direct/yaffs_attribs.c                     |  19 ----
 direct/yaffsfs.c                           |  19 ++--
 yaffs_bitmap.c                             |   8 +-
 yaffs_checkptrw.c                          |  26 ++---
 yaffs_endian.c                             |   2 +-
 yaffs_getblockinfo.h                       |   3 +-
 yaffs_guts.c                               | 122 +++++++++++----------
 yaffs_guts.h                               |  26 +++--
 yaffs_nameval.c                            |   9 +-
 yaffs_summary.c                            |   7 +-
 yaffs_tagsmarshall.c                       |   5 +-
 yaffs_verify.c                             |  21 ++--
 yaffs_yaffs1.c                             |   6 +-
 yaffs_yaffs2.c                             |  33 +++---
 30 files changed, 305 insertions(+), 318 deletions(-)

diff --git a/direct/test-framework/FrameworkRules.mk b/direct/test-framework/FrameworkRules.mk
index e33cde5..e400659 100644
--- a/direct/test-framework/FrameworkRules.mk
+++ b/direct/test-framework/FrameworkRules.mk
@@ -19,7 +19,7 @@
 
 CFLAGS =      -DCONFIG_YAFFS_DIRECT -DCONFIG_YAFFS_YAFFS2  -DCONFIG_YAFFS_DEFINES_TYPES
 CFLAGS +=     -DCONFIG_YAFFS_PROVIDE_DEFS -DCONFIG_YAFFSFS_PROVIDE_VALUES
-CFLAGS +=    -Wall -g $(EXTRA_COMPILE_FLAGS) -Wstrict-aliasing
+CFLAGS +=    -Wall -g $(EXTRA_COMPILE_FLAGS) -Wstrict-aliasing -Werror
 #CFLAGS +=    -fno-strict-aliasing
 CFLAGS +=    -O0
 CFLAGS +=    -Wextra -Wpointer-arith
diff --git a/direct/test-framework/nanddrv.c b/direct/test-framework/nanddrv.c
index 5fb05c0..2008ecf 100644
--- a/direct/test-framework/nanddrv.c
+++ b/direct/test-framework/nanddrv.c
@@ -75,7 +75,6 @@ int nanddrv_read_tr(struct nand_chip *this, int page,
 {
 	unsigned char status;
 	int ncycles;
-	unsigned char *buffer;
 
 	if(n_tr < 1)
 		return 0;
@@ -98,7 +97,7 @@ int nanddrv_read_tr(struct nand_chip *this, int page,
 				buffer++;
 			}
 		} else {
-			unsigned short *buffer = tr->buffer;
+			unsigned short *buffer = (unsigned short *)tr->buffer;
 
 			ncycles = tr->nbytes >> 1;
 			while (ncycles> 0) {
@@ -145,7 +144,7 @@ int nanddrv_write_tr(struct nand_chip *this, int page,
 				buffer++;
 			}
 		} else {
-			unsigned short *buffer = tr->buffer;
+			unsigned short *buffer = (unsigned short *)tr->buffer;
 
 			ncycles = tr->nbytes >> 1;
 			while (ncycles> 0) {
diff --git a/direct/test-framework/nandsim.c b/direct/test-framework/nandsim.c
index 9c8a6fe..ded465b 100644
--- a/direct/test-framework/nandsim.c
+++ b/direct/test-framework/nandsim.c
@@ -94,6 +94,8 @@ static void check_last(struct nandsim_private *ns,
 
 static void idle(struct nandsim_private *ns, int line)
 {
+	(void) line;
+
 	ns->read_offset = -1;
 	ns->write_offset = -1;
 	ns->addr_offset = -1;
@@ -175,27 +177,35 @@ static void set_offset(struct nandsim_private *ns)
 static void load_read_buffer(struct nandsim_private *ns)
 {
 	int addr = get_page_address(ns);
+
 	debug(1, "Store read at address %d\n", addr);
 	ns->store->retrieve(ns->store, addr,ns->buffer);
 }
 static void save_write_buffer(struct nandsim_private *ns)
 {
 	int addr = get_page_address(ns);
+
 	debug(1, "Store write at address %d\n", addr);
 	ns->store->store(ns->store, addr, ns->buffer);
 }
 
 static void check_read_buffer(struct nandsim_private *ns, int line)
 {
+	(void) ns;
+	(void) line;
 }
 
 static void end_cmd(struct nandsim_private *ns, int line)
 {
+	(void) line;
+
 	ns->last_cmd_byte = 0xff;
 }
 
 static void set_busy(struct nandsim_private *ns, int cycles, int line)
 {
+	(void) line;
+
 	ns->busy_count = cycles;
 }
 
@@ -380,11 +390,13 @@ static void read_status(struct nandsim_private *ns)
 
 static void read_id(struct nandsim_private *ns)
 {
+	(void) ns;
 }
 
 
 static void unsupported(struct nandsim_private *ns)
 {
+	(void) ns;
 }
 
 static void nandsim_cl_write(struct nandsim_private *ns, unsigned char val)
@@ -447,7 +459,7 @@ static void nandsim_al_write(struct nandsim_private *ns, unsigned char val)
 	check_not_busy(ns, __LINE__);
 	if(ns->addr_expected < 1 ||
 		ns->addr_offset < 0 ||
-		ns->addr_offset >= sizeof(ns->addr_buffer)){
+		ns->addr_offset >= (int)sizeof(ns->addr_buffer)){
 		debug(1, "Address write when not expected\n");
 	} else {
 		debug(1, "Address write when expecting %d bytes\n",
@@ -461,7 +473,7 @@ static void nandsim_al_write(struct nandsim_private *ns, unsigned char val)
 	}
 }
 
-static void nandsim_dl_write(struct nandsim_private *ns, 
+static void nandsim_dl_write(struct nandsim_private *ns,
 				unsigned val,
 				int bus_width_shift)
 {
diff --git a/direct/test-framework/tests/nor_stress.c b/direct/test-framework/tests/nor_stress.c
index adf1b29..93a9a8e 100644
--- a/direct/test-framework/tests/nor_stress.c
+++ b/direct/test-framework/tests/nor_stress.c
@@ -19,6 +19,7 @@
 #include "yaffs_fsx.h"
 
 #include <stdio.h>
+#include <unistd.h>
 
 
 extern int fuzz_test;
diff --git a/direct/test-framework/tests/yaffs_fsx.c b/direct/test-framework/tests/yaffs_fsx.c
index aa234cd..88fe99f 100644
--- a/direct/test-framework/tests/yaffs_fsx.c
+++ b/direct/test-framework/tests/yaffs_fsx.c
@@ -24,12 +24,12 @@
  *      yaffs direct. Seek out the original fsx.c if you want to do anything
  *	else.
  *
- *	
+ *
  *
  *	File:	fsx.c
  *	Author:	Avadis Tevanian, Jr.
  *
- *	File system exerciser. 
+ *	File system exerciser.
  *
  *	Rewrite and enhancements 1998-2001 Conrad Minshall -- conrad@mac.com
  *
@@ -120,7 +120,7 @@ char		state[256];
 unsigned long	testcalls = 0;		/* calls to function "test" */
 
 unsigned long	simulatedopcount = 0;	/* -b flag */
-int	closeprob = 0;			/* -c flag */
+unsigned	closeprob = 0;		/* -c flag */
 int	debug = 0;			/* -d flag */
 unsigned long	debugstart = 0;		/* -D flag */
 unsigned long	maxfilelen = 256 * 1024;	/* -l flag */
@@ -243,7 +243,7 @@ logdump(void)
 		lp = &oplog[i];
 		if ((closeopen = lp->operation < 0))
 			lp->operation = ~ lp->operation;
-			
+
 		switch (lp->operation) {
 		case OP_MAPREAD:
 			prt("MAPREAD\t0x%x thru 0x%x\t(0x%x bytes)",
@@ -333,7 +333,7 @@ save_buffer(char *buffer, off_t bufferlength, int fd)
 	ret = yaffs_lseek(fd, (off_t)0, SEEK_SET);
 	if (ret == (off_t)-1)
 		prterr("save_buffer: lseek 0");
-	
+
 	byteswritten = yaffs_write(fd, buffer, (size_t)bufferlength);
 	if (byteswritten != bufferlength) {
 		if (byteswritten == -1)
@@ -350,7 +350,7 @@ void
 report_failure(int status)
 {
 	logdump();
-	
+
 	if (fsxgoodfd) {
 		if (good_buf) {
 			save_buffer(good_buf, file_size, fsxgoodfd);
@@ -422,7 +422,8 @@ check_size(void)
 		statbuf.st_size = -1;
 	}
 	size_by_seek = yaffs_lseek(fd, (off_t)0, SEEK_END);
-	if (file_size != statbuf.st_size || file_size != size_by_seek) {
+	if (file_size != statbuf.st_size ||
+	   file_size != size_by_seek) {
 		prt("Size error: expected 0x%llx stat 0x%llx seek 0x%llx\n",
 		    (unsigned long long)file_size,
 		    (unsigned long long)statbuf.st_size,
@@ -461,7 +462,7 @@ doread(unsigned offset, unsigned size)
 		log4(OP_SKIPPED, OP_READ, offset, size);
 		return;
 	}
-	if (size + offset > file_size) {
+	if ((off_t)(size + offset) > file_size) {
 		if (!quiet && testcalls > simulatedopcount)
 			prt("skipping seek/read past end of file\n");
 		log4(OP_SKIPPED, OP_READ, offset, size);
@@ -488,7 +489,7 @@ doread(unsigned offset, unsigned size)
 	}
 	iret = yaffs_read(fd, temp_buf, size);
 	if (iret != size) {
-		if (iret == -1)
+		if (iret == (unsigned)(-1))
 			prterr("doread: read");
 		else
 			prt("short read: 0x%x bytes instead of 0x%x\n",
@@ -506,7 +507,7 @@ void
 gendata(char *original_buf, char *good_buf, unsigned offset, unsigned size)
 {
 	while (size--) {
-		good_buf[offset] = testcalls % 256; 
+		good_buf[offset] = testcalls % 256;
 		if (offset % 2)
 			good_buf[offset] += original_buf[offset];
 		offset++;
@@ -559,7 +560,7 @@ dowrite(unsigned offset, unsigned size)
 	}
 	iret = yaffs_write(fd, good_buf + offset, size);
 	if (iret != size) {
-		if (iret == -1)
+		if (iret == (unsigned)(-1))
 			prterr("dowrite: write");
 		else
 			prt("short write: 0x%x bytes instead of 0x%x\n",
@@ -590,7 +591,7 @@ dotruncate(unsigned size)
 
 	if (testcalls <= simulatedopcount)
 		return;
-	
+
 	if ((progressinterval && testcalls % progressinterval == 0) ||
 	    (debug && (monitorstart == -1 || monitorend == -1 ||
 		       size <= monitorend)))
@@ -631,7 +632,7 @@ writefileimage()
 
 void
 docloseopen(void)
-{ 
+{
 	if (testcalls <= simulatedopcount)
 		return;
 
@@ -668,7 +669,7 @@ yaffs_fsx_do_op(void)
 	testcalls++;
 
 	if (closeprob)
-		closeopen = (rv >> 3) < (1 << 28) / closeprob;
+		closeopen = (rv >> 3) < (1U << 28) / closeprob;
 
 	if (debugstart > 0 && testcalls >= debugstart)
 		debug = 1;
@@ -702,7 +703,7 @@ yaffs_fsx_do_op(void)
 					offset %= file_size;
 				else
 					offset = 0;
-				if (offset + size > file_size)
+				if ((ssize_t)(offset + size) > file_size)
 					size = file_size - offset;
 				doread(offset, size);
 			}
@@ -799,7 +800,7 @@ int mounted_by_fsx = 0;
 int
 yaffs_fsx_init(const char *mount_pt)
 {
-	int	i;
+	unsigned	i;
 
 	goodfile[0] = 0;
 	logfile[0] = 0;
@@ -812,7 +813,7 @@ yaffs_fsx_init(const char *mount_pt)
 	strcpy(mount_name,mount_pt);
 	strcpy(fname,mount_name);
 	strcat(fname,"/fsxdata");
-	
+
 #if 0
 	signal(SIGHUP,	cleanup);
 	signal(SIGINT,	cleanup);
@@ -873,7 +874,7 @@ yaffs_fsx_init(const char *mount_pt)
 		ssize_t written;
 
 		written = yaffs_write(fd, good_buf, (size_t)maxfilelen);
-		if (written != maxfilelen) {
+		if (written != (ssize_t)maxfilelen) {
 			if (written == -1) {
 				prterr(fname);
 				warn("main: error on write");
@@ -882,11 +883,11 @@ yaffs_fsx_init(const char *mount_pt)
 				     (unsigned)written, maxfilelen);
 			EXIT(98);
 		}
-	} else 
+	} else
 		check_trunc_hack();
-		
+
 	printf("yaffs_fsx_init done\n");
-		
+
 	return 0;
 }
 
@@ -897,9 +898,9 @@ int yaffs_fsx_complete(void)
 		prterr("close");
 		report_failure(99);
 	}
-	
+
 	yaffs_close(fsxgoodfd);
-	
+
 	prt("All operations completed A-OK!\n");
 
 	EXIT(0);
@@ -913,6 +914,6 @@ yaffs_fsx_main(const char *mount_pt, int numops)
 	while (numops == -1 || numops--)
 		yaffs_fsx_do_op();
 	yaffs_fsx_complete();
-	
+
 	return 0;
 }
diff --git a/direct/test-framework/yaffs_fileem.c b/direct/test-framework/yaffs_fileem.c
index 96a64c6..a791214 100644
--- a/direct/test-framework/yaffs_fileem.c
+++ b/direct/test-framework/yaffs_fileem.c
@@ -25,7 +25,7 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
-#include <unistd.h> 
+#include <unistd.h>
 
 
 
@@ -36,7 +36,7 @@
 
 
 
-typedef struct 
+typedef struct
 {
 	u8 data[528]; // Data + spare
 } yflash_Page;
@@ -44,7 +44,7 @@ typedef struct
 typedef struct
 {
 	yflash_Page page[32]; // The pages in the block
-	
+
 } yflash_Block;
 
 
@@ -60,56 +60,55 @@ static yflash_Device filedisk;
 static int  CheckInit(struct yaffs_dev *dev)
 {
 	static int initialised = 0;
-	
 	int i;
-
-	
 	int fSize;
 	int written;
-	
+
 	yflash_Page p;
-	
-	if(initialised) 
+
+	(void)dev;
+
+	if(initialised)
 	{
 		return YAFFS_OK;
 	}
 
 	initialised = 1;
-	
-	
+
+
 	filedisk.nBlocks = (SIZE_IN_MB * 1024 * 1024)/(16 * 1024);
-	
+
 	filedisk.handle = open("emfile-512-0", O_RDWR | O_CREAT, S_IREAD | S_IWRITE);
-	
+
 	if(filedisk.handle < 0)
 	{
 		perror("Failed to open yaffs emulation file");
 		return YAFFS_FAIL;
 	}
-	
-	
+
+
 	fSize = lseek(filedisk.handle,0,SEEK_END);
-	
+
 	if(fSize < SIZE_IN_MB * 1024 * 1024)
 	{
 		printf("Creating yaffs emulation file\n");
-		
+
 		lseek(filedisk.handle,0,SEEK_SET);
-		
+
 		memset(&p,0xff,sizeof(yflash_Page));
-		
+
 		for(i = 0; i < SIZE_IN_MB * 1024 * 1024; i+= 512)
 		{
 			written = write(filedisk.handle,&p,sizeof(yflash_Page));
-			
+
 			if(written != sizeof(yflash_Page))
 			{
 				printf("Write failed\n");
 				return YAFFS_FAIL;
 			}
-		}		
+		}
 	}
-	
+
 	return 1;
 }
 
@@ -118,27 +117,25 @@ int yflash_WriteChunkToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data,
 	int written;
 
 	CheckInit(dev);
-	
-	
-	
+
 	if(data)
 	{
 		lseek(filedisk.handle,nand_chunk * 528,SEEK_SET);
 		written = write(filedisk.handle,data,512);
-		
+
 		if(written != 512) return YAFFS_FAIL;
 	}
-	
+
 	if(spare)
 	{
 		lseek(filedisk.handle,nand_chunk * 528 + 512,SEEK_SET);
 		written = write(filedisk.handle,spare,16);
-		
+
 		if(written != 16) return YAFFS_FAIL;
 	}
-	
 
-	return YAFFS_OK;	
+
+	return YAFFS_OK;
 
 }
 
@@ -148,38 +145,35 @@ int yflash_ReadChunkFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, str
 	int nread;
 
 	CheckInit(dev);
-	
-	
-	
+
 	if(data)
 	{
 		lseek(filedisk.handle,nand_chunk * 528,SEEK_SET);
 		nread = read(filedisk.handle,data,512);
-		
+
 		if(nread != 512) return YAFFS_FAIL;
 	}
-	
+
 	if(spare)
 	{
 		lseek(filedisk.handle,nand_chunk * 528 + 512,SEEK_SET);
 		nread= read(filedisk.handle,spare,16);
-		
+
 		if(nread != 16) return YAFFS_FAIL;
 	}
-	
 
-	return YAFFS_OK;	
+
+	return YAFFS_OK;
 
 }
 
 
 int yflash_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber)
 {
-
 	int i;
-		
+
 	CheckInit(dev);
-	
+
 	if(blockNumber < 0 || blockNumber >= filedisk.nBlocks)
 	{
 		yaffs_trace(YAFFS_TRACE_ALWAYS,
@@ -189,25 +183,26 @@ int yflash_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber)
 	}
 	else
 	{
-	
+
 		yflash_Page pg;
-		
+
 		memset(&pg,0xff,sizeof(yflash_Page));
-		
+
 		lseek(filedisk.handle, blockNumber * 32 * 528, SEEK_SET);
-		
+
 		for(i = 0; i < 32; i++)
 		{
 			write(filedisk.handle,&pg,528);
 		}
 		return YAFFS_OK;
 	}
-	
+
 }
 
 int yflash_InitialiseNAND(struct yaffs_dev *dev)
 {
-	
+	(void) dev;
+
 	return YAFFS_OK;
 }
 
diff --git a/direct/test-framework/yaffs_fileem2k.c b/direct/test-framework/yaffs_fileem2k.c
index b9a00f1..8da77dc 100644
--- a/direct/test-framework/yaffs_fileem2k.c
+++ b/direct/test-framework/yaffs_fileem2k.c
@@ -93,7 +93,6 @@ static int nops_so_far;
 
 int ops_multiplier;
 
-
 static void yflash2_MaybePowerFail(unsigned int nand_chunk, int failPoint)
 {
 
@@ -110,12 +109,6 @@ static void yflash2_MaybePowerFail(unsigned int nand_chunk, int failPoint)
   }
 }
 
-
-
-
-
-static u8 localBuffer[PAGE_SIZE];
-
 static char *NToName(char *buf,int n)
 {
 	sprintf(buf,"emfile-2k-%d",n);
@@ -277,7 +270,7 @@ static int yflash2_ReadChunk(struct yaffs_dev *dev, int nand_chunk,
 
 static int yflash2_EraseBlock(struct yaffs_dev *dev, int block_no)
 {
-	int i;
+	u32 i;
 	int h;
 
 	CheckInit();
@@ -292,7 +285,6 @@ static int yflash2_EraseBlock(struct yaffs_dev *dev, int block_no)
 
 		u8 pg[PAGE_SIZE];
 		int syz = PAGE_SIZE;
-		int pos;
 
 		memset(pg,0xff,syz);
 
@@ -303,7 +295,6 @@ static int yflash2_EraseBlock(struct yaffs_dev *dev, int block_no)
 		{
 			write(h,pg,PAGE_SIZE);
 		}
-		pos = lseek(h, 0,SEEK_CUR);
 
 		return YAFFS_OK;
 	}
diff --git a/direct/test-framework/yaffs_m18_drv.c b/direct/test-framework/yaffs_m18_drv.c
index 9a8ee49..da425e0 100644
--- a/direct/test-framework/yaffs_m18_drv.c
+++ b/direct/test-framework/yaffs_m18_drv.c
@@ -224,6 +224,8 @@ static int m18_drv_ReadChunkFromNAND(struct yaffs_dev *dev,int nand_chunk,
 	u32 *dataAddr = Chunk2DataAddr(dev,nand_chunk);
 	u32 *spareAddr = Chunk2SpareAddr(dev,nand_chunk);
 
+	(void) data_len;
+
 	if(data)
 	{
 		m18_drv_FlashRead32(dataAddr,(u32 *)data,dev->param.total_bytes_per_chunk / 4);
@@ -305,7 +307,7 @@ static int m18_drv_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber)
 
 static int m18_drv_InitialiseNAND(struct yaffs_dev *dev)
 {
-	int i;
+	u32 i;
 
 	m18_drv_FlashInit();
 	/* Go through the blocks formatting them if they are not formatted */
diff --git a/direct/test-framework/yaffs_nand_drv.c b/direct/test-framework/yaffs_nand_drv.c
index 9bdcb55..f739d1d 100644
--- a/direct/test-framework/yaffs_nand_drv.c
+++ b/direct/test-framework/yaffs_nand_drv.c
@@ -83,7 +83,7 @@ static int yaffs_nand_drv_WriteChunk(struct yaffs_dev *dev, int nand_chunk,
 
 	/* Set up and execute transfer */
 
-	tr[0].buffer = data;
+	tr[0].buffer = (u8 *)data;
 	tr[0].offset = 0;
 	tr[0].nbytes = data_len;
 
@@ -196,8 +196,6 @@ static int yaffs_nand_drv_CheckBad(struct yaffs_dev *dev, int block_no)
 	struct nand_chip *chip = dev_to_chip(dev);
 	u8 *buffer = dev_to_buffer(dev);
 	int nand_chunk = block_no * chip->pages_per_block;
-	int ret;
-
 	struct nanddrv_transfer tr[1];
 
 	memset(buffer, 0, chip->spare_bytes_per_page);
@@ -206,7 +204,7 @@ static int yaffs_nand_drv_CheckBad(struct yaffs_dev *dev, int block_no)
 	tr[0].offset = chip->data_bytes_per_page;
 	tr[0].nbytes = chip->spare_bytes_per_page;
 
-	ret = nanddrv_read_tr(chip, nand_chunk, tr, 1);
+	nanddrv_read_tr(chip, nand_chunk, tr, 1);
 
 	/* Check that bad block marker is not set */
 	if(yaffs_hweight8(buffer[0]) + yaffs_hweight8(buffer[1]) < 14)
diff --git a/direct/test-framework/yaffs_nandsim_file.c b/direct/test-framework/yaffs_nandsim_file.c
index 16e69a0..fb123cc 100644
--- a/direct/test-framework/yaffs_nandsim_file.c
+++ b/direct/test-framework/yaffs_nandsim_file.c
@@ -13,7 +13,7 @@
 
 
 #include "yaffs_nandsim_file.h"
-
+#include "yaffs_nand_drv.h"
 #include "nandsim_file.h"
 #include "nand_chip.h"
 #include "yaffs_guts.h"
diff --git a/direct/test-framework/yaffs_nandsim_file.h b/direct/test-framework/yaffs_nandsim_file.h
index 0960dac..a374bf7 100644
--- a/direct/test-framework/yaffs_nandsim_file.h
+++ b/direct/test-framework/yaffs_nandsim_file.h
@@ -13,12 +13,12 @@
  * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
  */
 
-#ifndef __YAFFS_NAND_DRV_H__
-#define __YAFFS_NAND_DRV_H__
+#ifndef __YAFFS_NANDSIM_FILE_H__
+#define __YAFFS_NANDSIM_FILE_H__
 
 struct yaffs_dev;
 
-struct yaffs_dev *yaffs_nandsim_file_install(const char *dev_name,
+struct yaffs_dev *yaffs_nandsim_install_drv(const char *dev_name,
 					const char *backing_file_name,
 					int n_blocks);
 
diff --git a/direct/test-framework/yaffs_nor_drv.c b/direct/test-framework/yaffs_nor_drv.c
index 7ac108a..65faca1 100644
--- a/direct/test-framework/yaffs_nor_drv.c
+++ b/direct/test-framework/yaffs_nor_drv.c
@@ -199,6 +199,8 @@ static int nor_drv_ReadChunkFromNAND(struct yaffs_dev *dev,int nand_chunk,
 	u32 *dataAddr = Chunk2DataAddr(dev,nand_chunk);
 	u32 *spareAddr = Chunk2SpareAddr(dev,nand_chunk);
 
+	(void) data_len;
+
 	if (data) {
 		nor_drv_FlashRead32(dataAddr,(u32 *)data,dev->param.total_bytes_per_chunk / sizeof(u32));
 	}
@@ -278,7 +280,7 @@ static int nor_drv_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber)
 
 static int nor_drv_InitialiseNAND(struct yaffs_dev *dev)
 {
-	int i;
+	u32 i;
 
 	nor_drv_FlashInit();
 	/* Go through the blocks formatting them if they are not formatted */
diff --git a/direct/test-framework/yaffs_osglue.c b/direct/test-framework/yaffs_osglue.c
index e31ad22..6f0afab 100644
--- a/direct/test-framework/yaffs_osglue.c
+++ b/direct/test-framework/yaffs_osglue.c
@@ -53,6 +53,9 @@ int yaffsfs_GetLastError(void)
  */
 int yaffsfs_CheckMemRegion(const void *addr, size_t size, int write_request)
 {
+	(void) size;
+	(void) write_request;
+
 	if(!addr)
 		return -1;
 	return 0;
@@ -91,6 +94,8 @@ static void *bg_gc_func(void *dummy)
 	int result;
 	int next_urgent;
 
+	(void)dummy;
+
 	/* Sleep for a bit to allow start up */
 	sleep(2);
 
diff --git a/direct/test-framework/yaffs_ramdisk.c b/direct/test-framework/yaffs_ramdisk.c
index 3d71e51..12ee90c 100644
--- a/direct/test-framework/yaffs_ramdisk.c
+++ b/direct/test-framework/yaffs_ramdisk.c
@@ -36,7 +36,7 @@
 
 
 
-typedef struct 
+typedef struct
 {
 	u8 data[528]; // Data + spare
 } yramdisk_page;
@@ -44,7 +44,7 @@ typedef struct
 typedef struct
 {
 	yramdisk_page page[32]; // The pages in the block
-	
+
 } yramdisk_block;
 
 
@@ -60,31 +60,31 @@ static yramdisk_device ramdisk;
 static int  CheckInit(struct yaffs_dev *dev)
 {
 	static int initialised = 0;
-	
+
 	int i;
 	int fail = 0;
-	//int nBlocks; 
+	//int nBlocks;
 	int nAllocated = 0;
-	
-	if(initialised) 
+
+	if(initialised)
 	{
 		return YAFFS_OK;
 	}
 
 	initialised = 1;
-	
-	
+
+
 	ramdisk.nBlocks = (SIZE_IN_MB * 1024 * 1024)/(16 * 1024);
-	
+
 	ramdisk.block = malloc(sizeof(yramdisk_block *) * ramdisk.nBlocks);
-	
+
 	if(!ramdisk.block) return 0;
-	
+
 	for(i=0; i <ramdisk.nBlocks; i++)
 	{
 		ramdisk.block[i] = NULL;
 	}
-	
+
 	for(i=0; i <ramdisk.nBlocks && !fail; i++)
 	{
 		if((ramdisk.block[i] = malloc(sizeof(yramdisk_block))) == 0)
@@ -97,7 +97,7 @@ static int  CheckInit(struct yaffs_dev *dev)
 			nAllocated++;
 		}
 	}
-	
+
 	if(fail)
 	{
 		for(i = 0; i < nAllocated; i++)
@@ -105,14 +105,14 @@ static int  CheckInit(struct yaffs_dev *dev)
 			kfree(ramdisk.block[i]);
 		}
 		kfree(ramdisk.block);
-		
+
 		yaffs_trace(YAFFS_TRACE_ALWAYS,
 			"Allocation failed, could only allocate %dMB of %dMB requested.\n",
 			nAllocated/64,ramdisk.nBlocks * 528);
 		return 0;
 	}
-	
-	
+
+
 	return 1;
 }
 
@@ -120,29 +120,29 @@ int yramdisk_wr_chunk(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const
 {
 	int blk;
 	int pg;
-	
+
 
 	CheckInit(dev);
-	
+
 	blk = nand_chunk/32;
 	pg = nand_chunk%32;
-	
-	
+
+
 	if(data)
 	{
 		memcpy(ramdisk.block[blk]->page[pg].data,data,512);
 	}
-	
-	
+
+
 	if(tags)
 	{
 		struct yaffs_packed_tags1 pt;
-		
+
 		yaffs_pack_tags1(&pt,tags);
 		memcpy(&ramdisk.block[blk]->page[pg].data[512],&pt,sizeof(pt));
 	}
 
-	return YAFFS_OK;	
+	return YAFFS_OK;
 
 }
 
@@ -152,26 +152,26 @@ int yramdisk_rd_chunk(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaf
 	int blk;
 	int pg;
 
-	
+
 	CheckInit(dev);
-	
+
 	blk = nand_chunk/32;
 	pg = nand_chunk%32;
-	
-	
+
+
 	if(data)
 	{
 		memcpy(data,ramdisk.block[blk]->page[pg].data,512);
 	}
-	
-	
+
+
 	if(tags)
 	{
 		struct yaffs_packed_tags1 pt;
-		
+
 		memcpy(&pt,&ramdisk.block[blk]->page[pg].data[512],sizeof(pt));
 		yaffs_unpack_tags1(tags,&pt);
-		
+
 	}
 
 	return YAFFS_OK;
@@ -184,13 +184,13 @@ int yramdisk_check_chunk_erased(struct yaffs_dev *dev,int nand_chunk)
 	int pg;
 	int i;
 
-	
+
 	CheckInit(dev);
-	
+
 	blk = nand_chunk/32;
 	pg = nand_chunk%32;
-	
-	
+
+
 	for(i = 0; i < 528; i++)
 	{
 		if(ramdisk.block[blk]->page[pg].data[i] != 0xFF)
@@ -205,9 +205,9 @@ int yramdisk_check_chunk_erased(struct yaffs_dev *dev,int nand_chunk)
 
 int yramdisk_erase(struct yaffs_dev *dev, int blockNumber)
 {
-	
+
 	CheckInit(dev);
-	
+
 	if(blockNumber < 0 || blockNumber >= ramdisk.nBlocks)
 	{
 		yaffs_trace(YAFFS_TRACE_ALWAYS,
@@ -220,14 +220,16 @@ int yramdisk_erase(struct yaffs_dev *dev, int blockNumber)
 		memset(ramdisk.block[blockNumber],0xFF,sizeof(yramdisk_block));
 		return YAFFS_OK;
 	}
-	
+
 }
 
 int yramdisk_initialise(struct yaffs_dev *dev)
 {
-	//dev->use_nand_ecc = 1; // force on use_nand_ecc which gets faked. 
+	(void) dev;
+
+	//dev->use_nand_ecc = 1; // force on use_nand_ecc which gets faked.
 						 // This saves us doing ECC checks.
-	
+
 	return YAFFS_OK;
 }
 
diff --git a/direct/test-framework/yaffs_ramem2k.c b/direct/test-framework/yaffs_ramem2k.c
index cfb0f4f..11f9033 100644
--- a/direct/test-framework/yaffs_ramem2k.c
+++ b/direct/test-framework/yaffs_ramem2k.c
@@ -77,6 +77,7 @@ static int sizeInMB = EM_SIZE_IN_MEG;
 
 static void nandemul_yield(int n)
 {
+	(void)n;
 #ifdef __KERNEL__
 	if(n > 0) schedule_timeout(n);
 #endif
@@ -260,34 +261,9 @@ int nandemul2k_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev,int nand_chunk, u
 	return YAFFS_OK;
 }
 
-
-static int nandemul2k_CheckChunkErased(struct yaffs_dev *dev,int nand_chunk)
-{
-	int blk;
-	int pg;
-	int i;
-
-
-
-	blk = nand_chunk/PAGES_PER_BLOCK;
-	pg = nand_chunk%PAGES_PER_BLOCK;
-
-
-	for(i = 0; i < PAGE_TOTAL_SIZE; i++)
-	{
-		if(ned.block[blk]->page[pg]->data[i] != 0xFF)
-		{
-			return YAFFS_FAIL;
-		}
-	}
-
-	return YAFFS_OK;
-
-}
-
 int nandemul2k_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber)
 {
-
+	(void) dev;
 
 	if(blockNumber < 0 || blockNumber >= ned.nBlocks)
 	{
@@ -311,6 +287,8 @@ int nandemul2k_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber)
 
 int nandemul2k_InitialiseNAND(struct yaffs_dev *dev)
 {
+	(void) dev;
+
 	CheckInit();
 	return YAFFS_OK;
 }
@@ -320,6 +298,8 @@ int nandemul2k_MarkNANDBlockBad(struct yaffs_dev *dev, int block_no)
 
 	u8 *x;
 
+	(void) dev;
+
 	x = &ned.block[block_no]->page[0]->data[PAGE_DATA_SIZE];
 
 	memset(x,0,sizeof(struct yaffs_packed_tags2));
diff --git a/direct/test-framework/yaffscfg2k.c b/direct/test-framework/yaffscfg2k.c
index b053ce4..fc9466b 100644
--- a/direct/test-framework/yaffscfg2k.c
+++ b/direct/test-framework/yaffscfg2k.c
@@ -25,6 +25,7 @@
 #include "yaffs_nandemul2k.h"
 #include "yaffs_trace.h"
 #include "yaffs_osglue.h"
+#include "yaffs_nandsim_file.h"
 
 
 #include <errno.h>
diff --git a/direct/yaffs_attribs.c b/direct/yaffs_attribs.c
index de80fe4..de8e451 100644
--- a/direct/yaffs_attribs.c
+++ b/direct/yaffs_attribs.c
@@ -87,22 +87,3 @@ void yaffs_load_current_time(struct yaffs_obj *obj, int do_a, int do_c)
 		obj->yst_ctime = obj->yst_atime;
 #endif
 }
-
-static Y_LOFF_T yaffs_get_file_size(struct yaffs_obj *obj)
-{
-	YCHAR *alias = NULL;
-	obj = yaffs_get_equivalent_obj(obj);
-
-	switch (obj->variant_type) {
-	case YAFFS_OBJECT_TYPE_FILE:
-		return obj->variant.file_variant.file_size;
-	case YAFFS_OBJECT_TYPE_SYMLINK:
-		alias = obj->variant.symlink_variant.alias;
-		if (!alias)
-			return 0;
-		return yaffs_strnlen(alias, YAFFS_MAX_ALIAS_LENGTH);
-	default:
-		return 0;
-	}
-}
-
diff --git a/direct/yaffsfs.c b/direct/yaffsfs.c
index 3cb11a9..7647444 100644
--- a/direct/yaffsfs.c
+++ b/direct/yaffsfs.c
@@ -19,6 +19,7 @@
 
 #include "string.h"
 
+#define YAFFS_MAX_RW_SIZE	0x70000000
 #define YAFFSFS_MAX_SYMLINK_DEREFERENCES 5
 
 #ifndef NULL
@@ -1187,7 +1188,7 @@ static int yaffsfs_do_read(int handle, void *vbuf, unsigned int nbyte,
 		/* Not a reading handle */
 		yaffsfs_SetError(-EINVAL);
 		totalRead = -1;
-	} else if (nbyte > YAFFS_MAX_FILE_SIZE) {
+	} else if (nbyte > YAFFS_MAX_RW_SIZE) {
 		yaffsfs_SetError(-EINVAL);
 		totalRead = -1;
 	} else {
@@ -1211,7 +1212,7 @@ static int yaffsfs_do_read(int handle, void *vbuf, unsigned int nbyte,
 		endPos = pos + nbyte;
 
 		if (pos < 0 || pos > YAFFS_MAX_FILE_SIZE ||
-		    nbyte > YAFFS_MAX_FILE_SIZE ||
+		    nbyte > YAFFS_MAX_RW_SIZE ||
 		    endPos < 0 || endPos > YAFFS_MAX_FILE_SIZE) {
 			totalRead = -1;
 			nbyte = 0;
@@ -1220,7 +1221,7 @@ static int yaffsfs_do_read(int handle, void *vbuf, unsigned int nbyte,
 		while (nbyte > 0) {
 			nToRead = YAFFSFS_RW_SIZE -
 			    (pos & (YAFFSFS_RW_SIZE - 1));
-			if (nToRead > nbyte)
+			if (nToRead > (int)nbyte)
 				nToRead = nbyte;
 
 			/* Tricky bit...
@@ -1324,7 +1325,7 @@ static int yaffsfs_do_write(int handle, const void *vbuf, unsigned int nbyte,
 		endPos = pos + nbyte;
 
 		if (pos < 0 || pos > YAFFS_MAX_FILE_SIZE ||
-		    nbyte > YAFFS_MAX_FILE_SIZE ||
+		    nbyte > YAFFS_MAX_RW_SIZE ||
 		    endPos < 0 || endPos > YAFFS_MAX_FILE_SIZE) {
 			totalWritten = -1;
 			nbyte = 0;
@@ -1334,7 +1335,7 @@ static int yaffsfs_do_write(int handle, const void *vbuf, unsigned int nbyte,
 
 			nToWrite = YAFFSFS_RW_SIZE -
 			    (pos & (YAFFSFS_RW_SIZE - 1));
-			if (nToWrite > nbyte)
+			if (nToWrite > (int)nbyte)
 				nToWrite = nbyte;
 
 			/* Tricky bit...
@@ -1622,7 +1623,7 @@ int yaffs_fgetfl(int fd, int *flags)
 {
 	struct yaffsfs_FileDes *fdp = yaffsfs_HandleToFileDes(fd);
 	int retVal;
-	
+
 	yaffsfs_Lock();
 
 	if(!flags || !fdp) {
@@ -1637,7 +1638,7 @@ int yaffs_fgetfl(int fd, int *flags)
 			*flags = O_RDONLY;
 		retVal = 0;
 	}
-	
+
 	yaffsfs_Unlock();
 	return retVal;
 }
@@ -1790,7 +1791,7 @@ static int yaffsfs_DoStat(struct yaffs_obj *obj, struct yaffs_stat *buf)
 	obj = yaffs_get_equivalent_obj(obj);
 
 	if (obj && buf) {
-		buf->st_dev = (int)obj->my_dev->os_context;
+		buf->st_dev = 0;
 		buf->st_ino = obj->obj_id;
 		buf->st_mode = obj->yst_mode & ~S_IFMT;
 
@@ -3578,7 +3579,7 @@ struct yaffs_dirent *yaffsfs_readdir_no_lock(yaffs_DIR * dirp)
 		if (dsc->nextReturn) {
 			dsc->de.d_ino =
 			    yaffs_get_equivalent_obj(dsc->nextReturn)->obj_id;
-			dsc->de.d_dont_use = (unsigned)dsc->nextReturn;
+			dsc->de.d_dont_use = 0;
 			dsc->de.d_off = dsc->offset++;
 			yaffs_get_obj_name(dsc->nextReturn,
 					   dsc->de.d_name, NAME_MAX);
diff --git a/yaffs_bitmap.c b/yaffs_bitmap.c
index 4440e93..bf8cbb3 100644
--- a/yaffs_bitmap.c
+++ b/yaffs_bitmap.c
@@ -19,7 +19,8 @@
 
 static inline u8 *yaffs_block_bits(struct yaffs_dev *dev, int blk)
 {
-	if (blk < dev->internal_start_block || blk > dev->internal_end_block) {
+	if (blk < (int)dev->internal_start_block ||
+	    blk > (int)dev->internal_end_block) {
 		yaffs_trace(YAFFS_TRACE_ERROR,
 			"BlockBits block %d is not valid",
 			blk);
@@ -31,8 +32,9 @@ static inline u8 *yaffs_block_bits(struct yaffs_dev *dev, int blk)
 
 void yaffs_verify_chunk_bit_id(struct yaffs_dev *dev, int blk, int chunk)
 {
-	if (blk < dev->internal_start_block || blk > dev->internal_end_block ||
-	    chunk < 0 || chunk >= dev->param.chunks_per_block) {
+	if (blk < (int)dev->internal_start_block ||
+	    blk > (int)dev->internal_end_block ||
+	    chunk < 0 || chunk >= (int)dev->param.chunks_per_block) {
 		yaffs_trace(YAFFS_TRACE_ERROR,
 			"Chunk Id (%d:%d) invalid",
 			blk, chunk);
diff --git a/yaffs_checkptrw.c b/yaffs_checkptrw.c
index 59ca34a..c7cbda3 100644
--- a/yaffs_checkptrw.c
+++ b/yaffs_checkptrw.c
@@ -87,7 +87,7 @@ static int yaffs2_checkpt_space_ok(struct yaffs_dev *dev)
 
 static int yaffs_checkpt_erase(struct yaffs_dev *dev)
 {
-	int i;
+	u32 i;
 
 	if (!dev->drv.drv_erase_fn)
 		return 0;
@@ -126,7 +126,7 @@ static int yaffs_checkpt_erase(struct yaffs_dev *dev)
 
 static void yaffs2_checkpt_find_erased_block(struct yaffs_dev *dev)
 {
-	int i;
+	u32 i;
 	int blocks_avail = dev->n_erased_blocks - dev->param.n_reserved_blocks;
 
 	yaffs_trace(YAFFS_TRACE_CHECKPOINT,
@@ -135,7 +135,7 @@ static void yaffs2_checkpt_find_erased_block(struct yaffs_dev *dev)
 		blocks_avail, dev->checkpt_next_block);
 
 	if (dev->checkpt_next_block >= 0 &&
-	    dev->checkpt_next_block <= dev->internal_end_block &&
+	    dev->checkpt_next_block <= (int)dev->internal_end_block &&
 	    blocks_avail > 0) {
 
 		for (i = dev->checkpt_next_block; i <= dev->internal_end_block;
@@ -160,7 +160,7 @@ static void yaffs2_checkpt_find_erased_block(struct yaffs_dev *dev)
 
 static void yaffs2_checkpt_find_block(struct yaffs_dev *dev)
 {
-	int i;
+	u32 i;
 	struct yaffs_ext_tags tags;
 
 	yaffs_trace(YAFFS_TRACE_CHECKPOINT,
@@ -210,7 +210,7 @@ static void yaffs2_checkpt_find_block(struct yaffs_dev *dev)
 
 int yaffs2_checkpt_open(struct yaffs_dev *dev, int writing)
 {
-	int i;
+	u32 i;
 
 	dev->checkpt_open_write = writing;
 
@@ -319,7 +319,7 @@ static int yaffs2_checkpt_flush_buffer(struct yaffs_dev *dev)
 				       dev->checkpt_buffer, &tags);
 	dev->checkpt_page_seq++;
 	dev->checkpt_cur_chunk++;
-	if (dev->checkpt_cur_chunk >= dev->param.chunks_per_block) {
+	if (dev->checkpt_cur_chunk >= (int)dev->param.chunks_per_block) {
 		dev->checkpt_cur_chunk = 0;
 		dev->checkpt_cur_block = -1;
 	}
@@ -354,7 +354,7 @@ int yaffs2_checkpt_wr(struct yaffs_dev *dev, const void *data, int n_bytes)
 		dev->checkpt_byte_count++;
 
 		if (dev->checkpt_byte_offs < 0 ||
-		    dev->checkpt_byte_offs >= dev->data_bytes_per_chunk)
+		    dev->checkpt_byte_offs >= (int)dev->data_bytes_per_chunk)
 			ok = yaffs2_checkpt_flush_buffer(dev);
 	}
 
@@ -378,7 +378,7 @@ int yaffs2_checkpt_rd(struct yaffs_dev *dev, void *data, int n_bytes)
 	while (i < n_bytes) {
 
 		if (dev->checkpt_byte_offs < 0 ||
-		    dev->checkpt_byte_offs >= dev->data_bytes_per_chunk) {
+		    dev->checkpt_byte_offs >= (int)dev->data_bytes_per_chunk) {
 
 			if (dev->checkpt_cur_block < 0) {
 				yaffs2_checkpt_find_block(dev);
@@ -403,7 +403,7 @@ int yaffs2_checkpt_rd(struct yaffs_dev *dev, void *data, int n_bytes)
 						&tags);
 
 			/* Bail out if the chunk is corrupted. */
-			if (tags.chunk_id != (dev->checkpt_page_seq + 1) ||
+			if (tags.chunk_id != (u32)(dev->checkpt_page_seq + 1) ||
 			    tags.ecc_result > YAFFS_ECC_RESULT_FIXED ||
 			    tags.seq_number != YAFFS_SEQUENCE_CHECKPOINT_DATA)
 				break;
@@ -416,7 +416,7 @@ int yaffs2_checkpt_rd(struct yaffs_dev *dev, void *data, int n_bytes)
 			dev->checkpt_cur_chunk++;
 
 			if (dev->checkpt_cur_chunk >=
-					dev->param.chunks_per_block)
+					(int)dev->param.chunks_per_block)
 				dev->checkpt_cur_block = -1;
 
 		}
@@ -435,7 +435,7 @@ int yaffs2_checkpt_rd(struct yaffs_dev *dev, void *data, int n_bytes)
 
 int yaffs_checkpt_close(struct yaffs_dev *dev)
 {
-	int i;
+	u32 i;
 
 	if (dev->checkpt_open_write) {
 		if (dev->checkpt_byte_offs !=
@@ -448,8 +448,8 @@ int yaffs_checkpt_close(struct yaffs_dev *dev)
 			int blk = dev->checkpt_block_list[i];
 			struct yaffs_block_info *bi = NULL;
 
-			if (dev->internal_start_block <= blk &&
-			    blk <= dev->internal_end_block)
+			if ((int)dev->internal_start_block <= blk &&
+			    blk <= (int)dev->internal_end_block)
 				bi = yaffs_get_block_info(dev, blk);
 			if (bi && bi->block_state == YAFFS_BLOCK_STATE_EMPTY)
 				bi->block_state = YAFFS_BLOCK_STATE_CHECKPOINT;
diff --git a/yaffs_endian.c b/yaffs_endian.c
index 0bc67fe..8c291ad 100644
--- a/yaffs_endian.c
+++ b/yaffs_endian.c
@@ -37,7 +37,7 @@ void yaffs_do_endian_oh(struct yaffs_dev *dev, struct yaffs_obj_hdr *oh)
 		return;
 	/* Change every field */
 	oh->type = swap_u32(oh->type);
-	oh->parent_obj_id = swap_s32(oh->parent_obj_id);
+	oh->parent_obj_id = swap_u32(oh->parent_obj_id);
 
 	oh->yst_mode = swap_u32(oh->yst_mode);
 
diff --git a/yaffs_getblockinfo.h b/yaffs_getblockinfo.h
index 8fd0802..09b5a16 100644
--- a/yaffs_getblockinfo.h
+++ b/yaffs_getblockinfo.h
@@ -23,7 +23,8 @@
 static inline struct yaffs_block_info *yaffs_get_block_info(struct yaffs_dev
 							      *dev, int blk)
 {
-	if (blk < dev->internal_start_block || blk > dev->internal_end_block) {
+	if (blk < (int)dev->internal_start_block ||
+	    blk > (int)dev->internal_end_block) {
 		yaffs_trace(YAFFS_TRACE_ERROR,
 			"**>> yaffs: get_block_info block %d is not valid",
 			blk);
diff --git a/yaffs_guts.c b/yaffs_guts.c
index 72555d5..e95d870 100644
--- a/yaffs_guts.c
+++ b/yaffs_guts.c
@@ -303,7 +303,8 @@ static int yaffs_check_chunk_erased(struct yaffs_dev *dev, int nand_chunk)
 
 	result = yaffs_rd_chunk_tags_nand(dev, nand_chunk, data, &tags);
 
-	if (tags.ecc_result > YAFFS_ECC_RESULT_NO_ERROR)
+	if (result == YAFFS_FAIL ||
+	    tags.ecc_result > YAFFS_ECC_RESULT_NO_ERROR)
 		retval = YAFFS_FAIL;
 
 	if (!yaffs_check_ff(data, dev->data_bytes_per_chunk) ||
@@ -330,7 +331,8 @@ static int yaffs_verify_chunk_written(struct yaffs_dev *dev,
 	int result;
 
 	result = yaffs_rd_chunk_tags_nand(dev, nand_chunk, buffer, &temp_tags);
-	if (memcmp(buffer, data, dev->data_bytes_per_chunk) ||
+	if (result == YAFFS_FAIL ||
+	    memcmp(buffer, data, dev->data_bytes_per_chunk) ||
 	    temp_tags.obj_id != tags->obj_id ||
 	    temp_tags.chunk_id != tags->chunk_id ||
 	    temp_tags.n_bytes != tags->n_bytes)
@@ -358,7 +360,7 @@ int yaffs_check_alloc_available(struct yaffs_dev *dev, int n_chunks)
 
 static int yaffs_find_alloc_block(struct yaffs_dev *dev)
 {
-	int i;
+	u32 i;
 	struct yaffs_block_info *bi;
 
 	if (dev->n_erased_blocks < 1) {
@@ -375,8 +377,8 @@ static int yaffs_find_alloc_block(struct yaffs_dev *dev)
 
 	for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) {
 		dev->alloc_block_finder++;
-		if (dev->alloc_block_finder < dev->internal_start_block
-		    || dev->alloc_block_finder > dev->internal_end_block) {
+		if (dev->alloc_block_finder < (int)dev->internal_start_block
+		    || dev->alloc_block_finder > (int)dev->internal_end_block) {
 			dev->alloc_block_finder = dev->internal_start_block;
 		}
 
@@ -419,7 +421,7 @@ static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver,
 		return -1;
 	}
 
-	if (dev->n_erased_blocks < dev->param.n_reserved_blocks
+	if (dev->n_erased_blocks < (int)dev->param.n_reserved_blocks
 	    && dev->alloc_page == 0)
 		yaffs_trace(YAFFS_TRACE_ALLOCATE, "Allocating reserve");
 
@@ -488,7 +490,7 @@ static int yaffs_write_new_chunk(struct yaffs_dev *dev,
 				 const u8 *data,
 				 struct yaffs_ext_tags *tags, int use_reserver)
 {
-	int attempts = 0;
+	u32 attempts = 0;
 	int write_ok = 0;
 	int chunk;
 
@@ -569,7 +571,7 @@ static int yaffs_write_new_chunk(struct yaffs_dev *dev,
 		yaffs_handle_chunk_wr_ok(dev, chunk, data, tags);
 
 	} while (write_ok != YAFFS_OK &&
-		 (yaffs_wr_attempts <= 0 || attempts <= yaffs_wr_attempts));
+		 (yaffs_wr_attempts == 0 || attempts <= yaffs_wr_attempts));
 
 	if (!write_ok)
 		chunk = -1;
@@ -1019,8 +1021,8 @@ struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev,
 static int yaffs_tags_match(const struct yaffs_ext_tags *tags, int obj_id,
 			    int chunk_obj)
 {
-	return (tags->chunk_id == chunk_obj &&
-		tags->obj_id == obj_id &&
+	return (tags->chunk_id == (u32)chunk_obj &&
+		tags->obj_id == (u32)obj_id &&
 		!tags->is_deleted) ? 1 : 0;
 
 }
@@ -1520,7 +1522,7 @@ void yaffs_flush_whole_cache(struct yaffs_dev *dev, int discard)
  */
 static struct yaffs_cache *yaffs_grab_chunk_worker(struct yaffs_dev *dev)
 {
-	int i;
+	u32 i;
 
 	if (dev->param.n_caches > 0) {
 		for (i = 0; i < dev->param.n_caches; i++) {
@@ -1536,7 +1538,7 @@ static struct yaffs_cache *yaffs_grab_chunk_cache(struct yaffs_dev *dev)
 {
 	struct yaffs_cache *cache;
 	int usage;
-	int i;
+	u32 i;
 
 	if (dev->param.n_caches < 1)
 		return NULL;
@@ -1580,7 +1582,7 @@ static struct yaffs_cache *yaffs_find_chunk_cache(const struct yaffs_obj *obj,
 						  int chunk_id)
 {
 	struct yaffs_dev *dev = obj->my_dev;
-	int i;
+	u32 i;
 
 	if (dev->param.n_caches < 1)
 		return NULL;
@@ -1600,7 +1602,7 @@ static struct yaffs_cache *yaffs_find_chunk_cache(const struct yaffs_obj *obj,
 static void yaffs_use_cache(struct yaffs_dev *dev, struct yaffs_cache *cache,
 			    int is_write)
 {
-	int i;
+	u32 i;
 
 	if (dev->param.n_caches < 1)
 		return;
@@ -1641,7 +1643,7 @@ static void yaffs_invalidate_chunk_cache(struct yaffs_obj *object, int chunk_id)
  */
 static void yaffs_invalidate_whole_cache(struct yaffs_obj *in)
 {
-	int i;
+	u32 i;
 	struct yaffs_dev *dev = in->my_dev;
 
 	if (dev->param.n_caches > 0) {
@@ -2364,7 +2366,7 @@ void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no)
 {
 	struct yaffs_block_info *bi = yaffs_get_block_info(dev, block_no);
 	int erased_ok = 0;
-	int i;
+	u32 i;
 
 	/* If the block is still healthy erase it and mark as clean.
 	 * If the block has had a data failure, then retire it.
@@ -2380,12 +2382,12 @@ void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no)
 	bi->block_state = YAFFS_BLOCK_STATE_DIRTY;
 
 	/* If this is the block being garbage collected then stop gc'ing */
-	if (block_no == dev->gc_block)
+	if (block_no == (int)dev->gc_block)
 		dev->gc_block = 0;
 
 	/* If this block is currently the best candidate for gc
 	 * then drop as a candidate */
-	if (block_no == dev->gc_dirtiest) {
+	if (block_no == (int)dev->gc_dirtiest) {
 		dev->gc_dirtiest = 0;
 		dev->gc_pages_in_use = 0;
 	}
@@ -2589,7 +2591,7 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block)
 {
 	int old_chunk;
 	int ret_val = YAFFS_OK;
-	int i;
+	u32 i;
 	int is_checkpt_block;
 	int max_copies;
 	int chunks_before = yaffs_get_erased_chunks(dev);
@@ -2694,13 +2696,13 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block)
 static unsigned yaffs_find_gc_block(struct yaffs_dev *dev,
 				    int aggressive, int background)
 {
-	int i;
-	int iterations;
-	unsigned selected = 0;
+	u32 i;
+	u32 iterations;
+	u32 selected = 0;
 	int prioritised = 0;
 	int prioritised_exist = 0;
 	struct yaffs_block_info *bi;
-	int threshold;
+	u32 threshold;
 
 	/* First let's see if we need to grab a prioritised block */
 	if (dev->has_pending_prioritised_gc && !aggressive) {
@@ -2741,14 +2743,14 @@ static unsigned yaffs_find_gc_block(struct yaffs_dev *dev,
 	 */
 
 	if (!selected) {
-		int pages_used;
+		u32 pages_used;
 		int n_blocks =
 		    dev->internal_end_block - dev->internal_start_block + 1;
 		if (aggressive) {
 			threshold = dev->param.chunks_per_block;
 			iterations = n_blocks;
 		} else {
-			int max_threshold;
+			u32 max_threshold;
 
 			if (background)
 				max_threshold = dev->param.chunks_per_block / 2;
@@ -2934,14 +2936,14 @@ static int yaffs_check_gc(struct yaffs_dev *dev, int background)
 			gc_ok = yaffs_gc_block(dev, dev->gc_block, aggressive);
 		}
 
-		if (dev->n_erased_blocks < (dev->param.n_reserved_blocks) &&
+		if (dev->n_erased_blocks < (int)dev->param.n_reserved_blocks &&
 		    dev->gc_block > 0) {
 			yaffs_trace(YAFFS_TRACE_GC,
 				"yaffs: GC !!!no reclaim!!! n_erased_blocks %d after try %d block %d",
 				dev->n_erased_blocks, max_tries,
 				dev->gc_block);
 		}
-	} while ((dev->n_erased_blocks < dev->param.n_reserved_blocks) &&
+	} while ((dev->n_erased_blocks < (int)dev->param.n_reserved_blocks) &&
 		 (dev->gc_block > 0) && (max_tries < 2));
 
 	return aggressive ? gc_ok : YAFFS_OK;
@@ -3075,7 +3077,7 @@ static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk,
 	    (prev_chunk_id > 0) ? prev_tags.serial_number + 1 : 1;
 	new_tags.n_bytes = n_bytes;
 
-	if (n_bytes < 1 || n_bytes > dev->data_bytes_per_chunk) {
+	if (n_bytes < 1 || n_bytes > (int)dev->data_bytes_per_chunk) {
 		yaffs_trace(YAFFS_TRACE_ERROR,
 		  "Writing %d bytes to chunk!!!!!!!!!",
 		   n_bytes);
@@ -3235,30 +3237,30 @@ static void yaffs_check_obj_details_loaded(struct yaffs_obj *in)
 	struct yaffs_dev *dev;
 	struct yaffs_ext_tags tags;
 	int result;
-	int alloc_failed = 0;
 
 	if (!in || !in->lazy_loaded || in->hdr_chunk < 1)
 		return;
 
 	dev = in->my_dev;
-	in->lazy_loaded = 0;
 	buf = yaffs_get_temp_buffer(dev);
 
 	result = yaffs_rd_chunk_tags_nand(dev, in->hdr_chunk, buf, &tags);
+
+	if (result == YAFFS_FAIL)
+		return;
+
 	oh = (struct yaffs_obj_hdr *)buf;
 
 	yaffs_do_endian_oh(dev, oh);
 
+	in->lazy_loaded = 0;
 	in->yst_mode = oh->yst_mode;
 	yaffs_load_attribs(in, oh);
 	yaffs_set_obj_name_from_oh(in, oh);
 
-	if (in->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) {
+	if (in->variant_type == YAFFS_OBJECT_TYPE_SYMLINK)
 		in->variant.symlink_variant.alias =
 		    yaffs_clone_str(oh->alias);
-		if (!in->variant.symlink_variant.alias)
-			alloc_failed = 1;	/* Not returned */
-	}
 	yaffs_release_temp_buffer(dev, buf);
 }
 
@@ -3311,15 +3313,16 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
 		/* Access the old obj header just to read the name. */
 		result = yaffs_rd_chunk_tags_nand(dev, prev_chunk_id,
 						  buffer, &old_tags);
-
-		yaffs_verify_oh(in, oh, &old_tags, 0);
-		memcpy(old_name, oh->name, sizeof(oh->name));
-
-		/*
-		 * NB We only wipe the object header area because the rest of
-		 * the buffer might contain xattribs.
-		 */
-		memset(oh, 0xff, sizeof(*oh));
+		if (result == YAFFS_OK) {
+			yaffs_verify_oh(in, oh, &old_tags, 0);
+			memcpy(old_name, oh->name, sizeof(oh->name));
+
+			/*
+			* NB We only wipe the object header area because the rest of
+			* the buffer might contain xattribs.
+			*/
+			memset(oh, 0xff, sizeof(*oh));
+		}
 	} else {
 		memset(buffer, 0xff, dev->data_bytes_per_chunk);
 	}
@@ -3471,7 +3474,7 @@ int yaffs_file_rd(struct yaffs_obj *in, u8 * buffer, loff_t offset, int n_bytes)
 		 * a whole chunk or we're using inband tags then use the cache
 		 * (if there is caching) else bypass the cache.
 		 */
-		if (cache || n_copy != dev->data_bytes_per_chunk ||
+		if (cache || n_copy != (int)dev->data_bytes_per_chunk ||
 		    dev->param.inband_tags) {
 			if (dev->param.n_caches > 0) {
 
@@ -3546,7 +3549,7 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
 		    start >= dev->data_bytes_per_chunk) {
 			yaffs_trace(YAFFS_TRACE_ERROR,
 				"AddrToChunk of offset %lld gives chunk %d start %d",
-				offset, chunk, start);
+				(long  long)offset, chunk, start);
 		}
 		chunk++;	/* File pos to chunk in file offset */
 
@@ -3581,7 +3584,7 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
 			     (start + n)) ? n_bytes_read : (start + n);
 
 			if (n_writeback < 0 ||
-			    n_writeback > dev->data_bytes_per_chunk)
+			    n_writeback > (int)dev->data_bytes_per_chunk)
 				BUG();
 
 		} else {
@@ -3589,7 +3592,7 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
 			n_writeback = dev->data_bytes_per_chunk;
 		}
 
-		if (n_copy != dev->data_bytes_per_chunk ||
+		if (n_copy != (int)dev->data_bytes_per_chunk ||
 		    !dev->param.cache_bypass_aligned ||
 		    dev->param.inband_tags) {
 			/* An incomplete start or end chunk (or maybe both
@@ -3737,9 +3740,9 @@ static void yaffs_prune_chunks(struct yaffs_obj *in, loff_t new_size)
 		if (chunk_id < 1)
 			continue;
 
-		if (chunk_id <
+		if ((u32)chunk_id <
 		    (dev->internal_start_block * dev->param.chunks_per_block) ||
-		    chunk_id >=
+		    (u32)chunk_id >=
 		    ((dev->internal_end_block + 1) *
 		      dev->param.chunks_per_block)) {
 			yaffs_trace(YAFFS_TRACE_ALWAYS,
@@ -4535,7 +4538,8 @@ int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR *name, int buffer_size)
 							  obj->hdr_chunk,
 							  buffer, NULL);
 		}
-		yaffs_load_name_from_oh(obj->my_dev, name, oh->name,
+		if (result == YAFFS_OK)
+			yaffs_load_name_from_oh(obj->my_dev, name, oh->name,
 					buffer_size);
 
 		yaffs_release_temp_buffer(obj->my_dev, buffer);
@@ -4779,7 +4783,7 @@ int yaffs_guts_ll_init(struct yaffs_dev *dev)
 
 int yaffs_guts_format_dev(struct yaffs_dev *dev)
 {
-	int i;
+	u32 i;
 	enum yaffs_block_state state;
 	u32 dummy;
 
@@ -4802,8 +4806,8 @@ int yaffs_guts_format_dev(struct yaffs_dev *dev)
 int yaffs_guts_initialise(struct yaffs_dev *dev)
 {
 	int init_failed = 0;
-	unsigned x;
-	int bits;
+	u32 x;
+	u32 bits;
 
 	if(yaffs_guts_ll_init(dev) != YAFFS_OK)
 		return YAFFS_FAIL;
@@ -4915,9 +4919,9 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
 	dev->gc_cleanup_list = NULL;
 
 	if (!init_failed && dev->param.n_caches > 0) {
-		int i;
+		u32 i;
 		void *buf;
-		int cache_bytes =
+		u32 cache_bytes =
 		    dev->param.n_caches * sizeof(struct yaffs_cache);
 
 		if (dev->param.n_caches > YAFFS_MAX_SHORT_OP_CACHES)
@@ -5050,7 +5054,7 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
 void yaffs_deinitialise(struct yaffs_dev *dev)
 {
 	if (dev->is_mounted) {
-		int i;
+		u32 i;
 
 		yaffs_deinit_blocks(dev);
 		yaffs_deinit_tnodes_and_objs(dev);
@@ -5088,7 +5092,7 @@ void yaffs_deinitialise(struct yaffs_dev *dev)
 int yaffs_count_free_chunks(struct yaffs_dev *dev)
 {
 	int n_free = 0;
-	int b;
+	u32 b;
 	struct yaffs_block_info *blk;
 
 	blk = dev->block_info;
@@ -5116,7 +5120,7 @@ int yaffs_get_n_free_chunks(struct yaffs_dev *dev)
 	int n_free;
 	int n_dirty_caches;
 	int blocks_for_checkpt;
-	int i;
+	u32 i;
 
 	n_free = dev->n_free_chunks;
 	n_free += dev->n_deleted_files;
@@ -5193,7 +5197,7 @@ loff_t yaffs_oh_to_size(struct yaffs_dev *dev, struct yaffs_obj_hdr *oh,
 
 void yaffs_count_blocks_by_state(struct yaffs_dev *dev, int bs[10])
 {
-	int i;
+	u32 i;
 	struct yaffs_block_info *bi;
 	int s;
 
diff --git a/yaffs_guts.h b/yaffs_guts.h
index c7e201c..6bcf12d 100644
--- a/yaffs_guts.h
+++ b/yaffs_guts.h
@@ -324,7 +324,7 @@ struct yaffs_obj_hdr {
 	u32 type;  /* enum yaffs_obj_type  */
 
 	/* Apply to everything  */
-	int parent_obj_id;
+	u32 parent_obj_id;
 	u16 sum_no_longer_used;	/* checksum of name. No longer used */
 	YCHAR name[YAFFS_MAX_NAME_LENGTH + 1];
 
@@ -527,14 +527,14 @@ struct yaffs_param {
 	int inband_tags;	/* Use unband tags */
 	u32 total_bytes_per_chunk;	/* Should be >= 512, does not need to
 					 be a power of 2 */
-	int chunks_per_block;	/* does not need to be a power of 2 */
-	int spare_bytes_per_chunk;	/* spare area size */
-	int start_block;	/* Start block we're allowed to use */
-	int end_block;		/* End block we're allowed to use */
-	int n_reserved_blocks;	/* Tuneable so that we can reduce
+	u32 chunks_per_block;	/* does not need to be a power of 2 */
+	u32 spare_bytes_per_chunk;	/* spare area size */
+	u32 start_block;	/* Start block we're allowed to use */
+	u32 end_block;		/* End block we're allowed to use */
+	u32 n_reserved_blocks;	/* Tuneable so that we can reduce
 				 * reserved blocks on NOR and RAM. */
 
-	int n_caches;		/* If <= 0, then short op caching is disabled,
+	u32 n_caches;		/* If == 0, then short op caching is disabled,
 				 * else the number of short op caches.
 				 */
 	int cache_bypass_aligned; /* If non-zero then bypass the cache for
@@ -644,7 +644,7 @@ struct yaffs_dev {
 
 	int ll_init;
 	/* Runtime parameters. Set up by YAFFS. */
-	int data_bytes_per_chunk;
+	u32 data_bytes_per_chunk;
 
 	/* Non-wide tnode stuff */
 	u16 chunk_grp_bits;	/* Number of bits that need to be resolved if
@@ -670,8 +670,8 @@ struct yaffs_dev {
 	int swap_endian;	/* Stored endian needs endian swap. */
 
 	/* Stuff to support block offsetting to support start block zero */
-	int internal_start_block;
-	int internal_end_block;
+	u32 internal_start_block;
+	u32 internal_end_block;
 	int block_offset;
 	int chunk_offset;
 
@@ -681,12 +681,12 @@ struct yaffs_dev {
 	int checkpt_byte_offs;
 	u8 *checkpt_buffer;
 	int checkpt_open_write;
-	int blocks_in_checkpt;
+	u32 blocks_in_checkpt;
 	int checkpt_cur_chunk;
 	int checkpt_cur_block;
 	int checkpt_next_block;
 	int *checkpt_block_list;
-	int checkpt_max_blocks;
+	u32 checkpt_max_blocks;
 	u32 checkpt_sum;
 	u32 checkpt_xor;
 
@@ -892,6 +892,8 @@ int yaffs_get_n_free_chunks(struct yaffs_dev *dev);
 int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR * old_name,
 		     struct yaffs_obj *new_dir, const YCHAR * new_name);
 
+int yaffs_unlink_obj(struct yaffs_obj *obj);
+
 int yaffs_unlinker(struct yaffs_obj *dir, const YCHAR * name);
 int yaffs_del_obj(struct yaffs_obj *obj);
 struct yaffs_obj *yaffs_retype_obj(struct yaffs_obj *obj,
diff --git a/yaffs_nameval.c b/yaffs_nameval.c
index 478248e..eeb75be 100644
--- a/yaffs_nameval.c
+++ b/yaffs_nameval.c
@@ -28,6 +28,7 @@
 #include "yaffs_nameval.h"
 #include "yaffs_guts.h"
 #include "yportenv.h"
+#include "yaffs_endian.h"
 
 static int nval_find(struct yaffs_dev *dev,
 		     const char *xb, int xb_size, const YCHAR *name,
@@ -47,7 +48,7 @@ static int nval_find(struct yaffs_dev *dev,
 			return pos;
 		}
 		pos += size;
-		if (pos < xb_size - sizeof(size)) {
+		if (pos < (int)(xb_size - sizeof(size))) {
 			memcpy(&size, xb + pos, sizeof(size));
 			yaffs_do_endian_s32(dev, &size);
 
@@ -69,7 +70,7 @@ static int nval_used(struct yaffs_dev *dev, const char *xb, int xb_size)
 
 	while (size > 0 && (size < xb_size) && (pos + size < xb_size)) {
 		pos += size;
-		if (pos < xb_size - sizeof(size)) {
+		if (pos < (int)(xb_size - sizeof(size))) {
 			memcpy(&size, xb + pos, sizeof(size));
 			yaffs_do_endian_s32(dev, &size);
 		} else
@@ -192,7 +193,7 @@ int nval_list(struct yaffs_dev *dev, const char *xb, int xb_size, char *buf, int
 	memcpy(&size, xb + pos, sizeof(size));
 	yaffs_do_endian_s32(dev, &size);
 
-	while (size > sizeof(size) &&
+	while (size > (int)(sizeof(size)) &&
 		size <= xb_size &&
 		(pos + size) < xb_size &&
 		!filled) {
@@ -213,7 +214,7 @@ int nval_list(struct yaffs_dev *dev, const char *xb, int xb_size, char *buf, int
 			filled = 1;
 		}
 		pos += size;
-		if (pos < xb_size - sizeof(size)) {
+		if (pos < (int)(xb_size - sizeof(size))) {
 			memcpy(&size, xb + pos, sizeof(size));
 			yaffs_do_endian_s32(dev, &size);
 		}
diff --git a/yaffs_summary.c b/yaffs_summary.c
index 0250963..1e7776b 100644
--- a/yaffs_summary.c
+++ b/yaffs_summary.c
@@ -183,7 +183,7 @@ int yaffs_summary_read(struct yaffs_dev *dev,
 	u8 *buffer;
 	u8 *sum_buffer = (u8 *)st;
 	int n_bytes;
-	int chunk_id;
+	u32 chunk_id;
 	int chunk_in_nand;
 	int chunk_in_block;
 	int result;
@@ -191,10 +191,7 @@ int yaffs_summary_read(struct yaffs_dev *dev,
 	struct yaffs_summary_header hdr;
 	struct yaffs_block_info *bi = yaffs_get_block_info(dev, blk);
 	int sum_bytes_per_chunk = dev->data_bytes_per_chunk - sizeof(hdr);
-	int sum_tags_bytes;
 
-	sum_tags_bytes = sizeof(struct yaffs_summary_tags) *
-				dev->chunks_per_summary;
 	buffer = yaffs_get_temp_buffer(dev);
 	n_bytes = sizeof(struct yaffs_summary_tags) * dev->chunks_per_summary;
 	chunk_in_block = dev->chunks_per_summary;
@@ -296,7 +293,7 @@ int yaffs_summary_fetch(struct yaffs_dev *dev,
 void yaffs_summary_gc(struct yaffs_dev *dev, int blk)
 {
 	struct yaffs_block_info *bi = yaffs_get_block_info(dev, blk);
-	int i;
+	u32 i;
 
 	if (!bi->has_summary)
 		return;
diff --git a/yaffs_tagsmarshall.c b/yaffs_tagsmarshall.c
index c2e2369..4a120d8 100644
--- a/yaffs_tagsmarshall.c
+++ b/yaffs_tagsmarshall.c
@@ -101,6 +101,9 @@ static int yaffs_tags_marshall_read(struct yaffs_dev *dev,
 		BUG();
 
 
+	if (retval == YAFFS_FAIL)
+		return YAFFS_FAIL;
+
 	if (dev->param.inband_tags) {
 		if (tags) {
 			struct yaffs_packed_tags2_tags_only *pt2tp;
@@ -122,7 +125,7 @@ static int yaffs_tags_marshall_read(struct yaffs_dev *dev,
 		dev->n_ecc_unfixed++;
 	}
 
-	if (tags && ecc_result == -YAFFS_ECC_RESULT_FIXED) {
+	if (tags && ecc_result == YAFFS_ECC_RESULT_FIXED) {
 		if (tags->ecc_result <= YAFFS_ECC_RESULT_NO_ERROR)
 			tags->ecc_result = YAFFS_ECC_RESULT_FIXED;
 		dev->n_ecc_fixed++;
diff --git a/yaffs_verify.c b/yaffs_verify.c
index 4a2f5c3..7a341a2 100644
--- a/yaffs_verify.c
+++ b/yaffs_verify.c
@@ -77,10 +77,10 @@ void yaffs_verify_blk(struct yaffs_dev *dev, struct yaffs_block_info *bi, int n)
 	actually_used = bi->pages_in_use - bi->soft_del_pages;
 
 	if (bi->pages_in_use < 0 ||
-	    bi->pages_in_use > dev->param.chunks_per_block ||
+	    bi->pages_in_use > (int)dev->param.chunks_per_block ||
 	    bi->soft_del_pages < 0 ||
-	    bi->soft_del_pages > dev->param.chunks_per_block ||
-	    actually_used < 0 || actually_used > dev->param.chunks_per_block)
+	    bi->soft_del_pages > (int)dev->param.chunks_per_block ||
+	    actually_used < 0 || actually_used > (int)dev->param.chunks_per_block)
 		yaffs_trace(YAFFS_TRACE_VERIFY,
 			"Block %d has illegal values pages_in_used %d soft_del_pages %d",
 			n, bi->pages_in_use, bi->soft_del_pages);
@@ -110,8 +110,8 @@ void yaffs_verify_collected_blk(struct yaffs_dev *dev,
 
 void yaffs_verify_blocks(struct yaffs_dev *dev)
 {
-	int i;
-	int state_count[YAFFS_NUMBER_OF_BLOCK_STATES];
+	u32 i;
+	u32 state_count[YAFFS_NUMBER_OF_BLOCK_STATES];
 	int illegal_states = 0;
 
 	if (yaffs_skip_verification(dev))
@@ -149,7 +149,7 @@ void yaffs_verify_blocks(struct yaffs_dev *dev)
 			dev->blocks_in_checkpt,
 			state_count[YAFFS_BLOCK_STATE_CHECKPOINT]);
 
-	if (dev->n_erased_blocks != state_count[YAFFS_BLOCK_STATE_EMPTY])
+	if (dev->n_erased_blocks != (int)state_count[YAFFS_BLOCK_STATE_EMPTY])
 		yaffs_trace(YAFFS_TRACE_VERIFY,
 			"Erased block count wrong dev %d count %d",
 			dev->n_erased_blocks,
@@ -201,7 +201,7 @@ void yaffs_verify_oh(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh,
 			tags->obj_id, oh->parent_obj_id);
 
 	if (parent_check && obj->parent &&
-	    oh->parent_obj_id != obj->parent->obj_id &&
+	    oh->parent_obj_id !=  obj->parent->obj_id &&
 	    (oh->parent_obj_id != YAFFS_OBJECTID_UNLINKED ||
 	     obj->parent->obj_id != YAFFS_OBJECTID_DELETED))
 		yaffs_trace(YAFFS_TRACE_VERIFY,
@@ -224,12 +224,11 @@ void yaffs_verify_file(struct yaffs_obj *obj)
 {
 	u32 x;
 	int required_depth;
-	int actual_depth;
 	int last_chunk;
 	u32 offset_in_chunk;
 	u32 the_chunk;
 
-	u32 i;
+	int i;
 	struct yaffs_dev *dev;
 	struct yaffs_ext_tags tags;
 	struct yaffs_tnode *tn;
@@ -256,8 +255,6 @@ void yaffs_verify_file(struct yaffs_obj *obj)
 		required_depth++;
 	}
 
-	actual_depth = obj->variant.file_variant.top_level;
-
 	/* Check that the chunks in the tnode tree are all correct.
 	 * We do this by scanning through the tnode tree and
 	 * checking the tags for every chunk match.
@@ -276,7 +273,7 @@ void yaffs_verify_file(struct yaffs_obj *obj)
 		if (the_chunk > 0) {
 			yaffs_rd_chunk_tags_nand(dev, the_chunk, NULL,
 						 &tags);
-			if (tags.obj_id != obj_id || tags.chunk_id != i)
+			if (tags.obj_id != obj_id || tags.chunk_id != (u32)i)
 				yaffs_trace(YAFFS_TRACE_VERIFY,
 					"Object %d chunk_id %d NAND mismatch chunk %d tags (%d:%d)",
 					obj_id, i, the_chunk,
diff --git a/yaffs_yaffs1.c b/yaffs_yaffs1.c
index e98d04d..0cdc8c8 100644
--- a/yaffs_yaffs1.c
+++ b/yaffs_yaffs1.c
@@ -22,10 +22,10 @@
 int yaffs1_scan(struct yaffs_dev *dev)
 {
 	struct yaffs_ext_tags tags;
-	int blk;
+	u32 blk;
 	int result;
 	int chunk;
-	int c;
+	u32 c;
 	int deleted;
 	enum yaffs_block_state state;
 	LIST_HEAD(hard_list);
@@ -98,6 +98,8 @@ int yaffs1_scan(struct yaffs_dev *dev)
 			result = yaffs_rd_chunk_tags_nand(dev, chunk, NULL,
 							  &tags);
 
+			if (result != YAFFS_OK)
+				continue;
 			/* Let's have a good look at this chunk... */
 
 			if (tags.ecc_result == YAFFS_ECC_RESULT_UNFIXED ||
diff --git a/yaffs_yaffs2.c b/yaffs_yaffs2.c
index 6d46817..47fa8eb 100644
--- a/yaffs_yaffs2.c
+++ b/yaffs_yaffs2.c
@@ -42,7 +42,7 @@
  */
 void yaffs_calc_oldest_dirty_seq(struct yaffs_dev *dev)
 {
-	int i;
+	u32 i;
 	unsigned seq;
 	unsigned block_no = 0;
 	struct yaffs_block_info *b;
@@ -55,7 +55,7 @@ void yaffs_calc_oldest_dirty_seq(struct yaffs_dev *dev)
 	b = dev->block_info;
 	for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) {
 		if (b->block_state == YAFFS_BLOCK_STATE_FULL &&
-		    (b->pages_in_use - b->soft_del_pages) <
+		    (u32)(b->pages_in_use - b->soft_del_pages) <
 		    dev->param.chunks_per_block &&
 		    b->seq_number < seq) {
 			seq = b->seq_number;
@@ -345,7 +345,7 @@ static int yaffs2_wr_checkpt_dev(struct yaffs_dev *dev)
 	u32 n_bytes;
 	u32 n_blocks = dev->internal_end_block - dev->internal_start_block + 1;
 	int ok;
-	int i;
+	u32 i;
 	union yaffs_block_info_union bu;
 
 	/* Write device runtime values */
@@ -359,7 +359,8 @@ static int yaffs2_wr_checkpt_dev(struct yaffs_dev *dev)
 	/* Write block info. */
 	if (!dev->swap_endian) {
 		n_bytes = n_blocks * sizeof(struct yaffs_block_info);
-		ok = (yaffs2_checkpt_wr(dev, dev->block_info, n_bytes) == n_bytes);
+		ok = (yaffs2_checkpt_wr(dev, dev->block_info, n_bytes) ==
+			(int)n_bytes);
 	} else {
 		/*
 		 * Need to swap the endianisms. We can't do this in place
@@ -382,7 +383,8 @@ static int yaffs2_wr_checkpt_dev(struct yaffs_dev *dev)
 	 * no endian conversion is needed.
 	 */
 	n_bytes = n_blocks * dev->chunk_bit_stride;
-	ok = (yaffs2_checkpt_wr(dev, dev->chunk_bits, n_bytes) == n_bytes);
+	ok = (yaffs2_checkpt_wr(dev, dev->chunk_bits, n_bytes) ==
+		(int)n_bytes);
 
 	return ok ? 1 : 0;
 }
@@ -407,7 +409,8 @@ static int yaffs2_rd_checkpt_dev(struct yaffs_dev *dev)
 
 	n_bytes = n_blocks * sizeof(struct yaffs_block_info);
 
-	ok = (yaffs2_checkpt_rd(dev, dev->block_info, n_bytes) == n_bytes);
+	ok = (yaffs2_checkpt_rd(dev, dev->block_info, n_bytes) ==
+		(int)n_bytes);
 
 	if (!ok)
 		return 0;
@@ -424,7 +427,8 @@ static int yaffs2_rd_checkpt_dev(struct yaffs_dev *dev)
 
 	n_bytes = n_blocks * dev->chunk_bit_stride;
 
-	ok = (yaffs2_checkpt_rd(dev, dev->chunk_bits, n_bytes) == n_bytes);
+	ok = (yaffs2_checkpt_rd(dev, dev->chunk_bits, n_bytes) ==
+		(int)n_bytes);
 
 
 	return ok ? 1 : 0;
@@ -604,7 +608,7 @@ static int yaffs2_checkpt_tnode_worker(struct yaffs_obj *in,
 		 */
 		tn = yaffs2_do_endian_tnode_copy(dev, tn);
 		ok = (yaffs2_checkpt_wr(dev, tn, dev->tnode_size) ==
-			dev->tnode_size);
+			(int)dev->tnode_size);
 	}
 	return ok;
 }
@@ -649,7 +653,7 @@ static int yaffs2_rd_checkpt_tnodes(struct yaffs_obj *obj)
 		tn = yaffs_get_tnode(dev);
 		if (tn) {
 			ok = (yaffs2_checkpt_rd(dev, tn, dev->tnode_size) ==
-				dev->tnode_size);
+				(int)dev->tnode_size);
 			yaffs2_do_endian_tnode(dev, tn);
 		}
 		else
@@ -768,7 +772,7 @@ static int yaffs2_rd_checkpt_objs(struct yaffs_dev *dev)
 			cp.obj_id, cp.parent_id, cp_variant_type,
 			cp.hdr_chunk);
 
-		if (ok && cp.obj_id == ~0) {
+		if (ok && cp.obj_id == (u32)(~0)) {
 			done = 1;
 		} else if (ok) {
 			obj =
@@ -1050,7 +1054,7 @@ int yaffs2_handle_hole(struct yaffs_obj *obj, loff_t new_size)
 
 		while (increase > 0 && small_increase_ok) {
 			this_write = increase;
-			if (this_write > dev->data_bytes_per_chunk)
+			if (this_write > (int)dev->data_bytes_per_chunk)
 				this_write = dev->data_bytes_per_chunk;
 			written =
 			    yaffs_do_file_wr(obj, local_buffer, pos, this_write,
@@ -1136,6 +1140,9 @@ static inline int yaffs2_scan_chunk(struct yaffs_dev *dev,
 		dev->summary_used++;
 	}
 
+	if (result == YAFFS_FAIL)
+		yaffs_trace(YAFFS_TRACE_SCAN,
+				"Could not get tags for chunk %d\n", chunk);
 	/* Let's have a good look at this chunk... */
 
 	if (!tags.chunk_used) {
@@ -1334,7 +1341,7 @@ static inline int yaffs2_scan_chunk(struct yaffs_dev *dev,
 					yaffs_oh_to_size(dev, oh, 0) :
 					tags.extra_file_size;
 				u32 parent_obj_id = (oh) ?
-					oh->parent_obj_id :
+					(u32)oh->parent_obj_id :
 					tags.extra_parent_id;
 
 				is_shrink = (oh) ?
@@ -1517,7 +1524,7 @@ static inline int yaffs2_scan_chunk(struct yaffs_dev *dev,
 
 int yaffs2_scan_backwards(struct yaffs_dev *dev)
 {
-	int blk;
+	u32 blk;
 	int block_iter;
 	int start_iter;
 	int end_iter;
-- 
2.30.2