kernel/core/vfs.c

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