uffs_test.c

Go to the documentation of this file.
00001 
00007 #include <stdio.h>
00008 #include <string.h>
00009 #include "uffs/uffs_config.h"
00010 #include "uffs/uffs_public.h"
00011 #include "uffs/uffs_fs.h"
00012 #include "uffs/uffs_utils.h"
00013 #include "cmdline.h"
00014 
00015 extern int InitFileSystem(void);
00016 extern int ReleaseFileSystem(void);
00017 
00018 BOOL cmdFormat(const char *tail)
00019 {
00020     URET ret;
00021     const char *mount = "/";
00022     uffs_Device *dev;
00023 
00024     if (tail) {
00025         mount = cli_getparam(tail, NULL);
00026     }
00027     printf("Formating %s ... ", mount);
00028 
00029     dev = uffs_GetDevice(mount);
00030     if (dev == NULL) {
00031         printf("Can't get device from mount point.\n");
00032     }
00033     else {
00034         ret = uffs_FormatDevice(dev);
00035         if (ret != U_SUCC) {
00036             printf("Format fail.\n");
00037         }
00038         else {
00039             printf("Format succ.\n");
00040         }
00041     }
00042     return TRUE;    
00043 }
00044 
00045 BOOL cmdMkf(const char *tail)
00046 {
00047     uffs_Object *f;
00048     const char *name;
00049     URET ret;
00050     int oflags = UO_RDWR | UO_CREATE;
00051 
00052     if (tail == NULL) {
00053         return FALSE;
00054     }
00055 
00056     name = cli_getparam(tail, NULL);
00057     
00058     f = uffs_GetObject();
00059     if (f == NULL) {
00060         printf("Fail to get object.\n");
00061         return TRUE;
00062     }
00063 
00064     ret = uffs_CreateObject(f, name, oflags, US_IREAD|US_IWRITE);
00065     if (ret == U_FAIL) {
00066         printf("Create %s fail, err: %d\n", name, f->err);
00067         uffs_PutObject(f);
00068         return TRUE;
00069     }
00070     
00071     printf("Create %s succ.\n", name);
00072     uffs_CloseObject(f);
00073     uffs_PutObject(f);
00074     
00075     return TRUE;
00076 }
00077 
00078 BOOL cmdMkdir(const char *tail)
00079 {
00080     uffs_Object *f;
00081     const char *name;
00082     URET ret;
00083     int oflags = UO_RDWR | UO_CREATE | UO_DIR;
00084 
00085     if (tail == NULL) {
00086         return FALSE;
00087     }
00088 
00089     name = cli_getparam(tail, NULL);
00090     
00091     f = uffs_GetObject();
00092     if (f == NULL) {
00093         printf("Fail to get object.\n");
00094         return TRUE;
00095     }
00096 
00097     ret = uffs_CreateObject(f, name, oflags, US_IREAD|US_IWRITE);
00098     if (ret == U_FAIL) {
00099         printf("Create %s fail, err: %d\n", name, f->err);
00100         uffs_PutObject(f);
00101         return TRUE;
00102     }
00103     
00104     printf("Create %s succ.\n", name);
00105     uffs_CloseObject(f);
00106     uffs_PutObject(f);
00107     
00108     return TRUE;
00109 }
00110 
00111 
00112 static int CountObjectUnder(const char *dir)
00113 {
00114     uffs_FindInfo find = {0};
00115     int count = 0;
00116     URET ret;
00117 
00118     ret = uffs_OpenFindObject(&find, dir);
00119     if (ret == U_SUCC) {
00120         ret = uffs_FindFirstObject(NULL, &find);
00121         while(ret == U_SUCC) {
00122             count++;
00123             ret = uffs_FindNextObject(NULL, &find);
00124         }
00125         uffs_CloseFindObject(&find);
00126     }
00127 
00128     return count;
00129 }
00130 
00131 BOOL cmdLs(const char *tail)
00132 {
00133     uffs_FindInfo find = {0};
00134     uffs_ObjectInfo info;
00135     URET ret;
00136     int count = 0;
00137     char buf[MAX_PATH_LENGTH+2];
00138     char *sub;
00139     const char *name = "/";
00140 
00141     if (tail) {
00142         name = tail;
00143     }
00144 
00145     ret = uffs_OpenFindObject(&find, name);
00146     if (ret == U_FAIL) {
00147         printf("Can't open %s to find.\n", name);
00148         return TRUE;
00149     }
00150 
00151     printf("------name----size----serial--\n");
00152     ret = uffs_FindFirstObject(&info, &find);
00153     while(ret == U_SUCC) {
00154         printf("%9s", info.info.name);
00155         if (info.info.attr & FILE_ATTR_DIR) {
00156             strcpy(buf, name);
00157             sub = strcat(buf, "/");
00158             sub = strcat(sub, info.info.name);
00159             printf("/  \t<%2d>\t", CountObjectUnder(sub));
00160         }
00161         else {
00162             printf("   \t %2d \t", info.len);
00163         }
00164         printf("%d\n", info.serial);
00165         count++;
00166         ret = uffs_FindNextObject(&info, &find);
00167     }
00168     
00169     uffs_CloseFindObject(&find);
00170 
00171     printf("Total: %d objects.\n", count);
00172 
00173     return TRUE;
00174 }
00175 
00176 BOOL cmdRm(const char *tail)
00177 {
00178     const char *name = NULL;
00179     if (tail == NULL) return FALSE;
00180     name = cli_getparam(tail, NULL);
00181     if (uffs_DeleteObject(name) == U_SUCC) {
00182         printf("Delete %s succ.\n", name);
00183     }
00184     else {
00185         printf("Delete %s fail!\n", name);
00186     }
00187     return TRUE;
00188 }
00189 
00190 BOOL cmdRen(const char *tail)
00191 {
00192     const char *oldname;
00193     char *newname;
00194 
00195     if (tail == NULL) return FALSE;
00196     oldname = cli_getparam(tail, &newname);
00197     if (newname == NULL) return FALSE;
00198     if (uffs_RenameObject(oldname, newname) == U_SUCC) {
00199         printf("Rename from %s to %s succ.\n", oldname, newname);
00200     }
00201     else {
00202         printf("Rename from %s to %s fail!\n", oldname, newname);
00203     }
00204     return TRUE;
00205 }
00206 
00207 #ifdef USE_NATIVE_MEMORY_ALLOCATOR
00208 BOOL cmdMeminfo(const char *tail)
00209 {
00210     const char *mount = "/";
00211     int i;
00212     HEAP_MM *mm;
00213     int count = 0;
00214     int blocks = 0;
00215 
00216     uffs_Device *dev;
00217     
00218     if (tail) mount = cli_getparam(tail, NULL);
00219     dev = uffs_GetDevice(mount);
00220 
00221     if (!dev) {
00222         printf("can't get device from mount point %s\n", mount);
00223         return TRUE;
00224     }
00225     
00226     for (i = 0; i < HEAP_HASH_SIZE; i++) {
00227         mm = dev->mem->tbl[i];
00228         while (mm) {
00229             printf("%d, ", mm->size);
00230             count += mm->size;
00231             blocks++;
00232             mm = mm->next;
00233         }
00234     }
00235     printf("\n>>> total allocated %d blocks (%d bytes), max %d bytes. <<<\n", blocks, count, dev->mem->maxused);
00236     
00237     uffs_PutDevice(dev);
00238 
00239     return TRUE;
00240 }
00241 #endif
00242 
00243 BOOL cmdSt(const char *tail)
00244 {
00245     uffs_Device *dev;
00246     const char *mount = "/";
00247     uffs_stat *s;
00248     TreeNode *node;
00249 
00250     if (tail) {
00251         mount = cli_getparam(tail, NULL);
00252     }
00253 
00254     dev = uffs_GetDevice(mount);
00255     if (dev == NULL) {
00256         printf("Can't get device from mount point %s\n", mount);
00257         return TRUE;
00258     }
00259 
00260     s = &(dev->st);
00261 
00262     printf("-----------statistics-----------\n");
00263     printf("Block Erased: %d\n", s->blockEraseCount);
00264     printf("Write Page:   %d\n", s->pageWriteCount);
00265     printf("Write Spare:  %d\n", s->spareWriteCount);
00266     printf("Read Page:    %d\n", s->pageReadCount);
00267     printf("Read Spare:   %d\n", s->spareReadCount);
00268     printf("Disk total:   %d\n", uffs_GetDeviceTotal(dev));
00269     printf("Disk Used:    %d\n", uffs_GetDeviceUsed(dev));
00270     printf("Disk Free:    %d\n", uffs_GetDeviceFree(dev));
00271     printf("Block size:   %d\n", dev->attr.block_data_size);
00272     printf("Total blocks: %d\n", dev->attr.total_blocks);
00273     if (dev->tree.bad) {
00274         printf("Bad blocks: ");
00275         node = dev->tree.bad;
00276         while(node) {
00277             printf("%d, ", node->u.list.block);
00278             node = node->u.list.next;
00279         }
00280         printf("\n");
00281     }
00282 
00283     uffs_PutDevice(dev);
00284     return TRUE;
00285 
00286 }
00287 
00288 BOOL cmdTest1(const char *tail)
00289 {
00290     uffs_Object *f;
00291     URET ret;
00292     char buf[100];
00293     const char *name;
00294 
00295     if (!tail) {
00296         return FALSE;
00297     }
00298 
00299     name = cli_getparam(tail, NULL);
00300 
00301     f = uffs_GetObject();
00302     if (f == NULL) {
00303         printf("Fail to get object.\n");
00304         return TRUE;    
00305     }
00306 
00307     ret = uffs_OpenObject(f, name, UO_RDWR|UO_CREATE, US_IWRITE|US_IREAD);
00308     if (ret != U_SUCC) {
00309         printf("Can't open %s\n", name);
00310         goto fail;
00311     }
00312 
00313     sprintf(buf, "123456789ABCDEF");
00314     ret = uffs_WriteObject(f, buf, strlen(buf));
00315     printf("write %d bytes to file, content: %s\n", ret, buf);
00316 
00317     ret = uffs_SeekObject(f, 3, USEEK_SET);
00318     printf("new file position: %d\n", ret);
00319 
00320     memset(buf, 0, sizeof(buf));
00321     ret = uffs_ReadObject(f, buf, 5);
00322     printf("read %d bytes, content: %s\n", ret, buf);
00323 
00324     uffs_CloseObject(f);
00325 
00326 fail:
00327     uffs_PutObject(f);
00328 
00329     return TRUE;
00330 }
00331 
00332 BOOL cmdCp(const char *tail)
00333 {
00334     const char *src;
00335     char *des;
00336     char buf[100];
00337     uffs_Object *f1 = NULL, *f2 = NULL;
00338     int len;
00339     BOOL src_local = FALSE, des_local = FALSE;
00340     FILE *fp1 = NULL, *fp2 = NULL;
00341 
00342     if (!tail) return FALSE;
00343     src = cli_getparam(tail, &des);
00344     if (!des) return FALSE;
00345 
00346     if (memcmp(src, "::", 2) == 0) {
00347         src += 2;
00348         src_local = TRUE;
00349     }
00350     if (memcmp(des, "::", 2) == 0) {
00351         des += 2;
00352         des_local = TRUE;
00353     }
00354     f1 = uffs_GetObject();
00355     f2 = uffs_GetObject();
00356     if (!f1 || !f2) goto fail_2;
00357     
00358     if (src_local) {
00359         if ((fp1 = fopen(src, "rb")) == NULL) {
00360             printf("Can't open %s for copy.\n", src);
00361             goto fail_1;
00362         }
00363     }
00364     else {
00365         if (uffs_OpenObject(f1, src, UO_RDONLY, US_IREAD) != U_SUCC) {
00366             printf("Can't open %s for copy.\n", src);
00367             goto fail_1;
00368         }
00369     }
00370 
00371     if (des_local) {
00372         if ((fp2 = fopen(des, "wb")) == NULL) {
00373             printf("Can't open %s for copy.\n", des);
00374             goto fail_1;
00375         }
00376     }
00377     else {
00378         if (uffs_OpenObject(f2, des, UO_RDWR|UO_CREATE|UO_TRUNC, US_IREAD|US_IWRITE) != U_SUCC) {
00379             printf("Can't open %s for copy.\n", des);
00380             goto fail_1;
00381         }
00382     }
00383 
00384     while ( (src_local ? (feof(fp1) == 0) : (uffs_EndOfFile(f1) == 0)) ) {
00385         if (src_local) {
00386             len = fread(buf, 1, sizeof(buf), fp1);
00387         }
00388         else {
00389             len = uffs_ReadObject(f1, buf, sizeof(buf));
00390         }
00391         if (len == 0) break;
00392         if (len < 0) {
00393             printf("read file %s fail ?\n", src);
00394             break;
00395         }
00396         if (des_local) {
00397             if ((int)fwrite(buf, 1, len, fp2) != len) {
00398                 printf("write file %s fail ? \n", des);
00399                 break;
00400             }
00401         }
00402         else {
00403             if (uffs_WriteObject(f2, buf, len) != len) {
00404                 printf("write file %s fail ? \n", des);
00405                 break;
00406             }
00407         }
00408     }
00409 
00410 fail_1:
00411     uffs_CloseObject(f1);
00412     uffs_CloseObject(f2);
00413     if (fp1) fclose(fp1);
00414     if (fp2) fclose(fp2);
00415 fail_2:
00416     if (f1) {
00417         uffs_PutObject(f1);
00418     }
00419     if (f2) {
00420         uffs_PutObject(f2);
00421     }
00422     return TRUE;
00423 }
00424 
00425 BOOL cmdCat(const char *tail)
00426 {
00427     uffs_Object *obj;
00428     const char *name;
00429     char buf[100];
00430     int len;
00431 
00432     if (!tail) return FALSE;
00433     name = cli_getparam(tail, NULL);
00434 
00435     obj = uffs_GetObject();
00436     if (!obj) return FALSE;
00437 
00438     if (uffs_OpenObject(obj, name, UO_RDONLY, US_IREAD) == U_FAIL) 
00439         goto fail;
00440 
00441     while (uffs_EndOfFile(obj) == 0) {
00442         len = uffs_ReadObject(obj, buf, sizeof(buf) - 1);
00443         if (len == 0) break;
00444         if (len > 0) {
00445             buf[len] = 0;
00446             printf("%s", buf);
00447         }
00448     }
00449     printf("\n");
00450     uffs_CloseObject(obj);
00451 
00452 fail:
00453     uffs_PutObject(obj);
00454 
00455     return TRUE;
00456 }
00457 
00458 
00459 void DoTest(void)
00460 {
00461     uffs_Object *f;
00462     URET ret;
00463     char buf[100];
00464 
00465     f = uffs_GetObject();
00466     if (f == NULL) {
00467         printf("Fail to get object.\n");
00468         return; 
00469     }
00470 
00471     ret = uffs_OpenObject(f, "/abc", UO_RDWR|UO_DIR, US_IREAD|US_IWRITE);
00472     if (ret != U_SUCC) {
00473         printf("Can't open dir abc, err: %d\n", f->err);
00474         printf("Try to create a new one...\n");
00475         ret = uffs_OpenObject(f, "/abc", UO_RDWR|UO_CREATE|UO_DIR, US_IREAD|US_IWRITE);
00476         if (ret != U_SUCC) {
00477             printf("Can't create new dir abc.\n");
00478             goto fail;
00479         }
00480         else {
00481             uffs_CloseObject(f);
00482         }
00483     }
00484     else {
00485         uffs_CloseObject(f);
00486     }
00487     
00488     ret = uffs_OpenObject(f, "/abc/test.txt", UO_RDWR|UO_CREATE, US_IWRITE|US_IREAD);
00489     if (ret != U_SUCC) {
00490         printf("Can't open test.txt\n");
00491         goto fail;
00492     }
00493 
00494     sprintf(buf, "123456789ABCDEF");
00495     ret = uffs_WriteObject(f, buf, strlen(buf));
00496     printf("write %d bytes to file, content: %s\n", ret, buf);
00497 
00498     ret = uffs_SeekObject(f, 3, USEEK_SET);
00499     printf("new file position: %d\n", ret);
00500 
00501     memset(buf, 0, sizeof(buf));
00502     ret = uffs_ReadObject(f, buf, 5);
00503     printf("read %d bytes, content: %s\n", ret, buf);
00504 
00505 fail:
00506     uffs_CloseObject(f);
00507     uffs_PutObject(f);
00508 }
00509 
00510 
00511 static struct cli_commandset cmdset[] = 
00512 {
00513     { cmdFormat,    "format",       "[<mount>]",        "Format device" },
00514     { cmdMkf,       "mkfile",       "<name>",           "create a new file" },
00515     { cmdMkdir,     "mkdir",        "<name>",           "create a new directory" },
00516     { cmdRm,        "rm",           "<name>",           "delete file/directory" },
00517     { cmdRen,       "mv|ren",       "<old> <new>",      "rename file/directory" },
00518     { cmdLs,        "ls",           "<dir>",            "list dirs and files" },
00519     { cmdSt,        "info|st",      "<mount>",          "show statistic infomation" },
00520 #ifdef USE_NATIVE_MEMORY_ALLOCATOR
00521     { cmdMeminfo,   "mem",          "<mount>",          "show native memory allocator infomation" },
00522 #endif
00523     { cmdTest1,     "t1",           "<name>",           "test 1" },
00524     { cmdCp,        "cp",           "<src> <des>",      "copy files. the local file name start with '::'" },
00525     { cmdCat,       "cat",          "<name>",           "show file content" },
00526 
00527     { NULL, NULL, NULL, NULL }
00528 };
00529 
00530 
00531 int main(int argc, char *argv[])
00532 {
00533 
00534     int ret;
00535     
00536 #if 0
00537     printf("TreeNode size: %d\n", sizeof(TreeNode));
00538     printf("struct blocklistSt: %d\n", sizeof(struct blocklistSt));
00539     printf("struct dirhSt: %d\n", sizeof(struct dirhSt));
00540     printf("struct filehSt: %d\n", sizeof(struct filehSt));
00541     printf("struct fdataSt: %d\n", sizeof(struct fdataSt));
00542 #endif
00543 
00544     ret = InitFileSystem();
00545     if (ret != 0) {
00546         printf ("Init file system fail: %s\n", ret);
00547         return -1;
00548     }
00549 
00550     if (uffs_InitObjectBuf() == U_SUCC) {
00551         cli_add_commandset(cmdset);
00552         cliMain();
00553     }
00554     else {
00555         printf("Fail to init Object buffer.\n");
00556     }
00557 
00558     ReleaseFileSystem();
00559 
00560     return 0;
00561 }
00562 
00563 
00564 

Generated on Sat Mar 17 15:45:44 2007 for uffs-doc by  doxygen 1.5.0