status_t Inode::EnableFileCache() { TRACE("Inode::EnableFileCache()\n"); if (fCached) return B_OK; if (fCache != NULL) { fCached = true; return B_OK; } TRACE("Inode::EnableFileCache(): Creating file cache: %ld, %lld, %lld\n", fVolume->ID(), ID(), Size()); fCache = file_cache_create(fVolume->ID(), ID(), Size()); fMap = file_map_create(fVolume->ID(), ID(), Size()); if (fCache == NULL) { ERROR("Inode::EnableFileCache(): Failed to create file cache\n"); fCached = false; return B_ERROR; } fCached = true; TRACE("Inode::EnableFileCache(): Done\n"); return B_OK; }
status_t Inode::CreateFileCache() { TRACE("Inode::CreateFileCache()\n"); if (fCache != NULL) return B_OK; TRACE("Inode::CreateFileCache(): Creating file cache: %" B_PRIu32 ", %" B_PRIdINO ", %" B_PRIdOFF "\n", fVolume->ID(), ID(), Size()); fCache = file_cache_create(fVolume->ID(), ID(), Size()); if (fCache == NULL) { ERROR("Inode::CreateFileCache(): Failed to create file cache\n"); return B_ERROR; } fMap = file_map_create(fVolume->ID(), ID(), Size()); if (fMap == NULL) { ERROR("Inode::CreateFileCache(): Failed to create file map\n"); file_cache_delete(fCache); fCache = NULL; return B_ERROR; } TRACE("Inode::CreateFileCache(): Done\n"); return B_OK; }
/** Get an inode from an Ext2 filesystem. * @note Node creation/lookup are protected by the mount lock, * meaning this function does not need to lock. * @param mount Mount to read from. * @param num Inode number to read. * @param inodep Where to store pointer to inode structure. * @return Status code describing result of the operation. */ status_t ext2_inode_get(ext2_mount_t *mount, uint32_t num, ext2_inode_t **inodep) { ext2_inode_t *inode = NULL; size_t group, bytes; offset_t offset; status_t ret; /* Get the group descriptor table containing the inode. */ group = (num - 1) / mount->inodes_per_group; if(group >= mount->block_groups) { dprintf("ext2: group number %zu is invalid on mount %p\n", group, mount); return STATUS_CORRUPT_FS; } /* Get the offset of the inode in the group's inode table. */ offset = ((num - 1) % mount->inodes_per_group) * mount->inode_size; /* Create a structure to store details of the inode in memory. */ inode = kmalloc(sizeof(ext2_inode_t), MM_WAIT); mutex_init(&inode->lock, "ext2_inode_lock", MUTEX_RECURSIVE); inode->mount = mount; inode->num = num; inode->disk_size = MIN(mount->inode_size, sizeof(ext2_disk_inode_t)); inode->disk_offset = ((offset_t)le32_to_cpu(mount->group_tbl[group].bg_inode_table) * mount->block_size) + offset; /* Read it in. */ ret = device_read(mount->device, &inode->disk, inode->disk_size, inode->disk_offset, &bytes); if(ret != STATUS_SUCCESS) { dprintf("ext2: error occurred while reading inode %" PRIu32 " (%d)\n", num, ret); kfree(inode); return ret; } else if(bytes != inode->disk_size) { kfree(inode); return STATUS_CORRUPT_FS; } /* Work out the size of the node data. Regular files can be larger than * 4GB - the high 32-bits of the file size are stored in i_dir_acl. */ inode->size = le32_to_cpu(inode->disk.i_size); if(le16_to_cpu(inode->disk.i_mode) & EXT2_S_IFREG) { inode->size |= ((uint64_t)le32_to_cpu(inode->disk.i_dir_acl)) << 32; } /* Create the various caches. */ inode->map = file_map_create(mount->block_size, &ext2_file_map_ops, inode); inode->cache = vm_cache_create(inode->size, &file_map_vm_cache_ops, inode->map); inode->entries = entry_cache_create(&ext2_entry_cache_ops, inode); dprintf("ext2: read inode %" PRIu32 " from %" PRIu64 " (group: %zu, block: %zu)\n", num, inode->disk_offset, group, le32_to_cpu(mount->group_tbl[group].bg_inode_table)); *inodep = inode; return STATUS_SUCCESS; }
void storeDirConfigure(void) { SwapDir *SD; int i; Config.Swap.maxSize = 0; for (i = 0; i < Config.cacheSwap.n_configured; i++) { SD = &Config.cacheSwap.swapDirs[i];; Config.Swap.maxSize += SD->max_size; if (NULL == SD->map) SD->map = file_map_create(); } }
Inode::Inode(Volume* volume, ino_t id) : fVolume(volume), fID(id), fCache(NULL), fMap(NULL) { rw_lock_init(&fLock, "btrfs inode"); fInitStatus = UpdateNodeFromDisk(); if (fInitStatus == B_OK) { if (!IsDirectory() && !IsSymLink()) { fCache = file_cache_create(fVolume->ID(), ID(), Size()); fMap = file_map_create(fVolume->ID(), ID(), Size()); } } }