kernel/core/vfs.c

   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 <errno.h>
  26 #include <vfs.h>
  27 #include <smp.h>
  28 #include <fd.h>
  29
  30 vfs_t vfs_list;
  31
  32 extern mount_t mount_list;
  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 !");
  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 int 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                                         DPRINT ("vfs_mmap () - file '%s' not found in mounted filesystem", file);
 217                                         return 0;
 218                                 } else {
 219                                         printf ("ERROR -> device not respond\n");
 220                                         errno_set (EIO);
 221                                         return 0;
 222                                 }
 223                         } else {
 224                                 if (vfs->content) {
 225                                         printf ("ERROR -> You can't overwrite content of this file\n");
 226                                         errno_set (EINVAL);
 227                                         return 0;
 228                                 }
 229
 230                                 vfs->content = (vfs_content_t *) kmalloc (sizeof (vfs_content_t));
 231
 232                                 if (!vfs->content) {
 233                                         errno_set (ENOMEM);
 234                                         return 0;
 235                                 }
 236
 237                                 /* NOTE: when file in VFS is device, we match it as READable */
 238                                 if (!(vfs->attrib & VFS_FILEATTR_READ))
 239                                         vfs->attrib |= VFS_FILEATTR_READ;
 240
 241                                 vfs->content->ptr = data;
 242
 243                                 vfs->content->len = len;
 244                         }
 245
 246                         return 1;
 247                 }
 248         }
 249
 250         errno_set (ENOENT);
 251
 252         DPRINT ("vfs_mmap () - file '%s' not found", file);
 253
 254         return 0;
 255 }
 256
 257 extern unsigned long file_cache_id;
 258 int vfs_read (char *file, unsigned file_len)
 259 {
 260         vfs_t *vfs;
 261
 262         char pwd[64];
 263         strcpy (pwd, (char *) env_get ("PWD"));
 264
 265         char buf[65];
 266         unsigned pwd_len = strlen (pwd);
 267
 268         char block[4096];
 269         unsigned long len;
 270
 271         unsigned i = file[0] == '/' ? 1 : 0;
 272
 273         if (!i) {
 274                 memcpy (buf, pwd, pwd_len);
 275                 memcpy (buf+pwd_len, file+i, file_len-i);
 276                 buf[pwd_len+file_len-i] = '\0';
 277         } else {
 278                 memcpy (buf, file, file_len);
 279                 buf[file_len] = '\0';
 280         }
 281
 282         if (buf[pwd_len+file_len-i-1] == '/')
 283                 buf[pwd_len+file_len-i-1] = '\0';
 284
 285         for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next) {
 286                 unsigned mp_len = strlen (vfs->mountpoint);
 287                 unsigned nm_len = strlen (vfs->name);
 288
 289                 char buf2[128];
 290                 memcpy (buf2, vfs->mountpoint, mp_len);
 291                 memcpy (buf2+mp_len, vfs->name, nm_len);
 292                 buf2[mp_len+nm_len] = '\0';
 293
 294                 if (!cstrcmp (buf, buf2)) {
 295                         if (vfs->attrib & VFS_FILEATTR_DIR) {
 296                                 printf ("ERROR -> This is a directory, not an file\n");
 297                                 return -1;
 298                         }
 299
 300                         if (vfs->attrib & VFS_FILEATTR_MOUNTED) {
 301                                 partition_t *p = (partition_t *) partition_findbyfile (file);
 302
 303                                 if (p) {
 304                                         i = 0;
 305
 306                                         while (strlen (dir[i].name)) {
 307                                                 if (!strncmp (file, dir[i].name, file_len)) {
 308                                                         file_cache = (unsigned char *) FILE_CACHE;              // file_cache store address
 309
 310                                                         if (!p->fs->handler (FS_ACT_READ, block, i, len)) {
 311                                                                 file_cache_id = 0;
 312                                                                 printf ("ERROR -> Device read action\n");
 313                                                                 return -3;
 314                                                         }
 315
 316                                                         return i;
 317                                                 }
 318
 319                                                 i ++;
 320                                         }
 321                                 } else {
 322                                         printf ("ERROR -> device not respond\n");
 323                                         return -1;
 324                                 }
 325                         } else {
 326                                 if (vfs->attrib & VFS_FILEATTR_DEVICE && !(vfs->attrib & VFS_FILEATTR_READ)) {
 327                                         file_cache_id = 0;
 328                                         printf ("ERROR -> This file is non-char or non-block device\n");
 329                                         return -1;
 330                                 }
 331
 332                                 if (!vfs->content) {
 333                                         printf ("ERROR -> This file not contain a valid data\n");
 334                                         file_cache_id = 0;
 335                                         return -1;
 336                                 }
 337
 338                                 if (!vfs->content->ptr) {
 339                                         printf ("ERROR -> This file not contain a valid data\n");
 340                                         return -4;
 341                                 }
 342
 343                                 file_cache = vfs->content->ptr;
 344                                 file_cache_id = vfs->content->len;
 345
 346                                 return 0;
 347                         }
 348
 349                         file_cache_id = 0;
 350
 351                         return -2;
 352                 }
 353         }
 354
 355         file_cache_id = 0;
 356
 357         return -2;
 358 }
 359
 360 int vfs_cat (char *file, unsigned file_len)
 361 {
 362         unsigned long i;
 363         int index;
 364
 365         index = vfs_read (file, file_len);
 366
 367         if (index == -1)
 368                 return index;
 369
 370         for (i = 0; i < file_cache_id; i ++)
 371                 tty_putch (file_cache[i]);
 372
 373         return index;
 374 }
 375
 376 int vfs_cp (char *what, unsigned what_len, char *where, unsigned where_len)
 377 {
 378         unsigned long i;
 379         int index;
 380
 381         index = vfs_read (what, what_len);
 382
 383         if (index == -1)
 384                 return -2;
 385
 386         if (!vfs_touch (where, where_len))
 387                 return -1;
 388
 389         if (!vfs_mmap (where, where_len, file_cache, file_cache_id))
 390                 return 0;
 391
 392         return 1;
 393 }
 394
 395 int vfs_ls (char *file, unsigned file_len)
 396 {
 397         char ls[64];
 398
 399         vfs_t *vfs;
 400         bool res = false;
 401
 402         if (!file_len) {
 403                 strcpy (ls, (char *) env_get ("PWD"));
 404                 for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next)
 405                         if (!strcmp (vfs->mountpoint, ls)) {
 406                                 printf ("%s\t", vfs->name);
 407                                 res = true;
 408                         }
 409         } else {
 410                 if (!strncmp(file,"/",1)) {
 411                         strcpy (ls,file);
 412                 } else {
 413                         strcpy (ls,(char *) env_get ("PWD"));
 414                         strcpy (ls+strlen(ls),file);
 415                 }
 416
 417                 if (strncmp(file+file_len-1,"/",1)) {
 418                         strcpy(ls+strlen(ls),"/");
 419                 }
 420
 421                 for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next)
 422                         if (!strcmp (vfs->mountpoint, ls) ||
 423                             !strcmp (vfs->mountpoint+1, ls)) {
 424                                 printf ("%s\t", vfs->name);
 425                                 res = true;
 426                         }
 427         }
 428
 429                                 /*printf ("%s\t%u%u%u%u%u%u%u\n", vfs->name,
 430                                         vfs->attrib & VFS_FILEATTR_READ,
 431                                         vfs->attrib & VFS_FILEATTR_WRITE,
 432                                         vfs->attrib & VFS_FILEATTR_HIDDEN,
 433                                         vfs->attrib & VFS_FILEATTR_SYSTEM,
 434                                         vfs->attrib & VFS_FILEATTR_DIR,
 435                                         vfs->attrib & VFS_FILEATTR_BIN);*/
 436
 437         if (res)
 438                 printf ("\n");
 439
 440         return 1;
 441 }
 442
 443 int vfs_cd (char *file, unsigned file_len)
 444 {
 445         /* go back */
 446         if (!strcmp (file, "..")) {
 447                 char pwd[64];
 448                 strcpy (pwd, (char *) env_get ("PWD"));
 449
 450                 unsigned pwd_len = strlen (pwd);
 451
 452                 if (!strcmp (pwd, "/"))
 453                         return 0;
 454
 455                 /* vymaze kus retezce - az po predposledni / */
 456                 pwd_len --;     // preskoci / na konci retezce
 457                 while (pwd_len) {
 458                         pwd_len --;
 459                         if (pwd[pwd_len] == '/') {
 460                                 pwd[pwd_len+1] = '\0';
 461                                 break;
 462                         }
 463                 }
 464
 465                 vfs_t *vfs;
 466                 for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next)
 467                         if (!strcmp (vfs->mountpoint, pwd)) {
 468                                 if (vfs->attrib & VFS_FILEATTR_MOUNTED) {
 469                                         //printf ("vfs->mountpoint: %s | pwd: %s\n", vfs->mountpoint, pwd);
 470                                         partition_t *p = mount_find (pwd);
 471
 472                                         if (p) {
 473                                                 mount (p, file, "");    // first return to last directory
 474
 475                                                 umount (p, (char *) env_get ("PWD"));   // then umount old directory
 476
 477                                                 while (vfs_list_delbymp ((char *) env_get ("PWD")));
 478
 479                                                 break;
 480                                         } else {
 481                                                 printf ("ERROR -> device not respond\n");
 482                                                 return 0;
 483                                         }
 484                                 }
 485                         }
 486
 487                 env_set ("PWD", pwd);   // set new directory
 488
 489                 return 1;
 490         }
 491
 492         /* nothing */
 493         if (!strcmp (file, "."))
 494                 return 1;
 495
 496         vfs_t *vfs;
 497         /* go to root fs dir */
 498         if (!strcmp (file, "/")) {
 499                 env_set ("PWD", file);
 500
 501                 for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next) {
 502                         if (vfs->attrib & VFS_FILEATTR_MOUNTED) {
 503                                 partition_t *p = mount_find ((char *) env_get ("PWD"));
 504
 505                                 if (p)
 506                                         mount (p, file, "");
 507                         }
 508                 }
 509
 510                 return 1;
 511         }
 512
 513         /* go to another directory */
 514         char pwd[64];
 515         strcpy (pwd, (char *) env_get ("PWD"));
 516
 517         char buf[65];
 518         unsigned pwd_len = strlen (pwd);
 519
 520         unsigned i = file[0] == '/' ? 1 : 0;
 521
 522         if (!i) {
 523                 memcpy (buf, pwd, pwd_len);
 524                 memcpy (buf+pwd_len, file+i, file_len-i);
 525                 buf[pwd_len+file_len-i] = '\0';
 526         } else {
 527                 memcpy (buf, file, file_len);
 528                 buf[file_len] = '\0';
 529         }
 530
 531         if (buf[pwd_len+file_len-i-1] == '/')
 532                 buf[pwd_len+file_len-i-1] = '\0';
 533
 534         unsigned buf_l = strlen (buf);
 535         if (buf[buf_l-1] == '/')
 536                 buf[buf_l-1] = '\0';
 537
 538         for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next) {
 539                 unsigned mp_len = strlen (vfs->mountpoint);
 540                 unsigned nm_len = strlen (vfs->name);
 541
 542                 char buf2[65];
 543                 memcpy (buf2, vfs->mountpoint, mp_len);
 544                 memcpy (buf2+mp_len, vfs->name, nm_len);
 545                 buf2[mp_len+nm_len] = '\0';
 546
 547                 if (!cstrcmp (buf, buf2)) {
 548                         if (vfs->attrib & VFS_FILEATTR_FILE) {
 549                                 printf ("ERROR -> this is a file, not an directory\n");
 550                                 return 0;
 551                         }
 552
 553                         // check permissions
 554                         if (vfs->attrib & VFS_FILEATTR_SYSTEM && strcmp ((char *) env_get ("USER"), "root")) {
 555                                 printf ("ERROR -> only root can do that\n");
 556                                 return 0;
 557                         }
 558
 559                         memcpy (pwd, buf2, mp_len+nm_len);
 560                         pwd[mp_len+nm_len] = '/';
 561                         pwd[mp_len+nm_len+1] = '\0';
 562
 563                         if (vfs->attrib & VFS_FILEATTR_MOUNTED) {
 564                                 partition_t *p = mount_find ((char *) env_get ("PWD"));
 565
 566                                 if (p)
 567                                         mount (p, file, pwd);
 568                                 else {
 569                                         printf ("ERROR -> device not respond\n");
 570                                         return 0;
 571                                 }
 572                         }
 573
 574                         env_set ("PWD", pwd);
 575
 576                         return 1;
 577                 }
 578         }
 579
 580         return 0;
 581 }
 582
 583 int vfs_mkdir (char *file, unsigned file_len)
 584 {
 585         if (file_len) {
 586                 char pwd[64];
 587                 strcpy (pwd, (char *) env_get ("PWD"));
 588
 589                 unsigned i;
 590                 for (i = file_len; i; i --) {
 591                         if (file[i] == '/') {
 592                                 vfs_cd (file, i);
 593                                 break;
 594                         }
 595                 }
 596
 597                 char *path = 0;
 598                 char *f = 0;
 599
 600                 if (i) {
 601                         path = (char *) kmalloc (sizeof (char) * (file_len+1));
 602
 603                         if (!path)
 604                                 return 0;
 605
 606                         memcpy (path, file, i+1);
 607                         path[i+1] = '\0';
 608
 609                         f = file + i + 1;
 610                 } else {
 611                         path = (char *) pwd;
 612                         f = file;
 613                 }
 614
 615                 partition_t *p = mount_find ((char *) env_get ("PWD"));
 616
 617                 if (p) {
 618                         vfs_list_add (f, VFS_FILEATTR_DIR | VFS_FILEATTR_READ | VFS_FILEATTR_BIN | VFS_FILEATTR_MOUNTED, (char *) path);
 619                         p->fs->handler (FS_ACT_MKDIR, file, 0, strlen (file));
 620                 } else {
 621                         vfs_list_add (f, VFS_FILEATTR_DIR | VFS_FILEATTR_READ | VFS_FILEATTR_BIN, (char *) path);
 622                         DPRINT ("NOTE -> this directory is created only in virtual file system");
 623                 }
 624
 625                 if (i) {
 626                         kfree (path);
 627                         vfs_cd (pwd, strlen (pwd));
 628                 }
 629
 630                 DPRINT ("vfs_mkdir ()");
 631                 return 1;
 632         }
 633
 634         return 0;
 635 }
 636
 637 int vfs_touch (char *file, unsigned file_len)
 638 {
 639         if (file_len) {
 640                 char pwd[64];
 641                 strcpy (pwd, (char *) env_get ("PWD"));
 642
 643                 unsigned i;
 644                 for (i = file_len; i; i --) {
 645                         if (file[i] == '/') {
 646                                 vfs_cd (file, i);
 647                                 break;
 648                         }
 649                 }
 650
 651                 char *path = 0;
 652                 char *f = 0;
 653
 654                 if (i) {
 655                         path = (char *) kmalloc (sizeof (char) * (file_len+1));
 656
 657                         if (!path)
 658                                 return 0;
 659
 660                         memcpy (path, file, i+1);
 661                         path[i+1] = '\0';
 662
 663                         f = file + i + 1;
 664                 } else {
 665                         path = (char *) pwd;
 666                         f = file;
 667                 }
 668
 669                 partition_t *p = mount_find ((char *) env_get ("PWD"));
 670
 671                 if (p) {
 672                         vfs_list_add (f, VFS_FILEATTR_FILE | VFS_FILEATTR_READ | VFS_FILEATTR_BIN | VFS_FILEATTR_MOUNTED, (char *) path);
 673                         p->fs->handler (FS_ACT_TOUCH, file, 0, strlen (file));
 674                 } else {
 675                         vfs_list_add (f, VFS_FILEATTR_FILE | VFS_FILEATTR_READ | VFS_FILEATTR_BIN, (char *) path);
 676                         DPRINT ("NOTE -> this file is created only in virtual file system");
 677                 }
 678
 679                 if (i) {
 680                         kfree (path);
 681                         vfs_cd (pwd, strlen (pwd));
 682                 }
 683
 684                 DPRINT ("vfs_touch ()");
 685                 return 1;
 686         }
 687
 688         return 0;
 689 }
 690
 691 int vfs_rm (char *file, unsigned file_len)
 692 {
 693         if (file_len) {
 694                 char pwd[64];
 695                 strcpy (pwd, (char *) env_get ("PWD"));
 696
 697                 unsigned i;
 698                 for (i = file_len; i; i --) {
 699                         if (file[i] == '/') {
 700                                 vfs_cd (file, i);
 701                                 break;
 702                         }
 703                 }
 704
 705                 char *path = 0;
 706                 char *f = 0;
 707
 708                 if (i) {
 709                         path = (char *) kmalloc (sizeof (char) * (file_len+1));
 710
 711                         if (!path)
 712                                 return 0;
 713
 714                         memcpy (path, file, i+1);
 715                         path[i+1] = '\0';
 716
 717                         f = file + i + 1;
 718                 } else {
 719                         path = (char *) pwd;
 720                         f = file;
 721                 }
 722
 723                 vfs_t *vfs = vfs_list_find (f, (char *) path);
 724
 725                 /* file not found */
 726                 if (!vfs)
 727                         return -1;
 728
 729                 if (vfs->attrib & VFS_FILEATTR_SYSTEM || vfs->attrib & VFS_FILEATTR_DIR)
 730                         return -2;
 731
 732                 if (vfs->attrib & VFS_FILEATTR_MOUNTED) {
 733                         partition_t *p = mount_find ((char *) pwd);
 734
 735                         if (!p)
 736                                 return 0;
 737
 738                         p->fs->handler (FS_ACT_RM, file, 0, strlen (file));
 739                 } else {
 740                         /* delete vfs file with content */
 741                         vfs_list_del (vfs);
 742                 }
 743
 744                 if (i) {
 745                         kfree (path);
 746                         vfs_cd (pwd, strlen (pwd));
 747                 }
 748
 749                 DPRINT ("vfs_rm ()");
 750                 return 1;
 751         }
 752
 753         return 0;
 754 }
 755
 756 vfs_dirent_t *vfs_dirent ()
 757 {
 758         char pwd[64];
 759         strcpy (pwd, (char *) env_get ("PWD"));
 760
 761         vfs_t *vfs;
 762         bool res = false;
 763
 764         unsigned dirents = 0;
 765
 766         for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next)
 767                 if (!strcmp (vfs->mountpoint, pwd))
 768                         dirents ++;
 769
 770         if (!dirents)
 771                 return 0;
 772
 773         vfs_dirent_t *dirent = (vfs_dirent_t *) kmalloc (sizeof (vfs_dirent_t) * (dirents+1));
 774
 775         if (!dirent)
 776                 return 0;
 777
 778         unsigned i = 0;
 779         for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next)
 780                 if (!strcmp (vfs->mountpoint, pwd)) {
 781                         /*unsigned len = strlen (vfs->name);
 782                         dirent[i].name = (char *) kmalloc (sizeof (char) * (len + 1));
 783
 784                         if (!dirent[i].name)
 785                                 return 0;
 786
 787                         memcpy (dirent[i].name, vfs->name, len);
 788                         dirent[i].name[len] = '\0';*/
 789                         dirent[i].name = vfs->name;
 790
 791                         dirent[i].attrib = vfs->attrib;
 792
 793                         if ((i+1) == dirents)
 794                                 dirent[i].next = 0;
 795                         else
 796                                 dirent[i].next = 1;
 797
 798                         i ++;
 799                 }
 800
 801         dirent[dirents].next = 0;
 802
 803         return dirent;
 804 }
 805
 806 unsigned int init_vfs ()
 807 {
 808         mount_list.next = &mount_list;
 809         mount_list.prev = &mount_list;
 810
 811         vfs_list.next = &vfs_list;
 812         vfs_list.prev = &vfs_list;
 813
 814         if (!(kernel_attr & KERNEL_NOLIVE)) {
 815                 vfs_list_add ("bin", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/");
 816                 vfs_list_add ("cd", VFS_FILEATTR_FILE | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ | VFS_FILEATTR_BIN, "/bin/");
 817                 vfs_list_add ("ls", VFS_FILEATTR_FILE | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ | VFS_FILEATTR_BIN, "/bin/");
 818                 vfs_list_add ("exec", VFS_FILEATTR_FILE | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ | VFS_FILEATTR_BIN, "/bin/");
 819                 vfs_list_add ("dev", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/");
 820                 vfs_list_add ("etc", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/");
 821                 vfs_list_add ("mnt", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/");
 822                 vfs_list_add ("floppy", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/mnt/");
 823                 vfs_list_add ("cdrom", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/mnt/");
 824                 vfs_list_add ("hdd", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/mnt/");
 825                 vfs_list_add ("usr", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/");
 826                 vfs_list_add ("root", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/usr/");
 827                 vfs_list_add ("proc", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/");
 828         }
 829
 830         /* let's build /proc/cpuinfo */
 831         smp_cpu_check ();
 832
 833         return 1;
 834 }