?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Kernel 0.6.3; ZNFS filesystem is able to create file, directories, change directory...
[ZeXOS.git] / kernel / core / vfs.c
blob41c2b070d9fa634a125422e3dbbaa90ca69ef345
1 /*
2 * ZeX/OS
3 * Copyright (C) 2007 Tomas 'ZeXx86' Jedrzejek (zexx86@gmail.com)
4 * Copyright (C) 2008 Tomas 'ZeXx86' Jedrzejek (zexx86@gmail.com)
5 * Copyright (C) 2009 Tomas 'ZeXx86' Jedrzejek (zexx86@gmail.com)
6 *
7 * This program is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 */
20
21
22 #include <system.h>
23 #include <string.h>
24 #include <mount.h>
25 #include <vfs.h>
26 #include <smp.h>
27 #include <fd.h>
28
29 vfs_t vfs_list;
30
31 extern mount_t mount_list;
32 extern unsigned int fd_count;
33
34 vfs_t *vfs_list_find (char *name, char *mountpoint)
35 {
36 unsigned l = strlen (name);
37
38 vfs_t *vfs;
39 for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next) {
40 if (!strncmp (vfs->name, name, l) && !strcmp (vfs->mountpoint, mountpoint))
41 return vfs;
42 }
43
44 return 0;
45 }
46
47 vfs_t *vfs_list_findbymp (char *mountpoint)
48 {
49 char mdir[128];
50 char pwd[64];
51 strcpy (pwd, (char *) env_get ("PWD"));
52 unsigned l = strlen (pwd);
53
54 vfs_t *vfs;
55 for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next) {
56 if (strncmp (pwd, vfs->mountpoint, l))
57 continue;
58
59 sprintf (mdir, "%s%s/", vfs->mountpoint, vfs->name);
60
61 if (!strcmp (mdir, mountpoint))
62 return vfs;
63 }
64
65 return 0;
66 }
67
68 vfs_t *vfs_list_add (char *name, unsigned attrib, char *mountpoint)
69 {
70 unsigned name_len = strlen (name);
71 unsigned mp_len = strlen (mountpoint);
72
73 vfs_t *vfs;
74 for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next) {
75 if (!strcmp (vfs->name, name) && !strcmp (vfs->mountpoint, mountpoint)) {
76 DPRINT ("ERROR -> vfs_list_add () - vfs object already exist !\n");
77 return 0;
78 }
79 }
80
81 /* alloc and init context */
82 vfs = (vfs_t *) kmalloc (sizeof (vfs_t));
83
84 if (!vfs)
85 return 0;
86
87 memset (vfs, 0, sizeof (vfs_t));
88
89 vfs->name = (char *) kmalloc (sizeof (char) * VFS_FILENAME_LEN + 2);
90
91 if (!vfs->name) {
92 kfree (vfs);
93 return 0;
94 }
95
96 memset (vfs->name, 0, VFS_FILENAME_LEN);
97 memcpy (vfs->name, name, name_len);
98 vfs->name[name_len] = '\0';
99
100 memset (vfs->mountpoint, 0, VFS_MOUNTPOINT_LEN);
101 memcpy (vfs->mountpoint, mountpoint, mp_len);
102 vfs->mountpoint[mp_len] = '\0';
103
104 vfs->attrib = attrib;
105
106 vfs->content = 0;
107
108 /* add into list */
109 vfs->next = &vfs_list;
110 vfs->prev = vfs_list.prev;
111 vfs->prev->next = vfs;
112 vfs->next->prev = vfs;
113
114 return vfs;
115 }
116
117 bool vfs_list_del (vfs_t *vfs)
118 {
119 if (!vfs)
120 return 0;
121
122 vfs->next->prev = vfs->prev;
123 vfs->prev->next = vfs->next;
124
125 if (vfs->content) {
126 if (vfs->content->ptr)
127 kfree (vfs->content->ptr);
128
129 kfree (vfs->content);
130 }
131
132 return 1;
133 }
134
135 bool vfs_list_delbymp (char *mountpoint)
136 {
137 bool f = 0;
138 vfs_t *vfs;
139 for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next) {
140 if (!strncmp (vfs->mountpoint, mountpoint, strlen (mountpoint))) {
141 f = 1;
142 break;
143 }
144 }
145
146 if (f) {
147 vfs->next->prev = vfs->prev;
148 vfs->prev->next = vfs->next;
149
150 if (vfs->content) {
151 if (vfs->content->ptr)
152 kfree (vfs->content->ptr);
153
154 kfree (vfs->content);
155 }
156
157 //kfree (vfs);
158 return 1;
159 }
160
161 return 0;
162 }
163
164 bool vfs_mmap (char *file, unsigned file_len, char *data, unsigned long len)
165 {
166 vfs_t *vfs;
167
168 char pwd[64];
169 strcpy (pwd, (char *) env_get ("PWD"));
170
171 char buf[65];
172 unsigned pwd_len = strlen (pwd);
173
174 unsigned i = file[0] == '/' ? 1 : 0;
175
176 if (!i) {
177 memcpy (buf, pwd, pwd_len);
178 memcpy (buf+pwd_len, file+i, file_len-i);
179 buf[pwd_len+file_len-i] = '\0';
180 } else {
181 memcpy (buf, file, file_len);
182 buf[file_len] = '\0';
183 }
184
185 if (buf[pwd_len+file_len-i-1] == '/')
186 buf[pwd_len+file_len-i-1] = '\0';
187
188 for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next) {
189 unsigned mp_len = strlen (vfs->mountpoint);
190 unsigned nm_len = strlen (vfs->name);
191
192 char buf2[65];
193 memcpy (buf2, vfs->mountpoint, mp_len);
194 memcpy (buf2+mp_len, vfs->name, nm_len);
195 buf2[mp_len+nm_len] = '\0';
196
197 if (!cstrcmp (buf, buf2)) {
198 if (vfs->attrib & VFS_FILEATTR_DIR) {
199 printf ("ERROR -> this is a directory, not an file\n");
200 return 0;
201 }
202
203 if (vfs->attrib & VFS_FILEATTR_MOUNTED) {
204 partition_t *p = (partition_t *) partition_findbyfile (file);
205
206 if (p) {
207 i = 0;
208
209 while (strlen (dir[i].name)) {
210 if (!strncmp (file, dir[i].name, file_len))
211 return p->fs->handler (FS_ACT_WRITE, data, i, len);
212
213 i ++;
214 }
215
216 return 0;
217 } else {
218 printf ("ERROR -> device not respond\n");
219 return 0;
220 }
221 } else {
222 if (vfs->content) {
223 printf ("ERROR -> You can't overwrite content of this file\n");
224 return 1;
225 }
226
227 vfs->content = (vfs_content_t *) kmalloc (sizeof (vfs_content_t));
228
229 if (!vfs->content)
230 return 1;
231
232 /*vfs->content->ptr = (char *) kmalloc (sizeof (char) * (len+1));
233
234 if (!vfs->content->ptr) {
235 kfree (vfs->content);
236 vfs->content = 0;
237 return 0;
238 }
239
240 memcpy (vfs->content->ptr, data, len);
241 vfs->content->ptr[len] = '\0';*/
242
243 vfs->content->ptr = data;
244
245 vfs->content->len = len;
246 }
247
248 return 1;
249 }
250 }
251 return 0;
252 }
253
254 extern unsigned long file_cache_id;
255 int vfs_read (char *file, unsigned file_len)
256 {
257 vfs_t *vfs;
258
259 char pwd[64];
260 strcpy (pwd, (char *) env_get ("PWD"));
261
262 char buf[65];
263 unsigned pwd_len = strlen (pwd);
264
265 char *block;
266 unsigned long len;
267
268 unsigned i = file[0] == '/' ? 1 : 0;
269
270 if (!i) {
271 memcpy (buf, pwd, pwd_len);
272 memcpy (buf+pwd_len, file+i, file_len-i);
273 buf[pwd_len+file_len-i] = '\0';
274 } else {
275 memcpy (buf, file, file_len);
276 buf[file_len] = '\0';
277 }
278
279 if (buf[pwd_len+file_len-i-1] == '/')
280 buf[pwd_len+file_len-i-1] = '\0';
281
282 for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next) {
283 unsigned mp_len = strlen (vfs->mountpoint);
284 unsigned nm_len = strlen (vfs->name);
285
286 char buf2[65];
287 memcpy (buf2, vfs->mountpoint, mp_len);
288 memcpy (buf2+mp_len, vfs->name, nm_len);
289 buf2[mp_len+nm_len] = '\0';
290
291 if (!cstrcmp (buf, buf2)) {
292 if (vfs->attrib & VFS_FILEATTR_DIR) {
293 printf ("ERROR -> this is a directory, not an file\n");
294 return -1;
295 }
296
297 if (vfs->attrib & VFS_FILEATTR_MOUNTED) {
298 partition_t *p = (partition_t *) partition_findbyfile (file);
299
300 if (p) {
301 i = 0;
302
303 while (strlen (dir[i].name)) {
304 if (!strncmp (file, dir[i].name, file_len)) {
305 p->fs->handler (FS_ACT_READ, block, i, len);
306
307 return i;
308 }
309
310 i ++;
311 }
312 } else {
313 printf ("ERROR -> device not respond\n");
314 return -1;
315 }
316 } else {
317 if (vfs->attrib & VFS_FILEATTR_DEVICE) {
318 return 0;
319 }
320
321 if (!vfs->content) {
322 printf ("ERROR -> This file not contain a valid data\n");
323 return -1;
324 }
325
326 file_cache = vfs->content->ptr;
327 file_cache_id = vfs->content->len;
328
329 return 0;
330 }
331
332 return -1;
333 }
334 }
335
336 return -2;
337 }
338
339 bool vfs_cat (char *file, unsigned file_len)
340 {
341 unsigned long i;
342 int index;
343
344 index = vfs_read (file, file_len);
345
346 if (index == -1)
347 return 0;
348
349 for (i = 0; i < file_cache_id; i ++)
350 tty_putch (file_cache[i]);
351
352 return 1;
353 }
354
355 bool vfs_ls (char *file, unsigned file_len)
356 {
357 char ls[64];
358
359 vfs_t *vfs;
360 bool res = false;
361
362 if (!file_len) {
363 strcpy (ls, (char *) env_get ("PWD"));
364 for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next)
365 if (!strcmp (vfs->mountpoint, ls)) {
366 printf ("%s\t", vfs->name);
367 res = true;
368 }
369 } else {
370 if (!strncmp(file,"/",1)) {
371 strcpy (ls,file);
372 } else {
373 strcpy (ls,(char *) env_get ("PWD"));
374 strcpy (ls+strlen(ls),file);
375 }
376
377 if (strncmp(file+file_len-1,"/",1)) {
378 strcpy(ls+strlen(ls),"/");
379 }
380
381 for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next)
382 if (!strcmp (vfs->mountpoint, ls) ||
383 !strcmp (vfs->mountpoint+1, ls)) {
384 printf ("%s\t", vfs->name);
385 res = true;
386 }
387 }
388
389 /*printf ("%s\t%u%u%u%u%u%u%u\n", vfs->name,
390 vfs->attrib & VFS_FILEATTR_READ,
391 vfs->attrib & VFS_FILEATTR_WRITE,
392 vfs->attrib & VFS_FILEATTR_HIDDEN,
393 vfs->attrib & VFS_FILEATTR_SYSTEM,
394 vfs->attrib & VFS_FILEATTR_DIR,
395 vfs->attrib & VFS_FILEATTR_BIN);*/
396
397 if (res)
398 printf ("\n");
399
400 return 1;
401 }
402
403 bool vfs_cd (char *file, unsigned file_len)
404 {
405 /* go back */
406 if (!strcmp (file, "..")) {
407 char pwd[64];
408 strcpy (pwd, (char *) env_get ("PWD"));
409
410 unsigned pwd_len = strlen (pwd);
411
412 if (!strcmp (pwd, "/"))
413 return 0;
414
415 /* vymaze kus retezce - az po predposledni / */
416 pwd_len --; // preskoci / na konci retezce
417 while (pwd_len) {
418 pwd_len --;
419 if (pwd[pwd_len] == '/') {
420 pwd[pwd_len+1] = '\0';
421 break;
422 }
423 }
424
425 vfs_t *vfs;
426 for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next)
427 if (!strcmp (vfs->mountpoint, pwd)) {
428 if (vfs->attrib & VFS_FILEATTR_MOUNTED) {
429 //printf ("vfs->mountpoint: %s | pwd: %s\n", vfs->mountpoint, pwd);
430 partition_t *p = mount_find (pwd);
431
432 if (p) {
433 mount (p, file, ""); // first return to last directory
434
435 umount (p, (char *) env_get ("PWD")); // then umount old directory
436
437 while (vfs_list_delbymp ((char *) env_get ("PWD")));
438
439 break;
440 } else {
441 printf ("ERROR -> device not respond\n");
442 return 0;
443 }
444 }
445 }
446
447 env_set ("PWD", pwd); // set new directory
448
449 return 1;
450 }
451
452 /* nothing */
453 if (!strcmp (file, "."))
454 return 1;
455
456 vfs_t *vfs;
457 /* go to root fs dir */
458 if (!strcmp (file, "/")) {
459 env_set ("PWD", file);
460
461 for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next) {
462 if (vfs->attrib & VFS_FILEATTR_MOUNTED) {
463 partition_t *p = mount_find ((char *) env_get ("PWD"));
464
465 if (p)
466 mount (p, file, "");
467 }
468 }
469
470 return 1;
471 }
472
473 /* go to another directory */
474 char pwd[64];
475 strcpy (pwd, (char *) env_get ("PWD"));
476
477 char buf[65];
478 unsigned pwd_len = strlen (pwd);
479
480 unsigned i = file[0] == '/' ? 1 : 0;
481
482 if (!i) {
483 memcpy (buf, pwd, pwd_len);
484 memcpy (buf+pwd_len, file+i, file_len-i);
485 buf[pwd_len+file_len-i] = '\0';
486 } else {
487 memcpy (buf, file, file_len);
488 buf[file_len] = '\0';
489 }
490
491 if (buf[pwd_len+file_len-i-1] == '/')
492 buf[pwd_len+file_len-i-1] = '\0';
493
494 unsigned buf_l = strlen (buf);
495 if (buf[buf_l-1] == '/')
496 buf[buf_l-1] = '\0';
497
498 for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next) {
499 unsigned mp_len = strlen (vfs->mountpoint);
500 unsigned nm_len = strlen (vfs->name);
501
502 char buf2[65];
503 memcpy (buf2, vfs->mountpoint, mp_len);
504 memcpy (buf2+mp_len, vfs->name, nm_len);
505 buf2[mp_len+nm_len] = '\0';
506
507 if (!cstrcmp (buf, buf2)) {
508 if (vfs->attrib & VFS_FILEATTR_FILE) {
509 printf ("ERROR -> this is a file, not an directory\n");
510 return 0;
511 }
512
513 // check permissions
514 if (vfs->attrib & VFS_FILEATTR_SYSTEM && strcmp ((char *) env_get ("USER"), "root")) {
515 printf ("ERROR -> only root can do that\n");
516 return 0;
517 }
518
519 memcpy (pwd, buf2, mp_len+nm_len);
520 pwd[mp_len+nm_len] = '/';
521 pwd[mp_len+nm_len+1] = '\0';
522
523 if (vfs->attrib & VFS_FILEATTR_MOUNTED) {
524 partition_t *p = mount_find ((char *) env_get ("PWD"));
525
526 if (p)
527 mount (p, file, pwd);
528 else {
529 printf ("ERROR -> device not respond\n");
530 return 0;
531 }
532 }
533
534 env_set ("PWD", pwd);
535
536 return 1;
537 }
538 }
539
540 return 0;
541 }
542
543 bool vfs_mkdir (char *file, unsigned file_len)
544 {
545 if (file_len) {
546 char pwd[64];
547 strcpy (pwd, (char *) env_get ("PWD"));
548
549 partition_t *p = mount_find ((char *) pwd);
550
551 if (p) {
552 vfs_list_add (file, VFS_FILEATTR_DIR | VFS_FILEATTR_READ | VFS_FILEATTR_MOUNTED, (char *) pwd);
553 p->fs->handler (FS_ACT_MKDIR, file, 0, file_len);
554 } else {
555 vfs_list_add (file, VFS_FILEATTR_DIR | VFS_FILEATTR_READ, (char *) pwd);
556 DPRINT ("NOTE -> this directory is created only in virtual file system\n");
557 }
558
559 DPRINT ("vfs_mkdir ()\n");
560 return 1;
561 }
562
563 return 0;
564 }
565
566 bool vfs_touch (char *file, unsigned file_len)
567 {
568 if (file_len) {
569 char pwd[64];
570 strcpy (pwd, (char *) env_get ("PWD"));
571
572 unsigned i;
573 for (i = file_len; i; i --) {
574 if (file[i] == '/') {
575 vfs_cd (file, i);
576 break;
577 }
578 }
579
580 char *path = 0;
581 char *f = 0;
582
583 if (i) {
584 path = (char *) kmalloc (sizeof (char) * (file_len+1));
585
586 if (!path)
587 return 0;
588
589 memcpy (path, file, i+1);
590 path[i+1] = '\0';
591
592 f = file + i + 1;
593 } else {
594 path = (char *) pwd;
595 f = file;
596 }
597
598 partition_t *p = mount_find ((char *) pwd);
599
600 if (p) {
601 vfs_list_add (f, VFS_FILEATTR_FILE | VFS_FILEATTR_READ | VFS_FILEATTR_BIN | VFS_FILEATTR_MOUNTED, (char *) path);
602 p->fs->handler (FS_ACT_TOUCH, file, 0, strlen (file));
603 } else {
604 vfs_list_add (f, VFS_FILEATTR_FILE | VFS_FILEATTR_READ | VFS_FILEATTR_BIN, (char *) path);
605 DPRINT ("NOTE -> this file is created only in virtual file system\n");
606 }
607
608 if (i) {
609 kfree (path);
610 vfs_cd (pwd, strlen (pwd));
611 }
612
613 DPRINT ("vfs_touch ()\n");
614 return 1;
615 }
616
617 return 0;
618 }
619
620 int vfs_rm (char *file, unsigned file_len)
621 {
622 if (file_len) {
623 char pwd[64];
624 strcpy (pwd, (char *) env_get ("PWD"));
625
626 unsigned i;
627 for (i = file_len; i; i --) {
628 if (file[i] == '/') {
629 vfs_cd (file, i);
630 break;
631 }
632 }
633
634 char *path = 0;
635 char *f = 0;
636
637 if (i) {
638 path = (char *) kmalloc (sizeof (char) * (file_len+1));
639
640 if (!path)
641 return 0;
642
643 memcpy (path, file, i+1);
644 path[i+1] = '\0';
645
646 f = file + i + 1;
647 } else {
648 path = (char *) pwd;
649 f = file;
650 }
651
652 vfs_t *vfs = vfs_list_find (f, (char *) path);
653
654 /* file not found */
655 if (!vfs)
656 return -1;
657
658 if (vfs->attrib & VFS_FILEATTR_SYSTEM || vfs->attrib & VFS_FILEATTR_DIR)
659 return -2;
660
661 if (vfs->attrib & VFS_FILEATTR_MOUNTED) {
662 partition_t *p = mount_find ((char *) pwd);
663
664 if (!p)
665 return 0;
666
667 p->fs->handler (FS_ACT_RM, file, 0, strlen (file));
668 } else {
669 /* delete vfs file with content */
670 vfs_list_del (vfs);
671 }
672
673 if (i) {
674 kfree (path);
675 vfs_cd (pwd, strlen (pwd));
676 }
677
678 DPRINT ("vfs_rm ()\n");
679 return 1;
680 }
681
682 return 0;
683 }
684
685 vfs_dirent_t *vfs_dirent ()
686 {
687 char pwd[64];
688 strcpy (pwd, (char *) env_get ("PWD"));
689
690 vfs_t *vfs;
691 bool res = false;
692
693 unsigned dirents = 0;
694
695 for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next)
696 if (!strcmp (vfs->mountpoint, pwd))
697 dirents ++;
698
699 if (!dirents)
700 return 0;
701
702 vfs_dirent_t *dirent = (vfs_dirent_t *) kmalloc (sizeof (vfs_dirent_t) * (dirents+1));
703
704 if (!dirent)
705 return 0;
706
707 unsigned i = 0;
708 for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next)
709 if (!strcmp (vfs->mountpoint, pwd)) {
710 /*unsigned len = strlen (vfs->name);
711 dirent[i].name = (char *) kmalloc (sizeof (char) * (len + 1));
712
713 if (!dirent[i].name)
714 return 0;
715
716 memcpy (dirent[i].name, vfs->name, len);
717 dirent[i].name[len] = '\0';*/
718 dirent[i].name = vfs->name;
719
720 dirent[i].attrib = vfs->attrib;
721
722 if ((i+1) == dirents)
723 dirent[i].next = 0;
724 else
725 dirent[i].next = 1;
726
727 i ++;
728 }
729
730 dirent[dirents].next = 0;
731
732 return dirent;
733 }
734
735 unsigned int init_vfs ()
736 {
737 mount_list.next = &mount_list;
738 mount_list.prev = &mount_list;
739
740 vfs_list.next = &vfs_list;
741 vfs_list.prev = &vfs_list;
742
743 vfs_list_add ("bin", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/");
744 vfs_list_add ("cd", VFS_FILEATTR_FILE | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ | VFS_FILEATTR_BIN, "/bin/");
745 vfs_list_add ("ls", VFS_FILEATTR_FILE | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ | VFS_FILEATTR_BIN, "/bin/");
746 vfs_list_add ("exec", VFS_FILEATTR_FILE | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ | VFS_FILEATTR_BIN, "/bin/");
747 vfs_list_add ("dev", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/");
748 vfs_list_add ("etc", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/");
749 vfs_list_add ("mnt", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/");
750 vfs_list_add ("floppy", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/mnt/");
751 vfs_list_add ("cdrom", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/mnt/");
752 vfs_list_add ("hdd", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/mnt/");
753 vfs_list_add ("usr", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/");
754 vfs_list_add ("root", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/usr/");
755 vfs_list_add ("proc", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/");
756
757 /* let's build /proc/cpuinfo */
758 smp_cpu_check ();
759
760 return 1;
761 }
Operating System