system/modules/cdi/fs.c

   1 /*
   2 Copyright (C) 2008  Mathias Gottschlag
   3
   4 Permission is hereby granted, free of charge, to any person obtaining a copy of
   5 this software and associated documentation files (the "Software"), to deal in the
   6 Software without restriction, including without limitation the rights to use,
   7 copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
   8 Software, and to permit persons to whom the Software is furnished to do so,
   9 subject to the following conditions:
  10
  11 The above copyright notice and this permission notice shall be included in all
  12 copies or substantial portions of the Software.
  13
  14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
  15 INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  16 PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  17 HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  18 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  19 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  20 */
  21
  22 #include <cdi/fs.h>
  23 #include <ke/debug.h>
  24 #include <ke/errors.h>
  25 #include <ke/spinlock.h>
  26 #include <fs/request.h>
  27 #include <fs/fs.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30
  31 struct file_system_driver
  32 {
  33         FsFileSystemDriver driver;
  34         struct cdi_fs_driver *cdidriver;
  35         cdi_list_t filesystems;
  36 };
  37 static cdi_list_t fsdrivers = 0;
  38
  39 struct file_system
  40 {
  41         FsFileSystem fs;
  42         struct cdi_fs_filesystem cdifs;
  43 };
  44
  45 struct file
  46 {
  47         FsFile file;
  48         struct cdi_fs_res *res;
  49         int type;
  50         cdi_list_t dirlist;
  51         uint32_t mode;
  52 };
  53
  54 #define FILE_TYPE_FILE 0
  55 #define FILE_TYPE_DIR 1
  56
  57 KeSpinlock request_lock;
  58
  59 /*static void cdi_fs_check_filesystem_part(struct cdi_fs_filesystem *fs, struct cdi_fs_res *top, char *msg)
  60 {
  61         struct cdi_fs_res *res = top;
  62         struct cdi_fs_stream stream;
  63         stream.fs = fs;
  64         stream.res = res;
  65         stream.error = 0;
  66         // Loop through children
  67         if (!stream.res->loaded) stream.res->res->load(&stream);
  68         uint32_t i;
  69         for (i = 0; i < cdi_list_size(res->children); i++)
  70         {
  71                 struct cdi_fs_res *child = cdi_list_get(res->children, i);
  72                 if (child->name < 0xC0000000)
  73                 {
  74                         kePrint("%s Child of %s invalid: %x\n", msg, res->name, child->name);
  75                         kePanic(0, 10);
  76                 }
  77                 cdi_fs_check_filesystem_part(fs, child, msg);
  78         }
  79 }
  80 static void cdi_fs_check_filesystem(struct cdi_fs_filesystem *fs, char *msg)
  81 {
  82         cdi_fs_check_filesystem_part(fs, fs->root_res, msg);
  83 }*/
  84
  85 static struct cdi_fs_res *cdi_fs_get_file(struct cdi_fs_filesystem *fs, char *path)
  86 {
  87         char *tmppath = strdup(path);
  88         char *currentpath = tmppath;
  89         struct cdi_fs_res *res = fs->root_res;
  90         struct cdi_fs_stream stream;
  91         stream.fs = fs;
  92         stream.res = res;
  93         stream.error = 0;
  94         // Loop through parts of the path
  95         do
  96         {
  97                 char *nextpath = strchr(currentpath, '/');
  98                 if (nextpath)
  99                 {
 100                         *nextpath = 0;
 101                         nextpath++;
 102                 }
 103                 if (!stream.res->loaded) stream.res->res->load(&stream);
 104                 uint32_t i;
 105                 uint32_t found = 0;
 106                 for (i = 0; i < cdi_list_size(res->children); i++)
 107                 {
 108                         struct cdi_fs_res *child = cdi_list_get(res->children, i);
 109                         if (!strcmp(currentpath, child->name))
 110                         {
 111                                 res = child;
 112                                 stream.res = child;
 113                                 currentpath = nextpath;
 114                                 found = 1;
 115                                 break;
 116                         }
 117                 }
 118                 if (!found) return 0;
 119         }
 120         while (currentpath);
 121         return res;
 122 }
 123
 124 static int cdi_fs_open(struct FsFileSystem *fs, struct FsRequest *request)
 125 {
 126         struct cdi_fs_filesystem *cdifs = &((struct file_system*)fs)->cdifs;
 127         char *path = strdup(request->buffer);
 128         // Get file
 129         struct cdi_fs_res *res = 0;
 130         struct cdi_fs_stream stream;
 131         stream.fs = cdifs;
 132         stream.error = 0;
 133
 134         char *filename = 0;
 135         // Get parent directory
 136         if (strrchr(path, '/'))
 137         {
 138                 filename = strrchr(path, '/') + 1;
 139                 *strrchr(path, '/') = 0;
 140                 res = cdi_fs_get_file(cdifs, path);
 141                 if (!res)
 142                 {
 143                         free(path);
 144                         return -1;
 145                 }
 146                 stream.res = res;
 147         }
 148         else
 149         {
 150                 filename = path;
 151                 res = cdifs->root_res;
 152                 stream.res = res;
 153         }
 154
 155         if (!stream.res->loaded) stream.res->res->load(&stream);
 156         if (strcmp(filename, ""))
 157         {
 158                 // Look for file in directory
 159                 uint32_t found = 0;
 160                 uint32_t i;
 161                 for (i = 0; i < cdi_list_size(res->children); i++)
 162                 {
 163                         struct cdi_fs_res *child = cdi_list_get(res->children, i);
 164                         if (!strcmp(filename, child->name))
 165                         {
 166                                 found = 1;
 167                                 res = child;
 168                                 if (!res->loaded) res->res->load(&stream);
 169                                 break;
 170                         }
 171                 }
 172                 if (!found)
 173                 {
 174                         if (request->flags & FS_OPEN_CREATE)
 175                         {
 176                                 kePrint("Creating file %s.\n", filename);
 177                                 stream.res = 0;
 178                                 // Create file
 179                                 res->dir->create_child(&stream, filename, res);
 180                                 if (!stream.res->loaded) stream.res->res->load(&stream);
 181                                 stream.res->res->assign_class(&stream, CDI_FS_CLASS_FILE);
 182                                 res = stream.res;
 183                         }
 184                         else
 185                         {
 186                                 kePrint("cdi_fs: File not found.\n");
 187                                 free(path);
 188                                 return -1;
 189                         }
 190                 }
 191         }
 192         // Fill file structure
 193         struct file *file = malloc(sizeof(struct file));
 194         memset(file, 0, sizeof(struct file));
 195         file->res = res;
 196         if (res->dir)
 197                 file->type = FILE_TYPE_DIR;
 198         else
 199                 file->type = FILE_TYPE_FILE;
 200         file->file.fs = fs;
 201         file->mode = request->flags;
 202         cdifs->files = cdi_list_push(cdifs->files, file);
 203         free(path);
 204         request->file = &file->file;
 205         return 0;
 206 }
 207 static int cdi_fs_close(struct FsFileSystem *fs, struct FsRequest *request)
 208 {
 209         struct cdi_fs_filesystem *cdifs = &((struct file_system*)fs)->cdifs;
 210         // Find file
 211         uint32_t i;
 212         for (i = 0; i < cdi_list_size(cdifs->files); i++)
 213         {
 214                 struct file *file = cdi_list_get(cdifs->files, i);
 215                 if (&file->file == request->file)
 216                 {
 217                         // Close resource and delete file
 218                         struct cdi_fs_stream stream;
 219                         stream.res = file->res;
 220                         stream.fs = cdifs;
 221                         stream.error = 0;
 222                         // FIXME: The file might be opened twice, or there are children opened
 223                         //file->res->res->unload(&stream);
 224                         //if (file->dirlist) cdi_list_destroy(file->dirlist);
 225                         free(file);
 226                         cdi_list_remove(cdifs->files, i);
 227                         return 0;
 228                 }
 229         }
 230         return -1;
 231 }
 232 static int cdi_fs_mknod(struct FsFileSystem *fs, struct FsRequest *request)
 233 {
 234         struct cdi_fs_filesystem *cdifs = &((struct file_system*)fs)->cdifs;
 235         char *path = strdup(request->buffer);
 236         // Get file
 237         struct cdi_fs_res *res = 0;
 238         struct cdi_fs_stream stream;
 239         stream.fs = cdifs;
 240         stream.error = 0;
 241
 242         char *filename = 0;
 243         // Get parent directory
 244         if (strrchr(path, '/'))
 245         {
 246                 filename = strrchr(path, '/') + 1;
 247                 *strrchr(path, '/') = 0;
 248                 res = cdi_fs_get_file(cdifs, path);
 249                 if (!res)
 250                 {
 251                         free(path);
 252                         return -1;
 253                 }
 254                 stream.res = res;
 255         }
 256         else
 257         {
 258                 filename = path;
 259                 res = cdifs->root_res;
 260                 stream.res = res;
 261         }
 262
 263         if (!stream.res->loaded) stream.res->res->load(&stream);
 264         if (strcmp(filename, ""))
 265         {
 266                 // Look for file in directory
 267                 uint32_t found = 0;
 268                 uint32_t i;
 269                 for (i = 0; i < cdi_list_size(res->children); i++)
 270                 {
 271                         struct cdi_fs_res *child = cdi_list_get(res->children, i);
 272                         if (!strcmp(filename, child->name))
 273                         {
 274                                 return -1;
 275                         }
 276                 }
 277                 if (!found)
 278                 {
 279                         kePrint("Creating file %s.\n", filename);
 280                         stream.res = 0;
 281                         // Create file
 282                         res->dir->create_child(&stream, filename, res);
 283                         if (!stream.res->loaded) stream.res->res->load(&stream);
 284                         if (request->flags == FS_MKNOD_FILE)
 285                                 stream.res->res->assign_class(&stream, CDI_FS_CLASS_FILE);
 286                         else if (request->flags == FS_MKNOD_DIR)
 287                                 stream.res->res->assign_class(&stream, CDI_FS_CLASS_DIR);
 288                         else
 289                                 return -1;
 290                         return 0;
 291                 }
 292         }
 293         return -1;
 294 }
 295
 296 static int cdi_fs_read(struct FsFileSystem *fs, struct FsRequest *request)
 297 {
 298         struct cdi_fs_filesystem *cdifs = &((struct file_system*)fs)->cdifs;
 299         struct file *file = (struct file*)request->file;
 300         if (file->type == FILE_TYPE_FILE)
 301         {
 302                 if (!(file->mode & FS_OPEN_READ)) return -1;
 303                 // Read data from file
 304                 struct cdi_fs_stream stream;
 305                 stream.res = file->res;
 306                 stream.fs = cdifs;
 307                 stream.error = 0;
 308                 if (!file->res->file->read) return -1;
 309                 ssize_t ret = file->res->file->read(&stream, request->offset,
 310                         request->bufferlength, request->buffer);
 311                 if (ret <= 0)
 312                 {
 313                         if ((stream.error == CDI_FS_ERROR_EOF) || (stream.error == 0))
 314                                 return 0;
 315                         else
 316                                 return -1;
 317                 }
 318                 return ret;
 319         }
 320         else
 321         {
 322                 struct cdi_fs_stream stream;
 323                 stream.res = file->res;
 324                 stream.fs = cdifs;
 325                 stream.error = 0;
 326                 if (request->bufferlength < 1) return -1;
 327                 if (!file->dirlist)
 328                 {
 329                         if (file->res->dir == 0) return -1;
 330                         file->dirlist = file->res->dir->list(&stream);
 331                 }
 332                 if (request->offset < 2)
 333                 {
 334                         strncpy(request->buffer, request->offset?"..":".", request->bufferlength);
 335                         return 1;
 336                 }
 337                 struct cdi_fs_res *child = cdi_list_get(file->dirlist, request->offset - 2);
 338                 if (child)
 339                 {
 340                         strncpy(request->buffer, child->name, request->bufferlength);
 341                         return 1;
 342                 }
 343                 else return 0;
 344         }
 345 }
 346 static int cdi_fs_write(struct FsFileSystem *fs, struct FsRequest *request)
 347 {
 348         struct cdi_fs_filesystem *cdifs = &((struct file_system*)fs)->cdifs;
 349         struct file *file = (struct file*)request->file;
 350         if (file->type != FILE_TYPE_FILE) return -1;
 351         if (!(file->mode & FS_OPEN_WRITE)) return -1;
 352         // Write data to file
 353         struct cdi_fs_stream stream;
 354         stream.res = file->res;
 355         stream.fs = cdifs;
 356         stream.error = 0;
 357         if (!file->res->file->write) return -1;
 358         ssize_t ret = file->res->file->write(&stream, request->offset,
 359                 request->bufferlength, request->buffer);
 360         if (ret == 0)
 361         {
 362                 return -1;
 363         }
 364         return ret;
 365 }
 366 static int cdi_fs_seek(struct FsFileSystem *fs, struct FsRequest *request)
 367 {
 368         struct cdi_fs_filesystem *cdifs = &((struct file_system*)fs)->cdifs;
 369         struct file *file = (struct file*)request->file;
 370         // Get file size
 371         struct cdi_fs_stream stream;
 372         stream.res = file->res;
 373         stream.fs = cdifs;
 374         stream.error = 0;
 375         if (file->type == FILE_TYPE_FILE)
 376         {
 377                 int64_t size = file->res->res->meta_read(&stream, CDI_FS_META_SIZE);
 378                 // TODO: These casts to int are broken
 379                 switch (request->whence)
 380                 {
 381                         case 0:
 382                                 if ((int)request->offset > size)
 383                                         request->offset = size;
 384                                 if ((int)request->offset < 0)
 385                                         request->offset = 0;
 386                                 return 0;
 387                         case 1:
 388                                 if ((int)request->offset > size)
 389                                         request->offset = size;
 390                                 if ((int)request->offset < 0)
 391                                         request->offset = 0;
 392                                 return 0;
 393                         case 2:
 394                                 if ((int)request->offset > 0)
 395                                         request->offset = 0;
 396                                 if ((int)request->offset < -size)
 397                                         request->offset = -size;
 398                                 request->offset = (int)request->offset + size;
 399                                 return 0;
 400                         default:
 401                                 request->offset = 0;
 402                                 return -1;
 403                 }
 404         }
 405         else
 406         {
 407                 int64_t size = cdi_list_size(file->dirlist) + 2;
 408                 // TODO: These casts to int are broken
 409                 switch (request->whence)
 410                 {
 411                         case 0:
 412                                 if ((int)request->offset > size)
 413                                         request->offset = size;
 414                                 if ((int)request->offset < 0)
 415                                         request->offset = 0;
 416                                 return 0;
 417                         case 1:
 418                                 if ((int)request->offset > size)
 419                                         request->offset = size;
 420                                 if ((int)request->offset < 0)
 421                                         request->offset = 0;
 422                                 return 0;
 423                         case 2:
 424                                 if ((int)request->offset > 0)
 425                                         request->offset = 0;
 426                                 if ((int)request->offset < -size)
 427                                         request->offset = -size;
 428                                 request->offset = (int)request->offset + size;
 429                                 return 0;
 430                         default:
 431                                 request->offset = 0;
 432                                 return -1;
 433                 }
 434         }
 435 }
 436
 437 static int cdi_fs_unmount(struct FsFileSystem *fs)
 438 {
 439         // TODO
 440         return KE_ERROR_UNKNOWN;
 441 }
 442 static int cdi_fs_request(struct FsFileSystem *fs, struct FsRequest *request)
 443 {
 444         if (!request) return -1;
 445         keLockSpinlock(&request_lock);
 446         switch (request->type)
 447         {
 448                 case FS_REQUEST_OPEN:
 449                         request->return_value = cdi_fs_open(fs, request);
 450                         keUnlockSpinlock(&request_lock);
 451                         fsFinishRequest(request);
 452                         return 0;
 453                 case FS_REQUEST_CLOSE:
 454                         request->return_value = cdi_fs_close(fs, request);
 455                         keUnlockSpinlock(&request_lock);
 456                         fsFinishRequest(request);
 457                         return 0;
 458                 case FS_REQUEST_MKNOD:
 459                         request->return_value = cdi_fs_mknod(fs, request);
 460                         keUnlockSpinlock(&request_lock);
 461                         fsFinishRequest(request);
 462                         return 0;
 463                 case FS_REQUEST_READ:
 464                         request->return_value = cdi_fs_read(fs, request);
 465                         keUnlockSpinlock(&request_lock);
 466                         fsFinishRequest(request);
 467                         return 0;
 468                 case FS_REQUEST_WRITE:
 469                         request->return_value = cdi_fs_write(fs, request);
 470                         keUnlockSpinlock(&request_lock);
 471                         fsFinishRequest(request);
 472                         return 0;
 473                 case FS_REQUEST_SEEK:
 474                         request->return_value = cdi_fs_seek(fs, request);
 475                         keUnlockSpinlock(&request_lock);
 476                         fsFinishRequest(request);
 477                         return 0;
 478                 default:
 479                         keUnlockSpinlock(&request_lock);
 480                         return KE_ERROR_UNKNOWN;
 481         }
 482 }
 483
 484 static FsFileSystem *cdi_fs_mount(FsFileSystemDriver *driver, const char *path,
 485         const char *device, uint32_t flags)
 486 {
 487         struct file_system_driver *fsdrv = (struct file_system_driver*)driver;
 488         // Create file system
 489         struct file_system *fs = malloc(sizeof(struct file_system));
 490         memset(fs, 0, sizeof(struct file_system));
 491         fs->cdifs.driver = fsdrv->cdidriver;
 492         fs->cdifs.files = cdi_list_create();
 493         fs->fs.path = strdup(path);
 494         fs->fs.unmount = cdi_fs_unmount;
 495         fs->fs.query_request = cdi_fs_request;
 496         if (device && strcmp(device, ""))
 497         {
 498                 // Open source device
 499                 fs->fs.device = fsOpen(device, 0);
 500                 if (!fs->fs.device)
 501                 {
 502                         free(fs->fs.path);
 503                         free(fs);
 504                         return 0;
 505                 }
 506                 fs->cdifs.data = fs->fs.device;
 507         }
 508         // Initialize file system
 509         if (fsdrv->cdidriver->fs_init(&fs->cdifs))
 510         {
 511                 fsdrv->filesystems = cdi_list_push(fsdrv->filesystems, fs);
 512         }
 513         else
 514         {
 515                 free(fs->fs.path);
 516                 free(fs);
 517                 return 0;
 518         }
 519         return &fs->fs;
 520 }
 521
 522 void cdi_fs_driver_init(struct cdi_fs_driver *driver)
 523 {
 524         cdi_driver_init(&driver->drv);
 525 }
 526 void cdi_fs_driver_destroy(struct cdi_fs_driver *driver)
 527 {
 528         cdi_driver_destroy(&driver->drv);
 529 }
 530 void cdi_fs_driver_register(struct cdi_fs_driver *driver)
 531 {
 532         cdi_driver_register(&driver->drv);
 533         kePrint("File system: %s\n", driver->drv.name);
 534         struct file_system_driver *fsdrv = malloc(sizeof(struct file_system_driver));
 535         memset(fsdrv, 0, sizeof(struct file_system_driver));
 536         fsdrv->cdidriver = driver;
 537         fsdrv->driver.mount = cdi_fs_mount;
 538         fsdrv->filesystems = cdi_list_create();
 539         if (!fsdrivers) fsdrivers = cdi_list_create();
 540         fsdrivers = cdi_list_push(fsdrivers, driver);
 541         fsRegisterDriver(&fsdrv->driver, driver->drv.name);
 542 }
 543
 544
 545 size_t cdi_fs_data_read(struct cdi_fs_filesystem *fs, uint64_t start,
 546         size_t size, void *buffer)
 547 {
 548         if (!fs->data) return 0;
 549         fsSeek(fs->data, start, 0);
 550         int read = fsRead(fs->data, buffer, size, 1);
 551         return read;
 552 }
 553
 554 size_t cdi_fs_data_write(struct cdi_fs_filesystem* fs, uint64_t start,
 555         size_t size, const void* buffer)
 556 {
 557         if (!fs->data) return 0;
 558         fsSeek(fs->data, start, 0);
 559         int written = fsWrite(fs->data, (void*)buffer, size);
 560         return written;
 561 }
 562