blob: fb19a70508a43616d4f06a4ed901e56472607e6f [file] [log] [blame]
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <assert.h>
#include <string.h>
#include <endian.h>
#include "fatblock.h"
#include "fat.h"
#include "fs.h"
#include "utils.h"
#define DEFAULT_SECTOR_SIZE 512
static void fs_add_extent(struct fs *fs, struct extent *extent,
offset_t start, offset_t len, int type)
{
assert(fs);
assert(extent);
extent->start = start;
extent->len = len;
extent->type = type;
extent->next = fs->extents;
fs->extents = extent;
}
struct extent *fs_find_extent(struct fs *fs, offset_t start, offset_t len,
struct extent *last,
offset_t *r_start_out,
offset_t *e_start_out,
offset_t *len_out)
{
struct extent *e;
offset_t end;
offset_t e_start, e_end, e_len, e_rel_start, r_rel_start, rel_len;
assert(fs);
end = start + len;
e = last ? last->next : fs->extents;
for (; e; e = e->next) {
e_start = e->start;
e_len = e->len;
e_end = e_start + e_len;
if (start >= e_end)
continue;
if (end <= e_start)
continue;
if (e_start <= start) {
r_rel_start = 0;
e_rel_start = start - e_start;
if (end <= e_end)
rel_len = len;
else
rel_len = e_end - start;
} else {
e_rel_start = 0;
r_rel_start = e_start - start;
if (e_end <= end)
rel_len = e_len;
else
rel_len = end - e_start;
}
assert(e_rel_start < e_len);
assert(e_rel_start + rel_len <= e_len);
assert(r_rel_start < len);
assert(r_rel_start + rel_len <= len);
if (r_start_out)
*r_start_out = r_rel_start;
if (e_start_out)
*e_start_out = e_rel_start;
if (len_out)
*len_out = rel_len;
return e;
}
return NULL;
}
static void fs_set_fat(struct fs *fs, cluster_t cluster, fat_entry_t entry)
{
assert(fs);
fs->fat[cluster] = htole32(entry);
}
int fs_alloc_extent(struct fs *fs, struct extent *extent,
offset_t len, int type, cluster_t *first_cluster_out)
{
assert(fs);
assert(extent);
cluster_t clusters_needed, start;
cluster_t i;
if (len == 0) {
extent->start = 0;
extent->len = 0;
extent->type = type;
*first_cluster_out = 0;
return 0;
}
clusters_needed = (len + fs->cluster_size - 1) / fs->cluster_size;
/* Check for adequate space. */
if (fs->next_cluster + clusters_needed > fs->num_clusters) {
WARN("allocating extent: filesystem is full!\n");
return -1;
}
/* Allocate clusters. */
start = fs->next_cluster;
fs->next_cluster += clusters_needed;
/* Update FAT. */
for (i = 0; i < clusters_needed - 1; i++) {
fs_set_fat(fs, start + i, start + i + 1);
}
fs_set_fat(fs, start + clusters_needed - 1, FAT_ENTRY_EOC);
*first_cluster_out = start;
fs_add_extent(fs,
extent,
fs->data_offset + (offset_t)(start - FAT_CLUSTER_ZERO)
* fs->cluster_size,
(offset_t)clusters_needed * fs->cluster_size,
type);
return 0;
}
int fs_init(struct fs *fs, uint16_t cluster_size, offset_t data_size,
offset_t *total_size_out)
{
uint16_t sector_size;
cluster_t data_clusters;
sector_t reserved_sectors, fat_sectors, data_sectors, total_sectors;
sector_t sectors_per_cluster;
int fat_entries_per_sector;
fat_entry_t *fat;
struct fat_boot_sector *bs;
struct fat_info_sector *is;
assert(fs);
sector_size = DEFAULT_SECTOR_SIZE;
fs->cluster_size = cluster_size;
sectors_per_cluster = cluster_size / DEFAULT_SECTOR_SIZE;
fat_entries_per_sector = sector_size / sizeof(fat_entry_t);
data_clusters = (data_size + cluster_size - 1) / cluster_size;
data_sectors = data_clusters * sectors_per_cluster;
fat_sectors = ((data_clusters + 2) + fat_entries_per_sector - 1)
/ fat_entries_per_sector;
reserved_sectors = 3;
total_sectors = reserved_sectors + fat_sectors + data_sectors;
memset(&fs->boot, 0, sizeof(fs->boot));
bs = &fs->boot;
strpadcpy(bs->name, "FATBLOCK", ' ', sizeof(bs->name));
bs->sector_size = htole16(sector_size);
bs->sectors_per_cluster = sectors_per_cluster;
bs->reserved_sectors = htole16(reserved_sectors);
bs->fats = 1;
bs->media_desc = FAT_MEDIA_DESC_FIXED;
/* TODO: Calculate geometry? */
bs->sectors_per_track = htole16(42);
bs->heads = htole16(42);
bs->sectors32 = htole32(total_sectors);
bs->fat_sectors32 = htole32(fat_sectors);
/* bs->rootdir_start will be set later. */
bs->fs_info_sector = htole16(1);
bs->backup_boot_sector = htole16(2);
bs->phys_drive = FAT_PHYS_DRIVE_REMOVABLE;
bs->ext_boot_sig = FAT_EXT_BOOT_SIG;
bs->serial = 0x42424242;
strpadcpy(bs->vol_label, "FATBLOCK", ' ', sizeof(bs->vol_label));
strpadcpy(bs->type, "FAT32", ' ', sizeof(bs->type));
memcpy(bs->boot_sig, FAT_BOOT_SIG, sizeof(bs->boot_sig));
memset(&fs->info, 0, sizeof(fs->info));
is = &fs->info;
memcpy(is->info_sig1, FAT_INFO_SIG1, sizeof(is->info_sig1));
memcpy(is->info_sig2, FAT_INFO_SIG2, sizeof(is->info_sig2));
is->free_clusters = htole32(-1);
is->last_cluster = htole32(FAT_CLUSTER_ZERO);
memcpy(is->info_sig3, FAT_INFO_SIG3, sizeof(is->info_sig3));
fs->num_clusters = FAT_CLUSTER_ZERO + data_clusters;
fs->next_cluster = FAT_CLUSTER_ZERO;
fs->fat_size = fat_sectors * sector_size;
fs->fat = malloc(fs->fat_size);
if (!fs->fat) {
WARN("initializing filesystem: couldn't allocate FAT extent: "
"out of memory\n");
return MALLOC_FAIL;
}
memset(fs->fat, 0, fs->fat_size);
fs->data_offset = (reserved_sectors + fat_sectors) * sector_size;
fs->extents = NULL;
fs_add_extent(fs, &fs->boot_extent,
0, sector_size,
EXTENT_TYPE_BOOT);
fs_add_extent(fs, &fs->info_extent,
sector_size, sector_size,
EXTENT_TYPE_INFO);
fs_add_extent(fs, &fs->backup_boot_extent,
2 * sector_size, sector_size,
EXTENT_TYPE_BOOT);
fs_add_extent(fs, &fs->fat_extent,
reserved_sectors * sector_size, fs->fat_size,
EXTENT_TYPE_FAT);
*total_size_out = (offset_t)total_sectors * sector_size;
return 0;
}
void fs_set_rootdir_start(struct fs *fs, cluster_t rootdir_start)
{
assert(fs);
fs->boot.rootdir_start = htole32(rootdir_start);
}
void fs_update_free_clusters(struct fs *fs)
{
assert(fs);
fs->info.free_clusters = htole32(fs->num_clusters - fs->next_cluster);
}