43#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
45#include "errcode_fat.h"
88#define FTIME_MIN_OFFSET 6
89#define FTIME_HR_OFFSET 11
90#define FTIME_MTH_OFFSET 5
91#define FTIME_YEAR_OFFSET 9
92#define FTIME_DATE_OFFSET 16
93#define SEC_MULTIPLIER 2
100#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
101 if (result < 0 || result >= VIRERR_BASE) {
120 case FR_NO_FILESYSTEM:
124 case FR_INVALID_NAME:
129 case FR_INVALID_OBJECT:
139 case FR_WRITE_PROTECTED:
142 case FR_MKFS_ABORTED:
143 case FR_INVALID_PARAMETER:
147 case FR_NO_SPACE_LEFT:
153 case FR_NO_EMPTY_DIR:
170#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
172 status = -VIRERR_MODIFIED;
175 status = -VIRERR_CHAIN_ERR;
178 status = -VIRERR_OCCUPIED;
181 status = -VIRERR_NOTCLEAR;
184 status = -VIRERR_NOTFIT;
186 case FR_INVAILD_FATFS:
187 status = -VIRERR_INTER_ERR;
200 switch (fs->fs_type) {
202 return (cclust == FAT12_END_OF_CLUSTER);
204 return (cclust == FAT16_END_OF_CLUSTER);
207 return (cclust == FAT32_END_OF_CLUSTER);
213#ifdef LOSCFG_FS_FAT_CACHE
215 if (!(mountflags & (MS_NOSYNC | MS_RDONLY))) {
230 DIR_FILE *dfp_target = (DIR_FILE *)arg;
231 DIR_FILE *dfp = (DIR_FILE *)vp->
data;
233 return dfp_target->f_dir.sect != dfp->f_dir.sect ||
234 dfp_target->f_dir.dptr != dfp->f_dir.dptr ||
235 dfp_target->fno.sclst != dfp->fno.sclst;
240 DWORD hash = FNV1_32A_INIT;
251 if (attribute & AM_RDO) {
252 mask = S_IWUSR | S_IWGRP | S_IWOTH;
255 if (attribute & AM_DIR) {
257 }
else if (attribute & AM_LNK) {
280static FRESULT
init_cluster(DIR_FILE *pdfp, DIR *dp_new, FATFS *fs,
int type,
const char *target, DWORD *clust)
289 *clust = create_chain(&(dp_new->obj), 0);
291 return FR_NO_SPACE_LEFT;
293 if (*clust == 1 || *clust == DISK_ERROR) {
297 result = sync_window(fs);
298 if (result != FR_OK) {
299 remove_chain(&(dp_new->obj), *clust, 0);
304#ifndef LOSCFG_FS_FAT_VIRTUAL_PARTITION
307 dir = PARENTFS(fs)->win;
310 sect = clst2sect(fs, *clust);
311 mem_set(dir, 0, SS(fs));
312 if (type == AM_LNK && target) {
314 (
void)strcpy_s((
char *)dir, SS(fs), target);
317 mem_set(dir, 0, SS(fs));
318 mem_set(dir + DIR_Name,
' ', 11);
320 dir[DIR_Attr] = AM_DIR;
321 st_clust(fs, dir, *clust);
322 mem_cpy(dir + DIR_SIZE, dir, DIR_SIZE);
323 dir[DIR_SIZE + 1] =
'.';
324 pclust = pdfp->fno.sclst;
325 if (fs->fs_type == FS_FAT32 && pclust == fs->dirbase) {
328 st_clust(fs, dir + DIR_SIZE, pclust);
331#ifndef LOSCFG_FS_FAT_VIRTUAL_PARTITION
332 fs->winsect = sect++;
335 PARENTFS(fs)->winsect = sect++;
336 PARENTFS(fs)->wflag = 1;
338 result = sync_window(fs);
339 if (result != FR_OK) {
340 remove_chain(&(dp_new->obj), *clust, 0);
345 if (type == AM_DIR) {
346 mem_set(dir, 0, SS(fs));
347 for (n = fs->csize - 1; n > 0; n--) {
348#ifndef LOSCFG_FS_FAT_VIRTUAL_PARTITION
349 fs->winsect = sect++;
352 PARENTFS(fs)->winsect = sect++;
353 PARENTFS(fs)->wflag = 1;
355 result = sync_window(fs);
356 if (result != FR_OK) {
357 remove_chain(&(dp_new->obj), *clust, 0);
368 struct Vnode *vp = NULL;
371 FILINFO *finfo = &(dfp->fno);
372 DIR_FILE *dfp_new = NULL;
373 FILINFO *finfo_new = NULL;
381 if ((
type != AM_ARC) && (
type != AM_DIR) && (
type != AM_LNK)) {
382 result = FR_INVALID_NAME;
386 dfp_new = (DIR_FILE *)
zalloc(
sizeof(DIR_FILE));
387 if (dfp_new == NULL) {
388 result = FR_NOT_ENOUGH_CORE;
398 if (finfo->fattrib & AM_ARC || finfo->fattrib & AM_LNK) {
403 finfo_new = &(dfp_new->fno);
405 dp_new = &(dfp_new->f_dir);
407 dp_new->obj.sclust = finfo->sclst;
412 result = create_name(dp_new, &name);
413 if (result != FR_OK) {
417 result = dir_find(dp_new);
418 if (result == FR_OK) {
423 if (
type == AM_DIR ||
type == AM_LNK) {
425 if (result != FR_OK) {
430 result = dir_register(dp_new);
431 if (result != FR_OK) {
432 goto ERROR_REMOVE_CHAIN;
436 if (time_status == SYSTEM_TIME_ENABLE) {
437 time = GET_FATTIME();
441 st_dword(dp_new->dir + DIR_CrtTime,
time);
442 st_dword(dp_new->dir + DIR_ModTime,
time);
443 st_word(dp_new->dir + DIR_LstAccDate,
time >> FTIME_DATE_OFFSET);
444 dp_new->dir[DIR_Attr] =
type;
445 if (((DWORD)
mode & S_IWUSR) == 0) {
446 dp_new->dir[DIR_Attr] |= AM_RDO;
448 st_clust(fs, dp_new->dir, clust);
449 if (
type == AM_ARC) {
450 st_dword(dp_new->dir + DIR_FileSize, 0);
451 }
else if (
type == AM_LNK) {
452 st_dword(dp_new->dir + DIR_FileSize, strlen(target));
455#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
456 PARENTFS(fs)->wflag = 1;
460 result = sync_fs(fs);
461 if (result != FR_OK) {
462 goto ERROR_REMOVE_CHAIN;
464 result = dir_read(dp_new, 0);
465 if (result != FR_OK) {
466 goto ERROR_REMOVE_CHAIN;
468 dp_new->blk_ofs = dir_ofs(dp_new);
469 get_fileinfo(dp_new, finfo_new);
470 if (
type == AM_ARC) {
471 dp_new->obj.objsize = 0;
472 }
else if (
type == AM_LNK) {
473 dp_new->obj.objsize = strlen(target);
475 finfo_new->fsize = fs->csize * SS(fs);
480 result = FR_NOT_ENOUGH_CORE;
481 goto ERROR_REMOVE_CHAIN;
488 vp->
uid = fs->fs_uid;
489 vp->
gid = fs->fs_gid;
496 result = FR_NOT_ENOUGH_CORE;
497 goto ERROR_REMOVE_CHAIN;
501 unlock_fs(fs, FR_OK);
506 remove_chain(&(dp_new->obj), clust, 0);
508 unlock_fs(fs, result);
518 struct Vnode *vp = NULL;
522 FILINFO *finfo = NULL;
527 dfp = (DIR_FILE *)
zalloc(
sizeof(DIR_FILE));
542 dp->obj.sclust = ((DIR_FILE *)(
parent->
data))->fno.sclst;
546 result = create_name(dp, &path);
547 if (result != FR_OK) {
552 result = dir_find(dp);
553 if (result != FR_OK) {
558 if (dp->fn[NSFLAG] & NS_NONAME) {
559 result = FR_INVALID_NAME;
564 get_fileinfo(dp, finfo);
573 result = FR_NOT_ENOUGH_CORE;
580 vp->
uid = fs->fs_uid;
581 vp->
gid = fs->fs_gid;
583 if (finfo->fattrib & AM_DIR) {
585 finfo->fsize = fs->csize * SS(fs);
592 result = FR_INVALID_PARAMETER;
600 unlock_fs(fs, FR_OK);
606 unlock_fs(fs, result);
622 struct Vnode *vp = filep->f_vnode;
624 DIR_FILE *dfp = (DIR_FILE *)vp->
data;
625 DIR *dp = &(dfp->f_dir);
626 FILINFO *finfo = &(dfp->fno);
630 fp = (FIL *)
zalloc(
sizeof(FIL) + SS(fs));
641 fp->dir_sect = dp->sect;
642 fp->dir_ptr = dp->dir;
643 fp->obj.sclust = finfo->sclst;
644 fp->obj.objsize = finfo->fsize;
650 fp->flag = FA_READ | FA_WRITE;
654 fp->buf = (BYTE *)fp +
sizeof(FIL);
656 unlock_fs(fs, FR_OK);
669 FIL *fp = (FIL *)filep->
f_priv;
670 FATFS *fs = fp->obj.fs;
680 if (result != FR_OK) {
683 ret =
fatfs_sync(filep->f_vnode->originMount->mountFlags, fs);
685 unlock_fs(fs, FR_OK);
693 unlock_fs(fs, result);
699 FIL *fp = (FIL *)filep->
f_priv;
700 FATFS *fs = fp->obj.fs;
701 struct Vnode *vp = filep->f_vnode;
702 FILINFO *finfo = &((DIR_FILE *)(vp->data))->fno;
711 fp->obj.objsize = finfo->fsize;
712 fp->obj.sclust = finfo->sclst;
713 result = f_read(fp, buff, count, &rcount);
714 if (result != FR_OK) {
717 filep->
f_pos = fp->fptr;
719 unlock_fs(fs, result);
725 FATFS *fs = dp->obj.fs;
730 result = move_window(fs, dp->sect);
731 if (result != FR_OK) {
734 dbuff = fs->win + dp->dptr % SS(fs);
735 dbuff[DIR_Attr] = finfo->fattrib;
736 st_clust(fs, dbuff, finfo->sclst);
737 st_dword(dbuff + DIR_FileSize, (DWORD)finfo->fsize);
738 if (time_status == SYSTEM_TIME_ENABLE) {
743 st_dword(dbuff + DIR_ModTime, tm);
744 st_word(dbuff + DIR_LstAccDate, tm >> FTIME_DATE_OFFSET);
745#ifndef LOSCFG_FS_FAT_VIRTUAL_PARTITION
748 PARENTFS(fs)->wflag = 1;
755 FIL *fp = (FIL *)filep->
f_priv;
756 FATFS *fs = fp->obj.fs;
757 struct Vnode *vp = filep->f_vnode;
758 DIR_FILE *dfp = (DIR_FILE *)vp->data;
759 FILINFO *finfo = &(dfp->fno);
760 struct Mount *mount = vp->originMount;
767 offset = filep->
f_pos + offset;
780 offset = (off_t)((
long long)finfo->fsize + offset);
790 if (offset >= FAT32_MAXSIZE) {
799 if (fpos > finfo->fsize) {
800 if ((filep->
f_oflags & O_ACCMODE) == O_RDONLY) {
805 result = FR_WRITE_PROTECTED;
809 fp->obj.sclust = finfo->sclst;
810 fp->obj.objsize = finfo->fsize;
812 result = f_lseek(fp, fpos);
813 finfo->fsize = fp->obj.objsize;
814 finfo->sclst = fp->obj.sclust;
815 if (result != FR_OK) {
820 if (result != FR_OK) {
825 unlock_fs(fs, FR_OK);
828 unlock_fs(fs, result);
840 FATFS *fs = wfp->obj.fs;
844 LOS_DL_LIST_FOR_EACH_ENTRY(entry, list, FIL, fp_entry) {
848 if (entry->sect != 0) {
849 if (disk_read(fs->pdrv, entry->buf, entry->sect, 1) != RES_OK) {
860 FIL *fp = (FIL *)filep->
f_priv;
861 FATFS *fs = fp->obj.fs;
862 struct Vnode *vp = filep->f_vnode;
863 FILINFO *finfo = &(((DIR_FILE *)vp->data)->fno);
872 fp->obj.objsize = finfo->fsize;
873 fp->obj.sclust = finfo->sclst;
874 result = f_write(fp, buff, count, &wcount);
875 if (result != FR_OK) {
879 finfo->fsize = fp->obj.objsize;
880 finfo->sclst = fp->obj.sclust;
882 if (result != FR_OK) {
887 filep->
f_pos = fp->fptr;
889 unlock_fs(fs, FR_OK);
892 unlock_fs(fs, result);
899 FATFS *fs = fp->obj.fs;
909 unlock_fs(fs, result);
915 FIL *fp = (FIL *)filep->
f_priv;
916 FATFS *fs = fp->obj.fs;
917 struct Vnode *vp = filep->f_vnode;
918 FILINFO *finfo = &((DIR_FILE *)(vp->data))->fno;
922 if (offset < 0 || len <= 0) {
926 if (len >= FAT32_MAXSIZE || offset >= FAT32_MAXSIZE ||
927 len + offset >= FAT32_MAXSIZE) {
931 if (mode != FALLOC_FL_KEEP_SIZE) {
939 result = f_expand(fp, (FSIZE_t)offset, (FSIZE_t)len, 1);
940 if (result == FR_OK) {
941 if (finfo->sclst == 0) {
942 finfo->sclst = fp->obj.sclust;
946 unlock_fs(fs, result);
961 if (finfo->sclst != 0) {
962 result = remove_chain(obj, finfo->sclst, 0);
963 if (result != FR_OK) {
972 csize = SS(fs) * fs->csize;
973 if (finfo->sclst == 0) {
974 cclust = create_chain(obj, 0);
976 return FR_NO_SPACE_LEFT;
978 if (cclust == 1 || cclust == DISK_ERROR) {
981 finfo->sclst = cclust;
983 cclust = finfo->sclst;
984 while (remain > csize) {
986 cclust = create_chain(obj, pclust);
988 return FR_NO_SPACE_LEFT;
990 if (cclust == 1 || cclust == DISK_ERROR) {
996 cclust = get_fat(obj, pclust);
997 if ((cclust == BAD_CLUSTER) || (cclust == DISK_ERROR)) {
1001 result = remove_chain(obj, cclust, pclust);
1002 if (result != FR_OK) {
1018 DIR_FILE *dfp = (DIR_FILE *)vp->
data;
1019 DIR *dp = &(dfp->f_dir);
1020 FILINFO *finfo = &(dfp->fno);
1022 FRESULT result = FR_OK;
1025 if (len < 0 || len >= FAT32_MAXSIZE) {
1031 result = FR_TIMEOUT;
1034 if (len == finfo->fsize) {
1035 unlock_fs(fs, FR_OK);
1041 if (result != FR_OK) {
1044 finfo->fsize = (FSIZE_t)len;
1047 if (result != FR_OK) {
1050 unlock_fs(fs, FR_OK);
1053 unlock_fs(fs, result);
1067 if (blk_driver == NULL || blk_driver->
data == NULL) {
1071 struct drv_data *dd = blk_driver->
data;
1072 if (dd->ops == NULL) {
1075 const struct block_operations *bops = dd->ops;
1076 if (bops->open == NULL) {
1079 if (bops->open(blk_driver) < 0) {
1088 bops->close(blk_driver);
1092#ifndef FF_MULTI_PARTITION
1094 bops->close(blk_driver);
1105 struct Vnode *vp = NULL;
1107 DIR_FILE *dfp = NULL;
1126 fs = (FATFS *)
zalloc(
sizeof(FATFS));
1129 goto ERROR_PARTNAME;
1132#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
1133 fs->vir_flag = FS_PARENT;
1135 fs->vir_amount = DISK_ERROR;
1136 fs->vir_avail = FS_VIRDISABLE;
1139 ret = ff_cre_syncobj(0, &fs->sobj);
1148 goto ERROR_WITH_MUX;
1154#if FF_MAX_SS != FF_MIN_SS
1155 if (disk_ioctl(fs->pdrv, GET_SECTOR_SIZE, &(fs->ssize)) != RES_OK) {
1157 goto ERROR_WITH_LOCK;
1159 if (fs->ssize > FF_MAX_SS || fs->ssize < FF_MIN_SS || (fs->ssize & (fs->ssize - 1))) {
1161 goto ERROR_WITH_LOCK;
1165 fs->win = (BYTE *)ff_memalloc(SS(fs));
1166 if (fs->win == NULL) {
1168 goto ERROR_WITH_LOCK;
1172 if (result != FR_OK) {
1174 goto ERROR_WITH_FSWIN;
1178 if (result != FR_OK) {
1180 goto ERROR_WITH_FSWIN;
1189 dfp = (DIR_FILE *)
zalloc(
sizeof(DIR_FILE));
1192 goto ERROR_WITH_FSWIN;
1195 dfp->f_dir.obj.fs = fs;
1196 dfp->f_dir.obj.sclust = 0;
1197 dfp->f_dir.obj.attr = AM_DIR;
1198 dfp->f_dir.obj.objsize = 0;
1202 dfp->fno.fattrib = AM_DIR;
1204 dfp->fno.fsize = fs->csize * SS(fs);
1205 dfp->fno.fname[0] =
'/';
1206 dfp->fno.fname[1] =
'\0';
1212 goto ERROR_WITH_FSWIN;
1222 vp->
uid = fs->fs_uid;
1223 vp->
gid = fs->fs_gid;
1231 goto ERROR_WITH_LOCK;
1233 unlock_fs(fs, FR_OK);
1238 ff_memfree(fs->win);
1240 unlock_fs(fs, FR_OK);
1242 ff_del_syncobj(&fs->sobj);
1256 struct Vnode *device;
1257 FATFS *fs = (FATFS *)mnt->
data;
1268 unlock_fs(fs, FR_OK);
1272 if (device == NULL) {
1273 unlock_fs(fs, FR_OK);
1276#ifdef LOSCFG_FS_FAT_CACHE
1279 unlock_fs(fs, FR_DISK_ERR);
1283 if (part->part_name != NULL) {
1284 free(part->part_name);
1285 part->part_name = NULL;
1288 struct drv_data *dd = device->
data;
1289 if (dd->ops == NULL) {
1290 unlock_fs(fs, FR_OK);
1294 const struct block_operations *bops = dd->ops;
1295 if (bops != NULL && bops->close != NULL) {
1296 bops->close(*blkdriver);
1299 if (fs->win != NULL) {
1300 ff_memfree(fs->win);
1303 unlock_fs(fs, FR_OK);
1305 ret = ff_del_syncobj(&fs->sobj);
1311 *blkdriver = device;
1320#ifdef LOSCFG_FS_FAT_CACHE
1321 struct Vnode *dev = NULL;
1341 FATFS *fs = (FATFS *)mnt->
data;
1343 FRESULT result = FR_OK;
1346 info->f_type = MSDOS_SUPER_MAGIC;
1347#
if FF_MAX_SS != FF_MIN_SS
1348 info->f_bsize = fs->ssize * fs->csize;
1350 info->f_bsize = FF_MIN_SS * fs->csize;
1352 info->f_blocks = fs->n_fatent;
1358 if (fs->free_clst == DISK_ERROR) {
1359 result = fat_count_free_entries(&nclst, fs);
1361 info->f_bfree = fs->free_clst;
1362 info->f_bavail = fs->free_clst;
1363 unlock_fs(fs, result);
1367 info->f_namelen = FF_MAX_LFN;
1370 info->f_namelen = (8 + 1 + 3);
1372 info->f_fsid.__val[0] = MSDOS_SUPER_MAGIC;
1373 info->f_fsid.__val[1] = 1;
1374 info->f_frsize = SS(fs) * fs->csize;
1384 return (ftime & BITMASK5) * SEC_MULTIPLIER;
1388 return (ftime >> FTIME_MIN_OFFSET) & BITMASK6;
1392 return (ftime >> FTIME_HR_OFFSET) & BITMASK5;
1396 return fdate & BITMASK5;
1400 return (fdate >> FTIME_MTH_OFFSET) & BITMASK4;
1404 return (fdate >> FTIME_YEAR_OFFSET) & BITMASK7;
1409 struct tm
time = { 0 };
1416 time_t ret = mktime(&
time);
1425 localtime_r(&
time, &st);
1427 ftime = (DWORD)st.tm_mday;
1428 ftime |= ((DWORD)st.tm_mon) << FTIME_MTH_OFFSET;
1429 ftime |= ((DWORD)((st.tm_year > YEAR_OFFSET) ? (st.tm_year - YEAR_OFFSET) : 0)) << FTIME_YEAR_OFFSET;
1430 ftime <<= FTIME_DATE_OFFSET;
1432 ftime = (DWORD)st.tm_sec / SEC_MULTIPLIER;
1433 ftime |= ((DWORD)st.tm_min) << FTIME_MIN_OFFSET;
1434 ftime |= ((DWORD)st.tm_hour) << FTIME_HR_OFFSET;
1442 DIR_FILE *dfp = (DIR_FILE *)vp->
data;
1443 FILINFO *finfo = &(dfp->fno);
1452 sp->st_dev = fs->pdrv;
1455 sp->st_uid = fs->fs_uid;
1456 sp->st_gid = fs->fs_gid;
1457 sp->st_size = finfo->fsize;
1458 sp->st_blksize = fs->csize * SS(fs);
1459 if (finfo->fattrib & AM_ARC) {
1460 sp->st_blocks = finfo->fsize ? ((finfo->fsize - 1) / SS(fs) / fs->csize + 1) : 0;
1462 sp->st_blocks = fs->csize;
1470 unlock_fs(fs, FR_OK);
1476 BYTE *dir = dp->dir;
1480 st_word(dir + DIR_LstAccDate, (ftime >> FTIME_DATE_OFFSET));
1485 st_dword(dir + DIR_CrtTime, ftime);
1490 st_dword(dir + DIR_ModTime, ftime);
1497 DIR_FILE *dfp = (DIR_FILE *)vp->
data;
1498 DIR *dp = &(dfp->f_dir);
1499 FILINFO *finfo = &(dfp->fno);
1500 BYTE *dir = dp->dir;
1505 if (finfo->fname[0] ==
'/') {
1511 result = FR_TIMEOUT;
1515 result = move_window(fs, dp->sect);
1516 if (result != FR_OK) {
1522 if ((attr->
attr_chg_mode & S_IWUSR) == 0 && (finfo->fattrib & AM_RDO) == 0) {
1523 dir[DIR_Attr] |= AM_RDO;
1524 finfo->fattrib |= AM_RDO;
1526 }
else if ((attr->
attr_chg_mode & S_IWUSR) != 0 && (finfo->fattrib & AM_RDO) != 0) {
1527 dir[DIR_Attr] &= ~AM_RDO;
1528 finfo->fattrib &= ~AM_RDO;
1534 if (attr->
attr_chg_valid & (CHG_ATIME | CHG_CTIME | CHG_MTIME)) {
1536 ftime = ld_dword(dp->dir + DIR_ModTime);
1537 finfo->fdate = (WORD)(ftime >> FTIME_DATE_OFFSET);
1538 finfo->ftime = (WORD)ftime;
1541 result = sync_window(fs);
1542 if (result != FR_OK) {
1546 unlock_fs(fs, FR_OK);
1549 unlock_fs(fs, result);
1557 DIR_FILE *dfp = (DIR_FILE *)vp->
data;
1558 FILINFO *finfo = &(dfp->fno);
1564 dp = (DIR*)
zalloc(
sizeof(DIR));
1573 clst = finfo->sclst;
1575 dp->obj.sclust = clst;
1577 result = dir_sdi(dp, 0);
1578 if (result != FR_OK) {
1580 unlock_fs(fs, result);
1583 unlock_fs(fs, result);
1584 idir->u.fs_dir = dp;
1593 DIR* dp = (DIR*)idir->u.fs_dir;
1594 struct dirent *dirp = NULL;
1604 for (i = 0; i < idir->read_cnt; i++) {
1606 result = dir_read_massive(dp, 0);
1607 if (result == FR_NO_FILE) {
1609 }
else if (result != FR_OK) {
1612 get_fileinfo(dp, &fno);
1614 if (fno.fname[0] == 0x00 || fno.fname[0] == (TCHAR)0xFF) {
1618 dirp = &(idir->fd_dir[i]);
1619 if (fno.fattrib & AM_DIR) {
1620 dirp->d_type = DT_DIR;
1622 dirp->d_type = DT_REG;
1624 if (strncpy_s(dirp->d_name,
sizeof(dirp->d_name), fno.fname, strlen(fno.fname)) != EOK) {
1625 result = FR_NOT_ENOUGH_CORE;
1628 result = dir_next(dp, 0);
1629 if (result != FR_OK && result != FR_NO_FILE) {
1632 idir->fd_position++;
1633 idir->fd_dir[i].d_off = idir->fd_position;
1634 idir->fd_dir[i].d_reclen = (uint16_t)
sizeof(
struct dirent);
1636 unlock_fs(fs, FR_OK);
1640 unlock_fs(fs, result);
1647 DIR *dp = (DIR *)dir->u.fs_dir;
1648 FATFS *fs = dp->obj.fs;
1657 result = dir_sdi(dp, 0);
1658 unlock_fs(fs, result);
1664 DIR *dp = (DIR *)dir->u.fs_dir;
1666 dir->u.fs_dir = NULL;
1670static FRESULT
rename_check(DIR *dp_new, FILINFO *finfo_new, DIR *dp_old, FILINFO *finfo_old)
1674 if (finfo_new->fattrib & AM_ARC) {
1675 if (finfo_old->fattrib & AM_DIR) {
1678 }
else if (finfo_new->fattrib & AM_DIR) {
1679 if (finfo_old->fattrib & AM_ARC) {
1682 dir_sub.obj.fs = dp_old->obj.fs;
1683 dir_sub.obj.sclust = finfo_new->sclst;
1684 result = dir_sdi(&dir_sub, 0);
1685 if (result != FR_OK) {
1688 result = dir_read(&dir_sub, 0);
1689 if (result == FR_OK) {
1690 return FR_NO_EMPTY_DIR;
1701 DIR_FILE *dfp_old = (DIR_FILE *)old_vnode->
data;
1702 DIR *dp_old = &(dfp_old->f_dir);
1703 FILINFO *finfo_old = &(dfp_old->fno);
1704 DIR_FILE *dfp_new = NULL;
1706 FILINFO* finfo_new = NULL;
1716 dfp_new = (DIR_FILE *)
zalloc(
sizeof(DIR_FILE));
1717 if (dfp_new == NULL) {
1718 result = FR_NOT_ENOUGH_CORE;
1721 dp_new = &(dfp_new->f_dir);
1722 finfo_new = &(dfp_new->fno);
1724 dp_new->obj.sclust = ((DIR_FILE *)(new_parent->
data))->fno.sclst;
1725 dp_new->obj.fs = fs;
1730 result = create_name(dp_new, &newname);
1731 if (result != FR_OK) {
1734 result = dir_find(dp_new);
1735 if (result == FR_OK) {
1736 get_fileinfo(dp_new, finfo_new);
1737 result =
rename_check(dp_new, finfo_new, dp_old, finfo_old);
1738 if (result != FR_OK) {
1741 result = dir_remove(dp_old);
1742 if (result != FR_OK) {
1745 clust = finfo_new->sclst;
1747 result = remove_chain(&(dp_new->obj), clust, 0);
1748 if (result != FR_OK) {
1753 result = dir_remove(dp_old);
1754 if (result != FR_OK) {
1757 result = dir_register(dp_new);
1758 if (result != FR_OK) {
1765 if (result != FR_OK) {
1768 result = dir_read(dp_new, 0);
1769 if (result != FR_OK) {
1772 dp_new->blk_ofs = dir_ofs(dp_new);
1773 get_fileinfo(dp_new, finfo_new);
1775 dfp_new->fno.fp_list.pstNext = dfp_old->fno.fp_list.pstNext;
1776 dfp_new->fno.fp_list.pstPrev = dfp_old->fno.fp_list.pstPrev;
1777 ret = memcpy_s(dfp_old,
sizeof(DIR_FILE), dfp_new,
sizeof(DIR_FILE));
1779 result = FR_NOT_ENOUGH_CORE;
1783 unlock_fs(fs, FR_OK);
1790 unlock_fs(fs, result);
1799 if ((UINT)opt & FMT_ERASE) {
1800 opt = (UINT)opt & (~FMT_ERASE);
1802 PRINTK(
"Disk erase error.\n");
1807 if (opt != FM_FAT && opt != FM_FAT32) {
1836 part->
sector_start = LD_DWORD_DISK(&buf[PAR_OFFSET + PAR_START_OFFSET]);
1837 part->
sector_count = LD_DWORD_DISK(&buf[PAR_OFFSET + PAR_COUNT_OFFSET]);
1848 QWORD start_sector = 0;
1853#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
1854 fs.vir_flag = FS_PARENT;
1856 fs.vir_amount = DISK_ERROR;
1857 fs.vir_avail = FS_VIRDISABLE;
1859 if (disk_ioctl(fs.pdrv, GET_SECTOR_SIZE, &(fs.ssize)) != RES_OK) {
1862 fs.win = (BYTE *)ff_memalloc(fs.ssize);
1863 if (fs.win == NULL) {
1868 if (result != FR_OK) {
1874 if (result != FR_OK) {
1879 result = set_volumn_label(&fs,
FatLabel);
1887 BYTE *work_buff = NULL;
1890 MKFS_PARM opt = {0};
1894 if (part == NULL || device->
data == NULL) {
1898 if (sectors < 0 || sectors > FAT32_MAX_CLUSTER_SIZE || ((DWORD)sectors & ((DWORD)sectors - 1))) {
1902 if (option != FMT_FAT && option != FMT_FAT32 && option != FMT_ANY && option != FMT_ERASE) {
1910 work_buff = (BYTE *)
zalloc(FF_MAX_SS);
1911 if (work_buff == NULL) {
1915 opt.n_sect = sectors;
1916 opt.fmt = (BYTE)option;
1917 result =
_mkfs(part, &opt, work_buff, FF_MAX_SS);
1919 if (result != FR_OK) {
1924 if (result == FR_OK) {
1925#ifdef LOSCFG_FS_FAT_CACHE
1949 DIR_FILE *dfp = (DIR_FILE *)vp->
data;
1950 FILINFO *finfo = &(dfp->fno);
1951 DIR *dp = &(dfp->f_dir);
1953 FRESULT result = FR_OK;
1956 if (finfo->fattrib & AM_ARC) {
1966 result = FR_TIMEOUT;
1969 dir_sub.obj.fs = fs;
1970 dir_sub.obj.sclust = finfo->sclst;
1971 result = dir_sdi(&dir_sub, 0);
1972 if (result != FR_OK) {
1975 result = dir_read(&dir_sub, 0);
1976 if (result == FR_OK) {
1977 result = FR_NO_EMPTY_DIR;
1980 result = dir_remove(dp);
1981 if (result != FR_OK) {
1985 result = remove_chain(&(dp->obj), finfo->sclst, 0);
1986 if (result != FR_OK) {
1990 unlock_fs(fs, FR_OK);
1995 unlock_fs(fs, result);
2011 DIR_FILE *dfp = (DIR_FILE *)vp->
data;
2012 FILINFO *finfo = &(dfp->fno);
2013 DIR *dp = &(dfp->f_dir);
2014 FRESULT result = FR_OK;
2017 if (finfo->fattrib & AM_DIR) {
2023 result = FR_TIMEOUT;
2026 result = dir_remove(dp);
2027 if (result != FR_OK) {
2030 if (finfo->sclst != 0) {
2031 result = remove_chain(&(dp->obj), finfo->sclst, 0);
2032 if (result != FR_OK) {
2036 result = sync_fs(fs);
2037 if (result != FR_OK) {
2040 unlock_fs(fs, FR_OK);
2044 unlock_fs(fs, result);
2054#define CHECK_FILE_NUM 3
2057 return (finfo->fdate << FTIME_DATE_OFFSET) | finfo->ftime;
2066 for (i = 1; i < len; i++) {
2068 if (
time < old_time) {
2073 *oldest_time = old_time;
2079 DIR_FILE df[CHECK_FILE_NUM] = {0};
2084 DWORD old_time = -1;
2086 for (count = 0; count < CHECK_FILE_NUM; count++) {
2087 if ((result = f_readdir(dp, &fno)) != FR_OK) {
2090 if (fno.fname[0] == 0 || fno.fname[0] == (TCHAR)0xFF) {
2093 (
void)memcpy_s(&df[count].f_dir,
sizeof(DIR), dp,
sizeof(DIR));
2094 (
void)memcpy_s(&df[count].fno,
sizeof(FILINFO), &fno,
sizeof(FILINFO));
2096 if (
time < old_time) {
2102 while ((result = f_readdir(dp, &fno)) == FR_OK) {
2103 if (fno.fname[0] == 0 || fno.fname[0] == (TCHAR)0xFF) {
2107 if (
time < old_time) {
2108 (
void)memcpy_s(&df[index].f_dir,
sizeof(DIR), dp,
sizeof(DIR));
2109 (
void)memcpy_s(&df[index].fno,
sizeof(FILINFO), &fno,
sizeof(FILINFO));
2114 while (result == FR_OK && index < count) {
2115 result = f_fcheckfat(&df[index]);
2126 FILINFO *finfo = &(((DIR_FILE *)(vp->
data))->fno);
2127#ifdef LOSCFG_FS_FAT_CACHE
2133 if (fs->fs_type != FS_FAT32) {
2137 if ((finfo->fattrib & AM_DIR) == 0) {
2148 result = FR_TIMEOUT;
2149 goto ERROR_WITH_DIR;
2152 dp = (DIR *)dir->u.fs_dir;
2153 dp->obj.id = fs->id;
2155 if (result != FR_OK) {
2159 unlock_fs(fs, FR_OK);
2166#ifdef LOSCFG_FS_FAT_CACHE
2176 unlock_fs(fs, result);
2189 FRESULT res = FR_OK;
2192 DIR_FILE *dfp = (DIR_FILE *)(vnode->
data);
2193 DIR *dp = &(dfp->f_dir);
2194 FATFS *fs = dp->obj.fs;
2195 FILINFO *finfo = &(dfp->fno);
2196 size_t targetLen = finfo->fsize;
2204 clust = finfo->sclst;
2205 sect = clst2sect(fs, clust);
2211 if (move_window(fs, sect) != FR_OK) {
2216 cnt = (bufLen - 1) < targetLen ? (bufLen - 1) : targetLen;
2219 res = FR_INVALID_PARAMETER;
2224 unlock_fs(fs, FR_OK);
2235 DIR_FILE *dfp = (DIR_FILE *)(vnode->
data);
2236 FILINFO *finfo = &(dfp->fno);
2237 FAT_ENTRY *ep = &(dfp->fat_entry);
2244 BYTE *buf = (BYTE *)buff;
2245 size_t buflen = PAGE_SIZE;
2251 result = FR_TIMEOUT;
2255 if (finfo->fsize <= pos) {
2260 if (ep->clst == 0) {
2261 ep->clst = finfo->sclst;
2264 if (pos >= ep->pos) {
2268 clust = finfo->sclst;
2273 n = pos / SS(fs) / fs->csize - position / SS(fs) / fs->csize;
2275 clust = get_fat(&(dfp->f_dir.obj), clust);
2276 if ((clust == BAD_CLUSTER) || (clust == DISK_ERROR)) {
2277 result = FR_DISK_ERR;
2283 sect = clst2sect(fs, clust);
2284 sect += (pos / SS(fs)) & (fs->csize - 1);
2287 if (fs->csize < buflen / SS(fs)) {
2290 step = buflen / SS(fs);
2295 while (n < buflen / SS(fs)) {
2296 if (disk_read(fs->pdrv, buf, sect, step) != RES_OK) {
2297 result = FR_DISK_ERR;
2301 if (n >= buflen / SS(fs)) {
2306 clust = get_fat(&(dfp->f_dir.obj), clust);
2307 if ((clust == BAD_CLUSTER) || (clust == DISK_ERROR)) {
2308 result = FR_DISK_ERR;
2313 sect = clst2sect(fs, clust);
2314 buf += step * SS(fs);
2320 unlock_fs(fs, FR_OK);
2322 return (
ssize_t)min(finfo->fsize - pos, n * SS(fs));
2325 unlock_fs(fs, result);
2333 DIR_FILE *dfp = (DIR_FILE *)(vnode->
data);
2334 FILINFO *finfo = &(dfp->fno);
2335 FAT_ENTRY *ep = &(dfp->fat_entry);
2342 BYTE *buf = (BYTE *)buff;
2349 result = FR_TIMEOUT;
2353 if (finfo->fsize <= pos) {
2358 if (ep->clst == 0) {
2359 ep->clst = finfo->sclst;
2362 if (pos >= ep->pos) {
2366 clust = finfo->sclst;
2371 n = pos / SS(fs) / fs->csize - position / SS(fs) / fs->csize;
2373 clust = get_fat(&(dfp->f_dir.obj), clust);
2374 if ((clust == BAD_CLUSTER) || (clust == DISK_ERROR)) {
2375 result = FR_DISK_ERR;
2381 sect = clst2sect(fs, clust);
2382 sect += (pos / SS(fs)) & (fs->csize - 1);
2385 if (fs->csize < buflen / SS(fs)) {
2388 step = buflen / SS(fs);
2393 while (n < buflen / SS(fs)) {
2394 if (disk_write(fs->pdrv, buf, sect, step) != RES_OK) {
2395 result = FR_DISK_ERR;
2399 if (n >= buflen / SS(fs)) {
2404 clust = get_fat(&(dfp->f_dir.obj), clust);
2405 if ((clust == BAD_CLUSTER) || (clust == DISK_ERROR)) {
2406 result = FR_DISK_ERR;
2411 sect = clst2sect(fs, clust);
2412 buf += step * SS(fs);
2420 result = FR_DISK_ERR;
2424 unlock_fs(fs, FR_OK);
2426 return (
ssize_t)min(finfo->fsize - pos, n * SS(fs));
2428 unlock_fs(fs, result);
macro EXC_SP_SET reg1 mrc 获取CPU信息 and mov mul reg0 计算当前CPU栈的偏移位置 ldr reg1 相减得到栈顶 mov sp
INT32 EraseDiskByID(UINT32 diskID, size_t startSector, UINT32 sectors)
INT32 SetDiskPartName(los_part *part, const CHAR *src)
设置分区名称
static int fatfs_create_obj(struct Vnode *parent, const char *name, int mode, struct Vnode **vpp, BYTE type, const char *target)
off_t fatfs_lseek(struct file *filep, off_t offset, int whence)
struct MountOps fatfs_mops
off64_t fatfs_lseek64(struct file *filep, off64_t offset, int whence)
static int GET_MINUTES(WORD ftime)
static UINT get_oldest_time(DIR_FILE df[], DWORD *oldest_time, UINT len)
static int GET_DAY(WORD fdate)
ssize_t fatfs_readlink(struct Vnode *vnode, char *buffer, size_t bufLen)
struct VnodeOps fatfs_vops
fat 文件系统 vnode实现
FSMAP_ENTRY(fat_fsmap, "vfat", fatfs_mops, FALSE, TRUE)
static DWORD combine_time(FILINFO *finfo)
static int GET_YEAR(WORD fdate)
void fatfs_chtime(DIR *dp, struct IATTR *attr)
int fatfs_hash_cmp(struct Vnode *vp, void *arg)
哈希值比较函数,返回int
int fatfs_fscheck(struct Vnode *vp, struct fs_dirent_s *dir)
static int GET_MONTH(WORD fdate)
int fatfs_mkdir(struct Vnode *parent, const char *name, mode_t mode, struct Vnode **vpp)
int fatfs_chattr(struct Vnode *vp, struct IATTR *attr)
static FRESULT update_dir(DIR *dp, FILINFO *finfo)
int fatfs_fsync(struct file *filep)
static FRESULT fatfs_setlabel(los_part *part)
static FRESULT fscheck(DIR *dp)
static int fat_bind_check(struct Vnode *blk_driver, los_part **partition)
int fatfs_2_vfs(int result)
int fatfs_open(struct file *filep)
static FRESULT rename_check(DIR *dp_new, FILINFO *finfo_new, DIR *dp_old, FILINFO *finfo_old)
int fatfs_symlink(struct Vnode *parentVnode, struct Vnode **newVnode, const char *path, const char *target)
static FRESULT init_cluster(DIR_FILE *pdfp, DIR *dp_new, FATFS *fs, int type, const char *target, DWORD *clust)
static bool fatfs_is_last_cluster(FATFS *fs, DWORD cclust)
int fatfs_ioctl(struct file *filep, int req, unsigned long arg)
struct file_operations_vfs fatfs_fops
int fatfs_truncate(struct Vnode *vp, off_t len)
int fatfs_sync_adapt(struct Mount *mnt)
static FRESULT realloc_cluster(FILINFO *finfo, FFOBJID *obj, FSIZE_t size)
static int fatfs_set_part_info(los_part *part)
设置FAT分区信息
int fatfs_umount(struct Mount *mnt, struct Vnode **blkdriver)
int fatfs_create(struct Vnode *parent, const char *name, int mode, struct Vnode **vpp)
创建 fat vnode 节点
int fatfs_reclaim(struct Vnode *vp)
回收节点
int fatfs_fallocate64(struct file *filep, int mode, off64_t offset, off64_t len)
int fatfs_fallocate(struct file *filep, int mode, off_t offset, off_t len)
int fatfs_rename(struct Vnode *old_vnode, struct Vnode *new_parent, const char *oldname, const char *newname)
int fatfs_readdir(struct Vnode *vp, struct fs_dirent_s *idir)
int fatfs_opendir(struct Vnode *vp, struct fs_dirent_s *idir)
static int fatfs_erase(los_part *part, int option)
int fatfs_stat(struct Vnode *vp, struct stat *sp)
static int GET_HOURS(WORD ftime)
int fatfs_read(struct file *filep, char *buff, size_t count)
int fatfs_truncate64(struct Vnode *vp, off64_t len)
int fatfs_closedir(struct Vnode *vp, struct fs_dirent_s *dir)
int fatfs_rmdir(struct Vnode *parent, struct Vnode *vp, const char *name)
ssize_t fatfs_writepage(struct Vnode *vnode, char *buff, off_t pos, size_t buflen)
static enum VnodeType fatfstype_2_vnodetype(BYTE type)
类型转换
int fatfs_mkfs(struct Vnode *device, int sectors, int option)
static int fatfs_sync(unsigned long mountflags, FATFS *fs)
static mode_t fatfs_get_mode(BYTE attribute, mode_t fs_mode)
int fatfs_write(struct file *filep, const char *buff, size_t count)
int fatfs_lookup(struct Vnode *parent, const char *path, int len, struct Vnode **vpp)
fat文件系统对 Lookup 接口的实现
DWORD fattime_format(time_t time)
static int update_filbuff(FILINFO *finfo, FIL *wfp, const char *data)
int fatfs_statfs(struct Mount *mnt, struct statfs *info)
int fatfs_close(struct file *filep)
ssize_t fatfs_readpage(struct Vnode *vnode, char *buff, off_t pos)
int fatfs_mount(struct Mount *mnt, struct Vnode *blk_device, const void *data)
fat将分区文件系统挂载 举例: mount /dev/mmcblk0p0 /bin1/vs/sd vfat
static int GET_SECONDS(WORD ftime)
int fatfs_rewinddir(struct Vnode *vp, struct fs_dirent_s *dir)
static DWORD fatfs_hash(QWORD sect, DWORD dptr, DWORD sclst)
生成hash值的过程
static time_t fattime_transfer(WORD fdate, WORD ftime)
int fatfs_unlink(struct Vnode *parent, struct Vnode *vp, const char *name)
FRESULT find_fat_partition(FATFS *fs, los_part *part, BYTE *format, QWORD *start_sector)
FRESULT _mkfs(los_part *partition, const MKFS_PARM *opt, BYTE *work, UINT len)
FRESULT init_fatobj(FATFS *fs, BYTE fmt, QWORD start_sector)
INT32 los_disk_read(INT32 drvID, VOID *buf, UINT64 sector, UINT32 count, BOOL useRead)
Read data from disk driver.
los_disk * get_disk(INT32 id)
Find disk driver.
los_part * get_part(INT32 id)
Find disk partition.
los_part * los_part_find(struct Vnode *blkDriver)
Find disk partition.
LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_ListInit(LOS_DL_LIST *list)
LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_ListDelete(LOS_DL_LIST *node)
LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_ListAdd(LOS_DL_LIST *list, LOS_DL_LIST *node)
Insert a new node to a doubly linked list.
LITE_OS_SEC_ALW_INLINE STATIC INLINE UINT32 LOS_HashFNV32aBuf(const VOID *buf, size_t len, UINT32 hval)
INT32 OsVfsFileMmap(struct file *filep, LosVmMapRegion *region)
void * zalloc(size_t size)
void free(void *ptr)
释放ptr所指向的内存空间
unsigned attr_chg_ctime
节点自身被修改时间
unsigned attr_chg_atime
节点最近访问时间
unsigned attr_chg_mode
确定了文件的类型,以及它的所有者、它的group、其它用户访问此文件的权限 (S_IWUSR | ...)
unsigned attr_chg_mtime
节点对应的文件内容被修改时间
unsigned int attr_chg_valid
节点改变有效性 (CHG_MODE | CHG_UID | ... )
举例: mount /dev/mmcblk0p0 /bin1/vs/sd vfat 将/dev/mmcblk0p0 挂载到/bin1/vs/sd目录
struct Vnode * vnodeCovered
struct Vnode * vnodeBeCovered
int(* Mount)(struct Mount *mount, struct Vnode *vnode, const void *data)
挂载分区
vnode并不包含文件名,因为 vnode和文件名是 1:N 的关系
struct file_operations_vfs * fop
struct Mount * originMount
int(* Getattr)(struct Vnode *vnode, struct stat *st)
获取节点属性
ARG_NUM_3 ARG_NUM_1 ARG_NUM_2 ARG_NUM_2 ARG_NUM_3 ARG_NUM_1 ARG_NUM_4 ARG_NUM_2 ARG_NUM_2 ARG_NUM_5 ARG_NUM_2 ARG_NUM_0 ARG_NUM_2 ARG_NUM_1 ARG_NUM_2 ARG_NUM_3 ARG_NUM_7 ARG_NUM_2 ARG_NUM_3 ARG_NUM_2 ARG_NUM_4 ARG_NUM_5 ARG_NUM_6 ARG_NUM_3 ARG_NUM_5 ARG_NUM_7 ARG_NUM_1 ARG_NUM_4 ARG_NUM_5 ARG_NUM_4 ARG_NUM_7 ARG_NUM_2 ARG_NUM_3 ARG_NUM_7 ARG_NUM_7 ARG_NUM_3 ARG_NUM_3 ARG_NUM_3 ARG_NUM_7 ARG_NUM_3 ARG_NUM_2 char ARG_NUM_2 ARG_NUM_1 ARG_NUM_0 ARG_NUM_0 ARG_NUM_3 void ARG_NUM_1 ARG_NUM_0 unsigned ARG_NUM_0 ARG_NUM_2 ARG_NUM_3 ARG_NUM_2 ARG_NUM_5 ARG_NUM_3 ARG_NUM_3 ARG_NUM_4 ARG_NUM_1 ARG_NUM_1 ARG_NUM_3 ARG_NUM_2 ARG_NUM_1 ARG_NUM_4 ARG_NUM_4 ARG_NUM_5 ARG_NUM_3 ARG_NUM_2 void ARG_NUM_6 unsigned ARG_NUM_0 unsigned ARG_NUM_0 ARG_NUM_3 ARG_NUM_3 ARG_NUM_2 ARG_NUM_2 ARG_NUM_1 ARG_NUM_2 ARG_NUM_1 char ARG_NUM_0 ARG_NUM_4 ARG_NUM_1 ARG_NUM_2 ARG_NUM_2 ARG_NUM_4 ARG_NUM_5 ARG_NUM_2 ARG_NUM_3 ARG_NUM_3 ARG_NUM_3 ARG_NUM_3 ARG_NUM_6 ARG_NUM_6 ARG_NUM_5 ARG_NUM_3 void ARG_NUM_3 ARG_NUM_3 ARG_NUM_5 ARG_NUM_1 unsigned ARG_NUM_3 long
ARG_NUM_3 ARG_NUM_1 ARG_NUM_2 ARG_NUM_2 ARG_NUM_3 ARG_NUM_1 ARG_NUM_4 ARG_NUM_2 ARG_NUM_2 ARG_NUM_5 ARG_NUM_2 void
ARG_NUM_3 ARG_NUM_1 ARG_NUM_2 ARG_NUM_2 ARG_NUM_3 ARG_NUM_1 ARG_NUM_4 ARG_NUM_2 ARG_NUM_2 ARG_NUM_5 ARG_NUM_2 ARG_NUM_0 ARG_NUM_2 ARG_NUM_1 ARG_NUM_2 ARG_NUM_3 ARG_NUM_7 ARG_NUM_2 ARG_NUM_3 ARG_NUM_2 ARG_NUM_4 off64_t
ARG_NUM_3 ARG_NUM_1 ARG_NUM_2 ARG_NUM_2 ARG_NUM_3 ARG_NUM_1 ARG_NUM_4 ARG_NUM_2 ARG_NUM_2 ARG_NUM_5 ARG_NUM_2 ARG_NUM_0 ARG_NUM_2 ARG_NUM_1 ARG_NUM_2 ARG_NUM_3 ARG_NUM_7 ARG_NUM_2 ARG_NUM_3 ARG_NUM_2 ARG_NUM_4 ARG_NUM_5 ARG_NUM_6 ARG_NUM_3 ARG_NUM_5 ARG_NUM_7 ARG_NUM_1 ARG_NUM_4 ARG_NUM_5 ARG_NUM_4 ARG_NUM_7 ARG_NUM_2 ARG_NUM_3 ARG_NUM_7 ARG_NUM_7 ARG_NUM_3 ARG_NUM_3 ARG_NUM_3 ARG_NUM_7 ARG_NUM_3 ARG_NUM_2 char ARG_NUM_2 ARG_NUM_1 ARG_NUM_0 ARG_NUM_0 ARG_NUM_3 void ARG_NUM_1 ARG_NUM_0 unsigned ARG_NUM_0 ARG_NUM_2 ARG_NUM_3 ARG_NUM_2 ARG_NUM_5 ARG_NUM_3 ARG_NUM_3 ARG_NUM_4 ARG_NUM_1 ARG_NUM_1 ARG_NUM_3 ARG_NUM_2 mode_t
INT32 LOS_CopyFromKernel(VOID *dest, UINT32 max, const VOID *src, UINT32 count)
将内核数据拷贝到用户空间
int VfsHashGet(const struct Mount *mount, uint32_t hash, struct Vnode **vnode, VfsHashCmp *fun, void *arg)
通过哈希值获取节点信息
int VfsHashInsert(struct Vnode *vnode, uint32_t hash)
插入哈希表
mode_t GetUmask(void)
获取用户创建文件掩码
int VnodeAlloc(struct VnodeOps *vop, struct Vnode **vnode)
申请分配一个 vnode 节点,vop为操作节点的驱动程序