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