firmware/common/dircache.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2005 by Miika Pekkarinen
  11  *
  12  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19
  20 /* TODO:
  21    - Allow cache live updating while transparent rebuild is running.
  22 */
  23
  24 #include "config.h"
  25
  26 #include <stdio.h>
  27 #include <errno.h>
  28 #include <string.h>
  29 #include <stdbool.h>
  30 #include "debug.h"
  31 #include "atoi.h"
  32 #include "system.h"
  33 #include "logf.h"
  34 #include "dircache.h"
  35 #include "thread.h"
  36 #include "kernel.h"
  37 #include "usb.h"
  38 #include "file.h"
  39 #include "buffer.h"
  40 #if CONFIG_RTC
  41 #include "time.h"
  42 #include "timefuncs.h"
  43 #endif
  44
  45 /* Queue commands. */
  46 #define DIRCACHE_BUILD 1
  47 #define DIRCACHE_STOP  2
  48
  49 #define MAX_OPEN_DIRS 8
  50 DIR_CACHED opendirs[MAX_OPEN_DIRS];
  51
  52 static struct dircache_entry *fd_bindings[MAX_OPEN_FILES];
  53 static struct dircache_entry *dircache_root;
  54
  55 static bool dircache_initialized = false;
  56 static bool dircache_initializing = false;
  57 static bool thread_enabled = false;
  58 static unsigned long allocated_size = DIRCACHE_LIMIT;
  59 static unsigned long dircache_size = 0;
  60 static unsigned long entry_count = 0;
  61 static unsigned long reserve_used = 0;
  62 static unsigned int  cache_build_ticks = 0;
  63 static unsigned long appflags = 0;
  64 static char dircache_cur_path[MAX_PATH*2];
  65
  66 static struct event_queue dircache_queue;
  67 static long dircache_stack[(DEFAULT_STACK_SIZE + 0x900)/sizeof(long)];
  68 static const char dircache_thread_name[] = "dircache";
  69
  70 static struct fdbind_queue fdbind_cache[MAX_PENDING_BINDINGS];
  71 static int fdbind_idx = 0;
  72
  73 /* --- Internal cache structure control functions --- */
  74
  75 /**
  76  * Internal function to allocate a new dircache_entry from memory.
  77  */
  78 static struct dircache_entry* allocate_entry(void)
  79 {
  80     struct dircache_entry *next_entry;
  81
  82     if (dircache_size > allocated_size - MAX_PATH*2)
  83     {
  84         logf("size limit reached");
  85         return NULL;
  86     }
  87
  88     next_entry = (struct dircache_entry *)((char *)dircache_root+dircache_size);
  89 #ifdef ROCKBOX_STRICT_ALIGN
  90     /* Make sure the entry is long aligned. */
  91     if ((long)next_entry & 0x03)
  92     {
  93         dircache_size += 4 - ((long)next_entry & 0x03);
  94         next_entry = (struct dircache_entry *)(((long)next_entry & ~0x03) + 0x04);
  95     }
  96 #endif
  97     next_entry->name_len = 0;
  98     next_entry->d_name = NULL;
  99     next_entry->up = NULL;
 100     next_entry->down = NULL;
 101     next_entry->next = NULL;
 102
 103     dircache_size += sizeof(struct dircache_entry);
 104
 105     return next_entry;
 106 }
 107
 108 /**
 109  * Internal function to allocate a dircache_entry and set
 110  * ->next entry pointers.
 111  */
 112 static struct dircache_entry* dircache_gen_next(struct dircache_entry *ce)
 113 {
 114     struct dircache_entry *next_entry;
 115
 116     if ( (next_entry = allocate_entry()) == NULL)
 117         return NULL;
 118     next_entry->up = ce->up;
 119     ce->next = next_entry;
 120
 121     return next_entry;
 122 }
 123
 124 /*
 125  * Internal function to allocate a dircache_entry and set
 126  * ->down entry pointers.
 127  */
 128 static struct dircache_entry* dircache_gen_down(struct dircache_entry *ce)
 129 {
 130     struct dircache_entry *next_entry;
 131
 132     if ( (next_entry = allocate_entry()) == NULL)
 133         return NULL;
 134     next_entry->up = ce;
 135     ce->down = next_entry;
 136
 137     return next_entry;
 138 }
 139
 140 /* This will eat ~30 KiB of memory!
 141  * We should probably use that as additional reserve buffer in future. */
 142 #define MAX_SCAN_DEPTH 16
 143 static struct travel_data dir_recursion[MAX_SCAN_DEPTH];
 144
 145 /**
 146  * Returns true if there is an event waiting in the queue
 147  * that requires the current operation to be aborted.
 148  */
 149 static bool check_event_queue(void)
 150 {
 151     struct queue_event ev;
 152
 153     queue_wait_w_tmo(&dircache_queue, &ev, 0);
 154     switch (ev.id)
 155     {
 156         case DIRCACHE_STOP:
 157         case SYS_USB_CONNECTED:
 158             /* Put the event back into the queue. */
 159             queue_post(&dircache_queue, ev.id, ev.data);
 160             return true;
 161     }
 162
 163     return false;
 164 }
 165
 166 /**
 167  * Internal function to iterate a path.
 168  */
 169 static int dircache_scan(struct travel_data *td)
 170 {
 171 #ifdef SIMULATOR
 172     while ( ( td->entry = readdir_uncached(td->dir) ) )
 173 #else
 174     while ( (fat_getnext(td->dir, &td->entry) >= 0) && (td->entry.name[0]))
 175 #endif
 176     {
 177 #ifdef SIMULATOR
 178         if (!strcmp(".", td->entry->d_name) ||
 179              !strcmp("..", td->entry->d_name))
 180         {
 181             continue;
 182         }
 183
 184         td->ce->attribute = td->entry->attribute;
 185         td->ce->name_len = strlen(td->entry->d_name) + 1;
 186         td->ce->d_name = ((char *)dircache_root+dircache_size);
 187         td->ce->size = td->entry->size;
 188         td->ce->wrtdate = td->entry->wrtdate;
 189         td->ce->wrttime = td->entry->wrttime;
 190         memcpy(td->ce->d_name, td->entry->d_name, td->ce->name_len);
 191 #else
 192         if (!strcmp(".", td->entry.name) ||
 193              !strcmp("..", td->entry.name))
 194         {
 195             continue;
 196         }
 197
 198         td->ce->attribute = td->entry.attr;
 199         td->ce->name_len = strlen(td->entry.name) + 1;
 200         td->ce->d_name = ((char *)dircache_root+dircache_size);
 201         td->ce->startcluster = td->entry.firstcluster;
 202         td->ce->size = td->entry.filesize;
 203         td->ce->wrtdate = td->entry.wrtdate;
 204         td->ce->wrttime = td->entry.wrttime;
 205         memcpy(td->ce->d_name, td->entry.name, td->ce->name_len);
 206 #endif
 207         dircache_size += td->ce->name_len;
 208         entry_count++;
 209
 210 #ifdef SIMULATOR
 211         if (td->entry->attribute & ATTR_DIRECTORY)
 212 #else
 213         if (td->entry.attr & FAT_ATTR_DIRECTORY)
 214 #endif
 215         {
 216
 217             td->down_entry = dircache_gen_down(td->ce);
 218             if (td->down_entry == NULL)
 219                 return -2;
 220
 221             td->pathpos = strlen(dircache_cur_path);
 222             strncpy(&dircache_cur_path[td->pathpos], "/",
 223                     sizeof(dircache_cur_path) - td->pathpos - 1);
 224 #ifdef SIMULATOR
 225             strncpy(&dircache_cur_path[td->pathpos+1], td->entry->d_name,
 226                     sizeof(dircache_cur_path) - td->pathpos - 2);
 227
 228             td->newdir = opendir_uncached(dircache_cur_path);
 229             if (td->newdir == NULL)
 230             {
 231                 logf("Failed to opendir_uncached(): %s", dircache_cur_path);
 232                 return -3;
 233             }
 234 #else
 235             strncpy(&dircache_cur_path[td->pathpos+1], td->entry.name,
 236                     sizeof(dircache_cur_path) - td->pathpos - 2);
 237
 238             td->newdir = *td->dir;
 239             if (fat_opendir(IF_MV2(volume,) &td->newdir,
 240                 td->entry.firstcluster, td->dir) < 0 )
 241             {
 242                 return -3;
 243             }
 244 #endif
 245
 246             td->ce = dircache_gen_next(td->ce);
 247             if (td->ce == NULL)
 248                 return -4;
 249
 250             return 1;
 251         }
 252
 253         td->ce->down = NULL;
 254         td->ce = dircache_gen_next(td->ce);
 255         if (td->ce == NULL)
 256             return -5;
 257
 258         /* When simulator is used, it's only safe to yield here. */
 259         if (thread_enabled)
 260         {
 261             /* Stop if we got an external signal. */
 262             if (check_event_queue())
 263                 return -6;
 264             yield();
 265         }
 266
 267     }
 268
 269     return 0;
 270 }
 271
 272 /**
 273  * Recursively scan the hard disk and build the cache.
 274  */
 275 #ifdef SIMULATOR
 276 static int dircache_travel(DIR_UNCACHED *dir, struct dircache_entry *ce)
 277 #else
 278 static int dircache_travel(struct fat_dir *dir, struct dircache_entry *ce)
 279 #endif
 280 {
 281     int depth = 0;
 282     int result;
 283
 284     memset(ce, 0, sizeof(struct dircache_entry));
 285     dir_recursion[0].dir = dir;
 286     dir_recursion[0].ce = ce;
 287     dir_recursion[0].first = ce;
 288
 289     do {
 290         //logf("=> %s", dircache_cur_path);
 291         result = dircache_scan(&dir_recursion[depth]);
 292         switch (result) {
 293             case 0: /* Leaving the current directory. */
 294                 /* Add the standard . and .. entries. */
 295                 ce = dir_recursion[depth].ce;
 296                 ce->d_name = ".";
 297                 ce->name_len = 2;
 298 #ifdef SIMULATOR
 299                 closedir_uncached(dir_recursion[depth].dir);
 300                 ce->attribute = ATTR_DIRECTORY;
 301 #else
 302                 ce->attribute = FAT_ATTR_DIRECTORY;
 303                 ce->startcluster = dir_recursion[depth].dir->file.firstcluster;
 304 #endif
 305                 ce->size = 0;
 306                 ce->down = dir_recursion[depth].first;
 307
 308                 depth--;
 309                 if (depth < 0)
 310                     break ;
 311
 312                 dircache_cur_path[dir_recursion[depth].pathpos] = '\0';
 313
 314                 ce = dircache_gen_next(ce);
 315                 if (ce == NULL)
 316                 {
 317                     logf("memory allocation error");
 318                     return -3;
 319                 }
 320 #ifdef SIMULATOR
 321                 ce->attribute = ATTR_DIRECTORY;
 322 #else
 323                 ce->attribute = FAT_ATTR_DIRECTORY;
 324                 ce->startcluster = dir_recursion[depth].dir->file.firstcluster;
 325 #endif
 326                 ce->d_name = "..";
 327                 ce->name_len = 3;
 328                 ce->size = 0;
 329                 ce->down = dir_recursion[depth].first;
 330
 331                 break ;
 332
 333             case 1: /* Going down in the directory tree. */
 334                 depth++;
 335                 if (depth >= MAX_SCAN_DEPTH)
 336                 {
 337                     logf("Too deep directory structure");
 338                     return -2;
 339                 }
 340
 341 #ifdef SIMULATOR
 342                 dir_recursion[depth].dir = dir_recursion[depth-1].newdir;
 343 #else
 344                 dir_recursion[depth].dir = &dir_recursion[depth-1].newdir;
 345 #endif
 346                 dir_recursion[depth].first = dir_recursion[depth-1].down_entry;
 347                 dir_recursion[depth].ce = dir_recursion[depth-1].down_entry;
 348                 break ;
 349
 350             default:
 351                 logf("Scan failed");
 352                 logf("-> %s", dircache_cur_path);
 353                 return -1;
 354         }
 355     } while (depth >= 0) ;
 356
 357     return 0;
 358 }
 359
 360 /**
 361  * Internal function to get a pointer to dircache_entry for a given filename.
 362  *   path: Absolute path to a file or directory.
 363  *   get_before: Returns the cache pointer before the last valid entry found.
 364  *   only_directories: Match only filenames which are a directory type.
 365  */
 366 static struct dircache_entry* dircache_get_entry(const char *path,
 367         bool get_before, bool only_directories)
 368 {
 369     struct dircache_entry *cache_entry, *before;
 370     char namecopy[MAX_PATH*2];
 371     char* part;
 372     char* end;
 373
 374     strncpy(namecopy, path, sizeof(namecopy) - 1);
 375     cache_entry = dircache_root;
 376     before = NULL;
 377
 378     for ( part = strtok_r(namecopy, "/", &end); part;
 379           part = strtok_r(NULL, "/", &end)) {
 380
 381         /* scan dir for name */
 382         while (1)
 383         {
 384             if (cache_entry == NULL)
 385             {
 386                 return NULL;
 387             }
 388             else if (cache_entry->name_len == 0)
 389             {
 390                 cache_entry = cache_entry->next;
 391                 continue ;
 392             }
 393
 394             if (!strcasecmp(part, cache_entry->d_name))
 395             {
 396                 before = cache_entry;
 397                 if (cache_entry->down || only_directories)
 398                     cache_entry = cache_entry->down;
 399                 break ;
 400             }
 401
 402             cache_entry = cache_entry->next;
 403         }
 404     }
 405
 406     if (get_before)
 407         cache_entry = before;
 408
 409     return cache_entry;
 410 }
 411
 412 #ifdef HAVE_EEPROM_SETTINGS
 413 /**
 414  * Function to load the internal cache structure from disk to initialize
 415  * the dircache really fast and little disk access.
 416  */
 417 int dircache_load(void)
 418 {
 419     struct dircache_maindata maindata;
 420     int bytes_read;
 421     int fd;
 422
 423     if (dircache_initialized)
 424         return -1;
 425
 426     logf("Loading directory cache");
 427     dircache_size = 0;
 428
 429     fd = open(DIRCACHE_FILE, O_RDONLY);
 430     if (fd < 0)
 431         return -2;
 432
 433     bytes_read = read(fd, &maindata, sizeof(struct dircache_maindata));
 434     if (bytes_read != sizeof(struct dircache_maindata)
 435         || maindata.size <= 0)
 436     {
 437         logf("Dircache file header error");
 438         close(fd);
 439         remove(DIRCACHE_FILE);
 440         return -3;
 441     }
 442
 443     dircache_root = buffer_alloc(0);
 444     if ((long)maindata.root_entry != (long)dircache_root)
 445     {
 446         logf("Position missmatch");
 447         close(fd);
 448         remove(DIRCACHE_FILE);
 449         return -4;
 450     }
 451
 452     dircache_root = buffer_alloc(maindata.size + DIRCACHE_RESERVE);
 453     entry_count = maindata.entry_count;
 454     appflags = maindata.appflags;
 455     bytes_read = read(fd, dircache_root, MIN(DIRCACHE_LIMIT, maindata.size));
 456     close(fd);
 457     remove(DIRCACHE_FILE);
 458
 459     if (bytes_read != maindata.size)
 460     {
 461         logf("Dircache read failed");
 462         return -6;
 463     }
 464
 465     /* Cache successfully loaded. */
 466     dircache_size = maindata.size;
 467     allocated_size = dircache_size + DIRCACHE_RESERVE;
 468     reserve_used = 0;
 469     logf("Done, %ld KiB used", dircache_size / 1024);
 470     dircache_initialized = true;
 471     memset(fd_bindings, 0, sizeof(fd_bindings));
 472
 473     return 0;
 474 }
 475
 476 /**
 477  * Function to save the internal cache stucture to disk for fast loading
 478  * on boot.
 479  */
 480 int dircache_save(void)
 481 {
 482     struct dircache_maindata maindata;
 483     int fd;
 484     unsigned long bytes_written;
 485
 486     remove(DIRCACHE_FILE);
 487
 488     if (!dircache_initialized)
 489         return -1;
 490
 491     logf("Saving directory cache");
 492     fd = open(DIRCACHE_FILE, O_WRONLY | O_CREAT | O_TRUNC);
 493
 494     maindata.magic = DIRCACHE_MAGIC;
 495     maindata.size = dircache_size;
 496     maindata.root_entry = dircache_root;
 497     maindata.entry_count = entry_count;
 498     maindata.appflags = appflags;
 499
 500     /* Save the info structure */
 501     bytes_written = write(fd, &maindata, sizeof(struct dircache_maindata));
 502     if (bytes_written != sizeof(struct dircache_maindata))
 503     {
 504         close(fd);
 505         logf("dircache: write failed #1");
 506         return -2;
 507     }
 508
 509     /* Dump whole directory cache to disk */
 510     bytes_written = write(fd, dircache_root, dircache_size);
 511     close(fd);
 512     if (bytes_written != dircache_size)
 513     {
 514         logf("dircache: write failed #2");
 515         return -3;
 516     }
 517
 518     return 0;
 519 }
 520 #endif /* #if 0 */
 521
 522 /**
 523  * Internal function which scans the disk and creates the dircache structure.
 524  */
 525 static int dircache_do_rebuild(void)
 526 {
 527 #ifdef SIMULATOR
 528     DIR_UNCACHED *pdir;
 529 #else
 530     struct fat_dir dir, *pdir;
 531 #endif
 532     unsigned int start_tick;
 533     int i;
 534
 535     /* Measure how long it takes build the cache. */
 536     start_tick = current_tick;
 537     dircache_initializing = true;
 538     appflags = 0;
 539
 540 #ifdef SIMULATOR
 541     pdir = opendir_uncached("/");
 542     if (pdir == NULL)
 543     {
 544         logf("Failed to open rootdir");
 545         dircache_initializing = false;
 546         return -3;
 547     }
 548 #else
 549     if ( fat_opendir(IF_MV2(volume,) &dir, 0, NULL) < 0 ) {
 550         logf("Failed opening root dir");
 551         dircache_initializing = false;
 552         return -3;
 553     }
 554     pdir = &dir;
 555 #endif
 556
 557     memset(dircache_cur_path, 0, sizeof(dircache_cur_path));
 558     dircache_size = sizeof(struct dircache_entry);
 559
 560     cpu_boost(true);
 561     if (dircache_travel(pdir, dircache_root) < 0)
 562     {
 563         logf("dircache_travel failed");
 564         cpu_boost(false);
 565         dircache_size = 0;
 566         dircache_initializing = false;
 567         return -2;
 568     }
 569     cpu_boost(false);
 570
 571     logf("Done, %ld KiB used", dircache_size / 1024);
 572
 573     dircache_initialized = true;
 574     dircache_initializing = false;
 575     cache_build_ticks = current_tick - start_tick;
 576
 577     /* Initialized fd bindings. */
 578     memset(fd_bindings, 0, sizeof(fd_bindings));
 579     for (i = 0; i < fdbind_idx; i++)
 580         dircache_bind(fdbind_cache[i].fd, fdbind_cache[i].path);
 581     fdbind_idx = 0;
 582
 583     if (thread_enabled)
 584     {
 585         if (allocated_size - dircache_size < DIRCACHE_RESERVE)
 586             reserve_used = DIRCACHE_RESERVE - (allocated_size - dircache_size);
 587     }
 588     else
 589     {
 590         /* We have to long align the audiobuf to keep the buffer access fast. */
 591         audiobuf += (long)((dircache_size & ~0x03) + 0x04);
 592         audiobuf += DIRCACHE_RESERVE;
 593         allocated_size = dircache_size + DIRCACHE_RESERVE;
 594         reserve_used = 0;
 595     }
 596
 597     return 1;
 598 }
 599
 600 /**
 601  * Internal thread that controls transparent cache building.
 602  */
 603 static void dircache_thread(void)
 604 {
 605     struct queue_event ev;
 606
 607     while (1)
 608     {
 609         queue_wait(&dircache_queue, &ev);
 610
 611         switch (ev.id)
 612         {
 613             case DIRCACHE_BUILD:
 614                 thread_enabled = true;
 615                 dircache_do_rebuild();
 616                 thread_enabled = false;
 617                 break ;
 618
 619             case DIRCACHE_STOP:
 620                 logf("Stopped the rebuilding.");
 621                 dircache_initialized = false;
 622                 break ;
 623
 624 #ifndef SIMULATOR
 625             case SYS_USB_CONNECTED:
 626                 usb_acknowledge(SYS_USB_CONNECTED_ACK);
 627                 usb_wait_for_disconnect(&dircache_queue);
 628                 break ;
 629 #endif
 630         }
 631     }
 632 }
 633
 634 /**
 635  * Start scanning the disk to build the dircache.
 636  * Either transparent or non-transparent build method is used.
 637  */
 638 int dircache_build(int last_size)
 639 {
 640     if (dircache_initialized || thread_enabled)
 641         return -3;
 642
 643     logf("Building directory cache");
 644     remove(DIRCACHE_FILE);
 645
 646     /* Background build, dircache has been previously allocated */
 647     if (dircache_size > 0)
 648     {
 649         thread_enabled = true;
 650         dircache_initializing = true;
 651         queue_post(&dircache_queue, DIRCACHE_BUILD, 0);
 652         return 2;
 653     }
 654
 655     if (last_size > DIRCACHE_RESERVE && last_size < DIRCACHE_LIMIT )
 656     {
 657         allocated_size = last_size + DIRCACHE_RESERVE;
 658         dircache_root = buffer_alloc(allocated_size);
 659         thread_enabled = true;
 660
 661         /* Start a transparent rebuild. */
 662         queue_post(&dircache_queue, DIRCACHE_BUILD, 0);
 663         return 3;
 664     }
 665
 666     dircache_root = (struct dircache_entry *)(((long)audiobuf & ~0x03) + 0x04);
 667
 668     /* Start a non-transparent rebuild. */
 669     return dircache_do_rebuild();
 670 }
 671
 672 /**
 673  * Steal the allocated dircache buffer and disable dircache.
 674  */
 675 void* dircache_steal_buffer(long *size)
 676 {
 677     dircache_disable();
 678     if (dircache_size == 0)
 679     {
 680         *size = 0;
 681         return NULL;
 682     }
 683
 684     *size = dircache_size + (DIRCACHE_RESERVE-reserve_used);
 685
 686     return dircache_root;
 687 }
 688
 689 /**
 690  * Main initialization function that must be called before any other
 691  * operations within the dircache.
 692  */
 693 void dircache_init(void)
 694 {
 695     int i;
 696
 697     dircache_initialized = false;
 698     dircache_initializing = false;
 699
 700     memset(opendirs, 0, sizeof(opendirs));
 701     for (i = 0; i < MAX_OPEN_DIRS; i++)
 702     {
 703         opendirs[i].secondary_entry.d_name = buffer_alloc(MAX_PATH);
 704     }
 705
 706     queue_init(&dircache_queue, true);
 707     create_thread(dircache_thread, dircache_stack,
 708                 sizeof(dircache_stack), 0, dircache_thread_name
 709                 IF_PRIO(, PRIORITY_BACKGROUND)
 710                 IF_COP(, CPU));
 711 }
 712
 713 /**
 714  * Returns true if dircache has been initialized and is ready to be used.
 715  */
 716 bool dircache_is_enabled(void)
 717 {
 718     return dircache_initialized;
 719 }
 720
 721 /**
 722  * Returns true if dircache is being initialized.
 723  */
 724 bool dircache_is_initializing(void)
 725 {
 726     return dircache_initializing || thread_enabled;
 727 }
 728
 729 /**
 730  * Set application flags used to determine if dircache is still intact.
 731  */
 732 void dircache_set_appflag(long mask)
 733 {
 734     appflags |= mask;
 735 }
 736
 737 /**
 738  * Get application flags used to determine if dircache is still intact.
 739  */
 740 bool dircache_get_appflag(long mask)
 741 {
 742     return dircache_is_enabled() && (appflags & mask);
 743 }
 744
 745 /**
 746  * Returns the current number of entries (directories and files) in the cache.
 747  */
 748 int dircache_get_entry_count(void)
 749 {
 750     return entry_count;
 751 }
 752
 753 /**
 754  * Returns the allocated space for dircache (without reserve space).
 755  */
 756 int dircache_get_cache_size(void)
 757 {
 758     return dircache_is_enabled() ? dircache_size : 0;
 759 }
 760
 761 /**
 762  * Returns how many bytes of the reserve allocation for live cache
 763  * updates have been used.
 764  */
 765 int dircache_get_reserve_used(void)
 766 {
 767     return dircache_is_enabled() ? reserve_used : 0;
 768 }
 769
 770 /**
 771  * Returns the time in kernel ticks that took to build the cache.
 772  */
 773 int dircache_get_build_ticks(void)
 774 {
 775     return dircache_is_enabled() ? cache_build_ticks : 0;
 776 }
 777
 778 /**
 779  * Disables the dircache. Usually called on shutdown or when
 780  * accepting a usb connection.
 781  */
 782 void dircache_disable(void)
 783 {
 784     int i;
 785     bool cache_in_use;
 786
 787     if (thread_enabled)
 788         queue_post(&dircache_queue, DIRCACHE_STOP, 0);
 789
 790     while (thread_enabled)
 791         sleep(1);
 792     dircache_initialized = false;
 793
 794     logf("Waiting for cached dirs to release");
 795     do {
 796         cache_in_use = false;
 797         for (i = 0; i < MAX_OPEN_DIRS; i++) {
 798             if (!opendirs[i].regulardir && opendirs[i].busy)
 799             {
 800                 cache_in_use = true;
 801                 sleep(1);
 802                 break ;
 803             }
 804         }
 805     } while (cache_in_use) ;
 806
 807     logf("Cache released");
 808     entry_count = 0;
 809 }
 810
 811 /**
 812  * Usermode function to return dircache_entry pointer to the given path.
 813  */
 814 const struct dircache_entry *dircache_get_entry_ptr(const char *filename)
 815 {
 816     if (!dircache_initialized || filename == NULL)
 817         return NULL;
 818
 819     return dircache_get_entry(filename, false, false);
 820 }
 821
 822 /**
 823  * Function to copy the full absolute path from dircache to the given buffer
 824  * using the given dircache_entry pointer.
 825  */
 826 void dircache_copy_path(const struct dircache_entry *entry, char *buf, int size)
 827 {
 828     const struct dircache_entry *down[MAX_SCAN_DEPTH];
 829     int depth = 0;
 830
 831     if (size <= 0)
 832         return ;
 833
 834     buf[0] = '\0';
 835
 836     if (entry == NULL)
 837         return ;
 838
 839     do {
 840         down[depth] = entry;
 841         entry = entry->up;
 842         depth++;
 843     } while (entry != NULL && depth < MAX_SCAN_DEPTH);
 844
 845     while (--depth >= 0)
 846     {
 847         snprintf(buf, size, "/%s", down[depth]->d_name);
 848         buf += down[depth]->name_len; /* '/' + d_name */
 849         size -= down[depth]->name_len;
 850         if (size <= 0)
 851             break ;
 852     }
 853 }
 854
 855 /* --- Directory cache live updating functions --- */
 856 static int block_until_ready(void)
 857 {
 858     /* Block until dircache has been built. */
 859     while (!dircache_initialized && dircache_is_initializing())
 860         sleep(1);
 861
 862     if (!dircache_initialized)
 863         return -1;
 864
 865     return 0;
 866 }
 867
 868 static struct dircache_entry* dircache_new_entry(const char *path, int attribute)
 869 {
 870     struct dircache_entry *entry;
 871     char basedir[MAX_PATH*2];
 872     char *new;
 873     long last_cache_size = dircache_size;
 874
 875     strncpy(basedir, path, sizeof(basedir)-1);
 876     new = strrchr(basedir, '/');
 877     if (new == NULL)
 878     {
 879         logf("error occurred");
 880         dircache_initialized = false;
 881         return NULL;
 882     }
 883
 884     *new = '\0';
 885     new++;
 886
 887     entry = dircache_get_entry(basedir, false, true);
 888     if (entry == NULL)
 889     {
 890         logf("basedir not found!");
 891         logf("%s", basedir);
 892         dircache_initialized = false;
 893         return NULL;
 894     }
 895
 896     if (reserve_used + 2*sizeof(struct dircache_entry) + strlen(new)+1
 897         >= DIRCACHE_RESERVE)
 898     {
 899         logf("not enough space");
 900         dircache_initialized = false;
 901         return NULL;
 902     }
 903
 904     while (entry->next != NULL)
 905         entry = entry->next;
 906
 907     if (entry->name_len > 0)
 908         entry = dircache_gen_next(entry);
 909
 910     if (entry == NULL)
 911     {
 912         dircache_initialized = false;
 913         return NULL;
 914     }
 915
 916     entry->attribute = attribute;
 917     entry->name_len = MIN(254, strlen(new)) + 1;
 918     entry->d_name = ((char *)dircache_root+dircache_size);
 919     entry->startcluster = 0;
 920     entry->wrtdate = 0;
 921     entry->wrttime = 0;
 922     entry->size = 0;
 923     memcpy(entry->d_name, new, entry->name_len);
 924     dircache_size += entry->name_len;
 925
 926     if (attribute & ATTR_DIRECTORY)
 927     {
 928         logf("gen_down");
 929         dircache_gen_down(entry);
 930     }
 931
 932     reserve_used += dircache_size - last_cache_size;
 933
 934     return entry;
 935 }
 936
 937 void dircache_bind(int fd, const char *path)
 938 {
 939     struct dircache_entry *entry;
 940
 941     /* Queue requests until dircache has been built. */
 942     if (!dircache_initialized && dircache_is_initializing())
 943     {
 944         if (fdbind_idx >= MAX_PENDING_BINDINGS)
 945             return ;
 946         strncpy(fdbind_cache[fdbind_idx].path, path,
 947                 sizeof(fdbind_cache[fdbind_idx].path)-1);
 948         fdbind_cache[fdbind_idx].fd = fd;
 949         fdbind_idx++;
 950         return ;
 951     }
 952
 953     if (!dircache_initialized)
 954         return ;
 955
 956     logf("bind: %d/%s", fd, path);
 957     entry = dircache_get_entry(path, false, false);
 958     if (entry == NULL)
 959     {
 960         logf("not found!");
 961         dircache_initialized = false;
 962         return ;
 963     }
 964
 965     fd_bindings[fd] = entry;
 966 }
 967
 968 void dircache_update_filesize(int fd, long newsize, long startcluster)
 969 {
 970     if (!dircache_initialized || fd < 0)
 971         return ;
 972
 973     if (fd_bindings[fd] == NULL)
 974     {
 975         logf("dircache fd access error");
 976         dircache_initialized = false;
 977         return ;
 978     }
 979
 980     fd_bindings[fd]->size = newsize;
 981     fd_bindings[fd]->startcluster = startcluster;
 982 }
 983 void dircache_update_filetime(int fd)
 984 {
 985 #if CONFIG_RTC == 0
 986     (void)fd;
 987 #else
 988     short year;
 989     struct tm *now = get_time();
 990     if (!dircache_initialized || fd < 0)
 991         return ;
 992
 993     if (fd_bindings[fd] == NULL)
 994     {
 995         logf("dircache fd access error");
 996         dircache_initialized = false;
 997         return ;
 998     }
 999     year = now->tm_year+1900-1980;
1000     fd_bindings[fd]->wrtdate = (((year)&0x7f)<<9)           |
1001                                (((now->tm_mon+1)&0xf)<<5)   |
1002                                (((now->tm_mday)&0x1f));
1003     fd_bindings[fd]->wrttime = (((now->tm_hour)&0x1f)<<11)  |
1004                                (((now->tm_min)&0x3f)<<5)    |
1005                                (((now->tm_sec/2)&0x1f));
1006 #endif
1007 }
1008
1009 void dircache_mkdir(const char *path)
1010 { /* Test ok. */
1011     if (block_until_ready())
1012         return ;
1013
1014     logf("mkdir: %s", path);
1015     dircache_new_entry(path, ATTR_DIRECTORY);
1016 }
1017
1018 void dircache_rmdir(const char *path)
1019 { /* Test ok. */
1020     struct dircache_entry *entry;
1021
1022     if (block_until_ready())
1023         return ;
1024
1025     logf("rmdir: %s", path);
1026     entry = dircache_get_entry(path, true, true);
1027     if (entry == NULL)
1028     {
1029         logf("not found!");
1030         dircache_initialized = false;
1031         return ;
1032     }
1033
1034     entry->down = NULL;
1035     entry->name_len = 0;
1036 }
1037
1038 /* Remove a file from cache */
1039 void dircache_remove(const char *name)
1040 { /* Test ok. */
1041     struct dircache_entry *entry;
1042
1043     if (block_until_ready())
1044         return ;
1045
1046     logf("remove: %s", name);
1047
1048     entry = dircache_get_entry(name, false, false);
1049
1050     if (entry == NULL)
1051     {
1052         logf("not found!");
1053         dircache_initialized = false;
1054         return ;
1055     }
1056
1057     entry->name_len = 0;
1058 }
1059
1060 void dircache_rename(const char *oldpath, const char *newpath)
1061 { /* Test ok. */
1062     struct dircache_entry *entry, *newentry;
1063     struct dircache_entry oldentry;
1064     char absolute_path[MAX_PATH*2];
1065     char *p;
1066
1067     if (block_until_ready())
1068         return ;
1069
1070     logf("rename: %s->%s", oldpath, newpath);
1071
1072     entry = dircache_get_entry(oldpath, true, false);
1073     if (entry == NULL)
1074     {
1075         logf("not found!");
1076         dircache_initialized = false;
1077         return ;
1078     }
1079
1080     /* Delete the old entry. */
1081     entry->name_len = 0;
1082
1083     /** If we rename the same filename twice in a row, we need to
1084      * save the data, because the entry will be re-used. */
1085     oldentry = *entry;
1086
1087     /* Generate the absolute path for destination if necessary. */
1088     if (newpath[0] != '/')
1089     {
1090         strncpy(absolute_path, oldpath, sizeof(absolute_path)-1);
1091         p = strrchr(absolute_path, '/');
1092         if (!p)
1093         {
1094             logf("Invalid path");
1095             dircache_initialized = false;
1096             return ;
1097         }
1098
1099         *p = '\0';
1100         strncpy(p, absolute_path, sizeof(absolute_path)-1-strlen(p));
1101         newpath = absolute_path;
1102     }
1103
1104     newentry = dircache_new_entry(newpath, entry->attribute);
1105     if (newentry == NULL)
1106     {
1107         dircache_initialized = false;
1108         return ;
1109     }
1110
1111     newentry->down = oldentry.down;
1112     newentry->size = oldentry.size;
1113     newentry->startcluster = oldentry.startcluster;
1114     newentry->wrttime = oldentry.wrttime;
1115     newentry->wrtdate = oldentry.wrtdate;
1116 }
1117
1118 void dircache_add_file(const char *path, long startcluster)
1119 {
1120     struct dircache_entry *entry;
1121
1122     if (block_until_ready())
1123         return ;
1124
1125     logf("add file: %s", path);
1126     entry = dircache_new_entry(path, 0);
1127     if (entry == NULL)
1128         return ;
1129
1130     entry->startcluster = startcluster;
1131 }
1132
1133 DIR_CACHED* opendir_cached(const char* name)
1134 {
1135     struct dircache_entry *cache_entry;
1136     int dd;
1137     DIR_CACHED* pdir = opendirs;
1138
1139     if ( name[0] != '/' )
1140     {
1141         DEBUGF("Only absolute paths supported right now\n");
1142         return NULL;
1143     }
1144
1145     /* find a free dir descriptor */
1146     for ( dd=0; dd<MAX_OPEN_DIRS; dd++, pdir++)
1147         if ( !pdir->busy )
1148             break;
1149
1150     if ( dd == MAX_OPEN_DIRS )
1151     {
1152         DEBUGF("Too many dirs open\n");
1153         errno = EMFILE;
1154         return NULL;
1155     }
1156
1157     if (!dircache_initialized)
1158     {
1159         pdir->regulardir = opendir_uncached(name);
1160         if (!pdir->regulardir)
1161             return NULL;
1162
1163         pdir->busy = true;
1164         return pdir;
1165     }
1166
1167     pdir->busy = true;
1168     pdir->regulardir = NULL;
1169     cache_entry = dircache_get_entry(name, false, true);
1170     pdir->entry = cache_entry;
1171
1172     if (cache_entry == NULL)
1173     {
1174         pdir->busy = false;
1175         return NULL;
1176     }
1177
1178     return pdir;
1179 }
1180
1181 struct dircache_entry* readdir_cached(DIR_CACHED* dir)
1182 {
1183     struct dirent_uncached *regentry;
1184     struct dircache_entry *ce;
1185
1186     if (!dir->busy)
1187         return NULL;
1188
1189     if (dir->regulardir != NULL)
1190     {
1191         regentry = readdir_uncached(dir->regulardir);
1192         if (regentry == NULL)
1193             return NULL;
1194
1195         strncpy(dir->secondary_entry.d_name, regentry->d_name, MAX_PATH-1);
1196         dir->secondary_entry.size = regentry->size;
1197         dir->secondary_entry.startcluster = regentry->startcluster;
1198         dir->secondary_entry.attribute = regentry->attribute;
1199         dir->secondary_entry.wrttime = regentry->wrttime;
1200         dir->secondary_entry.wrtdate = regentry->wrtdate;
1201         dir->secondary_entry.next = NULL;
1202
1203         return &dir->secondary_entry;
1204     }
1205
1206     do {
1207         if (dir->entry == NULL)
1208             return NULL;
1209
1210         ce = dir->entry;
1211         if (ce->name_len == 0)
1212             dir->entry = ce->next;
1213     } while (ce->name_len == 0) ;
1214
1215     dir->entry = ce->next;
1216
1217     strncpy(dir->secondary_entry.d_name, ce->d_name, MAX_PATH-1);
1218     /* Can't do `dir->secondary_entry = *ce`
1219        because that modifies the d_name pointer. */
1220     dir->secondary_entry.size = ce->size;
1221     dir->secondary_entry.startcluster = ce->startcluster;
1222     dir->secondary_entry.attribute = ce->attribute;
1223     dir->secondary_entry.wrttime = ce->wrttime;
1224     dir->secondary_entry.wrtdate = ce->wrtdate;
1225     dir->secondary_entry.next = NULL;
1226     dir->internal_entry = ce;
1227
1228     //logf("-> %s", ce->name);
1229     return &dir->secondary_entry;
1230 }
1231
1232 int closedir_cached(DIR_CACHED* dir)
1233 {
1234     if (!dir->busy)
1235         return -1;
1236
1237     dir->busy=false;
1238     if (dir->regulardir != NULL)
1239         return closedir_uncached(dir->regulardir);
1240
1241     return 0;
1242 }
1243
1244 int mkdir_cached(const char *name)
1245 {
1246     int rc=mkdir_uncached(name);
1247     if (rc >= 0)
1248         dircache_mkdir(name);
1249     return(rc);
1250 }
1251
1252 int rmdir_cached(const char* name)
1253 {
1254     int rc=rmdir_uncached(name);
1255     if(rc>=0)
1256         dircache_rmdir(name);
1257     return(rc);
1258 }