RT-Thread RTOS 1.2.0
An open source embedded real-time operating system
载入中...
搜索中...
未找到
dfs_file.c
浏览该文件的文档.
1/*
2 * Copyright (c) 2006-2023, RT-Thread Development Team
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 *
6 * Change Logs:
7 * Date Author Notes
8 * 2023-05-05 Bernard Implement file APIs in dfs v2.0
9 */
10
11#include "errno.h"
12#include "fcntl.h"
13
14#include <dfs.h>
15
16#include "dfs_file.h"
17#include "dfs_dentry.h"
18#include "dfs_fs.h"
19#include "dfs_mnt.h"
20#include "dfs_private.h"
21
22#ifdef RT_USING_PAGECACHE
23#include "dfs_pcache.h"
24#endif
25
26#define DBG_TAG "DFS.file"
27#define DBG_LVL DBG_WARNING
28#include <rtdbg.h>
29
30#define MAX_RW_COUNT 0xfffc0000
31
32rt_inline int _first_path_len(const char *path)
33{
34 int i = 0;
35
36 if (path[i] == '/')
37 {
38 i++;
39 while (path[i] != '\0' && path[i] != '/')
40 {
41 i++;
42 }
43 }
44
45 return i;
46}
47
48static int _get_parent_path(const char *fullpath, char *path)
49{
50 int len = 0;
51 char *str = 0;
52
53 str = strrchr(fullpath, '/');
54
55 /* skip last '/' */
56 if (str && *(str + 1) == '\0')
57 {
58 str = strrchr(str - 1, '/');
59 }
60
61 if (str)
62 {
63 len = str - fullpath;
64 if (len > 0)
65 {
66 rt_memcpy(path, fullpath, len);
67 path[len] = '\0';
68 }
69 }
70
71 return len;
72}
73
74static int _try_readlink(const char *path, struct dfs_mnt *mnt, char *link)
75{
76 int ret = -1;
77 struct dfs_dentry *dentry = dfs_dentry_lookup(mnt, path, 0);
78
79 if (dentry && dentry->vnode->type == FT_SYMLINK)
80 {
81 if (mnt->fs_ops->readlink)
82 {
83 if (dfs_is_mounted(mnt) == 0)
84 {
85 ret = mnt->fs_ops->readlink(dentry, link, DFS_PATH_MAX);
86 }
87 }
88 }
89 dfs_dentry_unref(dentry);
90
91 return ret;
92}
93
94static char *_dfs_normalize_path(const char *path, int path_len, const char *link_fn, int link_len)
95{
96 char *tmp_path, *fp;
97
98 tmp_path = (char *)rt_malloc(path_len + link_len + 2);
99 if (!tmp_path)
100 {
101 return RT_NULL;
102 }
103
104 memcpy(tmp_path, path, path_len);
105 tmp_path[path_len] = '/';
106 memcpy(tmp_path + path_len + 1, link_fn, link_len);
107 tmp_path[path_len + 1 + link_len] = '\0';
108
109 fp = dfs_normalize_path(NULL, tmp_path);
110 rt_free(tmp_path);
111
112 return fp;
113}
114
115static int _insert_link_path(const char *link_fn, int link_len, char *tmp_path, int *index)
116{
117 int ret = -1;
118
119 if (link_fn[0] != '/')
120 {
121 if (link_len + 1 <= *index)
122 {
123 *index -= link_len;
124 rt_memcpy(tmp_path + *index, link_fn, link_len);
125 *index -= 1;
126 tmp_path[*index] = '/';
127 ret = 0;
128 }
129 }
130 else if (link_len <= *index)
131 {
132 *index -= link_len;
133 rt_memcpy(tmp_path + *index, link_fn, link_len);
134 ret = 1;
135 }
136
137 return ret;
138}
139
140/*
141 * rw_verify_area doesn't like huge counts. We limit
142 * them to something that fits in "int" so that others
143 * won't have to do range checks all the time.
144 */
145ssize_t rw_verify_area(struct dfs_file *file, off_t *ppos, size_t count)
146{
147 off_t pos;
148 ssize_t retval = -EINVAL;
149
150 if ((size_t)count < 0)
151 return retval;
152 pos = *ppos;
153 if (pos < 0)
154 {
155 if (count >= -pos) /* both values are in 0..LLONG_MAX */
156 return -EOVERFLOW;
157 }
158
159 return count > MAX_RW_COUNT ? MAX_RW_COUNT : count;
160}
161
162off_t dfs_file_get_fpos(struct dfs_file *file)
163{
164 if (file)
165 {
166 if (file->vnode->type == FT_REGULAR)
167 {
168 rt_mutex_take(&file->pos_lock, RT_WAITING_FOREVER);
169 }
170 return file->fpos;
171 }
172
173 return 0;
174}
175
176void dfs_file_set_fpos(struct dfs_file *file, off_t fpos)
177{
178 if (file)
179 {
180 if (file->vnode->type != FT_REGULAR)
181 {
182 rt_mutex_take(&file->pos_lock, RT_WAITING_FOREVER);
183 }
184 file->fpos = fpos;
185 rt_mutex_release(&file->pos_lock);
186 }
187}
188
189void dfs_file_init(struct dfs_file *file)
190{
191 if (file)
192 {
193 rt_memset(file, 0x00, sizeof(struct dfs_file));
194 file->magic = DFS_FD_MAGIC;
195 rt_mutex_init(&file->pos_lock, "fpos", RT_IPC_FLAG_PRIO);
196 rt_atomic_store(&(file->ref_count), 1);
197 }
198}
199
200void dfs_file_deinit(struct dfs_file *file)
201{
202 if (file)
203 {
204 rt_mutex_detach(&file->pos_lock);
205 }
206}
207
208static void dfs_file_unref(struct dfs_file *file)
209{
210 rt_err_t ret = RT_EOK;
211
212 ret = dfs_file_lock();
213 if (ret == RT_EOK)
214 {
215 if (rt_atomic_load(&(file->ref_count)) == 1)
216 {
217 /* should release this file */
218 if (file->dentry)
219 {
220 DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dfs_dentry_unref(dentry(%s))", file->dentry->pathname);
221 dfs_dentry_unref(file->dentry);
222 file->dentry = RT_NULL;
223 }
224 else if (file->vnode)
225 {
226 if (file->vnode->ref_count > 1)
227 {
228 rt_atomic_sub(&(file->vnode->ref_count), 1);
229 }
230 else if (file->vnode->ref_count == 1)
231 {
232 rt_free(file->vnode);
233 file->vnode = RT_NULL;
234 }
235 }
236
237 LOG_I("release a file: %p", file);
238 }
239
240 dfs_file_unlock();
241 }
242}
243
244/*
245 * this function is creat a nolink path.
246 *
247 * @param mnt
248 * @param fullpath
249 * @param mode
250 *
251 * @return new path.
252 */
253char *dfs_file_realpath(struct dfs_mnt **mnt, const char *fullpath, int mode)
254{
255 int path_len = 0, index = 0;
256 char *path = RT_NULL, *link_fn, *tmp_path;
257 struct dfs_mnt *tmp_mnt;
258
259 if (*mnt && fullpath)
260 {
261 int len, link_len;
262
263 path = (char *)rt_malloc((DFS_PATH_MAX * 3) + 3); // path + \0 + link_fn + \0 + tmp_path + \0
264 if (!path)
265 {
266 return RT_NULL;
267 }
268
269 link_fn = path + DFS_PATH_MAX + 1;
270 tmp_path = link_fn + (DFS_PATH_MAX + 1);
271
272 len = rt_strlen(fullpath);
273 if (len > DFS_PATH_MAX)
274 {
275 goto _ERR_RET;
276 }
277
278 index = (DFS_PATH_MAX - len);
279 rt_strcpy(tmp_path + index, fullpath);
280
281 if (mode == DFS_REALPATH_ONLY_LAST)
282 {
283 path_len = _get_parent_path(fullpath, path);
284 index += path_len;
285 }
286
287 while ((len = _first_path_len(tmp_path + index)) > 0)
288 {
289 if (len + path_len > DFS_PATH_MAX)
290 {
291 goto _ERR_RET;
292 }
293
294 rt_memcpy(path + path_len, tmp_path + index, len);
295 path[path_len + len] = '\0';
296 index += len;
297
298 tmp_mnt = dfs_mnt_lookup(path);
299 if (tmp_mnt == RT_NULL)
300 {
301 goto _ERR_RET;
302 }
303
304 *mnt = tmp_mnt;
305
306 /* the last should by mode process. */
307 if ((tmp_path[index] == '\0') && (mode == DFS_REALPATH_EXCEPT_LAST))
308 {
309 break;
310 }
311
312 link_len = _try_readlink(path, *mnt, link_fn);
313 if (link_len > 0)
314 {
315 if (link_fn[0] == '/')
316 {
317 int ret = _insert_link_path(link_fn, link_len, tmp_path, &index);
318 if (ret < 0)
319 {
320 goto _ERR_RET;
321 }
322 path_len = 0;
323 }
324 else
325 {
326 char *fp = _dfs_normalize_path(path, path_len, link_fn, link_len);
327 if (fp)
328 {
329 int pos = rt_strncmp(path, fp, path_len);
330 if (pos == 0)
331 {
332 int ret = _insert_link_path(fp + path_len, rt_strlen(fp + path_len), tmp_path, &index);
333 if (ret < 0)
334 {
335 rt_free(fp);
336 goto _ERR_RET;
337 }
338 }
339 else
340 {
341 int pos;
342
343 while(1)
344 {
345 while(path_len > 0 && path[path_len] != '/')
346 {
347 path_len--;
348 }
349
350 if (path_len > 0)
351 {
352 pos = rt_strncmp(path, fp, path_len);
353 }
354 else
355 {
356 pos = -1;
357 }
358
359 if (pos == 0 || path_len == 0)
360 {
361 int ret;
362
363 ret = _insert_link_path(fp + path_len, rt_strlen(fp + path_len), tmp_path, &index);
364 if (ret < 0)
365 {
366 rt_free(fp);
367 goto _ERR_RET;
368 }
369 else
370 {
371 break;
372 }
373 }
374 else
375 {
376 path_len--;
377 }
378 }
379 }
380 rt_free(fp);
381 }
382 }
383 }
384 else
385 {
386 path_len += len;
387 }
388 }
389
390 return path;
391
392_ERR_RET:
393 rt_free(path);
394 path = RT_NULL;
395 }
396
397 return path;
398}
399
409int dfs_file_open(struct dfs_file *file, const char *path, int oflags, mode_t mode)
410{
411 int ret = -RT_ERROR;
412 char *fullpath = RT_NULL;
413 struct dfs_dentry *dentry = RT_NULL;
414 int fflags = dfs_fflags(oflags);
415
416 if (mode == 0)
417 {
418 mode = (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH); /* 0666 */
419 }
420
421 if (file && path)
422 {
423 fullpath = dfs_normalize_path(NULL, path);
424 if (fullpath)
425 {
426 struct dfs_mnt *mnt = RT_NULL;
427
428 DLOG(msg, "dfs_file", "mnt", DLOG_MSG, "dfs_mnt_lookup(%s)", fullpath);
429 mnt = dfs_mnt_lookup(fullpath);
430 if (mnt)
431 {
432 char *tmp = dfs_file_realpath(&mnt, fullpath, DFS_REALPATH_EXCEPT_LAST);
433 if (tmp)
434 {
435 rt_free(fullpath);
436 fullpath = tmp;
437 }
438
439 DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dfs_dentry_lookup(mnt, %s)", fullpath);
440 dentry = dfs_dentry_lookup(mnt, fullpath, oflags);
441 if (dentry && dentry->vnode->type == FT_SYMLINK)
442 {
443 /* it's a symbol link but not follow */
444 if (oflags & O_NOFOLLOW)
445 {
446 /* no follow symbol link */
447 dfs_dentry_unref(dentry);
448 dentry = RT_NULL;
449 }
450 else
451 {
452 struct dfs_dentry *target_dentry = RT_NULL;
453 char *path = dfs_file_realpath(&mnt, fullpath, DFS_REALPATH_ONLY_LAST);
454 if (path)
455 {
456 target_dentry = dfs_dentry_lookup(mnt, path, oflags);
457 rt_free(path);
458 }
459 dfs_dentry_unref(dentry);
460 dentry = target_dentry;
461 }
462 }
463
464 if (dentry)
465 {
466 if (oflags & O_DIRECTORY)
467 {
468 if (dentry->vnode->type != FT_DIRECTORY)
469 {
470 dfs_dentry_unref(dentry);
471 dentry = RT_NULL;
472 }
473 }
474 else if (dentry->vnode->type == FT_DIRECTORY)
475 {
476 if (fflags & (DFS_F_FWRITE))
477 {
478 dfs_dentry_unref(dentry);
479 dentry = RT_NULL;
480 }
481 else
482 {
483 oflags |= O_DIRECTORY;
484 }
485 }
486 }
487
488 if (oflags & O_CREAT)
489 {
490 if (dentry)
491 {
492 oflags &= ~O_CREAT;
493
494 if (oflags & O_EXCL)
495 {
496 oflags &= ~O_EXCL;
497 /* the dentry already exists */
498 dfs_dentry_unref(dentry);
499 ret = -EEXIST;
500 goto _ERR_RET;
501 }
502 }
503 else
504 {
505 /* create file/directory */
506 if (mnt->fs_ops->create_vnode)
507 {
508 struct dfs_vnode *vnode = RT_NULL;
509
510 DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dfs_dentry_create(%s)", fullpath);
511 dfs_file_lock();
512 dentry = dfs_dentry_create(mnt, fullpath);
513 if (dentry)
514 {
515 DLOG(msg, "dfs_file", mnt->fs_ops->name, DLOG_MSG, "fs_ops->create_vnode");
516
517 if (dfs_is_mounted(mnt) == 0)
518 {
519 vnode = mnt->fs_ops->create_vnode(dentry, oflags & O_DIRECTORY ? FT_DIRECTORY:FT_REGULAR, mode);
520 }
521
522 if (vnode)
523 {
524 /* set vnode */
525 dentry->vnode = vnode; /* the refcount of created vnode is 1. no need to reference */
526 dfs_dentry_insert(dentry);
527 }
528 else
529 {
530 DLOG(msg, mnt->fs_ops->name, "dfs_file", DLOG_MSG_RET, "create failed.");
531 dfs_dentry_unref(dentry);
532 dentry = RT_NULL;
533 }
534 }
535 dfs_file_unlock();
536 }
537 }
538 }
539
540 if (dentry)
541 {
542 rt_bool_t permission = RT_TRUE;
543 file->dentry = dentry;
544 file->vnode = dentry->vnode;
545 file->fops = dentry->mnt->fs_ops->default_fops;
546 file->flags = oflags;
547
548 /* check permission */
549 if (!(oflags & O_CREAT))
550 {
551 if (fflags & DFS_F_FWRITE)
552 {
553 if (!(file->vnode->mode & S_IWUSR))
554 {
555 permission = RT_FALSE;
556 }
557 }
558
559 if (fflags & DFS_F_FREAD)
560 {
561 if (!(file->vnode->mode & S_IRUSR))
562 {
563 permission = RT_FALSE;
564 }
565 }
566
567 if (oflags & O_EXEC)
568 {
569 if (!(file->vnode->mode & S_IXUSR))
570 {
571 permission = RT_FALSE;
572 }
573 }
574 }
575
576 if (permission && file->fops->open)
577 {
578 DLOG(msg, "dfs_file", mnt->fs_ops->name, DLOG_MSG, "fops->open(file)");
579
580 if (dfs_is_mounted(file->vnode->mnt) == 0)
581 {
582 dfs_file_lock();
583 ret = file->fops->open(file);
584 dfs_file_unlock();
585 }
586 else
587 {
588 ret = -EINVAL;
589 }
590
591 if (ret < 0)
592 {
593 LOG_I("open %s failed in file system: %s", path, dentry->mnt->fs_ops->name);
594 DLOG(msg, mnt->fs_ops->name, "dfs_file", DLOG_MSG_RET, "open failed.");
595 dfs_file_unref(file);
596 }
597 else
598 {
599 /* for char/block device */
600 if ((S_ISCHR(file->vnode->mode)) || (S_ISBLK(file->vnode->mode)))
601 {
602 file->fops = file->vnode->fops;
603 }
604 }
605 }
606 else
607 {
608 DLOG(msg, "dfs_file", mnt->fs_ops->name, DLOG_MSG, "no permission or fops->open");
609 dfs_file_unref(file);
610 ret = -EPERM;
611 }
612 }
613 else
614 {
615 LOG_I("lookup file:%s failed in file system", path);
616 ret = -ENOENT;
617 }
618 }
619 }
620
621 if (ret >= 0 && (oflags & O_TRUNC))
622 {
623 /* trunc file */
624 if (!(fflags & DFS_F_FWRITE) || file->vnode->type == FT_DIRECTORY)
625 {
626 /* truncate on read a only file or a directory */
627 DLOG(msg, "dfs_file", "dfs_file", DLOG_MSG, "dfs_file_unref(file), trunc on RDOnly or directory");
628 ret = -RT_ERROR;
629 }
630 else
631 {
632 if (file->fops->truncate)
633 {
634 DLOG(msg, "dfs_file", dentry->mnt->fs_ops->name, DLOG_MSG, "fops->truncate(file, 0)");
635
636 if (dfs_is_mounted(file->vnode->mnt) == 0)
637 {
638#ifdef RT_USING_PAGECACHE
639 if (file->vnode->aspace)
640 {
641 dfs_aspace_clean(file->vnode->aspace);
642 }
643#endif
644 ret = file->fops->truncate(file, 0);
645 }
646 else
647 {
648 ret = -EINVAL;
649 }
650 }
651 }
652
653 if (ret < 0)
654 {
655 dfs_file_unref(file);
656 }
657
658 file->flags &= ~O_TRUNC;
659 }
660 }
661
662_ERR_RET:
663 if (fullpath != NULL)
664 {
665 rt_free(fullpath);
666 }
667 return ret;
668}
669
670int dfs_file_close(struct dfs_file *file)
671{
672 int ret = -RT_ERROR;
673
674 if (file)
675 {
676 if (dfs_file_lock() == RT_EOK)
677 {
678 rt_atomic_t ref_count = rt_atomic_load(&(file->ref_count));
679
680 if (ref_count == 1 && file->fops && file->fops->close)
681 {
682 DLOG(msg, "dfs_file", file->dentry->mnt->fs_ops->name, DLOG_MSG, "fops->close(file)");
683#ifdef RT_USING_PAGECACHE
684 if (file->vnode->aspace)
685 {
686 dfs_aspace_flush(file->vnode->aspace);
687 }
688#endif
689 ret = file->fops->close(file);
690
691 if (ret == 0) /* close file sucessfully */
692 {
693 DLOG(msg, "dfs_file", "dfs_file", DLOG_MSG, "dfs_file_unref(file)");
694 dfs_file_unref(file);
695 }
696 else
697 {
698 LOG_W("close file:%s failed on low level file system", file->dentry->pathname);
699 }
700 }
701 else
702 {
703 DLOG(msg, "dfs_file", "dfs_file", DLOG_MSG, "dfs_file_unref(file)");
704 dfs_file_unref(file);
705 ret = 0;
706 }
707 dfs_file_unlock();
708 }
709 }
710
711 return ret;
712}
713
714ssize_t dfs_file_pread(struct dfs_file *file, void *buf, size_t len, off_t offset)
715{
716 ssize_t ret = -EBADF;
717
718 if (file)
719 {
720 /* check whether read */
721 if (!(dfs_fflags(file->flags) & DFS_F_FREAD))
722 {
723 ret = -EPERM;
724 }
725 else if (!file->fops || !file->fops->read)
726 {
727 ret = -ENOSYS;
728 }
729 else if (file->vnode && file->vnode->type != FT_DIRECTORY)
730 {
731 off_t pos = offset;
732
733 ret = rw_verify_area(file, &pos, len);
734 if (ret > 0)
735 {
736 len = ret;
737
738 if (dfs_is_mounted(file->vnode->mnt) == 0)
739 {
740#ifdef RT_USING_PAGECACHE
741 if (file->vnode->aspace && !(file->flags & O_DIRECT))
742 {
743 ret = dfs_aspace_read(file, buf, len, &pos);
744 }
745 else
746#endif
747 {
748 ret = file->fops->read(file, buf, len, &pos);
749 }
750 }
751 else
752 {
753 ret = -EINVAL;
754 }
755 }
756 }
757 }
758
759 return ret;
760}
761
762ssize_t dfs_file_read(struct dfs_file *file, void *buf, size_t len)
763{
764 ssize_t ret = -EBADF;
765
766 if (file)
767 {
768 /* check whether read */
769 if (!(dfs_fflags(file->flags) & DFS_F_FREAD))
770 {
771 ret = -EPERM;
772 }
773 else if (!file->fops || !file->fops->read)
774 {
775 ret = -ENOSYS;
776 }
777 else if (file->vnode && file->vnode->type != FT_DIRECTORY)
778 {
779 /* fpos lock */
780 off_t pos = dfs_file_get_fpos(file);
781
782 ret = rw_verify_area(file, &pos, len);
783 if (ret > 0)
784 {
785 len = ret;
786
787 if (dfs_is_mounted(file->vnode->mnt) == 0)
788 {
789#ifdef RT_USING_PAGECACHE
790 if (file->vnode->aspace && !(file->flags & O_DIRECT))
791 {
792 ret = dfs_aspace_read(file, buf, len, &pos);
793 }
794 else
795#endif
796 {
797 ret = file->fops->read(file, buf, len, &pos);
798 }
799 }
800 else
801 {
802 ret = -EINVAL;
803 }
804 }
805 /* fpos unlock */
806 dfs_file_set_fpos(file, pos);
807 }
808 }
809
810 return ret;
811}
812
813ssize_t dfs_file_pwrite(struct dfs_file *file, const void *buf, size_t len, off_t offset)
814{
815 ssize_t ret = -EBADF;
816
817 if (file)
818 {
819 if (!(dfs_fflags(file->flags) & DFS_F_FWRITE))
820 {
821 LOG_W("bad write flags.");
822 ret = -EBADF;
823 }
824 else if (!file->fops || !file->fops->write)
825 {
826 LOG_W("no fops write.");
827 ret = -ENOSYS;
828 }
829 else if (file->vnode && file->vnode->type != FT_DIRECTORY)
830 {
831 off_t pos = offset;
832
833 ret = rw_verify_area(file, &pos, len);
834 if (ret > 0)
835 {
836 len = ret;
837 DLOG(msg, "dfs_file", file->dentry->mnt->fs_ops->name, DLOG_MSG,
838 "dfs_file_write(fd, buf, %d)", len);
839
840 if (dfs_is_mounted(file->vnode->mnt) == 0)
841 {
842#ifdef RT_USING_PAGECACHE
843 if (file->vnode->aspace && !(file->flags & O_DIRECT))
844 {
845 ret = dfs_aspace_write(file, buf, len, &pos);
846 }
847 else
848#endif
849 {
850 ret = file->fops->write(file, buf, len, &pos);
851 }
852
853 if (file->flags & O_SYNC)
854 {
855 file->fops->flush(file);
856 }
857 }
858 else
859 {
860 ret = -EINVAL;
861 }
862 }
863 }
864 }
865
866 return ret;
867}
868
869ssize_t dfs_file_write(struct dfs_file *file, const void *buf, size_t len)
870{
871 ssize_t ret = -EBADF;
872
873 if (file)
874 {
875 if (!(dfs_fflags(file->flags) & DFS_F_FWRITE))
876 {
877 LOG_W("bad write flags.");
878 ret = -EBADF;
879 }
880 else if (!file->fops || !file->fops->write)
881 {
882 LOG_W("no fops write.");
883 ret = -ENOSYS;
884 }
885 else if (file->vnode && file->vnode->type != FT_DIRECTORY)
886 {
887 off_t pos;
888
889 if (!(file->flags & O_APPEND))
890 {
891 /* fpos lock */
892 pos = dfs_file_get_fpos(file);
893 }
894 else
895 {
896 pos = file->vnode->size;
897 }
898
899 ret = rw_verify_area(file, &pos, len);
900 if (ret > 0)
901 {
902 len = ret;
903 DLOG(msg, "dfs_file", file->dentry->mnt->fs_ops->name, DLOG_MSG,
904 "dfs_file_write(fd, buf, %d)", len);
905
906 if (dfs_is_mounted(file->vnode->mnt) == 0)
907 {
908#ifdef RT_USING_PAGECACHE
909 if (file->vnode->aspace && !(file->flags & O_DIRECT))
910 {
911 ret = dfs_aspace_write(file, buf, len, &pos);
912 }
913 else
914#endif
915 {
916 ret = file->fops->write(file, buf, len, &pos);
917 }
918
919 if (file->flags & O_SYNC)
920 {
921 file->fops->flush(file);
922 }
923 }
924 else
925 {
926 ret = -EINVAL;
927 }
928 }
929 if (!(file->flags & O_APPEND))
930 {
931 /* fpos unlock */
932 dfs_file_set_fpos(file, pos);
933 }
934 }
935 }
936
937 return ret;
938}
939
940off_t generic_dfs_lseek(struct dfs_file *file, off_t offset, int whence)
941{
942 off_t foffset;
943
944 if (whence == SEEK_SET)
945 foffset = offset;
946 else if (whence == SEEK_CUR)
947 foffset = file->fpos + offset;
948 else if (whence == SEEK_END)
949 foffset = file->vnode->size + offset;
950 else
951 return -EINVAL;
952
953 return foffset;
954}
955
956off_t dfs_file_lseek(struct dfs_file *file, off_t offset, int wherece)
957{
958 off_t retval = -EINVAL;
959
960 if (file && file->fops->lseek)
961 {
962 if (dfs_is_mounted(file->vnode->mnt) == 0)
963 {
964 /* fpos lock */
965 off_t pos = dfs_file_get_fpos(file);
966 retval = file->fops->lseek(file, offset, wherece);
967 if (retval >= 0)
968 {
969 pos = retval;
970 }
971 /* fpos unlock */
972 dfs_file_set_fpos(file, pos);
973 }
974 }
975
976 return retval;
977}
978
979int dfs_file_stat(const char *path, struct stat *buf)
980{
981 int ret = -ENOENT;
982 char *fullpath = RT_NULL;
983 struct dfs_mnt *mnt = RT_NULL;
984 struct dfs_dentry *dentry = RT_NULL;
985
986 fullpath = dfs_normalize_path(NULL, path);
987 if (fullpath)
988 {
989 DLOG(msg, "dfs_file", "mnt", DLOG_MSG, "dfs_mnt_lookup(%s)", fullpath);
990 mnt = dfs_mnt_lookup(fullpath);
991 if (mnt)
992 {
993 char *tmp = dfs_file_realpath(&mnt, fullpath, DFS_REALPATH_EXCEPT_NONE);
994 if (tmp)
995 {
996 rt_free(fullpath);
997 fullpath = tmp;
998 }
999
1000 DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dentry = dfs_dentry_lookup(mnt, %s)", fullpath);
1001 dentry = dfs_dentry_lookup(mnt, fullpath, 0);
1002 if (dentry)
1003 {
1004 DLOG(msg, "dentry", "dfs_file", DLOG_MSG_RET, "return dentry");
1005 if (mnt->fs_ops->stat)
1006 {
1007 DLOG(msg, "dfs_file", mnt->fs_ops->name, DLOG_MSG, "fs_ops->stat(dentry, buf)");
1008
1009 if (dfs_is_mounted(mnt) == 0)
1010 {
1011 ret = mnt->fs_ops->stat(dentry, buf);
1012 }
1013 }
1014
1015 /* unref dentry */
1016 DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dfs_dentry_unref(dentry)");
1017 dfs_dentry_unref(dentry);
1018 dentry = RT_NULL;
1019 }
1020 }
1021
1022 rt_free(fullpath);
1023 fullpath = RT_NULL;
1024 }
1025 else
1026 {
1027 ret = -ENOMEM;
1028 }
1029
1030 return ret;
1031}
1032
1033int dfs_file_lstat(const char *path, struct stat *buf)
1034{
1035 int ret = -ENOENT;
1036 char *fullpath = RT_NULL;
1037 struct dfs_mnt *mnt = RT_NULL;
1038 struct dfs_dentry *dentry = RT_NULL;
1039
1040 fullpath = dfs_normalize_path(NULL, path);
1041 if (fullpath)
1042 {
1043 DLOG(msg, "dfs_file", "mnt", DLOG_MSG, "dfs_mnt_lookup(%s)", fullpath);
1044 mnt = dfs_mnt_lookup(fullpath);
1045 if (mnt)
1046 {
1047 char *tmp = dfs_file_realpath(&mnt, fullpath, DFS_REALPATH_EXCEPT_LAST);
1048 if (tmp)
1049 {
1050 rt_free(fullpath);
1051 fullpath = tmp;
1052 }
1053
1054 DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dentry = dfs_dentry_lookup(mnt, %s)", fullpath);
1055 dentry = dfs_dentry_lookup(mnt, fullpath, 0);
1056 if (dentry)
1057 {
1058 DLOG(msg, "dentry", "dfs_file", DLOG_MSG_RET, "return dentry");
1059 if (mnt->fs_ops->stat)
1060 {
1061 DLOG(msg, "dfs_file", mnt->fs_ops->name, DLOG_MSG, "fs_ops->stat(dentry, buf)");
1062
1063 if (dfs_is_mounted(mnt) == 0)
1064 {
1065 ret = mnt->fs_ops->stat(dentry, buf);
1066 }
1067 }
1068
1069 /* unref dentry */
1070 DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dfs_dentry_unref(dentry)");
1071 dfs_dentry_unref(dentry);
1072 dentry = RT_NULL;
1073 }
1074 }
1075
1076 rt_free(fullpath);
1077 fullpath = RT_NULL;
1078 }
1079 else
1080 {
1081 ret = -ENOMEM;
1082 }
1083
1084 rt_set_errno(-ret);
1085
1086 return ret;
1087}
1088
1089int dfs_file_fstat(struct dfs_file *file, struct stat *buf)
1090{
1091 size_t ret = -EBADF;
1092
1093 if (file)
1094 {
1095 if (file->fops && file->fops->ioctl)
1096 {
1097 // ret = file->fops->fstat(file, buf);
1098 }
1099 else
1100 {
1101 ret = -ENOSYS;
1102 }
1103 }
1104 else
1105 {
1106 ret = -EBADF;
1107 }
1108
1109 return ret;
1110}
1111
1112int dfs_file_setattr(const char *path, struct dfs_attr *attr)
1113{
1114 int ret = -RT_ERROR;
1115 char *fullpath = RT_NULL;
1116 struct dfs_mnt *mnt = RT_NULL;
1117 struct dfs_dentry *dentry = RT_NULL;
1118
1119 fullpath = dfs_normalize_path(NULL, path);
1120 if (fullpath)
1121 {
1122 DLOG(msg, "dfs_file", "mnt", DLOG_MSG, "dfs_mnt_lookup(%s)", fullpath);
1123 mnt = dfs_mnt_lookup(fullpath);
1124 if (mnt)
1125 {
1126 char *tmp = dfs_file_realpath(&mnt, fullpath, DFS_REALPATH_EXCEPT_LAST);
1127 if (tmp)
1128 {
1129 rt_free(fullpath);
1130 fullpath = tmp;
1131 }
1132
1133 DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dentry = dfs_dentry_lookup(mnt, %s)", fullpath);
1134 dentry = dfs_dentry_lookup(mnt, fullpath, 0);
1135 if (dentry)
1136 {
1137 DLOG(msg, "dentry", "dfs_file", DLOG_MSG_RET, "return dentry");
1138 if (mnt->fs_ops->setattr)
1139 {
1140 DLOG(msg, "dfs_file", mnt->fs_ops->name, DLOG_MSG, "fs_ops->setattr(dentry, attr)");
1141
1142 if (dfs_is_mounted(mnt) == 0)
1143 {
1144 ret = mnt->fs_ops->setattr(dentry, attr);
1145 }
1146 }
1147
1148 /* unref dentry */
1149 DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dfs_dentry_unref(dentry)");
1150 dfs_dentry_unref(dentry);
1151 dentry = RT_NULL;
1152 }
1153 }
1154
1155 rt_free(fullpath);
1156 fullpath = RT_NULL;
1157 }
1158
1159 return ret;
1160}
1161
1162int dfs_file_ioctl(struct dfs_file *file, int cmd, void *args)
1163{
1164 size_t ret = 0;
1165
1166 if (file)
1167 {
1168 if (file->fops && file->fops->ioctl)
1169 {
1170 if (dfs_is_mounted(file->vnode->mnt) == 0)
1171 {
1172 ret = file->fops->ioctl(file, cmd, args);
1173 }
1174 else
1175 {
1176 ret = -EINVAL;
1177 }
1178 }
1179 else
1180 {
1181 ret = -ENOSYS;
1182 }
1183 }
1184 else
1185 {
1186 ret = -EBADF;
1187 }
1188
1189 return ret;
1190}
1191
1192int dfs_file_fcntl(int fd, int cmd, unsigned long arg)
1193{
1194 int ret = 0;
1195 struct dfs_file *file;
1196
1197 file = fd_get(fd);
1198 if (file)
1199 {
1200 switch (cmd)
1201 {
1202 case F_DUPFD:
1203 ret = dfs_dup(fd, arg);
1204 break;
1205 case F_GETFD:
1206 ret = file->mode;
1207 break;
1208 case F_SETFD:
1209 file->mode = arg;
1210 break;
1211 case F_GETFL:
1212 ret = file->flags;
1213 break;
1214 case F_SETFL:
1215 {
1216 int flags = (int)(rt_base_t)arg;
1217 int mask =
1218#ifdef O_ASYNC
1219 O_ASYNC |
1220#endif
1221#ifdef O_DIRECT
1222 O_DIRECT |
1223#endif
1224#ifdef O_NOATIME
1225 O_NOATIME |
1226#endif
1227 O_APPEND | O_NONBLOCK;
1228
1229 flags &= mask;
1230 file->flags &= ~mask;
1231 file->flags |= flags;
1232 break;
1233 }
1234 case F_GETLK:
1235 break;
1236 case F_SETLK:
1237 case F_SETLKW:
1238 break;
1239#ifdef RT_USING_MUSLLIBC
1240 case F_DUPFD_CLOEXEC:
1241 ret = -EINVAL;
1242 break;
1243#endif
1244 default:
1245 ret = -EPERM;
1246 break;
1247 }
1248 }
1249 else
1250 {
1251 ret = -EBADF;
1252 }
1253
1254 return ret;
1255}
1256
1257int dfs_file_fsync(struct dfs_file *file)
1258{
1259 int ret = -EBADF;
1260
1261 if (file)
1262 {
1263 if (file->fops->flush)
1264 {
1265 if (dfs_is_mounted(file->vnode->mnt) == 0)
1266 {
1267#ifdef RT_USING_PAGECACHE
1268 if (file->vnode->aspace)
1269 {
1270 dfs_aspace_flush(file->vnode->aspace);
1271 }
1272#endif
1273 ret = file->fops->flush(file);
1274 }
1275 else
1276 {
1277 ret = -EINVAL;
1278 }
1279 }
1280 }
1281
1282 return ret;
1283}
1284
1285int dfs_file_unlink(const char *path)
1286{
1287 int ret = -RT_ERROR;
1288 char *fullpath = RT_NULL;
1289 struct dfs_mnt *mnt = RT_NULL;
1290 struct dfs_dentry *dentry = RT_NULL;
1291
1292 fullpath = dfs_normalize_path(NULL, path);
1293 if (fullpath)
1294 {
1295 DLOG(msg, "dfs_file", "mnt", DLOG_MSG, "dfs_mnt_lookup(%s)", fullpath);
1296 mnt = dfs_mnt_lookup(fullpath);
1297 if (mnt)
1298 {
1299 char *tmp = dfs_file_realpath(&mnt, fullpath, DFS_REALPATH_EXCEPT_LAST);
1300 if (tmp)
1301 {
1302 rt_free(fullpath);
1303 fullpath = tmp;
1304 }
1305
1306 if (strcmp(mnt->fullpath, fullpath) != 0)
1307 {
1308 DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dfs_dentry_lookup(mnt, %s)", fullpath);
1309 dentry = dfs_dentry_lookup(mnt, fullpath, 0);
1310 if (dentry)
1311 {
1312 rt_bool_t has_child = RT_FALSE;
1313
1314 has_child = dfs_mnt_has_child_mnt(mnt, fullpath);
1315#ifdef RT_USING_PAGECACHE
1316 if (dentry->vnode->aspace)
1317 {
1318 dfs_aspace_clean(dentry->vnode->aspace);
1319 }
1320#endif
1321 dfs_file_lock();
1322
1323 if (has_child == RT_FALSE)
1324 {
1325 /* no child mnt point, unlink it */
1326 ret = -RT_ERROR;
1327
1328 if (mnt->fs_ops->unlink)
1329 {
1330 if (dfs_is_mounted(mnt) == 0)
1331 {
1332 ret = mnt->fs_ops->unlink(dentry);
1333 }
1334 }
1335 }
1336 else
1337 {
1338 ret = -EBUSY;
1339 }
1340 dfs_file_unlock();
1341
1342 /* release this dentry */
1343 dfs_dentry_unref(dentry);
1344 }
1345 else
1346 {
1347 /* no this entry */
1348 ret = -ENOENT;
1349 }
1350 }
1351 else
1352 {
1353 /* it's a mount point, failed for busy */
1354 ret = -EBUSY;
1355 }
1356 }
1357 else
1358 {
1359 ret = -ENOENT;
1360 }
1361
1362 /* release fullpath */
1363 rt_free(fullpath);
1364 }
1365 else
1366 {
1367 ret = -ENOMEM;
1368 }
1369
1370 return ret;
1371}
1372
1373int dfs_file_link(const char *oldname, const char *newname)
1374{
1375 int ret = -1;
1376 struct stat stat;
1377 struct dfs_mnt *mnt = RT_NULL;
1378 char *old_fullpath, *new_fullpath;
1379
1380 if (dfs_file_isdir(oldname) == 0)
1381 {
1382 rt_set_errno(-EPERM);
1383 return ret;
1384 }
1385
1386 if (dfs_file_lstat(newname, &stat) >= 0)
1387 {
1388 return ret;
1389 }
1390
1391 old_fullpath = dfs_normalize_path(NULL, oldname);
1392 if (old_fullpath)
1393 {
1394 DLOG(msg, "dfs_file", "mnt", DLOG_MSG, "dfs_mnt_lookup(%s)", old_fullpath);
1395 mnt = dfs_mnt_lookup(old_fullpath);
1396 if (mnt == RT_NULL)
1397 {
1398 rt_free(old_fullpath);
1399 return -1;
1400 }
1401
1402 char *tmp = dfs_file_realpath(&mnt, old_fullpath, DFS_REALPATH_EXCEPT_LAST);
1403 if (tmp)
1404 {
1405 rt_free(old_fullpath);
1406 old_fullpath = tmp;
1407 }
1408 }
1409
1410 new_fullpath = dfs_normalize_path(NULL, newname);
1411 if (new_fullpath)
1412 {
1413 char *tmp = dfs_file_realpath(&mnt, new_fullpath, DFS_REALPATH_EXCEPT_LAST);
1414 if (tmp)
1415 {
1416 rt_free(new_fullpath);
1417 new_fullpath = tmp;
1418 }
1419 }
1420
1421 if (old_fullpath && new_fullpath)
1422 {
1423 struct dfs_dentry *old_dentry, *new_dentry;
1424
1425 DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dfs_dentry_lookup(mnt, %s)", old_fullpath);
1426 old_dentry = dfs_dentry_lookup(mnt, old_fullpath, 0);
1427 DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dfs_dentry_create(%s)", new_fullpath);
1428 new_dentry = dfs_dentry_create(mnt, new_fullpath);
1429
1430 if (old_dentry && new_dentry)
1431 {
1432 if (mnt->fs_ops->link)
1433 {
1434 if (dfs_is_mounted(mnt) == 0)
1435 {
1436 ret = mnt->fs_ops->link(old_dentry, new_dentry);
1437 }
1438 }
1439 }
1440
1441 dfs_dentry_unref(old_dentry);
1442 dfs_dentry_unref(new_dentry);
1443 }
1444
1445 if (old_fullpath)
1446 {
1447 rt_free(old_fullpath);
1448 }
1449
1450 if (new_fullpath)
1451 {
1452 rt_free(new_fullpath);
1453 }
1454
1455 return ret;
1456}
1457
1458/* symlink creates a symbolic link named `linkpath` which contains the string `target`. */
1459int dfs_file_symlink(const char *target, const char *linkpath)
1460{
1461 int ret = -RT_ERROR;
1462 char *fullpath = RT_NULL, *parent = RT_NULL;
1463 struct dfs_mnt *mnt = RT_NULL;
1464 struct dfs_dentry *dentry = RT_NULL;
1465
1466 if (target && linkpath)
1467 {
1468 if (linkpath[0] != '/')
1469 {
1470 fullpath = dfs_normalize_path(NULL, linkpath);
1471 }
1472 else
1473 {
1474 fullpath = (char*)linkpath;
1475 }
1476
1477 /* linkpath should be not exist */
1478 if (dfs_file_access(fullpath, O_RDONLY) != 0)
1479 {
1480 char *index;
1481
1482 /* get parent path */
1483 index = strrchr(fullpath, '/');
1484 if (index)
1485 {
1486 int length = index - fullpath;
1487 if (length > 0)
1488 {
1489 parent = (char*) rt_malloc (length + 1);
1490 if (parent)
1491 {
1492 memcpy(parent, fullpath, length);
1493 parent[length] = '\0';
1494 }
1495 }
1496 else
1497 {
1498 parent = (char*) rt_malloc (1 + 1);
1499 if (parent)
1500 {
1501 parent[0] = '/';
1502 parent[1] = '\0';
1503 }
1504 }
1505 }
1506
1507 if (parent)
1508 {
1509 DLOG(msg, "dfs_file", "mnt", DLOG_MSG, "dfs_mnt_lookup(%s)", fullpath);
1510 mnt = dfs_mnt_lookup(parent);
1511 if (mnt)
1512 {
1513 char *tmp = dfs_file_realpath(&mnt, parent, DFS_REALPATH_EXCEPT_LAST);
1514 if (tmp)
1515 {
1516 rt_free(parent);
1517 parent = tmp;
1518 }
1519
1520 DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dfs_dentry_lookup(mnt, %s)", fullpath);
1521 dentry = dfs_dentry_lookup(mnt, parent, DFS_REALPATH_EXCEPT_LAST);
1522 if (dentry)
1523 {
1524 if (dentry->mnt->fs_ops->symlink)
1525 {
1526 char *path = dfs_normalize_path(parent, target);
1527 if (path)
1528 {
1529 ret = rt_strncmp(parent, path, strlen(parent));
1530 if (ret == 0)
1531 {
1532 tmp = path + strlen(parent);
1533 if (*tmp == '/')
1534 {
1535 tmp ++;
1536 }
1537 }
1538 else
1539 {
1540 tmp = path;
1541 }
1542
1543 if (dfs_is_mounted(mnt) == 0)
1544 {
1545 ret = mnt->fs_ops->symlink(dentry, tmp, index + 1);
1546 }
1547
1548 rt_free(path);
1549 }
1550 }
1551 else
1552 {
1553 ret = -ENOSYS;
1554 }
1555
1556 dfs_dentry_unref(dentry);
1557 }
1558 else
1559 {
1560 ret = -ENOENT;
1561 }
1562 }
1563 else
1564 {
1565 ret = -ENOENT;
1566 }
1567
1568 rt_free(parent);
1569 }
1570 }
1571 else
1572 {
1573 rt_set_errno(-EPERM);
1574 }
1575
1576 if (fullpath != linkpath)
1577 rt_free(fullpath);
1578 }
1579 else
1580 {
1581 ret = -EINVAL;
1582 }
1583
1584 return ret;
1585}
1586
1587int dfs_file_readlink(const char *path, char *buf, int bufsize)
1588{
1589 int ret = -RT_ERROR;
1590 char *fullpath = RT_NULL;
1591 struct dfs_mnt *mnt = RT_NULL;
1592 struct dfs_dentry *dentry = RT_NULL;
1593
1594 fullpath = dfs_normalize_path(NULL, path);
1595 if (fullpath)
1596 {
1597 DLOG(msg, "dfs_file", "mnt", DLOG_MSG, "dfs_mnt_lookup(%s)", fullpath);
1598 mnt = dfs_mnt_lookup(fullpath);
1599 if (mnt)
1600 {
1601 char *tmp = dfs_file_realpath(&mnt, fullpath, DFS_REALPATH_EXCEPT_LAST);
1602 if (tmp)
1603 {
1604 rt_free(fullpath);
1605 fullpath = tmp;
1606 }
1607
1608 DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dfs_dentry_lookup(mnt, %s)", fullpath);
1609 dentry = dfs_dentry_lookup(mnt, fullpath, 0);
1610 if (dentry)
1611 {
1612 if (mnt->fs_ops->readlink)
1613 {
1614 if (dfs_is_mounted(mnt) == 0)
1615 {
1616 ret = mnt->fs_ops->readlink(dentry, buf, bufsize);
1617 }
1618 }
1619 else
1620 {
1621 ret = -ENOSYS;
1622 }
1623
1624 /* release this dentry */
1625 dfs_dentry_unref(dentry);
1626 }
1627 else
1628 {
1629 /* no this entry */
1630 ret = -ENOENT;
1631 }
1632 }
1633 else
1634 {
1635 ret = -ENOENT;
1636 }
1637
1638 /* release fullpath */
1639 rt_free(fullpath);
1640 }
1641 else
1642 {
1643 ret = -ENOMEM;
1644 }
1645
1646 return ret;
1647}
1648
1649int dfs_file_rename(const char *old_file, const char *new_file)
1650{
1651 int ret = -1;
1652 struct dfs_mnt *mnt = RT_NULL;
1653 char *old_fullpath, *new_fullpath;
1654
1655 old_fullpath = dfs_normalize_path(NULL, old_file);
1656 if (old_fullpath)
1657 {
1658 DLOG(msg, "dfs_file", "mnt", DLOG_MSG, "dfs_mnt_lookup(%s)", old_fullpath);
1659 mnt = dfs_mnt_lookup(old_fullpath);
1660 if (mnt == RT_NULL)
1661 {
1662 rt_free(old_fullpath);
1663 return -1;
1664 }
1665
1666 char *tmp = dfs_file_realpath(&mnt, old_fullpath, DFS_REALPATH_EXCEPT_LAST);
1667 if (tmp)
1668 {
1669 rt_free(old_fullpath);
1670 old_fullpath = tmp;
1671 }
1672 }
1673
1674 new_fullpath = dfs_normalize_path(NULL, new_file);
1675 if (new_fullpath)
1676 {
1677 char *tmp = dfs_file_realpath(&mnt, new_fullpath, DFS_REALPATH_EXCEPT_LAST);
1678 if (tmp)
1679 {
1680 rt_free(new_fullpath);
1681 new_fullpath = tmp;
1682 }
1683 }
1684
1685 if (old_fullpath && new_fullpath)
1686 {
1687 struct dfs_dentry *old_dentry, *new_dentry;
1688
1689 DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dfs_dentry_lookup(mnt, %s)", old_fullpath);
1690 old_dentry = dfs_dentry_lookup(mnt, old_fullpath, 0);
1691 DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dfs_dentry_create(%s)", new_fullpath);
1692 new_dentry = dfs_dentry_create(mnt, new_fullpath);
1693
1694 if (old_dentry && new_dentry)
1695 {
1696 if (mnt->fs_ops->rename)
1697 {
1698 if (dfs_is_mounted(mnt) == 0)
1699 {
1700#ifdef RT_USING_PAGECACHE
1701 if (old_dentry->vnode->aspace)
1702 {
1703 dfs_aspace_clean(old_dentry->vnode->aspace);
1704 }
1705#endif
1706 ret = mnt->fs_ops->rename(old_dentry, new_dentry);
1707 }
1708 }
1709 }
1710
1711 dfs_dentry_unref(old_dentry);
1712 dfs_dentry_unref(new_dentry);
1713 }
1714
1715 if (old_fullpath)
1716 {
1717 rt_free(old_fullpath);
1718 }
1719
1720 if (new_fullpath)
1721 {
1722 rt_free(new_fullpath);
1723 }
1724
1725 return ret;
1726}
1727
1728int dfs_file_ftruncate(struct dfs_file *file, off_t length)
1729{
1730 int ret = 0;
1731
1732 if (file)
1733 {
1734 if (file->fops->truncate)
1735 {
1736 if (dfs_is_mounted(file->vnode->mnt) == 0)
1737 {
1738#ifdef RT_USING_PAGECACHE
1739 if (file->vnode->aspace)
1740 {
1741 dfs_aspace_clean(file->vnode->aspace);
1742 }
1743#endif
1744 ret = file->fops->truncate(file, length);
1745 }
1746 else
1747 {
1748 ret = -EINVAL;
1749 }
1750 }
1751 else
1752 {
1753 ret = -ENOSYS;
1754 }
1755 }
1756 else
1757 {
1758 ret = -EBADF;
1759 }
1760
1761 return ret;
1762}
1763
1764int dfs_file_flush(struct dfs_file *file)
1765{
1766 int ret = 0;
1767
1768 if (file)
1769 {
1770 if (file->fops->flush)
1771 {
1772 if (dfs_is_mounted(file->vnode->mnt) == 0)
1773 {
1774#ifdef RT_USING_PAGECACHE
1775 if (file->vnode->aspace)
1776 {
1777 dfs_aspace_flush(file->vnode->aspace);
1778 }
1779#endif
1780 ret = file->fops->flush(file);
1781 }
1782 else
1783 {
1784 ret = -EINVAL;
1785 }
1786 }
1787 else
1788 {
1789 ret = -ENOSYS;
1790 }
1791 }
1792 else
1793 {
1794 ret = -EBADF;
1795 }
1796
1797 return ret;
1798}
1799
1800int dfs_file_getdents(struct dfs_file *file, struct dirent *dirp, size_t nbytes)
1801{
1802 int ret = -RT_ERROR;
1803
1804 if (file)
1805 {
1806 if (file->vnode && S_ISDIR(file->vnode->mode))
1807 {
1808 if (file->fops && file->fops->getdents)
1809 {
1810 DLOG(msg, "dfs_file", file->dentry->mnt->fs_ops->name, DLOG_MSG, "fops->getdents()");
1811
1812 if (dfs_is_mounted(file->vnode->mnt) == 0)
1813 {
1814 ret = file->fops->getdents(file, dirp, nbytes);
1815 }
1816 else
1817 {
1818 ret = -EINVAL;
1819 }
1820 }
1821 }
1822 }
1823 else
1824 {
1825 ret = -EBADF;
1826 }
1827
1828 return ret;
1829}
1830
1838int dfs_file_isdir(const char *path)
1839{
1840 int ret = -RT_ERROR;
1841 char *fullpath = RT_NULL;
1842 struct dfs_mnt *mnt = RT_NULL;
1843 struct dfs_dentry *dentry = RT_NULL;
1844
1845 fullpath = dfs_normalize_path(NULL, path);
1846 if (fullpath)
1847 {
1848 DLOG(msg, "dfs_file", "mnt", DLOG_MSG, "dfs_mnt_lookup(%s)", fullpath);
1849 mnt = dfs_mnt_lookup(fullpath);
1850 if (mnt)
1851 {
1852 char *tmp = dfs_file_realpath(&mnt, fullpath, DFS_REALPATH_EXCEPT_NONE);
1853 if (tmp)
1854 {
1855 rt_free(fullpath);
1856 fullpath = tmp;
1857 }
1858
1859 DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dentry = dfs_dentry_lookup(mnt, %s)", fullpath);
1860 dentry = dfs_dentry_lookup(mnt, fullpath, 0);
1861 if (dentry)
1862 {
1863 DLOG(msg, "dentry", "dfs_file", DLOG_MSG_RET, "return dentry");
1864 if (mnt->fs_ops->stat)
1865 {
1866 struct stat stat = {0};
1867 DLOG(msg, "dfs_file", mnt->fs_ops->name, DLOG_MSG, "fs_ops->stat(dentry, buf)");
1868
1869 if (dfs_is_mounted(mnt) == 0)
1870 {
1871 ret = mnt->fs_ops->stat(dentry, &stat);
1872 }
1873
1874 if (ret == RT_EOK && S_ISDIR(stat.st_mode))
1875 {
1876 ret = RT_EOK;
1877 }
1878 else
1879 {
1880 ret = -RT_ERROR;
1881 }
1882 }
1883
1884 /* unref dentry */
1885 DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dfs_dentry_unref(dentry)");
1886 dfs_dentry_unref(dentry);
1887 dentry = RT_NULL;
1888 }
1889 }
1890
1891 rt_free(fullpath);
1892 fullpath = RT_NULL;
1893 }
1894
1895 return ret;
1896}
1897
1898int dfs_file_access(const char *path, mode_t mode)
1899{
1900 int ret;
1901 struct dfs_file file;
1902
1903 dfs_file_init(&file);
1904
1905 if (dfs_file_open(&file, path, O_RDONLY, mode) >= 0)
1906 {
1907 ret = 0;
1908 dfs_file_close(&file);
1909 }
1910 else
1911 {
1912 ret = -1;
1913 }
1914
1915 dfs_file_deinit(&file);
1916
1917 return ret;
1918}
1919
1920#ifdef RT_USING_SMART
1921int dfs_file_mmap2(struct dfs_file *file, struct dfs_mmap2_args *mmap2)
1922{
1923 int ret = RT_EOK;
1924
1925 if (file && mmap2)
1926 {
1927 if (file->vnode->type == FT_REGULAR)
1928 {
1929 ret = dfs_file_mmap(file, mmap2);
1930 if (ret != 0)
1931 {
1932 ret = ret > 0 ? ret : -ret;
1933 rt_set_errno(ret);
1934 }
1935 }
1936 else if (file->vnode->type != FT_DEVICE || !file->vnode->fops->ioctl)
1937 {
1938 rt_set_errno(EINVAL);
1939 }
1940 else if (file->vnode->type == FT_DEVICE && file->vnode->fops->ioctl)
1941 {
1942 if (dfs_is_mounted(file->vnode->mnt) == 0)
1943 {
1944 ret = file->vnode->fops->ioctl(file, RT_FIOMMAP2, mmap2);
1945 }
1946 else
1947 {
1948 ret = EINVAL;
1949 }
1950
1951 if (ret != 0)
1952 {
1953 ret = ret > 0 ? ret : -ret;
1954 rt_set_errno(ret);
1955 }
1956 }
1957 }
1958
1959 return ret;
1960}
1961#endif
1962
1963#ifdef RT_USING_FINSH
1964
1965#define _COLOR_RED "\033[31m"
1966#define _COLOR_GREEN "\033[32m"
1967#define _COLOR_YELLOW "\033[33m"
1968#define _COLOR_BLUE "\033[34m"
1969#define _COLOR_CYAN "\033[36m"
1970#define _COLOR_WHITE "\033[37m"
1971#define _COLOR_NORMAL "\033[0m"
1972
1973void ls(const char *pathname)
1974{
1975 struct dirent dirent;
1976 struct stat stat;
1977 int length;
1978 char *fullpath, *path;
1979 struct dfs_file file;
1980
1981 if (pathname == NULL)
1982 {
1983#ifdef DFS_USING_WORKDIR
1984 /* open current working directory */
1985 path = rt_strdup(working_directory);
1986#else
1987 path = rt_strdup("/");
1988#endif
1989 if (path == NULL)
1990 {
1991 return; /* out of memory */
1992 }
1993 }
1994 else
1995 {
1996 path = dfs_normalize_path(NULL, (char *)pathname);
1997 if (path == NULL)
1998 {
1999 return; /* out of memory */
2000 }
2001 }
2002
2003 dfs_file_init(&file);
2004
2005 /* list directory */
2006 DLOG(msg, "dfs", "dfs_file", DLOG_MSG, "dfs_file_open(%s, O_DIRECTORY, 0)", path);
2007 if (dfs_file_open(&file, path, O_DIRECTORY, 0) >= 0)
2008 {
2009 char *link_fn = (char *)rt_malloc(DFS_PATH_MAX);
2010 if (link_fn)
2011 {
2012 rt_kprintf("Directory %s:\n", path);
2013 do
2014 {
2015 memset(&dirent, 0, sizeof(struct dirent));
2016
2017 DLOG(group, "foreach_item");
2018 DLOG(msg, "dfs", "dfs_file", DLOG_MSG, "dfs_file_getdents(&dirent)");
2019 length = dfs_file_getdents(&file, &dirent, sizeof(struct dirent));
2020 if (length > 0)
2021 {
2022 DLOG(msg, "dfs_file", "dfs", DLOG_MSG_RET, "dirent.d_name=%s", dirent.d_name);
2023 memset(&stat, 0, sizeof(struct stat));
2024
2025 /* build full path for each file */
2026 fullpath = dfs_normalize_path(path, dirent.d_name);
2027 if (fullpath == NULL)
2028 break;
2029
2030 DLOG(msg, "dfs", "dfs_file", DLOG_MSG, "dfs_file_lstat(%s, &stat)", fullpath);
2031 if (dfs_file_lstat(fullpath, &stat) == 0)
2032 {
2033 if (S_ISDIR(stat.st_mode))
2034 {
2035 rt_kprintf(_COLOR_BLUE "%-20s" _COLOR_NORMAL, dirent.d_name);
2036 rt_kprintf("%-25s\n", "<DIR>");
2037 }
2038 else if (S_ISLNK(stat.st_mode))
2039 {
2040 int ret = 0;
2041
2042 rt_kprintf(_COLOR_CYAN "%-20s" _COLOR_NORMAL, dirent.d_name);
2043
2044 ret = dfs_file_readlink(fullpath, link_fn, DFS_PATH_MAX);
2045 if (ret > 0)
2046 {
2047 char *link_path = link_fn;
2048 struct dfs_mnt *mnt = RT_NULL;
2049
2050 mnt = dfs_mnt_lookup(fullpath);
2051 if (mnt)
2052 {
2053 char *tmp = dfs_file_realpath(&mnt, fullpath, DFS_REALPATH_EXCEPT_LAST);
2054 if (tmp)
2055 {
2056 char *index;
2057
2058 index = strrchr(fullpath, '/');
2059 if (index)
2060 {
2061 int length = index - fullpath;
2062 char *parent = (char*) rt_malloc (length + 1);
2063 if (parent)
2064 {
2065 rt_memcpy(parent, fullpath, length);
2066 parent[length] = '\0';
2067
2068 ret = rt_strncmp(parent, link_fn, length);
2069 if (ret == 0)
2070 {
2071 link_path = link_fn + length;
2072 if (*link_path == '/')
2073 {
2074 link_path ++;
2075 }
2076 }
2077 rt_free(parent);
2078 }
2079 }
2080 rt_free(tmp);
2081 }
2082 }
2083
2084 rt_kprintf("-> %s\n", link_path);
2085 }
2086 else
2087 {
2088 rt_kprintf(_COLOR_RED "-> link_error\n" _COLOR_NORMAL);
2089 }
2090 }
2091 else if (stat.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))
2092 {
2093 rt_kprintf(_COLOR_GREEN "%-20s" _COLOR_NORMAL, dirent.d_name);
2094 rt_kprintf("%-25lu\n", (unsigned long)stat.st_size);
2095 }
2096 else if (S_ISCHR(stat.st_mode))
2097 {
2098 rt_kprintf(_COLOR_YELLOW "%-20s" _COLOR_NORMAL, dirent.d_name);
2099 rt_kprintf("%-25s\n", "<CHR>");
2100 }
2101 else
2102 {
2103 rt_kprintf("%-20s", dirent.d_name);
2104 rt_kprintf("%-25lu\n", (unsigned long)stat.st_size);
2105 }
2106 }
2107 else
2108 {
2109 rt_kprintf(_COLOR_RED "%-20s\n" _COLOR_NORMAL, dirent.d_name);
2110 }
2111
2112 rt_free(fullpath);
2113 }
2114 else
2115 {
2116 DLOG(msg, "dfs_file", "dfs", DLOG_MSG_RET, "return NULL");
2117 }
2118
2119 DLOG(group_end);
2120 } while (length > 0);
2121
2122 rt_free(link_fn);
2123 }
2124
2125 DLOG(msg, "dfs", "dfs_file", DLOG_MSG, "dfs_file_close()");
2126 dfs_file_close(&file);
2127 }
2128 else
2129 {
2130 rt_kprintf("No such directory\n");
2131 }
2132
2133 dfs_file_deinit(&file);
2134
2135 DLOG(msg, "dfs_file", "dfs", DLOG_MSG_RET, "return");
2136 rt_free(path);
2137}
2138
2139void cat(const char *filename)
2140{
2141 int length = 0;
2142 char buffer[81];
2143 struct dfs_file file;
2144
2145 if (filename && dfs_file_isdir(filename) == 0)
2146 {
2147 rt_kprintf("cat: %s Is a directory\n", filename);
2148 return;
2149 }
2150
2151 dfs_file_init(&file);
2152
2153 DLOG(msg, "dfs", "dfs_file", DLOG_MSG, "dfs_file_open(%s, O_RDONLY, 0)", filename);
2154 if (dfs_file_open(&file, filename, O_RDONLY, 0) < 0)
2155 {
2156 rt_kprintf("Open %s failed\n", filename);
2157 dfs_file_deinit(&file);
2158 return;
2159 }
2160
2161 do
2162 {
2163 rt_memset(buffer, 0x0, sizeof(buffer));
2164 DLOG(msg, "dfs", "dfs_file", DLOG_MSG, "dfs_file_read(fd, buffer, %d)", sizeof(buffer) - 1);
2165 length = dfs_file_read(&file, (void *)buffer, sizeof(buffer) - 1);
2166 if (length > 0)
2167 {
2168 buffer[length] = '\0';
2169 rt_kprintf("%s", buffer);
2170 }
2171 } while (length > 0);
2172 rt_kprintf("\n");
2173
2174 DLOG(msg, "dfs", "dfs_file", DLOG_MSG, "dfs_file_close()");
2175 dfs_file_close(&file);
2176 dfs_file_deinit(&file);
2177}
2178
2179#define BUF_SZ 4096
2180static void copyfile(const char *src, const char *dst)
2181{
2182 int ret;
2183 struct dfs_file src_file, dst_file;
2184 rt_uint8_t *block_ptr;
2185 rt_int32_t read_bytes;
2186
2187 block_ptr = (rt_uint8_t *)rt_malloc(BUF_SZ);
2188 if (block_ptr == NULL)
2189 {
2190 rt_kprintf("out of memory\n");
2191 return;
2192 }
2193
2194 dfs_file_init(&src_file);
2195
2196 ret = dfs_file_open(&src_file, src, O_RDONLY, 0);
2197 if (ret < 0)
2198 {
2199 dfs_file_deinit(&src_file);
2200 rt_free(block_ptr);
2201 rt_kprintf("Read %s failed\n", src);
2202 return;
2203 }
2204
2205 dfs_file_init(&dst_file);
2206
2207 ret = dfs_file_open(&dst_file, dst, O_WRONLY | O_CREAT | O_TRUNC, 0);
2208 if (ret < 0)
2209 {
2210 dfs_file_deinit(&dst_file);
2211 dfs_file_close(&src_file);
2212 dfs_file_deinit(&src_file);
2213 rt_free(block_ptr);
2214 rt_kprintf("Write %s failed\n", dst);
2215 return;
2216 }
2217
2218 do
2219 {
2220 read_bytes = dfs_file_read(&src_file, block_ptr, BUF_SZ);
2221 if (read_bytes > 0)
2222 {
2223 int length;
2224
2225 length = dfs_file_write(&dst_file, block_ptr, read_bytes);
2226 if (length != read_bytes)
2227 {
2228 /* write failed. */
2229 rt_kprintf("Write file data failed, errno=%d\n", length);
2230 break;
2231 }
2232 }
2233 } while (read_bytes > 0);
2234
2235 dfs_file_close(&dst_file);
2236 dfs_file_deinit(&dst_file);
2237 dfs_file_close(&src_file);
2238 dfs_file_deinit(&src_file);
2239 rt_free(block_ptr);
2240}
2241
2242extern int mkdir(const char *path, mode_t mode);
2243static void copydir(const char *src, const char *dst)
2244{
2245 struct dirent dirent;
2246 struct stat stat;
2247 int length;
2248 struct dfs_file file;
2249
2250 dfs_file_init(&file);
2251
2252 if (dfs_file_open(&file, src, O_DIRECTORY, 0) < 0)
2253 {
2254 rt_kprintf("open %s failed\n", src);
2255 dfs_file_deinit(&file);
2256 return ;
2257 }
2258
2259 do
2260 {
2261 rt_memset(&dirent, 0, sizeof(struct dirent));
2262
2263 length = dfs_file_getdents(&file, &dirent, sizeof(struct dirent));
2264 if (length > 0)
2265 {
2266 char *src_entry_full = NULL;
2267 char *dst_entry_full = NULL;
2268
2269 if (strcmp(dirent.d_name, "..") == 0 || strcmp(dirent.d_name, ".") == 0)
2270 continue;
2271
2272 /* build full path for each file */
2273 if ((src_entry_full = dfs_normalize_path(src, dirent.d_name)) == NULL)
2274 {
2275 rt_kprintf("out of memory!\n");
2276 break;
2277 }
2278 if ((dst_entry_full = dfs_normalize_path(dst, dirent.d_name)) == NULL)
2279 {
2280 rt_kprintf("out of memory!\n");
2281 rt_free(src_entry_full);
2282 break;
2283 }
2284
2285 rt_memset(&stat, 0, sizeof(struct stat));
2286 if (dfs_file_lstat(src_entry_full, &stat) != 0)
2287 {
2288 rt_kprintf("open file: %s failed\n", dirent.d_name);
2289 continue;
2290 }
2291
2292 if (S_ISDIR(stat.st_mode))
2293 {
2294 mkdir(dst_entry_full, 0);
2295 copydir(src_entry_full, dst_entry_full);
2296 }
2297 else
2298 {
2299 copyfile(src_entry_full, dst_entry_full);
2300 }
2301 rt_free(src_entry_full);
2302 rt_free(dst_entry_full);
2303 }
2304 }
2305 while (length > 0);
2306
2307 dfs_file_close(&file);
2308 dfs_file_deinit(&file);
2309}
2310
2311static const char *_get_path_lastname(const char *path)
2312{
2313 char *ptr;
2314 if ((ptr = (char *)strrchr(path, '/')) == NULL)
2315 return path;
2316
2317 /* skip the '/' then return */
2318 return ++ptr;
2319}
2320
2321void copy(const char *src, const char *dst)
2322{
2323#define FLAG_SRC_TYPE 0x03
2324#define FLAG_SRC_IS_DIR 0x01
2325#define FLAG_SRC_IS_FILE 0x02
2326#define FLAG_SRC_NON_EXSIT 0x00
2327
2328#define FLAG_DST_TYPE 0x0C
2329#define FLAG_DST_IS_DIR 0x04
2330#define FLAG_DST_IS_FILE 0x08
2331#define FLAG_DST_NON_EXSIT 0x00
2332
2333 struct stat stat;
2334 uint32_t flag = 0;
2335
2336 /* check the staus of src and dst */
2337 if (dfs_file_lstat(src, &stat) < 0)
2338 {
2339 rt_kprintf("copy failed, bad %s\n", src);
2340 return;
2341 }
2342 if (S_ISDIR(stat.st_mode))
2343 flag |= FLAG_SRC_IS_DIR;
2344 else
2345 flag |= FLAG_SRC_IS_FILE;
2346
2347 if (dfs_file_stat(dst, &stat) < 0)
2348 {
2349 flag |= FLAG_DST_NON_EXSIT;
2350 }
2351 else
2352 {
2353 if (S_ISDIR(stat.st_mode))
2354 flag |= FLAG_DST_IS_DIR;
2355 else
2356 flag |= FLAG_DST_IS_FILE;
2357 }
2358
2359 //2. check status
2360 if ((flag & FLAG_SRC_IS_DIR) && (flag & FLAG_DST_IS_FILE))
2361 {
2362 rt_kprintf("cp faild, cp dir to file is not permitted!\n");
2363 return ;
2364 }
2365
2366 //3. do copy
2367 if (flag & FLAG_SRC_IS_FILE)
2368 {
2369 if (flag & FLAG_DST_IS_DIR)
2370 {
2371 char *fdst;
2372 fdst = dfs_normalize_path(dst, _get_path_lastname(src));
2373 if (fdst == NULL)
2374 {
2375 rt_kprintf("out of memory\n");
2376 return;
2377 }
2378 copyfile(src, fdst);
2379 rt_free(fdst);
2380 }
2381 else
2382 {
2383 copyfile(src, dst);
2384 }
2385 }
2386 else //flag & FLAG_SRC_IS_DIR
2387 {
2388 if (flag & FLAG_DST_IS_DIR)
2389 {
2390 char *fdst;
2391 fdst = dfs_normalize_path(dst, _get_path_lastname(src));
2392 if (fdst == NULL)
2393 {
2394 rt_kprintf("out of memory\n");
2395 return;
2396 }
2397 mkdir(fdst, 0);
2398 copydir(src, fdst);
2399 rt_free(fdst);
2400 }
2401 else if ((flag & FLAG_DST_TYPE) == FLAG_DST_NON_EXSIT)
2402 {
2403 mkdir(dst, 0);
2404 copydir(src, dst);
2405 }
2406 else
2407 {
2408 copydir(src, dst);
2409 }
2410 }
2411}
2412FINSH_FUNCTION_EXPORT(copy, copy file or dir)
2413
2414#endif
DFS_F_FWRITE
#define DFS_F_FWRITE
定义 dfs.h:84
DFS_F_FREAD
#define DFS_F_FREAD
定义 dfs.h:83
dfs_fflags
rt_inline int dfs_fflags(int oflags)
定义 dfs.h:90
DFS_PATH_MAX
#define DFS_PATH_MAX
定义 dfs.h:72
dfs_dentry_create
struct dfs_dentry * dfs_dentry_create(struct dfs_mnt *mnt, char *fullpath)
定义 dfs_dentry.c:78
dfs_dentry_lookup
struct dfs_dentry * dfs_dentry_lookup(struct dfs_mnt *mnt, const char *path, uint32_t flags)
定义 dfs_dentry.c:199
dfs_dentry_unref
struct dfs_dentry * dfs_dentry_unref(struct dfs_dentry *dentry)
定义 dfs_dentry.c:107
dfs_dentry_insert
void dfs_dentry_insert(struct dfs_dentry *dentry)
定义 dfs_dentry.c:188
dfs_dentry.h
_COLOR_NORMAL
#define _COLOR_NORMAL
定义 dfs_file.c:1971
_COLOR_RED
#define _COLOR_RED
定义 dfs_file.c:1965
FLAG_SRC_IS_FILE
#define FLAG_SRC_IS_FILE
dfs_file_getdents
int dfs_file_getdents(struct dfs_file *file, struct dirent *dirp, size_t nbytes)
定义 dfs_file.c:1800
dfs_file_lstat
int dfs_file_lstat(const char *path, struct stat *buf)
定义 dfs_file.c:1033
copy
void copy(const char *src, const char *dst)
定义 dfs_file.c:2321
dfs_file_access
int dfs_file_access(const char *path, mode_t mode)
定义 dfs_file.c:1898
ls
void ls(const char *pathname)
定义 dfs_file.c:1973
FLAG_DST_NON_EXSIT
#define FLAG_DST_NON_EXSIT
BUF_SZ
#define BUF_SZ
定义 dfs_file.c:2179
cat
void cat(const char *filename)
定义 dfs_file.c:2139
dfs_file_get_fpos
off_t dfs_file_get_fpos(struct dfs_file *file)
定义 dfs_file.c:162
_first_path_len
rt_inline int _first_path_len(const char *path)
定义 dfs_file.c:32
_COLOR_GREEN
#define _COLOR_GREEN
定义 dfs_file.c:1966
dfs_file_unlink
int dfs_file_unlink(const char *path)
定义 dfs_file.c:1285
dfs_file_ftruncate
int dfs_file_ftruncate(struct dfs_file *file, off_t length)
定义 dfs_file.c:1728
dfs_file_init
void dfs_file_init(struct dfs_file *file)
定义 dfs_file.c:189
dfs_file_pwrite
ssize_t dfs_file_pwrite(struct dfs_file *file, const void *buf, size_t len, off_t offset)
定义 dfs_file.c:813
dfs_file_lseek
off_t dfs_file_lseek(struct dfs_file *file, off_t offset, int wherece)
定义 dfs_file.c:956
dfs_file_setattr
int dfs_file_setattr(const char *path, struct dfs_attr *attr)
定义 dfs_file.c:1112
dfs_file_flush
int dfs_file_flush(struct dfs_file *file)
定义 dfs_file.c:1764
dfs_file_symlink
int dfs_file_symlink(const char *target, const char *linkpath)
定义 dfs_file.c:1459
dfs_file_ioctl
int dfs_file_ioctl(struct dfs_file *file, int cmd, void *args)
定义 dfs_file.c:1162
dfs_file_read
ssize_t dfs_file_read(struct dfs_file *file, void *buf, size_t len)
定义 dfs_file.c:762
dfs_file_pread
ssize_t dfs_file_pread(struct dfs_file *file, void *buf, size_t len, off_t offset)
定义 dfs_file.c:714
dfs_file_fsync
int dfs_file_fsync(struct dfs_file *file)
定义 dfs_file.c:1257
_COLOR_BLUE
#define _COLOR_BLUE
定义 dfs_file.c:1968
dfs_file_fcntl
int dfs_file_fcntl(int fd, int cmd, unsigned long arg)
定义 dfs_file.c:1192
dfs_file_isdir
int dfs_file_isdir(const char *path)
定义 dfs_file.c:1838
dfs_file_close
int dfs_file_close(struct dfs_file *file)
定义 dfs_file.c:670
FLAG_SRC_IS_DIR
#define FLAG_SRC_IS_DIR
rw_verify_area
ssize_t rw_verify_area(struct dfs_file *file, off_t *ppos, size_t count)
定义 dfs_file.c:145
FLAG_DST_IS_DIR
#define FLAG_DST_IS_DIR
_COLOR_CYAN
#define _COLOR_CYAN
定义 dfs_file.c:1969
FLAG_DST_TYPE
#define FLAG_DST_TYPE
generic_dfs_lseek
off_t generic_dfs_lseek(struct dfs_file *file, off_t offset, int whence)
定义 dfs_file.c:940
FLAG_DST_IS_FILE
#define FLAG_DST_IS_FILE
dfs_file_realpath
char * dfs_file_realpath(struct dfs_mnt **mnt, const char *fullpath, int mode)
定义 dfs_file.c:253
dfs_file_readlink
int dfs_file_readlink(const char *path, char *buf, int bufsize)
定义 dfs_file.c:1587
dfs_file_open
int dfs_file_open(struct dfs_file *file, const char *path, int oflags, mode_t mode)
定义 dfs_file.c:409
dfs_file_set_fpos
void dfs_file_set_fpos(struct dfs_file *file, off_t fpos)
定义 dfs_file.c:176
_COLOR_YELLOW
#define _COLOR_YELLOW
定义 dfs_file.c:1967
dfs_file_deinit
void dfs_file_deinit(struct dfs_file *file)
定义 dfs_file.c:200
dfs_file_stat
int dfs_file_stat(const char *path, struct stat *buf)
定义 dfs_file.c:979
dfs_file_rename
int dfs_file_rename(const char *old_file, const char *new_file)
定义 dfs_file.c:1649
dfs_file_link
int dfs_file_link(const char *oldname, const char *newname)
定义 dfs_file.c:1373
MAX_RW_COUNT
#define MAX_RW_COUNT
定义 dfs_file.c:30
dfs_file_write
ssize_t dfs_file_write(struct dfs_file *file, const void *buf, size_t len)
定义 dfs_file.c:869
dfs_file_fstat
int dfs_file_fstat(struct dfs_file *file, struct stat *buf)
定义 dfs_file.c:1089
dfs_file.h
DFS_FD_MAGIC
#define DFS_FD_MAGIC
定义 dfs_file.h:84
DFS_REALPATH_EXCEPT_NONE
#define DFS_REALPATH_EXCEPT_NONE
定义 dfs_file.h:194
RT_FIOMMAP2
#define RT_FIOMMAP2
定义 dfs_file.h:190
DFS_REALPATH_ONLY_LAST
#define DFS_REALPATH_ONLY_LAST
定义 dfs_file.h:195
DFS_REALPATH_EXCEPT_LAST
#define DFS_REALPATH_EXCEPT_LAST
定义 dfs_file.h:193
dfs_file_mmap
int dfs_file_mmap(struct dfs_file *file, struct dfs_mmap2_args *mmap2)
定义 dfs_file_mmap.c:464
dfs_is_mounted
int dfs_is_mounted(struct dfs_mnt *mnt)
定义 dfs_fs.c:406
dfs_fs.h
dfs_mnt_has_child_mnt
rt_bool_t dfs_mnt_has_child_mnt(struct dfs_mnt *mnt, const char *fullpath)
定义 dfs_mnt.c:431
dfs_mnt_lookup
struct dfs_mnt * dfs_mnt_lookup(const char *fullpath)
定义 dfs_mnt.c:194
dfs_mnt.h
dfs_pcache.h
dfs_private.h
working_directory
char working_directory[]
dfs_dup
int dfs_dup(int oldfd, int startfd)
定义 dfs.c:526
dfs_normalize_path
char * dfs_normalize_path(const char *directory, const char *filename)
定义 dfs.c:779
dfs_file_unlock
void dfs_file_unlock(void)
定义 dfs.c:164
dfs_file_lock
rt_err_t dfs_file_lock(void)
定义 dfs.c:147
fd_get
struct dfs_file * fd_get(int fd)
定义 dfs.c:367
mkdir
int mkdir(const char *path, mode_t mode)
定义 dfs_posix.c:812
stat
int stat(const char *file, struct stat *buf)
定义 dfs_posix.c:526
RT_IPC_FLAG_PRIO
#define RT_IPC_FLAG_PRIO
定义 rtdef.h:973
RT_WAITING_FOREVER
#define RT_WAITING_FOREVER
定义 rtdef.h:980
rt_kprintf
#define rt_kprintf(...)
定义 rtthread.h:771
rt_free
rt_weak void rt_free(void *ptr)
This function will release the previously allocated memory block by rt_malloc. The released memory bl...
定义 kservice.c:886
rt_malloc
rt_weak void * rt_malloc(rt_size_t size)
Allocate a block of memory with a minimum of 'size' bytes.
定义 kservice.c:807
FINSH_FUNCTION_EXPORT
#define FINSH_FUNCTION_EXPORT(name, desc)
定义 components/finsh/finsh.h:119
rt_mutex_take
rt_err_t rt_mutex_take(rt_mutex_t mutex, rt_int32_t time)
定义 ipc.c:1537
rt_mutex_detach
rt_err_t rt_mutex_detach(rt_mutex_t mutex)
This function will detach a static mutex object.
定义 ipc.c:1054
rt_mutex_init
rt_err_t rt_mutex_init(rt_mutex_t mutex, const char *name, rt_uint8_t flag)
Initialize a static mutex object.
定义 ipc.c:1007
rt_mutex_release
rt_err_t rt_mutex_release(rt_mutex_t mutex)
This function will release a mutex. If there is thread suspended on the mutex, the thread will be res...
定义 ipc.c:1589
rt_atomic_sub
#define rt_atomic_sub(ptr, v)
定义 rtatomic.h:66
rt_atomic_store
#define rt_atomic_store(ptr, v)
定义 rtatomic.h:64
rt_atomic_load
#define rt_atomic_load(ptr)
定义 rtatomic.h:63
DLOG
#define DLOG(...)
定义 rtdbg.h:53
LOG_W
#define LOG_W(...)
定义 rtdbg.h:147
LOG_I
#define LOG_I(...)
定义 rtdbg.h:141
rt_base_t
rt_int32_t rt_base_t
定义 rttypes.h:68
rt_bool_t
int rt_bool_t
定义 rttypes.h:35
rt_err_t
rt_base_t rt_err_t
定义 rttypes.h:84
rt_uint8_t
unsigned char rt_uint8_t
定义 rttypes.h:51
RT_TRUE
#define RT_TRUE
定义 rttypes.h:110
rt_atomic_t
rt_base_t rt_atomic_t
定义 rttypes.h:105
RT_FALSE
#define RT_FALSE
定义 rttypes.h:111
RT_NULL
#define RT_NULL
定义 rttypes.h:114
rt_int32_t
signed int rt_int32_t
定义 rttypes.h:50
dfs_attr
定义 dfs_fs.h:65
dfs_dentry
定义 dfs_dentry.h:26
dfs_dentry::pathname
char * pathname
定义 dfs_dentry.h:35
dfs_dentry::mnt
struct dfs_mnt * mnt
定义 dfs_dentry.h:38
dfs_dentry::vnode
struct dfs_vnode * vnode
定义 dfs_dentry.h:37
dfs_file_ops::truncate
int(* truncate)(struct dfs_file *file, off_t offset)
定义 dfs_file.h:47
dfs_file_ops::write
ssize_t(* write)(struct dfs_file *file, const void *buf, size_t count, off_t *pos)
定义 dfs_file.h:44
dfs_file_ops::lseek
off_t(* lseek)(struct dfs_file *file, off_t offset, int wherece)
定义 dfs_file.h:46
dfs_file_ops::flush
int(* flush)(struct dfs_file *file)
定义 dfs_file.h:45
dfs_file_ops::read
ssize_t(* read)(struct dfs_file *file, void *buf, size_t count, off_t *pos)
定义 dfs_file.h:43
dfs_file_ops::ioctl
int(* ioctl)(struct dfs_file *file, int cmd, void *arg)
定义 dfs_file.h:42
dfs_file_ops::open
int(* open)(struct dfs_file *file)
定义 dfs_file.h:40
dfs_file_ops::close
int(* close)(struct dfs_file *file)
定义 dfs_file.h:41
dfs_file_ops::getdents
int(* getdents)(struct dfs_file *file, struct dirent *dirp, uint32_t count)
定义 dfs_file.h:48
dfs_file
定义 dfs_file.h:86
dfs_file::vnode
struct dfs_vnode * vnode
定义 dfs_file.h:98
dfs_file::dentry
struct dfs_dentry * dentry
定义 dfs_file.h:97
dfs_file::fops
const struct dfs_file_ops * fops
定义 dfs_file.h:96
dfs_file::magic
uint16_t magic
定义 dfs_file.h:87
dfs_file::pos_lock
struct rt_mutex pos_lock
定义 dfs_file.h:94
dfs_file::ref_count
rt_atomic_t ref_count
定义 dfs_file.h:91
dfs_file::fpos
off_t fpos
定义 dfs_file.h:93
dfs_file::flags
uint32_t flags
定义 dfs_file.h:90
dfs_file::mode
uint16_t mode
定义 dfs_file.h:88
dfs_filesystem_ops::unlink
int(* unlink)(struct dfs_dentry *dentry)
定义 dfs_fs.h:95
dfs_filesystem_ops::setattr
int(* setattr)(struct dfs_dentry *dentry, struct dfs_attr *attr)
定义 dfs_fs.h:103
dfs_filesystem_ops::rename
int(* rename)(struct dfs_dentry *old_dentry, struct dfs_dentry *new_dentry)
定义 dfs_fs.h:98
dfs_filesystem_ops::stat
int(* stat)(struct dfs_dentry *dentry, struct stat *buf)
定义 dfs_fs.h:99
dfs_filesystem_ops::symlink
int(* symlink)(struct dfs_dentry *parent_dentry, const char *target, const char *newpath)
定义 dfs_fs.h:96
dfs_filesystem_ops::link
int(* link)(struct dfs_dentry *src_dentry, struct dfs_dentry *dst_dentry)
定义 dfs_fs.h:94
dfs_filesystem_ops::default_fops
const struct dfs_file_ops * default_fops
定义 dfs_fs.h:86
dfs_filesystem_ops::name
const char * name
定义 dfs_fs.h:82
dfs_filesystem_ops::readlink
int(* readlink)(struct dfs_dentry *dentry, char *buf, int len)
定义 dfs_fs.h:93
dfs_filesystem_ops::create_vnode
struct dfs_vnode *(* create_vnode)(struct dfs_dentry *dentry, int type, mode_t mode)
定义 dfs_fs.h:107
dfs_mnt
定义 dfs_mnt.h:27
dfs_mnt::fullpath
char * fullpath
定义 dfs_mnt.h:33
dfs_mnt::fs_ops
const struct dfs_filesystem_ops * fs_ops
定义 dfs_mnt.h:48
dfs_mnt::parent
struct dfs_mnt * parent
定义 dfs_mnt.h:28
dfs_vnode
定义 dfs_file.h:57
dfs_vnode::size
size_t size
定义 dfs_file.h:66
dfs_vnode::aspace
struct dfs_aspace * aspace
定义 dfs_file.h:77
dfs_vnode::mode
uint32_t mode
定义 dfs_file.h:59
dfs_vnode::mnt
struct dfs_mnt * mnt
定义 dfs_file.h:64
dfs_vnode::fops
const struct dfs_file_ops * fops
定义 dfs_file.h:69
dfs_vnode::ref_count
rt_atomic_t ref_count
定义 dfs_file.h:62
dfs_vnode::type
int type
定义 dfs_file.h:60