X-Git-Url: http://www.aleph1.co.uk/gitweb/?p=yaffs2.git;a=blobdiff_plain;f=utils%2Fmkyaffsimage.c;h=1d835953298eb1a8364ccd0be3910b991a141199;hp=b7173eb3b91c354c81fc17d604362c2ea20cbbdd;hb=b4d5215f18486403d16f2e776000e43eba052f40;hpb=e33554a67753729f6b74677473cf0ec3b8d35a7e

diff --git a/utils/mkyaffsimage.c b/utils/mkyaffsimage.c
index b7173eb..1d83595 100644
--- a/utils/mkyaffsimage.c
+++ b/utils/mkyaffsimage.c
@@ -1,7 +1,7 @@
 /*
  * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
  *
- * Copyright (C) 2002-2007 Aleph One Ltd.
+ * Copyright (C) 2002-2011 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
  *
  * Created by Charles Manning <charles@aleph1.co.uk>
@@ -45,10 +45,9 @@ typedef struct
 
 
 static objItem obj_list[MAX_OBJECTS];
-static int n_obj = 0;
-static int obj_id = YAFFS_NOBJECT_BUCKETS + 1;
+static int obj_alloc_id = YAFFS_NOBJECT_BUCKETS + 1;
 
-static int nObjects, nDirectories, nPages;
+static int n_obj, nDirectories, nPages;
 
 static int outFile;
 
@@ -113,12 +112,12 @@ static int find_obj_in_list(dev_t dev, ino_t ino)
 }
 
 // NCB added 10/9/2002
-static __u16 yaffs_calc_name_sum(const char *name)
+static u16 yaffs_calc_name_sum(const char *name)
 {
-	__u16 sum = 0;
-	__u16 i = 1;
+	u16 sum = 0;
+	u16 i = 1;
 	
-	__u8 *bname = (__u8 *)name;
+	u8 *bname = (u8 *)name;
 	
 	while (*bname)
 	{
@@ -130,16 +129,16 @@ static __u16 yaffs_calc_name_sum(const char *name)
 }
 
 
-static void yaffs_calc_ecc(const __u8 *data, yaffs_Spare *spare)
+static void yaffs_calc_ecc(const u8 *data, struct yaffs_spare *spare)
 {
-	yaffs_ecc_cacl(data , spare->ecc1);
-	yaffs_ecc_cacl(&data[256] , spare->ecc2);
+	yaffs_ecc_calc(data , spare->ecc1);
+	yaffs_ecc_calc(&data[256] , spare->ecc2);
 }
 
-static void yaffs_calc_tags_ecc(yaffs_Tags *tags)
+static void yaffs_calc_tags_ecc(struct yaffs_tags *tags)
 {
 	// Todo don't do anything yet. Need to calculate ecc
-	unsigned char *b = ((yaffs_TagsUnion *)tags)->asBytes;
+	unsigned char *b = ((union yaffs_tags_union *)tags)->as_bytes;
 	unsigned  i,j;
 	unsigned  ecc = 0;
 	unsigned bit = 0;
@@ -181,68 +180,68 @@ static void yaffs_calc_tags_ecc(yaffs_Tags *tags)
         b[7] |= ((ecc & 0x3F) << 2);
     }
 }
-static void yaffs_load_tags_to_spare(yaffs_Spare *sparePtr, yaffs_Tags *tagsPtr)
+static void yaffs_load_tags_to_spare(struct yaffs_spare *sparePtr, struct yaffs_tags *tagsPtr)
 {
-	yaffs_TagsUnion *tu = (yaffs_TagsUnion *)tagsPtr;
+	union yaffs_tags_union *tu = (union yaffs_tags_union *)tagsPtr;
 	
 	//yaffs_calc_tags_ecc(tagsPtr);
 	
-	sparePtr->tagByte0 = tu->asBytes[0];
-	sparePtr->tagByte1 = tu->asBytes[1];
-	sparePtr->tagByte2 = tu->asBytes[2];
-	sparePtr->tagByte3 = tu->asBytes[3];
-	sparePtr->tagByte4 = tu->asBytes[4];
-	sparePtr->tagByte5 = tu->asBytes[5];
-	sparePtr->tagByte6 = tu->asBytes[6];
-	sparePtr->tagByte7 = tu->asBytes[7];
+	sparePtr->tb0 = tu->as_bytes[0];
+	sparePtr->tb1 = tu->as_bytes[1];
+	sparePtr->tb2 = tu->as_bytes[2];
+	sparePtr->tb3 = tu->as_bytes[3];
+	sparePtr->tb4 = tu->as_bytes[4];
+	sparePtr->tb5 = tu->as_bytes[5];
+	sparePtr->tb6 = tu->as_bytes[6];
+	sparePtr->tb7 = tu->as_bytes[7];
 }
 
 /* This little function converts a little endian tag to a big endian tag.
  * NOTE: The tag is not usable after this other than calculating the CRC
  * with.
  */
-static void little_to_big_endian(yaffs_Tags *tagsPtr)
+static void little_to_big_endian(struct yaffs_tags *tagsPtr)
 {
-    yaffs_TagsUnion * tags = (yaffs_TagsUnion* )tagsPtr; // Work in bytes.
-    yaffs_TagsUnion   temp;
+    union yaffs_tags_union * tags = (union yaffs_tags_union* )tagsPtr; // Work in bytes.
+    union yaffs_tags_union   temp;
 
     memset(&temp, 0, sizeof(temp));
     // Ick, I hate magic numbers.
-    temp.asBytes[0] = ((tags->asBytes[2] & 0x0F) << 4) | ((tags->asBytes[1] & 0xF0) >> 4);
-    temp.asBytes[1] = ((tags->asBytes[1] & 0x0F) << 4) | ((tags->asBytes[0] & 0xF0) >> 4);
-    temp.asBytes[2] = ((tags->asBytes[0] & 0x0F) << 4) | ((tags->asBytes[2] & 0x30) >> 2) | ((tags->asBytes[3] & 0xC0) >> 6);
-    temp.asBytes[3] = ((tags->asBytes[3] & 0x3F) << 2) | ((tags->asBytes[2] & 0xC0) >> 6);
-    temp.asBytes[4] = ((tags->asBytes[6] & 0x03) << 6) | ((tags->asBytes[5] & 0xFC) >> 2);
-    temp.asBytes[5] = ((tags->asBytes[5] & 0x03) << 6) | ((tags->asBytes[4] & 0xFC) >> 2);
-    temp.asBytes[6] = ((tags->asBytes[4] & 0x03) << 6) | (tags->asBytes[7] & 0x3F);
-    temp.asBytes[7] = (tags->asBytes[6] & 0xFC) | ((tags->asBytes[7] & 0xC0) >> 6);
+    temp.as_bytes[0] = ((tags->as_bytes[2] & 0x0F) << 4) | ((tags->as_bytes[1] & 0xF0) >> 4);
+    temp.as_bytes[1] = ((tags->as_bytes[1] & 0x0F) << 4) | ((tags->as_bytes[0] & 0xF0) >> 4);
+    temp.as_bytes[2] = ((tags->as_bytes[0] & 0x0F) << 4) | ((tags->as_bytes[2] & 0x30) >> 2) | ((tags->as_bytes[3] & 0xC0) >> 6);
+    temp.as_bytes[3] = ((tags->as_bytes[3] & 0x3F) << 2) | ((tags->as_bytes[2] & 0xC0) >> 6);
+    temp.as_bytes[4] = ((tags->as_bytes[6] & 0x03) << 6) | ((tags->as_bytes[5] & 0xFC) >> 2);
+    temp.as_bytes[5] = ((tags->as_bytes[5] & 0x03) << 6) | ((tags->as_bytes[4] & 0xFC) >> 2);
+    temp.as_bytes[6] = ((tags->as_bytes[4] & 0x03) << 6) | (tags->as_bytes[7] & 0x3F);
+    temp.as_bytes[7] = (tags->as_bytes[6] & 0xFC) | ((tags->as_bytes[7] & 0xC0) >> 6);
 
     // Now copy it back.
-    tags->asBytes[0] = temp.asBytes[0];
-    tags->asBytes[1] = temp.asBytes[1];
-    tags->asBytes[2] = temp.asBytes[2];
-    tags->asBytes[3] = temp.asBytes[3];
-    tags->asBytes[4] = temp.asBytes[4];
-    tags->asBytes[5] = temp.asBytes[5];
-    tags->asBytes[6] = temp.asBytes[6];
-    tags->asBytes[7] = temp.asBytes[7];
+    tags->as_bytes[0] = temp.as_bytes[0];
+    tags->as_bytes[1] = temp.as_bytes[1];
+    tags->as_bytes[2] = temp.as_bytes[2];
+    tags->as_bytes[3] = temp.as_bytes[3];
+    tags->as_bytes[4] = temp.as_bytes[4];
+    tags->as_bytes[5] = temp.as_bytes[5];
+    tags->as_bytes[6] = temp.as_bytes[6];
+    tags->as_bytes[7] = temp.as_bytes[7];
 }
 
-static int write_chunk(__u8 *data, __u32 objId, __u32 chunkId, __u32 nBytes)
+static int write_chunk(u8 *data, u32 obj_id, u32 chunk_id, u32 n_bytes)
 {
-	yaffs_Tags t;
-	yaffs_Spare s;
+	struct yaffs_tags t;
+	struct yaffs_spare s;
 
 	error = write(outFile,data,512);
 	if(error < 0) return error;
 
-	memset(&t,0xff,sizeof (yaffs_Tags));
-	memset(&s,0xff,sizeof (yaffs_Spare));
+	memset(&t,0xff,sizeof (struct yaffs_tags));
+	memset(&s,0xff,sizeof (struct yaffs_spare));
 	
-	t.chunkId = chunkId;
-	t.serialNumber = 0;
-	t.byteCountLSB = nBytes;
-	t.objectId = objId;
+	t.chunk_id = chunk_id;
+	t.serial_number = 0;
+	t.n_bytes_lsb = n_bytes;
+	t.obj_id = obj_id;
 
     if (convert_endian)
     {
@@ -255,7 +254,7 @@ static int write_chunk(__u8 *data, __u32 objId, __u32 chunkId, __u32 nBytes)
 	
 	nPages++;
 	
-	return write(outFile,&s,sizeof(yaffs_Spare));
+	return write(outFile,&s,sizeof(struct yaffs_spare));
 	
 }
 
@@ -268,75 +267,54 @@ static int write_chunk(__u8 *data, __u32 objId, __u32 chunkId, __u32 nBytes)
                      (((x) & 0xFF00) >> 8))
         
 // This one is easier, since the types are more standard. No funky shifts here.
-static void object_header_little_to_big_endian(yaffs_ObjectHeader* oh)
+static void object_header_little_to_big_endian(struct yaffs_obj_hdr* oh)
 {
     oh->type = SWAP32(oh->type); // GCC makes enums 32 bits.
-    oh->parentObjectId = SWAP32(oh->parentObjectId); // int
-    oh->sum__NoLongerUsed = SWAP16(oh->sum__NoLongerUsed); // __u16 - Not used, but done for completeness.
+    oh->parent_obj_id = SWAP32(oh->parent_obj_id); // int
+    oh->sum_no_longer_used = SWAP16(oh->sum_no_longer_used); // u16 - Not used, but done for completeness.
     // name = skip. Char array. Not swapped.
     oh->yst_mode = SWAP32(oh->yst_mode);
-#ifdef CONFIG_YAFFS_WINCE // WinCE doesn't implement this, but we need to just in case. 
-    // In fact, WinCE would be *THE* place where this would be an issue!
-    oh->notForWinCE[0] = SWAP32(oh->notForWinCE[0]);
-    oh->notForWinCE[1] = SWAP32(oh->notForWinCE[1]);
-    oh->notForWinCE[2] = SWAP32(oh->notForWinCE[2]);
-    oh->notForWinCE[3] = SWAP32(oh->notForWinCE[3]);
-    oh->notForWinCE[4] = SWAP32(oh->notForWinCE[4]);
-#else
+
     // Regular POSIX.
     oh->yst_uid = SWAP32(oh->yst_uid);
     oh->yst_gid = SWAP32(oh->yst_gid);
     oh->yst_atime = SWAP32(oh->yst_atime);
     oh->yst_mtime = SWAP32(oh->yst_mtime);
     oh->yst_ctime = SWAP32(oh->yst_ctime);
-#endif
 
-    oh->fileSize = SWAP32(oh->fileSize); // Aiee. An int... signed, at that!
-    oh->equivalentObjectId = SWAP32(oh->equivalentObjectId);
+    oh->file_size_low = SWAP32(oh->file_size_low); // Aiee. An int... signed, at that!
+    oh->equiv_id = SWAP32(oh->equiv_id);
     // alias  - char array.
     oh->yst_rdev = SWAP32(oh->yst_rdev);
 
-#ifdef CONFIG_YAFFS_WINCE
     oh->win_ctime[0] = SWAP32(oh->win_ctime[0]);
     oh->win_ctime[1] = SWAP32(oh->win_ctime[1]);
     oh->win_atime[0] = SWAP32(oh->win_atime[0]);
     oh->win_atime[1] = SWAP32(oh->win_atime[1]);
     oh->win_mtime[0] = SWAP32(oh->win_mtime[0]);
     oh->win_mtime[1] = SWAP32(oh->win_mtime[1]);
-    oh->roomToGrow[0] = SWAP32(oh->roomToGrow[0]);
-    oh->roomToGrow[1] = SWAP32(oh->roomToGrow[1]);
-    oh->roomToGrow[2] = SWAP32(oh->roomToGrow[2]);
-    oh->roomToGrow[3] = SWAP32(oh->roomToGrow[3]);
-    oh->roomToGrow[4] = SWAP32(oh->roomToGrow[4]);
-    oh->roomToGrow[5] = SWAP32(oh->roomToGrow[5]);
-#else
-    oh->roomToGrow[0] = SWAP32(oh->roomToGrow[0]);
-    oh->roomToGrow[1] = SWAP32(oh->roomToGrow[1]);
-    oh->roomToGrow[2] = SWAP32(oh->roomToGrow[2]);
-    oh->roomToGrow[3] = SWAP32(oh->roomToGrow[3]);
-    oh->roomToGrow[4] = SWAP32(oh->roomToGrow[4]);
-    oh->roomToGrow[5] = SWAP32(oh->roomToGrow[5]);
-    oh->roomToGrow[6] = SWAP32(oh->roomToGrow[6]);
-    oh->roomToGrow[7] = SWAP32(oh->roomToGrow[7]);
-    oh->roomToGrow[8] = SWAP32(oh->roomToGrow[8]);
-    oh->roomToGrow[9] = SWAP32(oh->roomToGrow[9]);
-    oh->roomToGrow[10] = SWAP32(oh->roomToGrow[10]);
-    oh->roomToGrow[11] = SWAP32(oh->roomToGrow[11]);
-#endif
+
+    oh->reserved[0] = SWAP32(oh->reserved[0]);
+    oh->reserved[1] = SWAP32(oh->reserved[1]);
+
+    oh->inband_shadowed_obj_id = SWAP32(oh->inband_shadowed_obj_id);
+    oh->inband_is_shrink = SWAP32(oh->inband_is_shrink);
+    oh->shadows_obj = SWAP32(oh->shadows_obj);
+    oh->is_shrink = SWAP32(oh->is_shrink);
 }
 
-static int write_object_header(int objId, yaffs_ObjectType t, struct stat *s, int parent, const char *name, int equivalentObj, const char * alias)
+static int write_object_header(int obj_id, enum yaffs_obj_type t, struct stat *s, int parent, const char *name, int equivalentObj, const char * alias)
 {
-	__u8 bytes[512];
+	u8 bytes[512];
 	
 	
-	yaffs_ObjectHeader *oh = (yaffs_ObjectHeader *)bytes;
+	struct yaffs_obj_hdr *oh = (struct yaffs_obj_hdr *)bytes;
 	
 	memset(bytes,0xff,512);
 	
 	oh->type = t;
 
-	oh->parentObjectId = parent;
+	oh->parent_obj_id = parent;
 	
 	strncpy(oh->name,name,YAFFS_MAX_NAME_LENGTH);
 	
@@ -355,12 +333,12 @@ static int write_object_header(int objId, yaffs_ObjectType t, struct stat *s, in
 	
 	if(t == YAFFS_OBJECT_TYPE_FILE)
 	{
-		oh->fileSize = s->st_size;
+		oh->file_size_low = s->st_size;
 	}
 	
 	if(t == YAFFS_OBJECT_TYPE_HARDLINK)
 	{
-		oh->equivalentObjectId = equivalentObj;
+		oh->equiv_id = equivalentObj;
 	}
 	
 	if(t == YAFFS_OBJECT_TYPE_SYMLINK)
@@ -373,7 +351,7 @@ static int write_object_header(int objId, yaffs_ObjectType t, struct stat *s, in
         object_header_little_to_big_endian(oh);
     }
 	
-	return write_chunk(bytes,objId,0,0xffff);
+	return write_chunk(bytes,obj_id,0,0xffff);
 	
 }
 
@@ -415,8 +393,8 @@ static int process_directory(int parent, const char *path)
 				    S_ISSOCK(stats.st_mode))
 				{
 				
-					newObj = obj_id++;
-					nObjects++;
+					newObj = obj_alloc_id++;
+					n_obj++;
 					
 					printf("Object %d, %s is a ",newObj,full_name);
 					
@@ -453,22 +431,22 @@ static int process_directory(int parent, const char *path)
 							if(error >= 0)
 							{
 								int h;
-								__u8 bytes[512];
-								int nBytes;
+								u8 bytes[512];
+								int n_bytes;
 								int chunk = 0;
 								
 								h = open(full_name,O_RDONLY);
 								if(h >= 0)
 								{
 									memset(bytes,0xff,512);
-									while((nBytes = read(h,bytes,512)) > 0)
+									while((n_bytes = read(h,bytes,512)) > 0)
 									{
 										chunk++;
-										write_chunk(bytes,newObj,chunk,nBytes);
+										write_chunk(bytes,newObj,chunk,n_bytes);
 										memset(bytes,0xff,512);
 									}
-									if(nBytes < 0) 
-									   error = nBytes;
+									if(n_bytes < 0) 
+									   error = n_bytes;
 									   
 									printf("%d data chunks written\n",chunk);
 								}
@@ -580,7 +558,7 @@ int main(int argc, char *argv[])
 	{
 		printf("Operation complete.\n"
 		       "%d objects in %d directories\n"
-		       "%d NAND pages\n",nObjects, nDirectories, nPages);
+		       "%d NAND pages\n",n_obj, nDirectories, nPages);
 	}
 	
 	close(outFile);