fs/fs.c

   1 /*
   2  * fs.c - posix like file functions
   3  *
   4  * Copyright (c) 2007 Sascha Hauer <s.hauer@pengutronix.de>, Pengutronix
   5  *
   6  * See file CREDITS for list of people who contributed to this
   7  * project.
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2
  11  * as published by the Free Software Foundation.
  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, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include <common.h>
  24 #include <fs.h>
  25 #include <driver.h>
  26 #include <errno.h>
  27 #include <malloc.h>
  28 #include <linux/stat.h>
  29 #include <fcntl.h>
  30 #include <xfuncs.h>
  31 #include <init.h>
  32 #include <module.h>
  33
  34 void *read_file(const char *filename, size_t *size)
  35 {
  36         int fd;
  37         struct stat s;
  38         void *buf = NULL;
  39
  40         if (stat(filename, &s))
  41                 return NULL;
  42
  43         buf = xzalloc(s.st_size + 1);
  44
  45         fd = open(filename, O_RDONLY);
  46         if (fd < 0)
  47                 goto err_out;
  48
  49         if (read(fd, buf, s.st_size) < s.st_size)
  50                 goto err_out1;
  51
  52         close(fd);
  53
  54         if (size)
  55                 *size = s.st_size;
  56
  57         return buf;
  58
  59 err_out1:
  60         close(fd);
  61 err_out:
  62         free(buf);
  63         return NULL;
  64 }
  65
  66 EXPORT_SYMBOL(read_file);
  67
  68 char *mkmodestr(unsigned long mode, char *str)
  69 {
  70         static const char *l = "xwr";
  71         int mask = 1, i;
  72         char c;
  73
  74         switch (mode & S_IFMT) {
  75                 case S_IFDIR:    str[0] = 'd'; break;
  76                 case S_IFBLK:    str[0] = 'b'; break;
  77                 case S_IFCHR:    str[0] = 'c'; break;
  78                 case S_IFIFO:    str[0] = 'f'; break;
  79                 case S_IFLNK:    str[0] = 'l'; break;
  80                 case S_IFSOCK:   str[0] = 's'; break;
  81                 case S_IFREG:    str[0] = '-'; break;
  82                 default:         str[0] = '?';
  83         }
  84
  85         for(i = 0; i < 9; i++) {
  86                 c = l[i%3];
  87                 str[9-i] = (mode & mask)?c:'-';
  88                 mask = mask<<1;
  89         }
  90
  91         if(mode & S_ISUID) str[3] = (mode & S_IXUSR)?'s':'S';
  92         if(mode & S_ISGID) str[6] = (mode & S_IXGRP)?'s':'S';
  93         if(mode & S_ISVTX) str[9] = (mode & S_IXOTH)?'t':'T';
  94         str[10] = '\0';
  95         return str;
  96 }
  97 EXPORT_SYMBOL(mkmodestr);
  98
  99 static char *cwd;
 100
 101 static int init_cwd(void)
 102 {
 103         cwd = xzalloc(PATH_MAX);
 104         *cwd = '/';
 105         return 0;
 106 }
 107
 108 postcore_initcall(init_cwd);
 109
 110 char *normalise_path(const char *pathname)
 111 {
 112         char *path = xzalloc(strlen(pathname) + strlen(cwd) + 2);
 113         char *in, *out, *slashes[32];
 114         int sl = 0;
 115
 116         debug("in: %s\n", pathname);
 117
 118         if (*pathname != '/')
 119                 strcpy(path, cwd);
 120         strcat(path, "/");
 121         strcat(path, pathname);
 122
 123         slashes[0] = in = out = path;
 124
 125         while (*in) {
 126                 if(*in == '/') {
 127                         slashes[sl++] = out;
 128                         *out++ = *in++;
 129                         while(*in == '/')
 130                                 in++;
 131                 } else {
 132                         if (*in == '.' && (*(in + 1) == '/' || !*(in + 1))) {
 133                                 sl--;
 134                                 if (sl < 0)
 135                                         sl = 0;
 136                                 out = slashes[sl];
 137                                 in++;
 138                                 continue;
 139                         }
 140                         if (*in == '.' && *(in + 1) == '.') {
 141                                 sl -= 2;
 142                                 if (sl < 0)
 143                                         sl = 0;
 144                                 out = slashes[sl];
 145                                 in += 2;
 146                                 continue;
 147                         }
 148                         *out++ = *in++;
 149                 }
 150         }
 151
 152         *out-- = 0;
 153
 154         /*
 155          * Remove trailing slash
 156          */
 157         if (*out == '/')
 158                 *out = 0;
 159
 160         if (!*path) {
 161                 *path = '/';
 162                 *(path + 1) = 0;
 163         }
 164
 165         return path;
 166 }
 167 EXPORT_SYMBOL(normalise_path);
 168
 169 static struct mtab_entry *mtab;
 170
 171 struct mtab_entry *get_mtab_entry_by_path(const char *_path)
 172 {
 173         struct mtab_entry *match = NULL, *e = mtab;
 174         char *path, *tok;
 175
 176         if (*_path != '/')
 177                 return NULL;
 178
 179         path = strdup(_path);
 180
 181         tok = strchr(path + 1, '/');
 182         if (tok)
 183                 *tok = 0;
 184
 185         while (e) {
 186                 if (!strcmp(path, e->path)) {
 187                         match = e;
 188                         break;
 189                 }
 190                 e = e->next;
 191         }
 192
 193         free(path);
 194
 195         return match ? match : mtab;
 196 }
 197
 198 struct mtab_entry *mtab_next_entry(struct mtab_entry *e)
 199 {
 200         if (!e)
 201                 return mtab;
 202         return e->next;
 203 }
 204
 205 const char *fsdev_get_mountpoint(struct fs_device_d *fsdev)
 206 {
 207         return fsdev->mtab.path;
 208 }
 209
 210 static FILE files[MAX_FILES];
 211
 212 static FILE *get_file(void)
 213 {
 214         int i;
 215
 216         for (i = 3; i < MAX_FILES; i++) {
 217                 if (!files[i].in_use) {
 218                         memset(&files[i], 0, sizeof(FILE));
 219                         files[i].in_use = 1;
 220                         files[i].no = i;
 221                         return &files[i];
 222                 }
 223         }
 224         return NULL;
 225 }
 226
 227 static void put_file(FILE *f)
 228 {
 229         files[f->no].in_use = 0;
 230 }
 231
 232 static int check_fd(int fd)
 233 {
 234         if (fd < 0 || fd >= MAX_FILES || !files[fd].in_use) {
 235                 errno = -EBADF;
 236                 return errno;
 237         }
 238
 239         return 0;
 240 }
 241
 242 static struct device_d *get_fs_device_by_path(char **path)
 243 {
 244         struct device_d *dev;
 245         struct mtab_entry *e;
 246
 247         e = get_mtab_entry_by_path(*path);
 248         if (!e)
 249                 return NULL;
 250         if (e != mtab)
 251                 *path += strlen(e->path);
 252
 253         dev = e->dev;
 254
 255         return dev;
 256 }
 257
 258 static int dir_is_empty(const char *pathname)
 259 {
 260         DIR *dir;
 261         struct dirent *d;
 262         int ret = 1;
 263
 264         dir = opendir(pathname);
 265         if (!dir) {
 266                 errno = -ENOENT;
 267                 return -ENOENT;
 268         }
 269
 270         while ((d = readdir(dir))) {
 271                 if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
 272                                 continue;
 273                 ret = 0;
 274                 break;
 275         }
 276
 277         closedir(dir);
 278         return ret;
 279 }
 280
 281 #define S_UB_IS_EMPTY           (1 << 31)
 282 #define S_UB_EXISTS             (1 << 30)
 283 #define S_UB_DOES_NOT_EXIST     (1 << 29)
 284
 285 /*
 286  * Helper function to check the prerequisites of a path given
 287  * to fs functions. Besides the flags above S_IFREG and S_IFDIR
 288  * can be passed in.
 289  */
 290 static int path_check_prereq(const char *path, unsigned int flags)
 291 {
 292         struct stat s;
 293         unsigned int m;
 294
 295         errno = 0;
 296
 297         if (stat(path, &s)) {
 298                 if (flags & S_UB_DOES_NOT_EXIST)
 299                         return 0;
 300                 errno = -ENOENT;
 301                 goto out;
 302         }
 303
 304         if (flags & S_UB_DOES_NOT_EXIST) {
 305                 errno = -EEXIST;
 306                 goto out;
 307         }
 308
 309         if (flags == S_UB_EXISTS)
 310                 return 0;
 311
 312         m = s.st_mode;
 313
 314         if (S_ISDIR(m)) {
 315                 if (flags & S_IFREG) {
 316                         errno = -EISDIR;
 317                         goto out;
 318                 }
 319                 if ((flags & S_UB_IS_EMPTY) && !dir_is_empty(path)) {
 320                         errno = -ENOTEMPTY;
 321                         goto out;
 322                 }
 323         }
 324         if ((flags & S_IFDIR) && S_ISREG(m)) {
 325                 errno = -ENOTDIR;
 326                 goto out;
 327         }
 328 out:
 329         return errno;
 330 }
 331
 332 const char *getcwd(void)
 333 {
 334         return cwd;
 335 }
 336 EXPORT_SYMBOL(getcwd);
 337
 338 int chdir(const char *pathname)
 339 {
 340         char *p = normalise_path(pathname);
 341         errno = 0;
 342
 343         if (path_check_prereq(p, S_IFDIR))
 344                 goto out;
 345
 346         strcpy(cwd, p);
 347
 348         free(p);
 349 out:
 350         return errno;
 351 }
 352 EXPORT_SYMBOL(chdir);
 353
 354 int unlink(const char *pathname)
 355 {
 356         struct device_d *dev;
 357         struct fs_driver_d *fsdrv;
 358         char *p = normalise_path(pathname);
 359         char *freep = p;
 360
 361         if (path_check_prereq(pathname, S_IFREG))
 362                 goto out;
 363
 364         dev = get_fs_device_by_path(&p);
 365         if (!dev)
 366                 goto out;
 367         fsdrv = (struct fs_driver_d *)dev->driver->type_data;
 368
 369         if (!fsdrv->unlink) {
 370                 errno = -ENOSYS;
 371                 goto out;
 372         }
 373
 374         errno = fsdrv->unlink(dev, p);
 375 out:
 376         free(freep);
 377         return errno;
 378 }
 379 EXPORT_SYMBOL(unlink);
 380
 381 int open(const char *pathname, int flags, ...)
 382 {
 383         struct device_d *dev;
 384         struct fs_driver_d *fsdrv;
 385         FILE *f;
 386         int exist;
 387         struct stat s;
 388         char *path = normalise_path(pathname);
 389         char *freep = path;
 390
 391         exist = (stat(path, &s) == 0) ? 1 : 0;
 392
 393         if (exist && S_ISDIR(s.st_mode)) {
 394                 errno = -EISDIR;
 395                 goto out1;
 396         }
 397
 398         if (!exist && !(flags & O_CREAT)) {
 399                 errno = -ENOENT;
 400                 goto out1;
 401         }
 402
 403         f = get_file();
 404         if (!f) {
 405                 errno = -EMFILE;
 406                 goto out1;
 407         }
 408
 409         dev = get_fs_device_by_path(&path);
 410         if (!dev)
 411                 goto out;
 412
 413         fsdrv = (struct fs_driver_d *)dev->driver->type_data;
 414
 415         f->dev = dev;
 416         f->flags = flags;
 417
 418         if ((flags & O_ACCMODE) && !fsdrv->write) {
 419                 errno = -EROFS;
 420                 goto out;
 421         }
 422
 423         if (!exist) {
 424                 if (NULL != fsdrv->create)
 425                         errno = fsdrv->create(dev, path,
 426                                         S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO);
 427                 else
 428                         errno = -EROFS;
 429                 if (errno)
 430                         goto out;
 431         }
 432         errno = fsdrv->open(dev, f, path);
 433         if (errno)
 434                 goto out;
 435
 436
 437         if (flags & O_TRUNC) {
 438                 errno = fsdrv->truncate(dev, f, 0);
 439                 f->size = 0;
 440                 if (errno)
 441                         goto out;
 442         }
 443
 444         if (flags & O_APPEND)
 445                 f->pos = f->size;
 446
 447         free(freep);
 448         return f->no;
 449
 450 out:
 451         put_file(f);
 452 out1:
 453         free(freep);
 454         return errno;
 455 }
 456 EXPORT_SYMBOL(open);
 457
 458 int creat(const char *pathname, mode_t mode)
 459 {
 460         return open(pathname, O_CREAT | O_WRONLY | O_TRUNC);
 461 }
 462 EXPORT_SYMBOL(creat);
 463
 464 int ioctl(int fd, int request, void *buf)
 465 {
 466         struct device_d *dev;
 467         struct fs_driver_d *fsdrv;
 468         FILE *f = &files[fd];
 469
 470         if (check_fd(fd))
 471                 return errno;
 472
 473         dev = f->dev;
 474
 475         fsdrv = (struct fs_driver_d *)dev->driver->type_data;
 476
 477         if (fsdrv->ioctl)
 478                 errno = fsdrv->ioctl(dev, f, request, buf);
 479         else
 480                 errno = -ENOSYS;
 481         return errno;
 482 }
 483
 484 int read(int fd, void *buf, size_t count)
 485 {
 486         struct device_d *dev;
 487         struct fs_driver_d *fsdrv;
 488         FILE *f = &files[fd];
 489
 490         if (check_fd(fd))
 491                 return errno;
 492
 493         dev = f->dev;
 494
 495         fsdrv = (struct fs_driver_d *)dev->driver->type_data;
 496
 497         if (f->pos + count > f->size)
 498                 count = f->size - f->pos;
 499         errno = fsdrv->read(dev, f, buf, count);
 500
 501         if (errno > 0)
 502                 f->pos += errno;
 503         return errno;
 504 }
 505 EXPORT_SYMBOL(read);
 506
 507 ssize_t write(int fd, const void *buf, size_t count)
 508 {
 509         struct device_d *dev;
 510         struct fs_driver_d *fsdrv;
 511         FILE *f = &files[fd];
 512
 513         if (check_fd(fd))
 514                 return errno;
 515
 516         dev = f->dev;
 517
 518         fsdrv = (struct fs_driver_d *)dev->driver->type_data;
 519         if (f->pos + count > f->size) {
 520                 errno = fsdrv->truncate(dev, f, f->pos + count);
 521                 if (errno) {
 522                         if (errno != -ENOSPC)
 523                                 return errno;
 524                         count = f->size - f->pos;
 525                         if (!count)
 526                                 return errno;
 527                 } else {
 528                         f->size = f->pos + count;
 529                 }
 530         }
 531         errno = fsdrv->write(dev, f, buf, count);
 532
 533         if (errno > 0)
 534                 f->pos += errno;
 535         return errno;
 536 }
 537 EXPORT_SYMBOL(write);
 538
 539 off_t lseek(int fildes, off_t offset, int whence)
 540 {
 541         struct device_d *dev;
 542         struct fs_driver_d *fsdrv;
 543         FILE *f = &files[fildes];
 544         off_t pos;
 545
 546         if (check_fd(fildes))
 547                 return -1;
 548
 549         errno = 0;
 550
 551         dev = f->dev;
 552         fsdrv = (struct fs_driver_d *)dev->driver->type_data;
 553         if (!fsdrv->lseek) {
 554                 errno = -ENOSYS;
 555                 return -1;
 556         }
 557
 558         switch(whence) {
 559         case SEEK_SET:
 560                 if (offset > f->size)
 561                         goto out;
 562                 pos = offset;
 563                 break;
 564         case SEEK_CUR:
 565                 if (offset + f->pos > f->size)
 566                         goto out;
 567                 pos = f->pos + offset;
 568                 break;
 569         case SEEK_END:
 570                 if (offset)
 571                         goto out;
 572                 pos = f->size;
 573                 break;
 574         default:
 575                 goto out;
 576         }
 577
 578         return fsdrv->lseek(dev, f, pos);
 579
 580 out:
 581         errno = -EINVAL;
 582         return -1;
 583 }
 584 EXPORT_SYMBOL(lseek);
 585
 586 int erase(int fd, size_t count, unsigned long offset)
 587 {
 588         struct device_d *dev;
 589         struct fs_driver_d *fsdrv;
 590         FILE *f = &files[fd];
 591
 592         if (check_fd(fd))
 593                 return errno;
 594
 595         dev = f->dev;
 596
 597         fsdrv = (struct fs_driver_d *)dev->driver->type_data;
 598
 599         if (f->pos + count > f->size)
 600                 count = f->size - f->pos;
 601
 602         if (fsdrv->erase)
 603                 errno = fsdrv->erase(dev, f, count, offset);
 604         else
 605                 errno = -ENOSYS;
 606
 607         return errno;
 608 }
 609 EXPORT_SYMBOL(erase);
 610
 611 int protect(int fd, size_t count, unsigned long offset, int prot)
 612 {
 613         struct device_d *dev;
 614         struct fs_driver_d *fsdrv;
 615         FILE *f = &files[fd];
 616
 617         if (check_fd(fd))
 618                 return errno;
 619
 620         dev = f->dev;
 621
 622         fsdrv = (struct fs_driver_d *)dev->driver->type_data;
 623
 624         if (f->pos + count > f->size)
 625                 count = f->size - f->pos;
 626
 627         if (fsdrv->protect)
 628                 errno = fsdrv->protect(dev, f, count, offset, prot);
 629         else
 630                 errno = -ENOSYS;
 631
 632         return errno;
 633 }
 634 EXPORT_SYMBOL(protect);
 635
 636 int protect_file(const char *file, int prot)
 637 {
 638         int fd, ret;
 639
 640         fd = open(file, O_WRONLY);
 641         if (fd < 0)
 642                 return fd;
 643
 644         ret = protect(fd, ~0, 0, prot);
 645
 646         close(fd);
 647
 648         return ret;
 649 }
 650
 651 void *memmap(int fd, int flags)
 652 {
 653         struct device_d *dev;
 654         struct fs_driver_d *fsdrv;
 655         FILE *f = &files[fd];
 656         void *ret = (void *)-1;
 657
 658         if (check_fd(fd))
 659                 return ret;
 660
 661         dev = f->dev;
 662
 663         fsdrv = (struct fs_driver_d *)dev->driver->type_data;
 664
 665         if (fsdrv->memmap)
 666                 errno = fsdrv->memmap(dev, f, &ret, flags);
 667         else
 668                 errno = -EINVAL;
 669
 670         return ret;
 671 }
 672 EXPORT_SYMBOL(memmap);
 673
 674 int close(int fd)
 675 {
 676         struct device_d *dev;
 677         struct fs_driver_d *fsdrv;
 678         FILE *f = &files[fd];
 679
 680         if (check_fd(fd))
 681                 return errno;
 682
 683         dev = f->dev;
 684
 685         fsdrv = (struct fs_driver_d *)dev->driver->type_data;
 686         errno = fsdrv->close(dev, f);
 687
 688         put_file(f);
 689         return errno;
 690 }
 691 EXPORT_SYMBOL(close);
 692
 693 static LIST_HEAD(fs_driver_list);
 694
 695 int register_fs_driver(struct fs_driver_d *fsdrv)
 696 {
 697         list_add_tail(&fsdrv->list, &fs_driver_list);
 698         register_driver(&fsdrv->drv);
 699         return 0;
 700 }
 701 EXPORT_SYMBOL(register_fs_driver);
 702
 703 /*
 704  * Mount a device to a directory.
 705  * We do this by registering a new device on which the filesystem
 706  * driver will match. The filesystem driver then grabs the infomation
 707  * it needs from the new devices type_data.
 708  */
 709 int mount(const char *device, const char *fsname, const char *_path)
 710 {
 711         struct fs_driver_d *fs_drv = NULL, *f;
 712         struct mtab_entry *entry;
 713         struct fs_device_d *fsdev;
 714         struct device_d *dev, *parent_device = NULL;
 715         int ret;
 716         char *path = normalise_path(_path);
 717
 718         errno = 0;
 719
 720         debug("mount: %s on %s type %s\n", device, path, fsname);
 721
 722         if (get_mtab_entry_by_path(path) != mtab) {
 723                 errno = -EBUSY;
 724                 goto out;
 725         }
 726
 727         if (strchr(path + 1, '/')) {
 728                 printf("mounting allowed on first directory level only\n");
 729                 errno = -EBUSY;
 730                 goto out;
 731         }
 732
 733         list_for_each_entry(f, &fs_driver_list, list) {
 734                 if (!strcmp(f->drv.name, fsname)) {
 735                         fs_drv = f;
 736                         break;
 737                 }
 738         }
 739
 740         if (!fs_drv) {
 741                 errno = -EINVAL;
 742                 goto out;
 743         }
 744
 745         if (mtab) {
 746                 if (path_check_prereq(path, S_IFDIR))
 747                         goto out;
 748         } else {
 749                 /* no mtab, so we only allow to mount on '/' */
 750                 if (*path != '/' || *(path + 1)) {
 751                         errno = -ENOTDIR;
 752                         goto out;
 753                 }
 754         }
 755
 756         fsdev = xzalloc(sizeof(struct fs_device_d));
 757         if (!fs_drv->flags & FS_DRIVER_NO_DEV) {
 758                 fsdev->backingstore = strdup(device);
 759                 if (!device) {
 760                         printf("need a device for driver %s\n", fsname);
 761                         errno = -ENODEV;
 762                         free(fsdev);
 763                         goto out;
 764                 }
 765         }
 766         sprintf(fsdev->dev.name, "%s", fsname);
 767         fsdev->dev.type_data = fsdev;
 768
 769         if ((ret = register_device(&fsdev->dev))) {
 770                 free(fsdev);
 771                 errno = ret;
 772                 goto out;
 773         }
 774
 775         if (!fsdev->dev.driver) {
 776                 /* driver didn't accept the device. Bail out */
 777                 free(fsdev);
 778                 errno = -EINVAL;
 779                 goto out;
 780         }
 781
 782         if (parent_device)
 783                 dev_add_child(parent_device, &fsdev->dev);
 784
 785         dev = &fsdev->dev;
 786
 787         /* add mtab entry */
 788         entry = &fsdev->mtab;
 789         sprintf(entry->path, "%s", path);
 790         entry->dev = dev;
 791         entry->parent_device = parent_device;
 792         entry->next = NULL;
 793
 794         if (!mtab)
 795                 mtab = entry;
 796         else {
 797                 struct mtab_entry *e = mtab;
 798                 while (e->next)
 799                         e = e->next;
 800                 e->next = entry;
 801         }
 802 out:
 803         free(path);
 804         return errno;
 805 }
 806 EXPORT_SYMBOL(mount);
 807
 808 int umount(const char *pathname)
 809 {
 810         struct mtab_entry *entry = mtab;
 811         struct mtab_entry *last = mtab;
 812         char *p = normalise_path(pathname);
 813         struct fs_device_d *fsdev;
 814
 815         while(entry && strcmp(p, entry->path)) {
 816                 last = entry;
 817                 entry = entry->next;
 818         }
 819
 820         free(p);
 821
 822         if (!entry) {
 823                 errno = -EFAULT;
 824                 return errno;
 825         }
 826
 827         if (entry == mtab)
 828                 mtab = mtab->next;
 829         else
 830                 last->next = entry->next;
 831
 832         unregister_device(entry->dev);
 833         fsdev = entry->dev->type_data;
 834         free(fsdev->backingstore);
 835         free(fsdev);
 836
 837         return 0;
 838 }
 839 EXPORT_SYMBOL(umount);
 840
 841 DIR *opendir(const char *pathname)
 842 {
 843         DIR *dir = NULL;
 844         struct device_d *dev;
 845         struct fs_driver_d *fsdrv;
 846         char *p = normalise_path(pathname);
 847         char *freep = p;
 848
 849         if (path_check_prereq(pathname, S_IFDIR))
 850                 goto out;
 851
 852         dev = get_fs_device_by_path(&p);
 853         if (!dev)
 854                 goto out;
 855         fsdrv = (struct fs_driver_d *)dev->driver->type_data;
 856
 857         debug("opendir: fsdrv: %p\n",fsdrv);
 858
 859         dir = fsdrv->opendir(dev, p);
 860         if (dir) {
 861                 dir->dev = dev;
 862                 dir->fsdrv = fsdrv;
 863         }
 864
 865 out:
 866         free(freep);
 867         return dir;
 868 }
 869 EXPORT_SYMBOL(opendir);
 870
 871 struct dirent *readdir(DIR *dir)
 872 {
 873         if (!dir)
 874                 return NULL;
 875
 876         return dir->fsdrv->readdir(dir->dev, dir);
 877 }
 878 EXPORT_SYMBOL(readdir);
 879
 880 int closedir(DIR *dir)
 881 {
 882         if (!dir) {
 883                 errno = -EBADF;
 884                 return -1;
 885         }
 886
 887         return dir->fsdrv->closedir(dir->dev, dir);
 888 }
 889 EXPORT_SYMBOL(closedir);
 890
 891 int stat(const char *filename, struct stat *s)
 892 {
 893         struct device_d *dev;
 894         struct fs_driver_d *fsdrv;
 895         struct mtab_entry *e;
 896         char *f = normalise_path(filename);
 897         char *freep = f;
 898
 899         memset(s, 0, sizeof(struct stat));
 900
 901         e = get_mtab_entry_by_path(f);
 902         if (!e) {
 903                 errno = -ENOENT;
 904                 goto out;
 905         }
 906
 907         if (e != mtab && strcmp(f, e->path)) {
 908                 f += strlen(e->path);
 909                 dev = e->dev;
 910         } else
 911                 dev = mtab->dev;
 912
 913         fsdrv = (struct fs_driver_d *)dev->driver->type_data;
 914
 915         if (*f == 0)
 916                 f = "/";
 917
 918         errno = fsdrv->stat(dev, f, s);
 919 out:
 920         free(freep);
 921         return errno;
 922 }
 923 EXPORT_SYMBOL(stat);
 924
 925 int mkdir (const char *pathname, mode_t mode)
 926 {
 927         struct fs_driver_d *fsdrv;
 928         struct device_d *dev;
 929         char *p = normalise_path(pathname);
 930         char *freep = p;
 931
 932         if (path_check_prereq(pathname, S_UB_DOES_NOT_EXIST))
 933                 goto out;
 934
 935         dev = get_fs_device_by_path(&p);
 936         if (!dev)
 937                 goto out;
 938         fsdrv = (struct fs_driver_d *)dev->driver->type_data;
 939
 940         if (fsdrv->mkdir) {
 941                 errno = fsdrv->mkdir(dev, p);
 942                 goto out;
 943         }
 944
 945         errno = -EROFS;
 946 out:
 947         free(freep);
 948         return errno;
 949 }
 950 EXPORT_SYMBOL(mkdir);
 951
 952 int rmdir (const char *pathname)
 953 {
 954         struct fs_driver_d *fsdrv;
 955         struct device_d *dev;
 956         char *p = normalise_path(pathname);
 957         char *freep = p;
 958
 959         if (path_check_prereq(pathname, S_IFDIR | S_UB_IS_EMPTY))
 960                 goto out;
 961
 962         dev = get_fs_device_by_path(&p);
 963         if (!dev)
 964                 goto out;
 965         fsdrv = (struct fs_driver_d *)dev->driver->type_data;
 966
 967         if (fsdrv->rmdir) {
 968                 errno = fsdrv->rmdir(dev, p);
 969                 goto out;
 970         }
 971
 972         errno = -EROFS;
 973 out:
 974         free(freep);
 975         return errno;
 976 }
 977 EXPORT_SYMBOL(rmdir);
 978
 979 static void memcpy_sz(void *_dst, const void *_src, ulong count, ulong rwsize)
 980 {
 981         ulong dst = (ulong)_dst;
 982         ulong src = (ulong)_src;
 983
 984         /* no rwsize specification given. Do whatever memcpy likes best */
 985         if (!rwsize) {
 986                 memcpy(_dst, _src, count);
 987                 return;
 988         }
 989
 990         rwsize = rwsize >> O_RWSIZE_SHIFT;
 991
 992         count /= rwsize;
 993
 994         while (count-- > 0) {
 995                 switch (rwsize) {
 996                 case 1:
 997                         *((u_char *)dst) = *((u_char *)src);
 998                         break;
 999                 case 2:
1000                         *((ushort *)dst) = *((ushort *)src);
1001                         break;
1002                 case 4:
1003                         *((ulong  *)dst) = *((ulong  *)src);
1004                         break;
1005                 }
1006                 dst += rwsize;
1007                 src += rwsize;
1008         }
1009 }
1010
1011 ssize_t mem_read(struct cdev *cdev, void *buf, size_t count, ulong offset, ulong flags)
1012 {
1013         ulong size;
1014         struct device_d *dev;
1015
1016         if (!cdev->dev)
1017                 return -1;
1018         dev = cdev->dev;
1019
1020         size = min((ulong)count, dev->size - offset);
1021         debug("mem_read: dev->map_base: %p size: %d offset: %d\n",dev->map_base, size, offset);
1022         memcpy_sz(buf, (void *)(dev->map_base + offset), size, flags & O_RWSIZE_MASK);
1023         return size;
1024 }
1025 EXPORT_SYMBOL(mem_read);
1026
1027 ssize_t mem_write(struct cdev *cdev, const void *buf, size_t count, ulong offset, ulong flags)
1028 {
1029         ulong size;
1030         struct device_d *dev;
1031
1032         if (!cdev->dev)
1033                 return -1;
1034         dev = cdev->dev;
1035
1036         size = min((ulong)count, dev->size - offset);
1037         memcpy_sz((void *)(dev->map_base + offset), buf, size, flags & O_RWSIZE_MASK);
1038         return size;
1039 }
1040 EXPORT_SYMBOL(mem_write);
1041