X-Git-Url: http://www.aleph1.co.uk/gitweb/?p=yaffs2.git;a=blobdiff_plain;f=yaffs_guts.c;h=df6cb001995f0cdc1d7364c9d5b51221dd274008;hp=c6d508c0c375ddd098b745ed5c1794080e7654ab;hb=d9cae0a277c62c660e4802d3b8745500583273da;hpb=9a20a1043042ed312c6d076ba2369d9138354702

diff --git a/yaffs_guts.c b/yaffs_guts.c
index c6d508c..df6cb00 100644
--- a/yaffs_guts.c
+++ b/yaffs_guts.c
@@ -27,6 +27,7 @@
 #include "yaffs_nameval.h"
 #include "yaffs_allocator.h"
 #include "yaffs_attribs.h"
+#include "yaffs_summary.h"
 
 /* Note YAFFS_GC_GOOD_ENOUGH must be <= YAFFS_GC_PASSIVE_THRESHOLD */
 #define YAFFS_GC_GOOD_ENOUGH 2
@@ -43,8 +44,8 @@ static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk,
 
 /* Function to calculate chunk and offset */
 
-static inline void yaffs_addr_to_chunk(struct yaffs_dev *dev, loff_t addr,
-					int *chunk_out, u32 *offset_out)
+void yaffs_addr_to_chunk(struct yaffs_dev *dev, loff_t addr,
+				int *chunk_out, u32 *offset_out)
 {
 	int chunk;
 	u32 offset;
@@ -127,44 +128,30 @@ static int yaffs_init_tmp_buffers(struct yaffs_dev *dev)
 	memset(dev->temp_buffer, 0, sizeof(dev->temp_buffer));
 
 	for (i = 0; buf && i < YAFFS_N_TEMP_BUFFERS; i++) {
-		dev->temp_buffer[i].line = 0;	/* not in use */
-		dev->temp_buffer[i].buffer = buf =
-		    kmalloc(dev->param.total_bytes_per_chunk, GFP_NOFS);
+		dev->temp_buffer[i].in_use = 0;
+		buf = kmalloc(dev->param.total_bytes_per_chunk, GFP_NOFS);
+		dev->temp_buffer[i].buffer = buf;
 	}
 
 	return buf ? YAFFS_OK : YAFFS_FAIL;
 }
 
-u8 *yaffs_get_temp_buffer(struct yaffs_dev * dev, int line_no)
+u8 *yaffs_get_temp_buffer(struct yaffs_dev * dev)
 {
 	int i;
-	int j;
 
 	dev->temp_in_use++;
 	if (dev->temp_in_use > dev->max_temp)
 		dev->max_temp = dev->temp_in_use;
 
 	for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
-		if (dev->temp_buffer[i].line == 0) {
-			dev->temp_buffer[i].line = line_no;
-			if ((i + 1) > dev->max_temp) {
-				dev->max_temp = i + 1;
-				for (j = 0; j <= i; j++)
-					dev->temp_buffer[j].max_line =
-					    dev->temp_buffer[j].line;
-			}
-
+		if (dev->temp_buffer[i].in_use == 0) {
+			dev->temp_buffer[i].in_use = 1;
 			return dev->temp_buffer[i].buffer;
 		}
 	}
 
-	yaffs_trace(YAFFS_TRACE_BUFFERS,
-		"Out of temp buffers at line %d, other held by lines:",
-		line_no);
-	for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++)
-		yaffs_trace(YAFFS_TRACE_BUFFERS,
-			" %d", dev->temp_buffer[i].line);
-
+	yaffs_trace(YAFFS_TRACE_BUFFERS, "Out of temp buffers");
 	/*
 	 * If we got here then we have to allocate an unmanaged one
 	 * This is not good.
@@ -175,7 +162,7 @@ u8 *yaffs_get_temp_buffer(struct yaffs_dev * dev, int line_no)
 
 }
 
-void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 *buffer, int line_no)
+void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 *buffer)
 {
 	int i;
 
@@ -183,7 +170,7 @@ void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 *buffer, int line_no)
 
 	for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
 		if (dev->temp_buffer[i].buffer == buffer) {
-			dev->temp_buffer[i].line = 0;
+			dev->temp_buffer[i].in_use = 0;
 			return;
 		}
 	}
@@ -191,8 +178,7 @@ void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 *buffer, int line_no)
 	if (buffer) {
 		/* assume it is an unmanaged one. */
 		yaffs_trace(YAFFS_TRACE_BUFFERS,
-		  "Releasing unmanaged temp buffer in line %d",
-		   line_no);
+			"Releasing unmanaged temp buffer");
 		kfree(buffer);
 		dev->unmanaged_buffer_deallocs++;
 	}
@@ -295,7 +281,8 @@ static void yaffs_handle_chunk_wr_error(struct yaffs_dev *dev, int nand_chunk,
 
 static inline int yaffs_hash_fn(int n)
 {
-	n = abs(n);
+	if (n < 0)
+		n = -n;
 	return n % YAFFS_NOBJECT_BUCKETS;
 }
 
@@ -332,7 +319,7 @@ int yaffs_check_ff(u8 *buffer, int n_bytes)
 static int yaffs_check_chunk_erased(struct yaffs_dev *dev, int nand_chunk)
 {
 	int retval = YAFFS_OK;
-	u8 *data = yaffs_get_temp_buffer(dev, __LINE__);
+	u8 *data = yaffs_get_temp_buffer(dev);
 	struct yaffs_ext_tags tags;
 	int result;
 
@@ -348,7 +335,7 @@ static int yaffs_check_chunk_erased(struct yaffs_dev *dev, int nand_chunk)
 		retval = YAFFS_FAIL;
 	}
 
-	yaffs_release_temp_buffer(dev, data, __LINE__);
+	yaffs_release_temp_buffer(dev, data);
 
 	return retval;
 
@@ -361,7 +348,7 @@ static int yaffs_verify_chunk_written(struct yaffs_dev *dev,
 {
 	int retval = YAFFS_OK;
 	struct yaffs_ext_tags temp_tags;
-	u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__);
+	u8 *buffer = yaffs_get_temp_buffer(dev);
 	int result;
 
 	result = yaffs_rd_chunk_tags_nand(dev, nand_chunk, buffer, &temp_tags);
@@ -371,7 +358,7 @@ static int yaffs_verify_chunk_written(struct yaffs_dev *dev,
 	    temp_tags.n_bytes != tags->n_bytes)
 		retval = YAFFS_FAIL;
 
-	yaffs_release_temp_buffer(dev, buffer, __LINE__);
+	yaffs_release_temp_buffer(dev, buffer);
 
 	return retval;
 }
@@ -613,7 +600,7 @@ static int yaffs_write_new_chunk(struct yaffs_dev *dev,
 		yaffs_trace(YAFFS_TRACE_ERROR,
 			"**>> yaffs write required %d attempts",
 			attempts);
-		dev->n_retired_writes += (attempts - 1);
+		dev->n_retried_writes += (attempts - 1);
 	}
 
 	return chunk;
@@ -641,7 +628,7 @@ static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block)
 			int chunk_id =
 			    flash_block * dev->param.chunks_per_block;
 
-			u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__);
+			u8 *buffer = yaffs_get_temp_buffer(dev);
 
 			memset(buffer, 0xff, dev->data_bytes_per_chunk);
 			memset(&tags, 0, sizeof(tags));
@@ -654,7 +641,7 @@ static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block)
 					"yaffs: Failed to write bad block marker to block %d",
 					flash_block);
 
-			yaffs_release_temp_buffer(dev, buffer, __LINE__);
+			yaffs_release_temp_buffer(dev, buffer);
 		}
 	}
 
@@ -687,7 +674,6 @@ static u16 yaffs_calc_name_sum(const YCHAR *name)
 
 void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR * name)
 {
-#ifndef CONFIG_YAFFS_NO_SHORT_NAMES
 	memset(obj->short_name, 0, sizeof(obj->short_name));
 	if (name &&
 		strnlen(name, YAFFS_SHORT_NAME_LENGTH + 1) <=
@@ -695,7 +681,6 @@ void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR * name)
 		strcpy(obj->short_name, name);
 	else
 		obj->short_name[0] = _Y('\0');
-#endif
 	obj->sum = yaffs_calc_name_sum(name);
 }
 
@@ -713,6 +698,11 @@ void yaffs_set_obj_name_from_oh(struct yaffs_obj *obj,
 #endif
 }
 
+loff_t yaffs_max_file_size(struct yaffs_dev *dev)
+{
+	return ((loff_t) YAFFS_MAX_CHUNK_ID) * dev->data_bytes_per_chunk;
+}
+
 /*-------------------- TNODES -------------------
 
  * List of spare tnodes
@@ -1970,7 +1960,8 @@ struct yaffs_obj *yaffs_new_obj(struct yaffs_dev *dev, int number,
 	case YAFFS_OBJECT_TYPE_FILE:
 		the_obj->variant.file_variant.file_size = 0;
 		the_obj->variant.file_variant.scanned_size = 0;
-		the_obj->variant.file_variant.shrink_size = ~0; /* max */
+		the_obj->variant.file_variant.shrink_size =
+						yaffs_max_file_size(dev);
 		the_obj->variant.file_variant.top_level = 0;
 		the_obj->variant.file_variant.top = tn;
 		break;
@@ -2398,6 +2389,8 @@ void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no)
 	bi->has_shrink_hdr = 0;
 	bi->skip_erased_check = 1;	/* Clean, so no need to check */
 	bi->gc_prioritise = 0;
+	bi->has_summary = 0;
+
 	yaffs_clear_chunk_bits(dev, block_no);
 
 	yaffs_trace(YAFFS_TRACE_ERASE, "Erased block %d", block_no);
@@ -2511,9 +2504,10 @@ static inline int yaffs_gc_process_chunk(struct yaffs_dev *dev,
 
 			/* Update file size */
 			if (object->variant_type == YAFFS_OBJECT_TYPE_FILE) {
-				oh->file_size =
+				yaffs_oh_size_load(oh,
+				    object->variant.file_variant.file_size);
+				tags.extra_file_size =
 				    object->variant.file_variant.file_size;
-				tags.extra_length = oh->file_size;
 			}
 
 			yaffs_verify_oh(object, oh, &tags, 1);
@@ -2573,6 +2567,8 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block)
 
 	dev->gc_disable = 1;
 
+	yaffs_summary_gc(dev, block);
+
 	if (is_checkpt_block || !yaffs_still_some_chunks(dev, block)) {
 		yaffs_trace(YAFFS_TRACE_TRACING,
 			"Collecting block %d that has no chunks in use",
@@ -2580,7 +2576,7 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block)
 		yaffs_block_became_dirty(dev, block);
 	} else {
 
-		u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__);
+		u8 *buffer = yaffs_get_temp_buffer(dev);
 
 		yaffs_verify_blk(dev, bi, block);
 
@@ -2600,7 +2596,7 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block)
 							old_chunk, buffer);
 			}
 		}
-		yaffs_release_temp_buffer(dev, buffer, __LINE__);
+		yaffs_release_temp_buffer(dev, buffer);
 	}
 
 	yaffs_verify_collected_blk(dev, bi, block);
@@ -3126,7 +3122,7 @@ static int yaffs_do_xattrib_fetch(struct yaffs_obj *obj, const YCHAR *name,
 			return 0;
 	}
 
-	buffer = (char *)yaffs_get_temp_buffer(dev, __LINE__);
+	buffer = (char *)yaffs_get_temp_buffer(dev);
 	if (!buffer)
 		return -ENOMEM;
 
@@ -3148,7 +3144,7 @@ static int yaffs_do_xattrib_fetch(struct yaffs_obj *obj, const YCHAR *name,
 		else
 			retval = nval_list(x_buffer, x_size, value, size);
 	}
-	yaffs_release_temp_buffer(dev, (u8 *) buffer, __LINE__);
+	yaffs_release_temp_buffer(dev, (u8 *) buffer);
 	return retval;
 }
 
@@ -3188,7 +3184,7 @@ static void yaffs_check_obj_details_loaded(struct yaffs_obj *in)
 
 	dev = in->my_dev;
 	in->lazy_loaded = 0;
-	buf = yaffs_get_temp_buffer(dev, __LINE__);
+	buf = yaffs_get_temp_buffer(dev);
 
 	result = yaffs_rd_chunk_tags_nand(dev, in->hdr_chunk, buf, &tags);
 	oh = (struct yaffs_obj_hdr *)buf;
@@ -3203,7 +3199,7 @@ static void yaffs_check_obj_details_loaded(struct yaffs_obj *in)
 		if (!in->variant.symlink_variant.alias)
 			alloc_failed = 1;	/* Not returned */
 	}
-	yaffs_release_temp_buffer(dev, buf, __LINE__);
+	yaffs_release_temp_buffer(dev, buf);
 }
 
 static void yaffs_load_name_from_oh(struct yaffs_dev *dev, YCHAR *name,
@@ -3227,6 +3223,7 @@ static void yaffs_load_name_from_oh(struct yaffs_dev *dev, YCHAR *name,
 		}
 	} else {
 #else
+	dev = dev;
 	{
 #endif
 		strncpy(name, oh_name, buff_size - 1);
@@ -3270,6 +3267,7 @@ static void yaffs_load_oh_from_name(struct yaffs_dev *dev, YCHAR *oh_name,
 		}
 	} else {
 #else
+	dev = dev;
 	{
 #endif
 		strncpy(oh_name, name, YAFFS_MAX_NAME_LENGTH - 1);
@@ -3295,6 +3293,7 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
 	u8 *buffer = NULL;
 	YCHAR old_name[YAFFS_MAX_NAME_LENGTH + 1];
 	struct yaffs_obj_hdr *oh = NULL;
+	loff_t file_size = 0;
 
 	strcpy(old_name, _Y("silly old name"));
 
@@ -3304,7 +3303,7 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
 	yaffs_check_gc(dev, 0);
 	yaffs_check_obj_details_loaded(in);
 
-	buffer = yaffs_get_temp_buffer(in->my_dev, __LINE__);
+	buffer = yaffs_get_temp_buffer(in->my_dev);
 	oh = (struct yaffs_obj_hdr *)buffer;
 
 	prev_chunk_id = in->hdr_chunk;
@@ -3347,10 +3346,10 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
 		/* Should not happen */
 		break;
 	case YAFFS_OBJECT_TYPE_FILE:
-		oh->file_size =
-		    (oh->parent_obj_id == YAFFS_OBJECTID_DELETED ||
-		     oh->parent_obj_id == YAFFS_OBJECTID_UNLINKED) ?
-		     0 : in->variant.file_variant.file_size;
+		if (oh->parent_obj_id != YAFFS_OBJECTID_DELETED &&
+		    oh->parent_obj_id != YAFFS_OBJECTID_UNLINKED)
+			file_size = in->variant.file_variant.file_size;
+		yaffs_oh_size_load(oh, file_size);
 		break;
 	case YAFFS_OBJECT_TYPE_HARDLINK:
 		oh->equiv_id = in->variant.hardlink_variant.equiv_id;
@@ -3384,7 +3383,7 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
 	/* Add extra info for file header */
 	new_tags.extra_available = 1;
 	new_tags.extra_parent_id = oh->parent_obj_id;
-	new_tags.extra_length = oh->file_size;
+	new_tags.extra_file_size = file_size;
 	new_tags.extra_is_shrink = oh->is_shrink;
 	new_tags.extra_equiv_id = oh->equiv_id;
 	new_tags.extra_shadows = (oh->shadows_obj > 0) ? 1 : 0;
@@ -3397,7 +3396,7 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
 				  (prev_chunk_id > 0) ? 1 : 0);
 
 	if (buffer)
-		yaffs_release_temp_buffer(dev, buffer, __LINE__);
+		yaffs_release_temp_buffer(dev, buffer);
 
 	if (new_chunk_id < 0)
 		return new_chunk_id;
@@ -3493,13 +3492,12 @@ int yaffs_file_rd(struct yaffs_obj *in, u8 * buffer, loff_t offset, int n_bytes)
 				/* Read into the local buffer then copy.. */
 
 				u8 *local_buffer =
-				    yaffs_get_temp_buffer(dev, __LINE__);
+				    yaffs_get_temp_buffer(dev);
 				yaffs_rd_data_obj(in, chunk, local_buffer);
 
 				memcpy(buffer, &local_buffer[start], n_copy);
 
-				yaffs_release_temp_buffer(dev, local_buffer,
-							  __LINE__);
+				yaffs_release_temp_buffer(dev, local_buffer);
 			}
 		} else {
 			/* A full chunk. Read directly into the buffer. */
@@ -3514,7 +3512,7 @@ int yaffs_file_rd(struct yaffs_obj *in, u8 * buffer, loff_t offset, int n_bytes)
 }
 
 int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
-		     int n_bytes, int write_trhrough)
+		     int n_bytes, int write_through)
 {
 
 	int chunk;
@@ -3523,10 +3521,10 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
 	int n = n_bytes;
 	int n_done = 0;
 	int n_writeback;
-	int start_write = offset;
+	loff_t start_write = offset;
 	int chunk_written = 0;
 	u32 n_bytes_read;
-	u32 chunk_start;
+	loff_t chunk_start;
 	struct yaffs_dev *dev;
 
 	dev = in->my_dev;
@@ -3534,11 +3532,12 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
 	while (n > 0 && chunk_written >= 0) {
 		yaffs_addr_to_chunk(dev, offset, &chunk, &start);
 
-		if (chunk * dev->data_bytes_per_chunk + start != offset ||
+		if (((loff_t)chunk) *
+		    dev->data_bytes_per_chunk + start != offset ||
 		    start >= dev->data_bytes_per_chunk) {
 			yaffs_trace(YAFFS_TRACE_ERROR,
-				"AddrToChunk of offset %d gives chunk %d start %d",
-				(int)offset, chunk, start);
+				"AddrToChunk of offset %lld gives chunk %d start %d",
+				offset, chunk, start);
 		}
 		chunk++;	/* File pos to chunk in file offset */
 
@@ -3555,7 +3554,8 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
 			 * before.
 			 */
 
-			chunk_start = ((chunk - 1) * dev->data_bytes_per_chunk);
+			chunk_start = (((loff_t)(chunk - 1)) *
+					dev->data_bytes_per_chunk);
 
 			if (chunk_start > in->variant.file_variant.file_size)
 				n_bytes_read = 0;	/* Past end of file */
@@ -3623,7 +3623,7 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
 					cache->locked = 0;
 					cache->n_bytes = n_writeback;
 
-					if (write_trhrough) {
+					if (write_through) {
 						chunk_written =
 						    yaffs_wr_data_obj
 						    (cache->object,
@@ -3641,8 +3641,7 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
 				 * local buffer then copy over and write back.
 				 */
 
-				u8 *local_buffer =
-				    yaffs_get_temp_buffer(dev, __LINE__);
+				u8 *local_buffer = yaffs_get_temp_buffer(dev);
 
 				yaffs_rd_data_obj(in, chunk, local_buffer);
 				memcpy(&local_buffer[start], buffer, n_copy);
@@ -3652,8 +3651,7 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
 						      local_buffer,
 						      n_writeback, 0);
 
-				yaffs_release_temp_buffer(dev, local_buffer,
-							  __LINE__);
+				yaffs_release_temp_buffer(dev, local_buffer);
 			}
 		} else {
 			/* A full chunk. Write directly from the buffer. */
@@ -3685,25 +3683,34 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
 }
 
 int yaffs_wr_file(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
-		  int n_bytes, int write_trhrough)
+		  int n_bytes, int write_through)
 {
 	yaffs2_handle_hole(in, offset);
-	return yaffs_do_file_wr(in, buffer, offset, n_bytes, write_trhrough);
+	return yaffs_do_file_wr(in, buffer, offset, n_bytes, write_through);
 }
 
 /* ---------------------- File resizing stuff ------------------ */
 
-static void yaffs_prune_chunks(struct yaffs_obj *in, int new_size)
+static void yaffs_prune_chunks(struct yaffs_obj *in, loff_t new_size)
 {
 
 	struct yaffs_dev *dev = in->my_dev;
-	int old_size = in->variant.file_variant.file_size;
+	loff_t old_size = in->variant.file_variant.file_size;
 	int i;
 	int chunk_id;
-	int last_del = 1 + (old_size - 1) / dev->data_bytes_per_chunk;
-	int start_del = 1 + (new_size + dev->data_bytes_per_chunk - 1) /
-	    dev->data_bytes_per_chunk;
+	u32 dummy;
+	int last_del;
+	int start_del;
+
+	if (old_size > 0)
+		yaffs_addr_to_chunk(dev, old_size - 1, &last_del, &dummy);
+	else
+		last_del = 0;
 
+	yaffs_addr_to_chunk(dev, new_size + dev->data_bytes_per_chunk - 1,
+				&start_del, &dummy);
+	last_del++;
+	start_del++;
 
 	/* Delete backwards so that we don't end up with holes if
 	 * power is lost part-way through the operation.
@@ -3746,7 +3753,7 @@ void yaffs_resize_file_down(struct yaffs_obj *obj, loff_t new_size)
 
 	if (new_partial != 0) {
 		int last_chunk = 1 + new_full;
-		u8 *local_buffer = yaffs_get_temp_buffer(dev, __LINE__);
+		u8 *local_buffer = yaffs_get_temp_buffer(dev);
 
 		/* Rewrite the last chunk with its new size and zero pad */
 		yaffs_rd_data_obj(obj, last_chunk, local_buffer);
@@ -3756,7 +3763,7 @@ void yaffs_resize_file_down(struct yaffs_obj *obj, loff_t new_size)
 		yaffs_wr_data_obj(obj, last_chunk, local_buffer,
 				  new_partial, 1);
 
-		yaffs_release_temp_buffer(dev, local_buffer, __LINE__);
+		yaffs_release_temp_buffer(dev, local_buffer);
 	}
 
 	obj->variant.file_variant.file_size = new_size;
@@ -3767,7 +3774,7 @@ void yaffs_resize_file_down(struct yaffs_obj *obj, loff_t new_size)
 int yaffs_resize_file(struct yaffs_obj *in, loff_t new_size)
 {
 	struct yaffs_dev *dev = in->my_dev;
-	int old_size = in->variant.file_variant.file_size;
+	loff_t old_size = in->variant.file_variant.file_size;
 
 	yaffs_flush_file_cache(in);
 	yaffs_invalidate_whole_cache(in);
@@ -4367,7 +4374,7 @@ struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory,
 			 */
 			yaffs_get_obj_name(l, buffer,
 				YAFFS_MAX_NAME_LENGTH + 1);
-			if (strncmp(name, buffer, YAFFS_MAX_NAME_LENGTH) == 0)
+			if (!strncmp(name, buffer, YAFFS_MAX_NAME_LENGTH))
 				return l;
 		}
 	}
@@ -4432,15 +4439,13 @@ int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR *name, int buffer_size)
 {
 	memset(name, 0, buffer_size * sizeof(YCHAR));
 	yaffs_check_obj_details_loaded(obj);
-	if (obj->obj_id == YAFFS_OBJECTID_LOSTNFOUND)
+	if (obj->obj_id == YAFFS_OBJECTID_LOSTNFOUND) {
 		strncpy(name, YAFFS_LOSTNFOUND_NAME, buffer_size - 1);
-#ifndef CONFIG_YAFFS_NO_SHORT_NAMES
-	else if (obj->short_name[0])
+	} else if (obj->short_name[0]) {
 		strcpy(name, obj->short_name);
-#endif
-	else if (obj->hdr_chunk > 0) {
+	} else if (obj->hdr_chunk > 0) {
 		int result;
-		u8 *buffer = yaffs_get_temp_buffer(obj->my_dev, __LINE__);
+		u8 *buffer = yaffs_get_temp_buffer(obj->my_dev);
 
 		struct yaffs_obj_hdr *oh = (struct yaffs_obj_hdr *)buffer;
 
@@ -4454,7 +4459,7 @@ int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR *name, int buffer_size)
 		yaffs_load_name_from_oh(obj->my_dev, name, oh->name,
 					buffer_size);
 
-		yaffs_release_temp_buffer(obj->my_dev, buffer, __LINE__);
+		yaffs_release_temp_buffer(obj->my_dev, buffer);
 	}
 
 	yaffs_fix_null_name(obj, name, buffer_size);
@@ -4462,7 +4467,7 @@ int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR *name, int buffer_size)
 	return strnlen(name, YAFFS_MAX_NAME_LENGTH);
 }
 
-int yaffs_get_obj_length(struct yaffs_obj *obj)
+loff_t yaffs_get_obj_length(struct yaffs_obj *obj)
 {
 	/* Dereference any hard linking */
 	obj = yaffs_get_equivalent_obj(obj);
@@ -4552,8 +4557,6 @@ static int yaffs_check_dev_fns(const struct yaffs_dev *dev)
 	if (!dev->param.erase_fn || !dev->param.initialise_flash_fn)
 		return 0;
 
-#ifdef CONFIG_YAFFS_YAFFS2
-
 	/* Can use the "with tags" style interface for yaffs1 or yaffs2 */
 	if (dev->param.write_chunk_tags_fn &&
 	    dev->param.read_chunk_tags_fn &&
@@ -4561,7 +4564,6 @@ static int yaffs_check_dev_fns(const struct yaffs_dev *dev)
 	    !dev->param.read_chunk_fn &&
 	    dev->param.bad_block_fn && dev->param.query_block_fn)
 		return 1;
-#endif
 
 	/* Can use the "spare" style interface for yaffs1 */
 	if (!dev->param.is_yaffs2 &&
@@ -4832,6 +4834,11 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
 	if (!init_failed && !yaffs_create_initial_dir(dev))
 		init_failed = 1;
 
+	if (!init_failed && dev->param.is_yaffs2 &&
+		!dev->param.disable_summary &&
+		!yaffs_summary_init(dev))
+		init_failed = 1;
+
 	if (!init_failed) {
 		/* Now scan the flash. */
 		if (dev->param.is_yaffs2) {
@@ -4894,7 +4901,7 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
 	dev->n_page_writes = 0;
 	dev->n_erasures = 0;
 	dev->n_gc_copies = 0;
-	dev->n_retired_writes = 0;
+	dev->n_retried_writes = 0;
 
 	dev->n_retired_blocks = 0;
 
@@ -4917,6 +4924,8 @@ void yaffs_deinitialise(struct yaffs_dev *dev)
 
 		yaffs_deinit_blocks(dev);
 		yaffs_deinit_tnodes_and_objs(dev);
+		yaffs_summary_deinit(dev);
+
 		if (dev->param.n_caches > 0 && dev->cache) {
 
 			for (i = 0; i < dev->param.n_caches; i++) {
@@ -4998,3 +5007,26 @@ int yaffs_get_n_free_chunks(struct yaffs_dev *dev)
 
 	return n_free;
 }
+
+/*\
+ * Marshalling functions to get loff_t file sizes into aand out of
+ * object headers.
+ */
+void yaffs_oh_size_load(struct yaffs_obj_hdr *oh, loff_t fsize)
+{
+	oh->file_size_low = (fsize & 0xFFFFFFFF);
+	oh->file_size_high = ((fsize >> 32) & 0xFFFFFFFF);
+}
+
+loff_t yaffs_oh_to_size(struct yaffs_obj_hdr *oh)
+{
+	loff_t retval;
+
+	if (~(oh->file_size_high))
+		retval = (((loff_t) oh->file_size_high) << 32) |
+			(((loff_t) oh->file_size_low) & 0xFFFFFFFF);
+	else
+		retval = (loff_t) oh->file_size_low;
+
+	return retval;
+}