kernel/drivers/fs/zexfs.c

   1 /*
   2  *  ZeX/OS
   3  *  Copyright (C) 2008  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   4  *  Copyright (C) 2009  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   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 <config.h>
  22 #include <build.h>
  23
  24 #ifdef ARCH_i386
  25
  26 #include <system.h>
  27 #include <string.h>
  28 #include <dev.h>
  29 #include <fs.h>
  30 #include <partition.h>
  31 #include <cache.h>
  32 #include <vfs.h>
  33
  34 #define ZEXFS_INITBLOCK_SECTOR                  63
  35 #define ZEXFS_DIRENT_SECTOR                     64
  36 #define ZEXFS_IDIRENT_SECTOR                    ZEXFS_DIRENT_SECTOR+30
  37 #define ZEXFS_BLKENT_SECTOR                     1024
  38 #define ZEXFS_IBLKENT_SECTOR                    2048
  39
  40 #define ZEXFS_DIRENT_PREALLOC                   512     /* you can create # new dirents in fs */
  41 #define ZEXFS_BLKENT_PREALLOC                   512     /* you can create # new blkents in fs */
  42
  43 #define ZEXFS_DIRENT_FREE                       0x0
  44 #define ZEXFS_DIRENT_DIR                        0x1
  45 #define ZEXFS_DIRENT_FILE                       0x2
  46
  47 #define ZEXFS_BLKENT_FREE                       0x0
  48 #define ZEXFS_BLKENT_USED                       0x1
  49
  50 #define __PACKED__ __attribute__ ((__packed__))
  51
  52 /* zexos filesystem structures */
  53 typedef struct {
  54         /* main variables of this ent */
  55         unsigned char magic[5];                 /* Magic ID of zexfs */
  56         unsigned short dirents;                 /* Count of created dirents */
  57         unsigned short blkents;                 /* Count of created blkents */
  58 } zexfs_infoblock;
  59
  60 typedef struct {
  61         /* main variables of this ent */
  62         unsigned char flags;                    /* Flags for this ent */
  63
  64         unsigned short parent;                  /* Parent node */
  65         short children;                         /* Children node */
  66
  67         /* time stamp */
  68         unsigned char tm_sec;                   /* Seconds.     [0-60] (1 leap second) */
  69         unsigned char tm_min;                   /* Minutes.     [0-59] */
  70         unsigned char tm_hour;                  /* Hours.       [0-23] */
  71         unsigned char tm_mday;                  /* Day.         [1-31] */
  72         unsigned char tm_mon;                   /* Month.       [0-11] */
  73         unsigned char tm_year;                  /* Year =       2000 + tm_year */
  74
  75         unsigned char name[21];
  76 } __PACKED__ zexfs_dirent;
  77
  78 typedef struct {
  79         unsigned short next;
  80         unsigned short len;
  81 } __PACKED__ zexfs_blk_header;
  82
  83 /* zexos filesystem structure */
  84 typedef struct {
  85         zexfs_infoblock iblock;
  86
  87         unsigned char *dirents;
  88         unsigned char *blkents;
  89
  90         unsigned char cache[512];
  91
  92         unsigned short node_curr;
  93         unsigned short node_prev;
  94 } zexfs_t;
  95
  96 zexfs_t zexfs;
  97
  98 /* clear and pre-set dir[] structure */
  99 void zexfs_dir_flush ()
 100 {
 101         unsigned i = 0;
 102
 103 //      if (zexfs.node_curr != 0) {
 104 //              printf ("eyk\n");
 105 //      }
 106
 107         for (; i < 223; i ++)
 108                 memset (dir[i].name, 0, 10);
 109 }
 110
 111 /* read 1024 byte block */
 112 unsigned zexfs_block_read (partition_t *p, unsigned sector, unsigned char *block)
 113 {
 114         lba28_drive_read (p, sector, (unsigned char *) block);
 115         lba28_drive_read (p, sector+1, (unsigned char *) block+512);
 116
 117         return 1;
 118 }
 119
 120 int zexfs_blkent_create (partition_t *p)
 121 {
 122         unsigned i;
 123         unsigned y = 0;
 124
 125         /* find free dirent in array */
 126         for (i = 0; i < zexfs.iblock.blkents + ZEXFS_BLKENT_PREALLOC; i ++) {
 127                 if (zexfs.blkents[i] == ZEXFS_BLKENT_FREE) {
 128                         /* match dirent as file or directory */
 129                         zexfs.blkents[i] = ZEXFS_BLKENT_USED;
 130
 131                         lba28_drive_write (p, ZEXFS_BLKENT_SECTOR+y, zexfs.blkents+(i/512));
 132
 133                         /* increase dirents count in infoblock structure */
 134                         zexfs.iblock.blkents ++;
 135
 136                         /* update initblock on drive */
 137                         memset (zexfs.cache+sizeof (zexfs.iblock), 0, 512-sizeof (zexfs.iblock));
 138                         memcpy (zexfs.cache, &zexfs.iblock, sizeof (zexfs.iblock));
 139                         lba28_drive_write (p, ZEXFS_INITBLOCK_SECTOR, (unsigned char *) zexfs.cache);
 140
 141                         DPRINT (DBG_DRIVER | DBG_FS, "ZeXFS -> blkent %d:%d created", i, zexfs.iblock.blkents);
 142
 143                         return i;
 144                 }
 145         }
 146
 147         kprintf ("ZeXFS -> Sorry, but your filesystem blkent table is full, please reboot or delete some files for correct the problem\n");
 148 }
 149
 150 /* function for write data of file */
 151 unsigned zexfs_write_file (partition_t *p, unsigned char *name, vfs_content_t *content)
 152 {
 153         unsigned y = 0;
 154         unsigned x = -1;
 155         int z = -1;
 156         unsigned i = 0;
 157         unsigned s = 0;
 158         int ret = 0;
 159         zexfs_dirent *dirent = 0;
 160
 161         for (i = 0; i < zexfs.iblock.dirents + ZEXFS_DIRENT_PREALLOC; i ++) {
 162                 if (zexfs.dirents[i] != ZEXFS_DIRENT_FREE) {
 163                         s = i * sizeof (zexfs_dirent);
 164
 165                         y = s/512;
 166
 167                         /* read data from sector to cache */
 168                         if (x != y)
 169                                 lba28_drive_read (p, ZEXFS_IDIRENT_SECTOR+y, zexfs.cache);
 170
 171                         unsigned char *l = zexfs.cache + (s-(y*512));
 172                         dirent = (zexfs_dirent *) l;
 173
 174                         if (zexfs.node_curr == dirent->parent) {
 175 //                              kprintf ("cd_root: %d : %s\n", (s-(y*512)), dirent->name);
 176
 177                                 if (!strcmp (dirent->name, name)) {
 178                                         z = dirent->children;
 179                                         ret = 1;
 180 //                                      kprintf ("z: %d: %d\n", z, y);
 181                                         break;
 182                                 }
 183                         }
 184
 185                         x = y;
 186                 }
 187         }
 188
 189         if (!ret) {
 190                 kprintf ("ZeXFS -> file %s not found\n", name);
 191                 return 0;
 192         }
 193
 194         /* is file block already created ? */
 195         if (z == -1) {
 196                 z = zexfs_blkent_create (p);
 197
 198                 if (z == -1) {
 199                         kprintf ("ZeXFS -> Drive is full\n");
 200                         return 0;
 201                 }
 202
 203                 lba28_drive_read (p, ZEXFS_IDIRENT_SECTOR+y, zexfs.cache);
 204
 205                 dirent->children = z;
 206                 /* in memory just rewrite dirent structure */
 207                 memcpy (zexfs.cache+(s-(y*512)), (void *) dirent, sizeof (zexfs_dirent));
 208
 209                 /* write new data from cache */
 210                 lba28_drive_write (p, ZEXFS_IDIRENT_SECTOR+y, zexfs.cache);
 211         }
 212
 213         zexfs_blk_header blk;
 214
 215         unsigned l;
 216         int z2 = z;
 217         for (l = 0; l < content->len; l += (512-sizeof (zexfs_blk_header))) {
 218                 blk.next = (content->len > (l + (512-sizeof (zexfs_blk_header)))) ? 1 : 0;
 219
 220                 if (blk.next) {
 221                         blk.next = zexfs_blkent_create (p) - z2;
 222                         blk.len = 512-sizeof (zexfs_blk_header);
 223                 } else
 224                         blk.len = content->len - l;
 225 //kprintf ("next: %d | %d | %d | %d\n", blk.next, ZEXFS_IBLKENT_SECTOR, z, l);
 226
 227                 memcpy (zexfs.cache, &blk, sizeof (zexfs_blk_header));
 228                 memcpy (zexfs.cache+sizeof (zexfs_blk_header), content->ptr+l, 512-sizeof (zexfs_blk_header));
 229
 230                 lba28_drive_write (p, ZEXFS_IBLKENT_SECTOR+z+l, zexfs.cache);
 231                 z2 = z;
 232         }
 233
 234         return 1;
 235 }
 236
 237 /* function for read data of file */
 238 unsigned zexfs_read_file (partition_t *p, unsigned char *name, vfs_content_t *content)
 239 {
 240         unsigned y = 0;
 241         unsigned x = -1;
 242         int z = -1;
 243         unsigned i = 0;
 244         unsigned s = 0;
 245         int ret = 0;
 246         zexfs_dirent *dirent = 0;
 247
 248         for (i = 0; i < zexfs.iblock.dirents + ZEXFS_DIRENT_PREALLOC; i ++) {
 249                 if (zexfs.dirents[i] != ZEXFS_DIRENT_FREE) {
 250                         s = i * sizeof (zexfs_dirent);
 251
 252                         y = s/512;
 253
 254                         /* read data from sector to cache */
 255                         if (x != y)
 256                                 lba28_drive_read (p, ZEXFS_IDIRENT_SECTOR+y, zexfs.cache);
 257
 258                         unsigned char *l = zexfs.cache + (s-(y*512));
 259                         dirent = (zexfs_dirent *) l;
 260
 261                         if (zexfs.node_curr == dirent->parent) {
 262 //                              kprintf ("cd_root: %d : %s\n", (s-(y*512)), dirent->name);
 263
 264                                 if (!strcmp (dirent->name, name)) {
 265                                         z = dirent->children;
 266                                         ret = 1;
 267                                         break;
 268                                 }
 269                         }
 270
 271                         x = y;
 272                 }
 273         }
 274
 275         if (!ret) {
 276                 kprintf ("ZeXFS -> file %s not found\n", name);
 277                 return 0;
 278         }
 279
 280         /* is file block already created ? */
 281         if (z == -1) {
 282                 kprintf ("ZeXFS -> file %s is empty\n", name);
 283                 return 0;
 284         }
 285
 286         zexfs_blk_header *blk = (zexfs_blk_header *) &zexfs.cache;
 287
 288         cache_t *cache = cache_create (0, 0, 0);
 289
 290         if (!cache)
 291                 return 0;
 292
 293         unsigned l;
 294
 295         for (l = 0; ; l += (512-sizeof (zexfs_blk_header))) {
 296                 lba28_drive_read (p, ZEXFS_IBLKENT_SECTOR+z+l, zexfs.cache);
 297
 298                 z += blk->next;
 299
 300                 cache_add (zexfs.cache+sizeof (zexfs_blk_header), blk->len);
 301
 302                 if (!blk->next)
 303                         break;
 304         }
 305
 306         content->ptr = (char *) &cache->data;
 307         content->len = cache->limit;
 308
 309         return 1;
 310 }
 311
 312
 313 /* NOTE: I dont want to use realloc, so we use preallocated memory block for new dirents */
 314 int zexfs_dirent_create (partition_t *p, zexfs_dirent *dirent)
 315 {
 316         unsigned i;
 317         unsigned y = 0;
 318
 319         /* find free dirent in array */
 320         for (i = 0; i < zexfs.iblock.dirents + ZEXFS_DIRENT_PREALLOC; i ++) {
 321                 if (zexfs.dirents[i] == ZEXFS_DIRENT_FREE) {
 322                         /* match dirent as file or directory */
 323                         zexfs.dirents[i] = dirent->flags & ZEXFS_DIRENT_FILE ? ZEXFS_DIRENT_FILE : ZEXFS_DIRENT_DIR;
 324
 325                         lba28_drive_write (p, ZEXFS_DIRENT_SECTOR+y, zexfs.dirents+(i/512));
 326
 327                         /* increase dirents count in infoblock structure */
 328                         zexfs.iblock.dirents ++;
 329
 330                         /* update initblock on drive */
 331                         memset (zexfs.cache+sizeof (zexfs.iblock), 0, 512-sizeof (zexfs.iblock));
 332                         memcpy (zexfs.cache, &zexfs.iblock, sizeof (zexfs.iblock));
 333                         lba28_drive_write (p, ZEXFS_INITBLOCK_SECTOR, (unsigned char *) zexfs.cache);
 334
 335                         DPRINT (DBG_DRIVER | DBG_FS, "ZeXFS -> dirent %d:%d created", i, zexfs.iblock.dirents);
 336
 337                         return i;
 338                 }
 339         }
 340
 341         kprintf ("ZeXFS -> Sorry, but your filesystem dirent table is full, please reboot or delete some files for correct the problem\n");
 342
 343         return -1;
 344 }
 345
 346 int zexfs_dirent_find (partition_t *p, zexfs_dirent *mydirent, unsigned char *name)
 347 {
 348         unsigned i;
 349         unsigned y = 0;
 350         unsigned x = -1;
 351
 352         /* find free dirent in array */
 353         for (i = 0; i < zexfs.iblock.dirents + ZEXFS_DIRENT_PREALLOC; i ++) {
 354                 if (zexfs.dirents[i] & ZEXFS_DIRENT_DIR) {
 355                         unsigned s = i * sizeof (zexfs_dirent);
 356
 357                         y = s/512;
 358
 359                         /* read data from sector to cache */
 360                         if (x != y)
 361                                 lba28_drive_read (p, ZEXFS_IDIRENT_SECTOR+y, zexfs.cache);
 362
 363                         unsigned char *l = zexfs.cache + (s-(y*512));
 364                         zexfs_dirent *dirent = (zexfs_dirent *) l;
 365
 366                         /* we need find same parent node as current node */
 367                         if (dirent->parent == zexfs.node_curr)
 368                                 if (!strcmp (name, dirent->name)) {     /* verify name of dirent with searched name */
 369                                         /* copy structure from founded dirent to our dirent structure */
 370                                         memcpy (&mydirent, &dirent, sizeof (zexfs_dirent));
 371                                         return i;
 372                                 }
 373
 374                         x = y;
 375                 }
 376         }
 377
 378         return -1;
 379 }
 380
 381 int zexfs_dirent_findbynode (partition_t *p, zexfs_dirent *mydirent, unsigned short node)
 382 {
 383         unsigned i = node;
 384         unsigned y = 0;
 385
 386         if (i > zexfs.iblock.dirents + ZEXFS_DIRENT_PREALLOC)
 387                 return -1;
 388
 389         if (zexfs.dirents[i] == ZEXFS_DIRENT_FREE)
 390                 return -1;
 391
 392         unsigned s = i * sizeof (zexfs_dirent);
 393
 394         y = s/512;
 395
 396         /* read data from sector to cache */
 397         lba28_drive_read (p, ZEXFS_IDIRENT_SECTOR+y, zexfs.cache);
 398         //kprintf ("r: %d\n", s-(y*512));
 399         unsigned char *l = zexfs.cache + (s-(y*512));
 400         zexfs_dirent *dirent = (zexfs_dirent *) l;
 401
 402         /* copy structure from founded dirent to our dirent structure */
 403         memcpy (mydirent, dirent, sizeof (zexfs_dirent));
 404
 405         return 0;
 406 }
 407
 408 /* function for create blank file or directory */
 409 unsigned zexfs_create_entity (partition_t *p, unsigned char *name, unsigned flags)
 410 {
 411         zexfs_dirent dirent;
 412
 413         memset (&dirent, 0, sizeof (zexfs_dirent));
 414
 415         dirent.flags |= flags;
 416         dirent.parent = zexfs.node_curr;
 417
 418         if (flags & ZEXFS_DIRENT_FILE)
 419                 dirent.children = -1;
 420
 421         unsigned l = strlen (name);
 422         memcpy (dirent.name, name, l);
 423         dirent.name[l] = '\0';
 424
 425         int r = zexfs_dirent_create (p, &dirent);
 426
 427         if (r == -1)
 428                 return 0;
 429
 430         r *= sizeof (zexfs_dirent);
 431
 432         unsigned x = r/512;     /* sizeof (zexfs_dirent) must be dividable by sector size */
 433
 434 //      kprintf ("he: %d .. %d .. %d\n", x, r, r-(x*512));
 435
 436         unsigned i;
 437         for (i = 0; i < 223; i ++)
 438                 if (!dir[i].name[0])
 439                         break;
 440
 441         strcpy (dir[i].name, name);
 442
 443         /* first read old sector data to cache */
 444         lba28_drive_read (p, ZEXFS_IDIRENT_SECTOR+x, zexfs.cache);
 445
 446         /* in memory just rewrite dirent structure */
 447         memcpy (zexfs.cache+(r-(x*512)), &dirent, sizeof (zexfs_dirent));
 448
 449         /* write new data from cache */
 450         lba28_drive_write (p, ZEXFS_IDIRENT_SECTOR+x, zexfs.cache);
 451
 452         return 1;
 453 }
 454
 455 /* go to next directory placed in current directory */
 456 unsigned zexfs_cd (partition_t *p, unsigned char *name)
 457 {
 458         zexfs_dirent dirent;
 459
 460         int r = -1;
 461 //      kprintf ("name: %s : %d\n", name, strlen (name));
 462         if (!strcmp (name, "..")) {
 463                 zexfs.node_curr = zexfs.node_prev;
 464
 465                 r = zexfs_dirent_findbynode (p, &dirent, zexfs.node_prev);
 466 //              kprintf ("he: %d\n", r);
 467                 if (r == -1) {
 468                         kprintf ("ZeXFS -> dirent with this name not found\n");
 469                         return 0;
 470                 }
 471
 472                 zexfs.node_prev = dirent.parent;
 473                 r = zexfs.node_prev;
 474 //              kprintf ("zexfs.node_prev: %d\n", zexfs.node_prev);
 475         } else {
 476                 r = zexfs_dirent_find (p, &dirent, name);
 477 //              kprintf ("he2: %d\n", r);
 478                 if (r == -1) {
 479                         kprintf ("ZeXFS -> dirent with this name not found\n");
 480                         return 0;
 481                 }
 482
 483                 zexfs.node_prev = zexfs.node_curr;
 484                 zexfs.node_curr = r;
 485         }
 486
 487 //      kprintf ("node_curr: %d\n", r);
 488 //      kprintf ("name: %s\n", dirent.name);
 489
 490         zexfs_dir_flush ();
 491
 492         unsigned y = 0;
 493         unsigned x = -1;
 494         unsigned id = 0;
 495         unsigned i = 0;
 496
 497         if (zexfs.node_curr) {
 498                 strcpy (dir[0].name, "..");
 499                 id ++;
 500         }
 501
 502         for (i = 0; i < zexfs.iblock.dirents + ZEXFS_DIRENT_PREALLOC; i ++) {
 503                 if (zexfs.dirents[i] != ZEXFS_DIRENT_FREE) {
 504                         unsigned s = i * sizeof (zexfs_dirent);
 505
 506                         y = s/512;
 507
 508                         /* read data from sector to cache */
 509                         if (x != y)
 510                                 lba28_drive_read (p, ZEXFS_IDIRENT_SECTOR+y, zexfs.cache);
 511
 512                         unsigned char *l = zexfs.cache + (s-(y*512));
 513                         zexfs_dirent *dirent = (zexfs_dirent *) l;
 514
 515                         if (zexfs.node_curr == dirent->parent) {
 516 //                              kprintf ("cd_root: %d : %s\n", (s-(y*512)), dirent->name);
 517
 518                                 memcpy (dir[id].name, dirent->name, 10);
 519                                 dir[id].dir = dirent->flags & ZEXFS_DIRENT_DIR ? 1 : 0;
 520
 521                                 id ++;
 522                         }
 523
 524                         x = y;
 525                 }
 526         }
 527
 528         return 1;
 529 }
 530
 531 /* go to root '/' directory on partition */
 532 unsigned zexfs_cd_root (partition_t *p)
 533 {
 534         zexfs.node_curr = 0;
 535
 536         zexfs_dir_flush ();
 537
 538         unsigned i;
 539         unsigned y = 0;
 540         unsigned x = -1;
 541         unsigned id = 0;
 542
 543         for (i = 0; i < zexfs.iblock.dirents + 32; i ++) {
 544                 if (zexfs.dirents[i] != ZEXFS_DIRENT_FREE) {
 545                         unsigned s = i * sizeof (zexfs_dirent);
 546
 547                         y = s/512;
 548
 549                         /* read data from sector to cache */
 550                         if (x != y)
 551                                 lba28_drive_read (p, ZEXFS_IDIRENT_SECTOR+y, zexfs.cache);
 552
 553                         unsigned char *l = zexfs.cache + (s-(y*512));
 554                         zexfs_dirent *dirent = (zexfs_dirent *) l;
 555
 556                         if (zexfs.node_curr == dirent->parent) {
 557                                 kprintf ("cd_root: %d : %s\n", (s-(y*512)), dirent->name);
 558
 559                                 memcpy (dir[id].name, dirent->name, 10);
 560                                 dir[id].dir = dirent->flags & ZEXFS_DIRENT_DIR ? 1 : 0;
 561
 562                                 id ++;
 563                         }
 564
 565                         x = y;
 566                 }
 567         }
 568
 569         return 1;
 570 }
 571
 572 /* mkzexfs utility for create zexfs filesystem on partition */
 573 unsigned mkzexfs (partition_t *p)
 574 {
 575         if (!p)
 576                 return 0;
 577
 578         printf ("mkzexfs\n");
 579
 580         unsigned i;
 581         for (i = 0; i < zexfs.iblock.dirents + ZEXFS_DIRENT_PREALLOC; i ++)
 582                 zexfs.dirents[i] = ZEXFS_DIRENT_FREE;
 583
 584         memcpy (zexfs.iblock.magic, "zexfs", 5);
 585
 586         zexfs.iblock.dirents = 0;
 587         zexfs.iblock.blkents = 0;
 588
 589         memset (zexfs.cache, 0, 512);
 590         memcpy (zexfs.cache, (void *) &zexfs.iblock, sizeof (zexfs_infoblock));
 591
 592         if (!lba28_drive_write (p, ZEXFS_INITBLOCK_SECTOR, zexfs.cache))
 593                 return 0;
 594
 595         memset (zexfs.cache, 0, 512);
 596
 597         for (i = ZEXFS_DIRENT_SECTOR; i < ZEXFS_IDIRENT_SECTOR; i ++) {
 598                 if (!lba28_drive_write (p, i, zexfs.cache))
 599                         return 0;
 600         }
 601
 602         for (i = ZEXFS_IDIRENT_SECTOR; i < ZEXFS_IDIRENT_SECTOR+10; i ++) {
 603                 if (!lba28_drive_write (p, ZEXFS_IDIRENT_SECTOR, zexfs.cache))
 604                         return 0;
 605         }
 606
 607         if (!lba28_drive_write (p, ZEXFS_BLKENT_SECTOR, zexfs.cache))
 608                 return 0;
 609
 610         zexfs.node_curr = 0;
 611         zexfs.node_prev = 0;
 612
 613         /* create dirent with node id 0 - root directory */
 614         zexfs_create_entity (p, ".", ZEXFS_DIRENT_FILE);
 615
 616         printf ("zexfs filesystem was succefully created\n");
 617
 618         return 1;
 619 }
 620
 621 /* zexos filesystem initialization function */
 622 unsigned zexfs_init (partition_t *p)
 623 {
 624         lba28_drive_read (p, ZEXFS_INITBLOCK_SECTOR, (unsigned char *) zexfs.cache);
 625
 626         memcpy (&zexfs.iblock, zexfs.cache, sizeof (zexfs.iblock));
 627
 628         if (strncmp (zexfs.iblock.magic, "zexfs", 5)) {
 629                 kprintf ("ZeXFS not found\n");
 630                 return 1;
 631         }
 632
 633         kprintf ("ZeXFS -> filesystem contain %d dirents\n", zexfs.iblock.dirents);
 634         kprintf ("ZeXFS -> filesystem contain %d blkents\n", zexfs.iblock.blkents);
 635
 636         /* alloc memory for dirents array */
 637         zexfs.dirents = (unsigned char *) kmalloc ((zexfs.iblock.dirents+ZEXFS_DIRENT_PREALLOC) * sizeof (unsigned char));
 638
 639         if (!zexfs.dirents) {
 640                 kprintf ("ZeXFS -> zexfs.dirents : out of memory\n");
 641
 642                 return 0;
 643         }
 644
 645         /* alloc memory for blkents array */
 646         zexfs.blkents = (unsigned char *) kmalloc ((zexfs.iblock.blkents+ZEXFS_BLKENT_PREALLOC) * sizeof (unsigned char));
 647
 648         if (!zexfs.blkents) {
 649                 kprintf ("ZeXFS -> zexfs.blkents : out of memory\n");
 650                 kfree (zexfs.dirents);
 651
 652                 return 0;
 653         }
 654
 655         /* clean end of memory block, where physical data are'nt loaded */
 656         if (zexfs.iblock.dirents >= ZEXFS_DIRENT_PREALLOC)
 657                 memset (zexfs.dirents-ZEXFS_DIRENT_PREALLOC, 0, ZEXFS_DIRENT_PREALLOC);
 658         else
 659                 memset (zexfs.dirents, 0, ZEXFS_DIRENT_PREALLOC);
 660
 661         /* clean end of memory block, where physical data are'nt loaded */
 662         if (zexfs.iblock.blkents >= ZEXFS_BLKENT_PREALLOC)
 663                 memset (zexfs.blkents-ZEXFS_BLKENT_PREALLOC, 0, ZEXFS_BLKENT_PREALLOC);
 664         else
 665                 memset (zexfs.blkents, 0, ZEXFS_BLKENT_PREALLOC);
 666
 667         unsigned i;
 668         unsigned y = 0;
 669
 670         /* read dirent database from drive */
 671         for (i = 0; i < zexfs.iblock.dirents; i += 512)
 672                 lba28_drive_read (p, ZEXFS_DIRENT_SECTOR+(i/512), (unsigned char *) ((unsigned char *) zexfs.dirents+((i/512)*512)));
 673
 674         /* read blkent database from drive */
 675         for (i = 0; i < zexfs.iblock.blkents; i += 512)
 676                 lba28_drive_read (p, ZEXFS_BLKENT_SECTOR+(i/512), (unsigned char *) ((unsigned char *) zexfs.blkents+((i/512)*512)));
 677
 678         zexfs.node_curr = 0;
 679
 680         return 1;
 681 }
 682
 683 /* handler which is used by device management and pretty needed
 684          for communication between zexos and this filesystem */
 685 bool zexfs_handler (unsigned act, char *block, unsigned n, unsigned long l)
 686 {
 687         switch (act) {
 688                 case FS_ACT_INIT:
 689                 {
 690                         return zexfs_init ((partition_t *) block);
 691                 }
 692                 break;
 693                 case FS_ACT_READ:
 694                 {
 695                         return zexfs_read_file (curr_part, dir[n].name, (vfs_content_t *) block);
 696                 }
 697                 break;
 698                 case FS_ACT_WRITE:
 699                 {
 700                         return zexfs_write_file (curr_part, dir[n].name, (vfs_content_t *) block);
 701                 }
 702                 break;
 703                 case FS_ACT_CHDIR:
 704                 {
 705                         if (n == -1)
 706                                 return zexfs_cd_root (curr_part);
 707
 708                         /* go to another directory */
 709                         return zexfs_cd (curr_part, block);
 710                 }
 711                 break;
 712                 case FS_ACT_MKDIR:
 713                 {
 714                         return zexfs_create_entity (curr_part, block, ZEXFS_DIRENT_DIR);
 715                 }
 716                 break;
 717                 case FS_ACT_TOUCH:
 718                 {
 719                         return zexfs_create_entity (curr_part, block, ZEXFS_DIRENT_FILE);
 720                 }
 721         }
 722
 723         return 0;
 724 }
 725 #endif