int32 TFFS_umount( IN tffs_handle_t htffs) { tffs_t * ptffs; int32 ret; if (!htffs) return ERR_TFFS_INVALID_PARAM; ptffs = (tffs_t *)htffs; ret = TFFS_OK; if (ptffs->pbs) free(ptffs->pbs); if (ptffs->pfat) fat_destroy(ptffs->pfat); if (ptffs->root_dir) dir_destroy(ptffs->root_dir); if (ptffs->cur_dir) dir_destroy(ptffs->cur_dir); if (ptffs->pcache) ret = _cache_destroy(ptffs->pcache); if (ret > 0 && (HAI_closedevice(ptffs->hdev) != HAI_OK)) ret = ERR_TFFS_DEVICE_FAIL; free(ptffs); return ret; }
static gboolean cache_clean_foreach(const gchar* key, Dir* dir, CleanData* cd) { GTime last_access; last_access = dir_get_last_access(dir); if ((cd->now - last_access) >= cd->length) { if (!dir_sync_pending(dir)) { dir_destroy(dir); return TRUE; } else { gconf_log(GCL_WARNING, _("Unable to remove directory `%s' from the XML backend cache, because it has not been successfully synced to disk"), dir_get_name(dir)); return FALSE; } } else return FALSE; }
int32 TFFS_fclose( IN tfile_handle_t hfile) { int32 ret; tfile_t * pfile = (tfile_t *)hfile; if (!hfile) return ERR_TFFS_INVALID_PARAM; ret = TFFS_OK; if (file_write_sector(pfile) != FILE_OK) { ret = ERR_TFFS_DEVICE_FAIL; } dirent_set_file_size(pfile->pdir_entry, pfile->file_size); if (dir_update_direntry(pfile->pdir, pfile->pdir_entry) != DIR_OK) { ret = ERR_TFFS_DEVICE_FAIL; } dir_destroy(pfile->pdir); dirent_release(pfile->pdir_entry); Free(pfile->secbuf); Free(pfile); return ret; }
static void cache_destroy_foreach(const gchar* key, Dir* dir, gpointer data) { #ifdef GCONF_ENABLE_DEBUG if (dir_sync_pending (dir)) gconf_log(GCL_DEBUG, "Destroying a directory (%s) with sync still pending", dir_get_name (dir)); #endif dir_destroy (dir); }
void dir_destroy_all(void) { vector_clear(active_dirs); List *dir = root_dir.list.next; while(dir != NULL) { List* t = dir->next; // FIXME: use container dir_destroy((Dir*)dir); dir = t; } //fprintf(stderr, "Destroying dir %s\n", root_path); int res = rmdir(root_path); if (res != 0 && errno != ENOENT) { perror(root_path); } }
static void cache_sync_foreach (Dir *dir, SyncData *sd) { GError* error = NULL; gboolean deleted; deleted = FALSE; /* log errors but don't report the specific ones */ if (!dir_sync (dir, &deleted, &error)) { sd->failed = TRUE; g_return_if_fail (error != NULL); gconf_log (GCL_ERR, "%s", error->message); g_error_free (error); g_return_if_fail (dir_sync_pending (dir)); } else { g_return_if_fail (error == NULL); g_return_if_fail (!dir_sync_pending (dir)); if (deleted) { /* Get rid of this directory */ cache_remove_from_parent (sd->dc, dir); g_hash_table_remove (sd->dc->cache, dir_get_name (dir)); cache_set_nonexistent (sd->dc, dir_get_name (dir), TRUE); dir_destroy (dir); sd->deleted_some = TRUE; } } }
int32 /* Start of GurumNetworks modification TFFS_mount( IN FileSystemDriver* driver, OUT tffs_handle_t * phtffs) End of GurumNetworks modification*/ TFFS_mount( IN FileSystemDriver* driver, int first_lba) { int32 ret; tffs_t * tffs; boot_sector_t * pbs = NULL; DiskDriver* disk_driver = driver->driver; tdir_t * proot_dir = NULL; tdir_t * pcur_dir = NULL; tfat_t * pfat = NULL; uint32 rootdir_clus; void* read_buf = NULL; void* fat = NULL; /* Start of GurumNetworks modification tdev_handle_t hdev; tcache_t * pcache = NULL; End of GurumNetworks modification */ /* Start of GurumNetworks modification if (!dev || !phtffs) return ERR_TFFS_INVALID_PARAM; End of GurumNetworks modification */ ret = TFFS_OK; tffs = (tffs_t *)malloc(sizeof(tffs_t)); memset(tffs, 0, sizeof(tffs_t)); pbs = (boot_sector_t *)gmalloc(sizeof(boot_sector_t)); memset(pbs, 0, sizeof(boot_sector_t)); #ifdef _KERNEL_ ASSERT(sizeof(boot_sector_t) == 512); #endif /* Start of GurumNetworks modification hdev = HAI_initdevice(dev, 512); if (hdev == NULL) { ret = ERR_TFFS_DEVICE_FAIL; goto _release; } tffs->hdev = hdev; if (HAI_readsector(hdev, 0, (ubyte *)pbs) != HAI_OK) { ret = ERR_TFFS_DEVICE_FAIL; goto _release; } End of GurumNetworks modification */ tffs->driver = driver; tffs->first_lba = first_lba; if(disk_driver->read(disk_driver, tffs->first_lba, 1, (void*)pbs) < 0) goto _release; tffs->pbs = pbs; if (!_validate_bs(pbs)) { ret = ERR_TFFS_BAD_BOOTSECTOR; goto _release; } _parse_boot_sector(pbs, tffs); DBG("tffs->fat_type:%d\n", tffs->fat_type); DBG("tffs->sec_fat:%d\n", tffs->sec_fat); DBG("tffs->sec_root_dir:%d\n", tffs->sec_root_dir); DBG("tffs->sec_first_data:%d\n", tffs->sec_first_data); if ((pfat = fat_init(tffs)) == NULL) { ret = ERR_TFFS_BAD_FAT; goto _release; } tffs->pfat = pfat; /* Start of GurumNetworks modification if ((pcache = cache_init(hdev, 32, tffs->pbs->byts_per_sec)) == NULL) { WARN("TFFS: cache is disable.\n"); pcache = cache_init(hdev, 0, tffs->pbs->byts_per_sec); } tffs->pcache = pcache; End of GurumNetworks modification */ rootdir_clus = tffs->fat_type == FT_FAT32 ? tffs->pbs->bh32.root_clus : ROOT_DIR_CLUS_FAT16; if (dir_init_by_clus(tffs, rootdir_clus, &proot_dir) != DIR_OK || dir_init_by_clus(tffs, rootdir_clus, &pcur_dir) != DIR_OK) { ret = ERR_TFFS_DEVICE_FAIL; goto _release; } tffs->root_dir = proot_dir; tffs->cur_dir = pcur_dir; /* Start of GurumNetworks modification *phtffs = (tffs_handle_t)tffs; End of GurumNetworks modification */ int i = 0; size_t read_size = 0; size_t fat_size = tffs->fatsz * pbs->byts_per_sec; read_buf = gmalloc(FS_BLOCK_SIZE); fat = bmalloc(); while(read_size < fat_size) { #define MIN(x, y) (((x) < (y)) ? (x) : (y)) if(disk_driver->read(disk_driver, tffs->sec_fat + i * FS_SECTOR_PER_BLOCK, FS_SECTOR_PER_BLOCK, read_buf) < 0) { ret = -99; // TODO: errno for fat error goto _release; } size_t copy_size = MIN(fat_size - read_size, FS_BLOCK_SIZE); memcpy((uint8_t*)fat + read_size, read_buf, copy_size); read_size += copy_size; i++; } tffs->fat = fat; DBG("tffs->fat:%p\n", tffs->fat); DBG("tffs->fat size:%d\n", tffs->fatsz); DBG("Tiny FAT file system mount OK.\n"); driver->priv = tffs; gfree(read_buf); return ret; _release: if (pfat) fat_destroy(pfat); if (proot_dir) dir_destroy(proot_dir); if (pcur_dir) dir_destroy(pcur_dir); if (HAI_closedevice(tffs->hdev) != HAI_OK) ret = ERR_TFFS_DEVICE_FAIL; if(read_buf) gfree(read_buf); if(fat) free(fat); free(pbs); free(tffs); return ret; }
int32 TFFS_rmfile( IN tffs_handle_t hfs, IN byte * file_path) { int32 ret; byte * fname, * path; byte * dup_file_path; tdir_t * pdir; tffs_t * ptffs; tdir_entry_t * pdir_entry; ret = TFFS_OK; if (!hfs || !file_path) return ERR_TFFS_INVALID_PARAM; ptffs = (tffs_t *)hfs; dup_file_path = dup_string(file_path); fname = (byte *)Malloc(DNAME_MAX); pdir_entry = dirent_malloc(); path = dup_file_path; if (!divide_path(dup_file_path, fname)) { ret = ERR_TFFS_INVALID_PATH; goto _release; } if ((dir_init(ptffs, path, &pdir)) != DIR_OK) { ret = ERR_TFFS_INVALID_PATH; goto _release; } if ((ret = dirent_find(pdir, fname, pdir_entry)) == DIRENTRY_OK) { if (dirent_get_dir_attr(pdir_entry) & ATTR_DIRECTORY) { ret = ERR_TFFS_IS_NOT_A_FILE; goto _release; } if (dir_del_direntry(pdir, fname) != DIR_OK) { ret = ERR_TFFS_REMOVE_FILE_FAIL; goto _release; } if (fat_free_clus(pdir->ptffs->pfat, dirent_get_clus(pdir_entry)) != FAT_OK) { ret = ERR_TFFS_REMOVE_FILE_FAIL; goto _release; } ret = TFFS_OK; } else { ret = ERR_TFFS_NO_SUCH_FILE; goto _release; } _release: Free(fname); Free(dup_file_path); dirent_release(pdir_entry); dir_destroy(pdir); return ret; }
Dir* cache_lookup (Cache *cache, const gchar *key, gboolean create_if_missing, GError **err) { Dir* dir; g_assert(key != NULL); g_return_val_if_fail(cache != NULL, NULL); /* Check cache */ dir = g_hash_table_lookup(cache->cache, key); if (dir != NULL) { gconf_log(GCL_DEBUG, "Using dir %s from cache", key); return dir; } else { /* Not in cache, check whether we already failed to load it */ if (cache_is_nonexistent(cache, key)) { if (!create_if_missing) return NULL; } else { /* Didn't already fail to load, try to load */ dir = dir_load (key, cache->root_dir, err); if (dir != NULL) { g_assert(err == NULL || *err == NULL); /* Cache it and add to parent */ cache_insert (cache, dir); cache_add_to_parent (cache, dir); return dir; } else { /* Remember that we failed to load it */ if (!create_if_missing) { cache_set_nonexistent(cache, key, TRUE); return NULL; } else { if (err && *err) { g_error_free(*err); *err = NULL; } } } } } g_assert(dir == NULL); g_assert(create_if_missing); g_assert(err == NULL || *err == NULL); if (dir == NULL) { gconf_log(GCL_DEBUG, "Creating new dir %s", key); dir = dir_new(key, cache->root_dir, cache->dir_mode, cache->file_mode); if (!dir_ensure_exists(dir, err)) { dir_destroy(dir); g_return_val_if_fail((err == NULL) || (*err != NULL) , NULL); return NULL; } else { cache_insert (cache, dir); cache_add_to_parent (cache, dir); cache_unset_nonexistent (cache, dir_get_name (dir)); } } return dir; }