/*
* Copyright (C) 2013 Raphael S. Carvalho <raphael.scarv@gmail.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the
* Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <dprintf.h>
#include <stdio.h>
#include <string.h>
#include <sys/dirent.h>
#include <cache.h>
#include <disk.h>
#include <fs.h>
#include <minmax.h>
#include "core.h"
#include "ufs.h"
/*
* Read the super block and check magic fields based on
* passed paramaters.
*/
static bool
do_checksb(struct ufs_super_block *sb, struct disk *disk,
const uint32_t sblock_off, const uint32_t ufs_smagic)
{
uint32_t lba;
static uint32_t count;
/* How many sectors are needed to fill sb struct */
if (!count)
count = sizeof *sb >> disk->sector_shift;
/* Get lba address based on sector size of disk */
lba = sblock_off >> (disk->sector_shift);
/* Read super block */
disk->rdwr_sectors(disk, sb, lba, count, 0);
if (sb->magic == ufs_smagic)
return true;
return false;
}
/*
* Go through all possible ufs superblock offsets.
* TODO: Add UFS support to removable media (sb offset: 0).
*/
static int
ufs_checksb(struct ufs_super_block *sb, struct disk *disk)
{
/* Check for UFS1 sb */
if (do_checksb(sb, disk, UFS1_SBLOCK_OFFSET, UFS1_SUPER_MAGIC))
return UFS1;
/* Check for UFS2 sb */
if (do_checksb(sb, disk, UFS2_SBLOCK_OFFSET, UFS2_SUPER_MAGIC))
return UFS2;
/* UFS2 may also exist in 256k-, but this isn't the default */
if (do_checksb(sb, disk, UFS2_SBLOCK2_OFFSET, UFS2_SUPER_MAGIC))
return UFS2_PIGGY;
return NONE;
}
/*
* lblock stands for linear block address,
* whereas pblock is the actual blk ptr to get data from.
*
* UFS1/2 use frag addrs rather than blk ones, then
* the offset into the block must be calculated.
*/
static const void *
ufs_get_cache(struct inode *inode, block_t lblock)
{
const void *data;
struct fs_info *fs = inode->fs;
struct ufs_sb_info *sb = UFS_SB(inode->fs);
uint64_t frag_addr, frag_offset;
uint32_t frag_shift;
block_t pblock;
frag_addr = ufs_bmap(inode, lblock, NULL);
if (!frag_addr)
return NULL;
frag_shift = fs->block_shift - sb->c_blk_frag_shift;
/* Get fragment byte address */
frag_offset = frag_addr << frag_shift;
/* Convert frag addr to blk addr */
pblock = frag_to_blk(fs, frag_addr);
/* Read the blk */
data = get_cache(fs->fs_dev, pblock);
/* Return offset into block */
return data + (frag_offset & (fs->block_size - 1));
}
/*
* Based on fs/ext2/ext2.c
* find a dir entry, return it if found, or return NULL.
*/
static const struct ufs_dir_entry *
ufs_find_entry(struct fs_info *fs, struct inode *inode, const char *dname)
{
const struct ufs_dir_entry *dir;
const char *data;
int32_t i, offset, maxoffset;
block_t index = 0;
ufs_debug("ufs_find_entry: dname: %s ", dname);
for (i = 0; i < inode->size; i += fs->block_size) {
data = ufs_get_cache(inode, index++);
offset = 0;
maxoffset = min(inode->size-i, fs->block_size);
/* The smallest possible size is 9 bytes */
while (offset < maxoffset-8) {
dir = (const struct ufs_dir_entry *)(data + offset);
if (dir->dir_entry_len > maxoffset - offset)
break;
/*
* Name fields are variable-length and null terminated,
* then it's possible to use strcmp directly.
*/
if (dir->inode_value && !strcmp(dname, (const char *)dir->name)) {
ufs_debug("(found)\n");
return dir;
}
offset += dir->dir_entry_len;
}
}
ufs_debug("(not found)\n");
return NULL;
}
/*
* Get either UFS1/2 inode structures.
*/
static const void *
ufs_get_inode(struct fs_info *fs, int inr)
{
const char *data;
uint32_t group, inode_offset, inode_table;
uint32_t block_num, block_off;
/* Get cylinder group nr. */
group = inr / UFS_SB(fs)->inodes_per_cg;
/*
* Ensuring group will not exceed the range 0:groups_count-1.
* By the way, this should *never* happen.
* Unless the (on-disk) fs structure is corrupted!
*/
if (group >= UFS_SB(fs)->groups_count) {
printf("ufs_get_inode: "
"group(%d) exceeded the avail. range (0:%d)\n",
group, UFS_SB(fs)->groups_count - 1);
return NULL;
}
/* Offset into inode table of the cylinder group */
inode_offset = inr % UFS_SB(fs)->inodes_per_cg;
/* Get inode table blk addr respective to cylinder group */
inode_table = (group * UFS_SB(fs)->blocks_per_cg) +
UFS_SB(fs)->off_inode_tbl;
/* Calculating staggering offset (UFS1 only!) */
if (UFS_SB(fs)->fs_type == UFS1)
inode_table += UFS_SB(fs)->ufs1.delta_value *
(group & UFS_SB(fs)->ufs1.cycle_mask);
/* Get blk nr and offset into the blk */
block_num = inode_table + inode_offset / UFS_SB(fs)->inodes_per_block;
block_off = inode_offset % UFS_SB(fs)->inodes_per_block;
/*
* Read the blk from the blk addr previously computed;
* Calc the inode struct offset into the read block.
*/
data = get_cache(fs->fs_dev, block_num);
return data + block_off * UFS_SB(fs)->inode_size;
}
static struct inode *
ufs1_iget_by_inr(struct fs_info *fs, uint32_t inr)
{
const struct ufs1_inode *ufs_inode;
struct inode *inode;
uint64_t *dest;
uint32_t *source;
int i;
ufs_inode = (struct ufs1_inode *) ufs_get_inode(fs, inr);
if (!ufs_inode)
return NULL;
if (!(inode = alloc_inode(fs, inr, sizeof(struct ufs_inode_pvt))))
return NULL;
/* UFS1 doesn't support neither creation nor deletion times */
inode->refcnt = ufs_inode->link_count;
inode->mode = IFTODT(ufs_inode->file_mode);
inode->size = ufs_inode->size;
inode->atime = ufs_inode->a_time;
inode->mtime = ufs_inode->m_time;
inode->blocks = ufs_inode->blocks_held;
inode->flags = ufs_inode->flags;
/*
* Copy and extend blk pointers to 64 bits, so avoid
* having two structures for inode private.
*/
dest = (uint64_t *) inode->pvt;
source = (uint32_t *) ufs_inode->direct_blk_ptr;
for (i = 0; i < UFS_NBLOCKS; i++)
dest[i] = ((uint64_t) source[i]) & 0xFFFFFFFF;
return inode;
}
static struct inode *
ufs2_iget_by_inr(struct fs_info *fs, uint32_t inr)
{
const struct ufs2_inode *ufs_inode;
struct inode *inode;
ufs_inode = (struct ufs2_inode *) ufs_get_inode(fs, inr);
if (!ufs_inode)
return NULL;
if (!(inode = alloc_inode(fs, inr, sizeof(struct ufs_inode_pvt))))
return NULL;
/* UFS2 doesn't support deletion time */
inode->refcnt = ufs_inode->link_count;
inode->mode = IFTODT(ufs_inode->file_mode);
inode->size = ufs_inode->size;
inode->atime = ufs_inode->a_time;
inode->ctime = ufs_inode->creat_time;
inode->mtime = ufs_inode->m_time;
inode->blocks = ufs_inode->bytes_held >> fs->block_shift;
inode->flags = ufs_inode->flags;
memcpy(inode->pvt, ufs_inode->direct_blk_ptr,
sizeof(uint64_t) * UFS_NBLOCKS);
return inode;
}
/*
* Both ufs_iget_root and ufs_iget callback based on ufs type.
*/
static struct inode *
ufs_iget_root(struct fs_info *fs)
{
return UFS_SB(fs)->ufs_iget_by_inr(fs, UFS_ROOT_INODE);
}
static struct inode *
ufs_iget(const char *dname, struct inode *parent)
{
const struct ufs_dir_entry *dir;
struct fs_info *fs = parent->fs;
dir = ufs_find_entry(fs, parent, dname);
if (!dir)
return NULL;
return UFS_SB(fs)->ufs_iget_by_inr(fs, dir->inode_value);
}
static void ufs1_read_blkaddrs(struct inode *inode, char *buf)
{
uint32_t dest[UFS_NBLOCKS];
const uint64_t *source = (uint64_t *) (inode->pvt);
int i;
/* Convert ufs_inode_pvt uint64_t fields into uint32_t
* Upper-half part of ufs1 private blk addrs are always supposed to be
* zero (it's previosuly extended by us), thus data isn't being lost. */
for (i = 0; i < UFS_NBLOCKS; i++) {
if ((source[i] >> 32) != 0) {
/* This should never happen, but will not prevent anything
* from working. */
ufs_debug("ufs1: inode->pvt[%d]: warning!\n", i);
}
dest[i] = (uint32_t)(source[i] & 0xFFFFFFFF);
}
memcpy(buf, (const char *) dest, inode->size);
}
static void ufs2_read_blkaddrs(struct inode *inode, char *buf)
{
memcpy(buf, (const char *) (inode->pvt), inode->size);
}
/*
* Taken from ext2/ext2.c.
* Read the entire contents of an inode into a memory buffer
*/
static int cache_get_file(struct inode *inode, void *buf, size_t bytes)
{
struct fs_info *fs = inode->fs;
size_t block_size = BLOCK_SIZE(fs);
uint32_t index = 0; /* Logical block number */
size_t chunk;
const char *data;
char *p = buf;
if (inode->size > bytes)
bytes = inode->size;
while (bytes) {
chunk = min(bytes, block_size);
data = ufs_get_cache(inode, index++);
memcpy(p, data, chunk);
bytes -= chunk;
p += chunk;
}
return 0;
}
static int ufs_readlink(struct inode *inode, char *buf)
{
struct fs_info *fs = inode->fs;
uint32_t i_symlink_limit;
if (inode->size > BLOCK_SIZE(fs))
return -1; /* Error! */
// TODO: use UFS_SB(fs)->maxlen_isymlink instead.
i_symlink_limit = ((UFS_SB(fs)->fs_type == UFS1) ?
sizeof(uint32_t) : sizeof(uint64_t)) * UFS_NBLOCKS;
ufs_debug("UFS_SB(fs)->maxlen_isymlink=%d", UFS_SB(fs)->maxlen_isymlink);
if (inode->size <= i_symlink_limit)
UFS_SB(fs)->ufs_read_blkaddrs(inode, buf);
else
cache_get_file(inode, buf, inode->size);
return inode->size;
}
static inline enum dir_type_flags get_inode_mode(uint8_t type)
{
switch(type) {
case UFS_DTYPE_FIFO: return DT_FIFO;
case UFS_DTYPE_CHARDEV: return DT_CHR;
case UFS_DTYPE_DIR: return DT_DIR;
case UFS_DTYPE_BLOCK: return DT_BLK;
case UFS_DTYPE_RFILE: return DT_REG;
case UFS_DTYPE_SYMLINK: return DT_LNK;
case UFS_DTYPE_SOCKET: return DT_SOCK;
case UFS_DTYPE_WHITEOUT: return DT_WHT;
default: return DT_UNKNOWN;
}
}
/*
* Read one directory entry at a time
*/
static int ufs_readdir(struct file *file, struct dirent *dirent)
{
struct fs_info *fs = file->fs;
struct inode *inode = file->inode;
const struct ufs_dir_entry *dir;
const char *data;
block_t index = file->offset >> fs->block_shift;
if (file->offset >= inode->size)
return -1; /* End of file */
data = ufs_get_cache(inode, index);
dir = (const struct ufs_dir_entry *)
(data + (file->offset & (BLOCK_SIZE(fs) - 1)));
dirent->d_ino = dir->inode_value;
dirent->d_off = file->offset;
dirent->d_reclen = offsetof(struct dirent, d_name) + dir->name_length + 1;
dirent->d_type = get_inode_mode(dir->file_type & 0x0F);
memcpy(dirent->d_name, dir->name, dir->name_length);
dirent->d_name[dir->name_length] = '\0';
file->offset += dir->dir_entry_len; /* Update for next reading */
return 0;
}
static inline struct ufs_sb_info *
set_ufs_info(struct ufs_super_block *sb, int ufs_type)
{
struct ufs_sb_info *sbi;
sbi = malloc(sizeof *sbi);
if (!sbi)
malloc_error("ufs_sb_info structure");
/* Setting up UFS-dependent info */
if (ufs_type == UFS1) {
sbi->inode_size = sizeof (struct ufs1_inode);
sbi->groups_count = sb->ufs1.nr_frags / sb->frags_per_cg;
sbi->ufs1.delta_value = sb->ufs1.delta_value;
sbi->ufs1.cycle_mask = sb->ufs1.cycle_mask;
sbi->ufs_iget_by_inr = ufs1_iget_by_inr;
sbi->ufs_read_blkaddrs = ufs1_read_blkaddrs;
sbi->addr_shift = UFS1_ADDR_SHIFT;
} else { // UFS2 or UFS2_PIGGY
sbi->inode_size = sizeof (struct ufs2_inode);
sbi->groups_count = sb->ufs2.nr_frags / sb->frags_per_cg;
sbi->ufs_iget_by_inr = ufs2_iget_by_inr;
sbi->ufs_read_blkaddrs = ufs2_read_blkaddrs;
sbi->addr_shift = UFS2_ADDR_SHIFT;
}
sbi->inodes_per_block = sb->block_size / sbi->inode_size;
sbi->inodes_per_cg = sb->inodes_per_cg;
sbi->blocks_per_cg = sb->frags_per_cg >> sb->c_blk_frag_shift;
sbi->off_inode_tbl = sb->off_inode_tbl >> sb->c_blk_frag_shift;
sbi->c_blk_frag_shift = sb->c_blk_frag_shift;
sbi->maxlen_isymlink = sb->maxlen_isymlink;
sbi->fs_type = ufs_type;
return sbi;
}
/*
* Init the fs metadata and return block size
*/
static int ufs_fs_init(struct fs_info *fs)
{
struct disk *disk = fs->fs_dev->disk;
struct ufs_super_block sb;
struct cache *cs;
int ufs_type = ufs_checksb(&sb, disk);
if (ufs_type == NONE)
return -1;
ufs_debug("%s SB FOUND!\n", ufs_type == UFS1 ? "UFS1" : "UFS2");
ufs_debug("Block size: %u\n", sb.block_size);
fs->fs_info = (struct ufs_sb_info *) set_ufs_info(&sb, ufs_type);
fs->sector_shift = disk->sector_shift;
fs->sector_size = disk->sector_size;
fs->block_shift = sb.block_shift;
fs->block_size = sb.block_size;
/* Initialize the cache, and force a clean on block zero */
cache_init(fs->fs_dev, sb.block_shift);
cs = _get_cache_block(fs->fs_dev, 0);
memset(cs->data, 0, fs->block_size);
cache_lock_block(cs);
/* For debug purposes */
//ufs_checking(fs);
//return -1;
return fs->block_shift;
}
const struct fs_ops ufs_fs_ops = {
.fs_name = "ufs",
.fs_flags = FS_USEMEM | FS_THISIND,
.fs_init = ufs_fs_init,
.searchdir = NULL,
.getfssec = generic_getfssec,
.close_file = generic_close_file,
.mangle_name = generic_mangle_name,
.open_config = generic_open_config,
.readlink = ufs_readlink,
.readdir = ufs_readdir,
.iget_root = ufs_iget_root,
.iget = ufs_iget,
.next_extent = ufs_next_extent,
};