X-Git-Url: http://www.aleph1.co.uk/gitweb/?p=yaffs2.git;a=blobdiff_plain;f=utils%2Fmkyaffsimage.c;h=d6f6241157677d88f8bd2c99d6532c768f6a1d4b;hp=2b8dc1e919d2b96416157dcdddf9a45876ba2068;hb=HEAD;hpb=e1ac494e05a5dc7ab61d799af815d103a11d318c diff --git a/utils/mkyaffsimage.c b/utils/mkyaffsimage.c index 2b8dc1e..d6f6241 100644 --- a/utils/mkyaffsimage.c +++ b/utils/mkyaffsimage.c @@ -1,8 +1,7 @@ /* * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. * - * Copyright (C) 2002-2007 Aleph One Ltd. - * for Toby Churchill Ltd and Brightstar Engineering + * Copyright (C) 2002-2018 Aleph One Ltd. * * Created by Charles Manning * Nick Bane modifications flagged NCB @@ -14,11 +13,11 @@ */ /* - * makeyaffsimage.c + * makeyaffsimage.c * * Makes a YAFFS file system image that can be used to load up a file system. */ - + #include #include #include @@ -45,10 +44,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; @@ -59,15 +57,15 @@ static int convert_endian = 0; static int obj_compare(const void *a, const void * b) { objItem *oa, *ob; - + oa = (objItem *)a; ob = (objItem *)b; - + if(oa->dev < ob->dev) return -1; if(oa->dev > ob->dev) return 1; if(oa->ino < ob->ino) return -1; if(oa->ino > ob->ino) return 1; - + return 0; } @@ -81,7 +79,7 @@ static void add_obj_to_list(dev_t dev, ino_t ino, int obj) obj_list[n_obj].obj = obj; n_obj++; qsort(obj_list,n_obj,sizeof(objItem),obj_compare); - + } else { @@ -99,7 +97,7 @@ static int find_obj_in_list(dev_t dev, ino_t ino) test.dev = dev; test.ino = ino; - + if(n_obj > 0) { i = bsearch(&test,obj_list,n_obj,sizeof(objItem),obj_compare); @@ -112,14 +110,15 @@ static int find_obj_in_list(dev_t dev, ino_t ino) return -1; } +#if 0 // 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; - - __u8 *bname = (__u8 *)name; - + u16 sum = 0; + u16 i = 1; + + u8 *bname = (u8 *)name; + while (*bname) { sum += (*bname) * i; @@ -128,18 +127,18 @@ static __u16 yaffs_CalcNameSum(const char *name) } return sum; } +#endif - -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; @@ -155,7 +154,7 @@ static void yaffs_CalcTagsECC(yaffs_Tags *tags) b[6] &= 0xC0; b[7] &= 0x03; } - + for(i = 0; i < 8; i++) { // NCB modified 20-9-02 for(j = 1; j &0x7f; j<<=1) @@ -168,7 +167,7 @@ static void yaffs_CalcTagsECC(yaffs_Tags *tags) } } } - + // Write out ECC if (!convert_endian) { @@ -181,82 +180,82 @@ static void yaffs_CalcTagsECC(yaffs_Tags *tags) 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)); - - t.chunkId = chunkId; - t.serialNumber = 0; - t.byteCount = nBytes; - t.objectId = objId; + memset(&t,0xff,sizeof (struct yaffs_tags)); + memset(&s,0xff,sizeof (struct yaffs_spare)); + + 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)); + } #define SWAP32(x) ((((x) & 0x000000FF) << 24) | \ @@ -266,81 +265,59 @@ static int write_chunk(__u8 *data, __u32 objId, __u32 chunkId, __u32 nBytes) #define SWAP16(x) ((((x) & 0x00FF) << 8) | \ (((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->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]; - - - yaffs_ObjectHeader *oh = (yaffs_ObjectHeader *)bytes; - + u8 bytes[512]; + + + 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_HARDLINK) { oh->yst_mode = s->st_mode; @@ -352,17 +329,17 @@ static int write_object_header(int objId, yaffs_ObjectType t, struct stat *s, in oh->yst_ctime = s->st_ctime; oh->yst_rdev = s->st_rdev; } - + 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) { strncpy(oh->alias,alias,YAFFS_MAX_ALIAS_LENGTH); @@ -372,9 +349,9 @@ 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); + } @@ -385,14 +362,14 @@ static int process_directory(int parent, const char *path) struct dirent *entry; nDirectories++; - + dir = opendir(path); - + if(dir) { while((entry = readdir(dir)) != NULL) { - + /* Ignore . and .. */ if(strcmp(entry->d_name,".") && strcmp(entry->d_name,"..")) @@ -401,11 +378,11 @@ static int process_directory(int parent, const char *path) struct stat stats; int equivalentObj; int newObj; - + sprintf(full_name,"%s/%s",path,entry->d_name); - + lstat(full_name,&stats); - + if(S_ISLNK(stats.st_mode) || S_ISREG(stats.st_mode) || S_ISDIR(stats.st_mode) || @@ -414,12 +391,12 @@ static int process_directory(int parent, const char *path) S_ISCHR(stats.st_mode) || S_ISSOCK(stats.st_mode)) { - - newObj = obj_id++; - nObjects++; - + + newObj = obj_alloc_id++; + n_obj++; + printf("Object %d, %s is a ",newObj,full_name); - + /* We're going to create an object for it */ if((equivalentObj = find_obj_in_list(stats.st_dev, stats.st_ino)) > 0) { @@ -427,20 +404,24 @@ static int process_directory(int parent, const char *path) printf("hard link to object %d\n",equivalentObj); error = write_object_header(newObj, YAFFS_OBJECT_TYPE_HARDLINK, &stats, parent, entry->d_name, equivalentObj, NULL); } - else + else { - + add_obj_to_list(stats.st_dev,stats.st_ino,newObj); - + if(S_ISLNK(stats.st_mode)) { - + char symname[500]; - + int ret; + memset(symname,0, sizeof(symname)); - - readlink(full_name,symname,sizeof(symname) -1); - + + ret = readlink(full_name,symname,sizeof(symname) -1); + + if (ret < 0) + perror("readlink of symlink"); + printf("symlink to \"%s\"\n",symname); error = write_object_header(newObj, YAFFS_OBJECT_TYPE_SYMLINK, &stats, parent, entry->d_name, -1, symname); @@ -453,23 +434,23 @@ 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); } else @@ -477,9 +458,9 @@ static int process_directory(int parent, const char *path) perror("Error opening file"); } close(h); - - } - + + } + } else if(S_ISSOCK(stats.st_mode)) { @@ -517,7 +498,7 @@ static int process_directory(int parent, const char *path) } } } - + return 0; } @@ -526,9 +507,9 @@ static int process_directory(int parent, const char *path) int main(int argc, char *argv[]) { struct stat stats; - + printf("mkyaffsimage: image building tool for YAFFS built "__DATE__"\n"); - + if(argc < 3) { printf("usage: mkyaffsimage dir image_file [convert]\n"); @@ -542,35 +523,35 @@ int main(int argc, char *argv[]) { convert_endian = 1; } - + if(stat(argv[1],&stats) < 0) { printf("Could not stat %s\n",argv[1]); exit(1); } - + if(!S_ISDIR(stats.st_mode)) { printf(" %s is not a directory\n",argv[1]); exit(1); } - + outFile = open(argv[2],O_CREAT | O_TRUNC | O_WRONLY, S_IREAD | S_IWRITE); - - + + if(outFile < 0) { printf("Could not open output file %s\n",argv[2]); exit(1); } - + printf("Processing directory %s into image file %s\n",argv[1],argv[2]); error = write_object_header(1, YAFFS_OBJECT_TYPE_DIRECTORY, &stats, 1,"", -1, NULL); if(error) error = process_directory(YAFFS_OBJECTID_ROOT,argv[1]); - + close(outFile); - + if(error < 0) { perror("operation incomplete"); @@ -580,11 +561,11 @@ 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); - + exit(0); -} +}