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  *
   6  *  This program is free software: you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation, either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20
  21 #include <system.h>
  22 #include <string.h>
  23 #include <vfs.h>
  24 #include <mount.h>
  25
  26 vfs_t vfs_list;
  27 extern mount_t mount_list;
  28 fd_t fd_list;
  29 extern unsigned int fd_count;
  30
  31 vfs_t *vfs_list_findbymp (char *mountpoint)
  32 {
  33         vfs_t *vfs;
  34         for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next) {
  35                 if (!strcmp (vfs->mountpoint, mountpoint))
  36                         return vfs;
  37         }
  38
  39         return 0;
  40 }
  41
  42 bool vfs_list_add (char *name, unsigned attrib, char *mountpoint)
  43 {
  44         unsigned name_len = strlen (name);
  45         unsigned mp_len = strlen (mountpoint);
  46
  47         vfs_t *vfs;
  48
  49         /* alloc and init context */
  50         vfs = (vfs_t *) kmalloc (sizeof (vfs_t));
  51         if (!vfs)
  52                 return 0;
  53
  54         memset (vfs, 0, sizeof (vfs_t));
  55
  56         vfs->name = (char *) kmalloc (sizeof (char) * VFS_FILENAME_LEN + 2);
  57         if (!vfs->name) {
  58                 kfree (vfs);
  59                 return 0;
  60         }
  61
  62         memset (vfs->name, 0, VFS_FILENAME_LEN);
  63         memcpy (vfs->name, name, name_len);
  64         vfs->name[name_len] = '\0';
  65         //printf ("dd: '%s' '%s'", name, vfs->name);
  66         memset (vfs->mountpoint, 0, VFS_MOUNTPOINT_LEN);
  67         memcpy (vfs->mountpoint, mountpoint, mp_len);
  68         vfs->mountpoint[mp_len] = '\0';
  69
  70         vfs->attrib = attrib;
  71
  72         vfs->ptr = 0;
  73
  74         /* add into list */
  75         vfs->next = &vfs_list;
  76         vfs->prev = vfs_list.prev;
  77         vfs->prev->next = vfs;
  78         vfs->next->prev = vfs;
  79
  80         return 1;
  81 }
  82
  83 bool vfs_list_del (char *mountpoint)
  84 {
  85         bool f = 0;
  86         vfs_t *vfs;
  87         for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next) {
  88                 if (!strncmp (vfs->mountpoint, mountpoint, strlen (mountpoint))) {
  89                         f = 1;
  90                         break;
  91                 }
  92         }
  93
  94         if (f) {
  95                 vfs->next->prev = vfs->prev;
  96                 vfs->prev->next = vfs->next;
  97
  98                 //kfree (vfs);
  99                 return 1;
 100         }
 101
 102         return 0;
 103 }
 104
 105 bool vfs_ls (char *file, unsigned file_len)
 106 {
 107         char pwd[64];
 108         strcpy (pwd, (char *) env_get ("PWD"));
 109
 110 //      puts ("name    rwhsdb\n");
 111
 112         vfs_t *vfs;
 113         bool res = false;
 114
 115         if (!file_len) {
 116                 for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next)
 117                         if (!strcmp (vfs->mountpoint, pwd)) {
 118                                 printf ("%s\t", vfs->name);
 119                                 res = true;
 120                         }
 121         } else {
 122                 for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next)
 123                         if (!strcmp (vfs->mountpoint, file) ||
 124                             !strcmp (vfs->mountpoint+1, file)) {
 125                                 printf ("%s\t", vfs->name);
 126                                 res = true;
 127                         }
 128         }
 129
 130                                 /*printf ("%s\t%u%u%u%u%u%u%u\n", vfs->name,
 131                                         vfs->attrib & VFS_FILEATTR_READ,
 132                                         vfs->attrib & VFS_FILEATTR_WRITE,
 133                                         vfs->attrib & VFS_FILEATTR_HIDDEN,
 134                                         vfs->attrib & VFS_FILEATTR_SYSTEM,
 135                                         vfs->attrib & VFS_FILEATTR_DIR,
 136                                         vfs->attrib & VFS_FILEATTR_BIN);*/
 137
 138         if (res)
 139                 printf ("\n");
 140
 141         return 1;
 142 }
 143
 144 bool vfs_cd (char *file, unsigned file_len)
 145 {
 146         /* go back */
 147         if (!strcmp (file, "..")) {
 148                 char pwd[64];
 149                 strcpy (pwd, (char *) env_get ("PWD"));
 150
 151                 unsigned pwd_len = strlen (pwd);
 152
 153                 if (!strcmp (pwd, "/"))
 154                         return 0;
 155
 156                 /* vymaze kus retezce - az po predposledni / */
 157                 pwd_len --;     // preskoci / na konci retezce
 158                 while (pwd_len) {
 159                         pwd_len --;
 160                         if (pwd[pwd_len] == '/') {
 161                                 pwd[pwd_len+1] = '\0';
 162                                 break;
 163                         }
 164                 }
 165
 166                 vfs_t *vfs;
 167                 for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next)
 168                         if (!strcmp (vfs->mountpoint, pwd)) {
 169                                 if (vfs->attrib & VFS_FILEATTR_MOUNTED) {
 170                                         //printf ("vfs->mountpoint: %s | pwd: %s\n", vfs->mountpoint, pwd);
 171                                         partition_t *p = mount_find (pwd);
 172
 173                                         if (p) {
 174                                                 mount (p, file, "");    // first return to last directory
 175
 176                                                 umount (p, (char *) env_get ("PWD"));   // then umount old directory
 177
 178                                                 while (vfs_list_del ((char *) env_get ("PWD")));
 179
 180                                         } else {
 181                                                 printf ("ERROR -> device not respond\n");
 182                                                 return 0;
 183                                         }
 184                                 }
 185                         }
 186
 187                 env_set ("PWD", pwd);   // set new directory
 188
 189                 return 1;
 190         }
 191
 192         /* nothing */
 193         if (!strcmp (file, "."))
 194                 return 1;
 195
 196         vfs_t *vfs;
 197         /* go to root fs dir */
 198         if (!strcmp (file, "/")) {
 199
 200                 env_set ("PWD", file);
 201
 202                 for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next) {
 203                         if (vfs->attrib & VFS_FILEATTR_MOUNTED) {
 204                                 partition_t *p = mount_find ((char *) env_get ("PWD"));
 205
 206                                 if (p)
 207                                         mount (p, file, "");
 208                         }
 209                 }
 210
 211                 return 1;
 212         }
 213
 214         /* go to another directory */
 215         char pwd[64];
 216         strcpy (pwd, (char *) env_get ("PWD"));
 217
 218
 219         char buf[65];
 220         unsigned pwd_len = strlen (pwd);
 221
 222         unsigned i = file[0] == '/' ? 1 : 0;
 223
 224         if (!i) {
 225                 memcpy (buf, pwd, pwd_len);
 226                 memcpy (buf+pwd_len, file+i, file_len-i);
 227                 buf[pwd_len+file_len-i] = '\0';
 228         } else {
 229                 memcpy (buf, file, file_len);
 230                 buf[file_len] = '\0';
 231         }
 232
 233         if (buf[pwd_len+file_len-i-1] == '/')
 234                 buf[pwd_len+file_len-i-1] = '\0';
 235
 236
 237         for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next) {
 238                 unsigned mp_len = strlen (vfs->mountpoint);
 239                 unsigned nm_len = strlen (vfs->name);
 240
 241                 char buf2[65];
 242                 memcpy (buf2, vfs->mountpoint, mp_len);
 243                 memcpy (buf2+mp_len, vfs->name, nm_len);
 244                 buf2[mp_len+nm_len] = '\0';
 245
 246                 if (!strcmp (buf, buf2)) {
 247                         if (vfs->attrib & VFS_FILEATTR_FILE) {
 248                                 printf ("ERROR -> this is a file, not an directory\n");
 249                                 return 0;
 250                         }
 251
 252                         // check permissions
 253                         if (vfs->attrib & VFS_FILEATTR_SYSTEM && strcmp ((char *) env_get ("USER"), "root")) {
 254                                 printf ("ERROR -> only root can do that\n");
 255                                 return 0;
 256                         }
 257
 258                         memcpy (pwd, buf2, mp_len+nm_len);
 259                         pwd[mp_len+nm_len] = '/';
 260                         pwd[mp_len+nm_len+1] = '\0';
 261
 262                         if (vfs->attrib & VFS_FILEATTR_MOUNTED) {
 263                                 partition_t *p = mount_find ((char *) env_get ("PWD"));
 264
 265                                 if (p)
 266                                         mount (p, file, pwd);
 267                                 else {
 268                                         printf ("ERROR -> device not respond\n");
 269                                         return 0;
 270                                 }
 271                         }
 272
 273                         env_set ("PWD", pwd);
 274
 275                         return 1;
 276                 }
 277         }
 278
 279         return 0;
 280 }
 281
 282 bool vfs_mkdir (char *file, unsigned file_len)
 283 {
 284         if (file_len) {
 285                 char pwd[64];
 286                 strcpy (pwd, (char *) env_get ("PWD"));
 287
 288                 vfs_list_add (file, VFS_FILEATTR_DIR | VFS_FILEATTR_READ | VFS_FILEATTR_MOUNTED, (char *) pwd);
 289
 290                 partition_t *p = mount_find ((char *) pwd);
 291
 292                 if (p)
 293                         p->fs->handler (FS_ACT_WRITE, FS_ARG_DIR, file, 0, file_len);
 294                 else {
 295                         printf ("ERROR -> device not respond\n");
 296                         return 0;
 297                 }
 298
 299                 DPRINT ("vfs_mkdir ()\n");
 300                 return 1;
 301         }
 302
 303         return 0;
 304 }
 305
 306 vfs_dirent_t *vfs_dirent ()
 307 {
 308         char pwd[64];
 309         strcpy (pwd, (char *) env_get ("PWD"));
 310
 311         vfs_t *vfs;
 312         bool res = false;
 313
 314         unsigned dirents = 0;
 315
 316         for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next)
 317                 if (!strcmp (vfs->mountpoint, pwd))
 318                         dirents ++;
 319
 320         if (!dirents)
 321                 return 0;
 322
 323         vfs_dirent_t *dirent = (vfs_dirent_t *) kmalloc (sizeof (vfs_dirent_t) * (dirents+1));
 324
 325         if (!dirent)
 326                 return 0;
 327
 328         unsigned i = 0;
 329         for (vfs = vfs_list.next; vfs != &vfs_list; vfs = vfs->next)
 330                 if (!strcmp (vfs->mountpoint, pwd)) {
 331                         /*unsigned len = strlen (vfs->name);
 332                         dirent[i].name = (char *) kmalloc (sizeof (char) * (len + 1));
 333
 334                         if (!dirent[i].name)
 335                                 return 0;
 336
 337                         memcpy (dirent[i].name, vfs->name, len);
 338                         dirent[i].name[len] = '\0';*/
 339                         dirent[i].name = vfs->name;
 340
 341                         dirent[i].attrib = vfs->attrib;
 342
 343                         if ((i+1) == dirents)
 344                                 dirent[i].next = 0;
 345                         else
 346                                 dirent[i].next = 1;
 347
 348                         i ++;
 349
 350
 351                 }
 352
 353         dirent[dirents].next = 0;
 354
 355 }
 356
 357 unsigned int init_vfs ()
 358 {
 359         fd_count = 3;
 360
 361         fd_list.next = &fd_list;
 362         fd_list.prev = &fd_list;
 363
 364         mount_list.next = &mount_list;
 365         mount_list.prev = &mount_list;
 366
 367         vfs_list.next = &vfs_list;
 368         vfs_list.prev = &vfs_list;
 369
 370         vfs_list_add ("bin", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/");
 371         vfs_list_add ("cd", VFS_FILEATTR_FILE | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ | VFS_FILEATTR_BIN, "/bin/");
 372         vfs_list_add ("ls", VFS_FILEATTR_FILE | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ | VFS_FILEATTR_BIN, "/bin/");
 373         vfs_list_add ("exec", VFS_FILEATTR_FILE | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ | VFS_FILEATTR_BIN, "/bin/");
 374         vfs_list_add ("dev", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/");
 375         vfs_list_add ("etc", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/");
 376         vfs_list_add ("mnt", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/");
 377         vfs_list_add ("floppy", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/mnt/");
 378         vfs_list_add ("cdrom", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/mnt/");
 379         vfs_list_add ("hdd", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/mnt/");
 380         vfs_list_add ("usr", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/");
 381         vfs_list_add ("root", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/usr/");
 382         vfs_list_add ("proc", VFS_FILEATTR_DIR | VFS_FILEATTR_SYSTEM | VFS_FILEATTR_READ, "/");
 383
 384         /*dev_t *dev = dev_find ("/dev/fd0");
 385
 386         if (dev)
 387                 mount (dev, "", "/mnt/floppy/");*/
 388
 389         return 1;
 390 }