/*
* 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>
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;
}
// NCB added 10/9/2002
-static __u16 yaffs_CalcNameSum(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)
{
}
-static void yaffs_CalcECC(const __u8 *data, yaffs_Spare *spare)
+static void yaffs_calc_ecc(const u8 *data, struct yaffs_spare *spare)
{
- yaffs_ECCCalculate(data , spare->ecc1);
- yaffs_ECCCalculate(&data[256] , spare->ecc2);
+ yaffs_ecc_calc(data , spare->ecc1);
+ yaffs_ecc_calc(&data[256] , spare->ecc2);
}
-static void yaffs_CalcTagsECC(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;
b[7] |= ((ecc & 0x3F) << 2);
}
}
-static void yaffs_LoadTagsIntoSpare(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;
-
- //yaffs_CalcTagsECC(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];
+ union yaffs_tags_union *tu = (union yaffs_tags_union *)tagsPtr;
+
+ //yaffs_calc_tags_ecc(tagsPtr);
+
+ 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.byteCount = 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)
{
little_to_big_endian(&t);
}
- yaffs_CalcTagsECC(&t);
- yaffs_LoadTagsIntoSpare(&s,&t);
- yaffs_CalcECC(data,&s);
+ yaffs_calc_tags_ecc(&t);
+ yaffs_load_tags_to_spare(&s,&t);
+ yaffs_calc_ecc(data,&s);
nPages++;
- return write(outFile,&s,sizeof(yaffs_Spare));
+ return write(outFile,&s,sizeof(struct yaffs_spare));
}
(((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);
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)
object_header_little_to_big_endian(oh);
}
- return write_chunk(bytes,objId,0,0xffff);
+ return write_chunk(bytes,obj_id,0,0xffff);
}
S_ISSOCK(stats.st_mode))
{
- newObj = obj_id++;
- nObjects++;
+ newObj = obj_alloc_id++;
+ n_obj++;
printf("Object %d, %s is a ",newObj,full_name);
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);
}
{
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);
projects / yaffs2.git / blobdiff