ref: dd0677d54d3503c2eeabfc128fa6fad0848e6406
dir: /src/ext4_inode.c/
/*
* Copyright (c) 2013 Grzegorz Kostka ([email protected])
*
*
* HelenOS:
* Copyright (c) 2012 Martin Sucha
* Copyright (c) 2012 Frantisek Princ
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* - The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/** @addtogroup lwext4
* @{
*/
/**
* @file ext4_inode.c
* @brief Inode handle functions
*/
#include "ext4_config.h"
#include "ext4_types.h"
#include "ext4_misc.h"
#include "ext4_errno.h"
#include "ext4_debug.h"
#include "ext4_inode.h"
#include "ext4_super.h"
/**@brief Compute number of bits for block count.
* @param block_size Filesystem block_size
* @return Number of bits
*/
static uint32_t ext4_inode_block_bits_count(uint32_t block_size)
{
uint32_t bits = 8;
uint32_t size = block_size;
do {
bits++;
size = size >> 1;
} while (size > 256);
return bits;
}
uint32_t ext4_inode_get_mode(struct ext4_sblock *sb, struct ext4_inode *inode)
{
uint32_t v = to_le16(inode->mode);
if (ext4_get32(sb, creator_os) == EXT4_SUPERBLOCK_OS_HURD) {
v |= ((uint32_t)to_le16(inode->osd2.hurd2.mode_high)) << 16;
}
return v;
}
void ext4_inode_set_mode(struct ext4_sblock *sb, struct ext4_inode *inode,
uint32_t mode)
{
inode->mode = to_le16((mode << 16) >> 16);
if (ext4_get32(sb, creator_os) == EXT4_SUPERBLOCK_OS_HURD)
inode->osd2.hurd2.mode_high = to_le16(mode >> 16);
}
uint32_t ext4_inode_get_uid(struct ext4_inode *inode)
{
return to_le32(inode->uid);
}
void ext4_inode_set_uid(struct ext4_inode *inode, uint32_t uid)
{
inode->uid = to_le32(uid);
}
uint64_t ext4_inode_get_size(struct ext4_sblock *sb, struct ext4_inode *inode)
{
uint64_t v = to_le32(inode->size_lo);
if ((ext4_get32(sb, rev_level) > 0) &&
(ext4_inode_is_type(sb, inode, EXT4_INODE_MODE_FILE)))
v |= ((uint64_t)to_le32(inode->size_hi)) << 32;
return v;
}
void ext4_inode_set_size(struct ext4_inode *inode, uint64_t size)
{
inode->size_lo = to_le32((size << 32) >> 32);
inode->size_hi = to_le32(size >> 32);
}
uint32_t ext4_inode_get_csum(struct ext4_sblock *sb, struct ext4_inode *inode)
{
uint16_t inode_size = ext4_get16(sb, inode_size);
uint32_t v = to_le16(inode->osd2.linux2.checksum_lo);
if (inode_size > EXT4_GOOD_OLD_INODE_SIZE)
v |= ((uint32_t)to_le16(inode->checksum_hi)) << 16;
return v;
}
void ext4_inode_set_csum(struct ext4_sblock *sb, struct ext4_inode *inode,
uint32_t checksum)
{
uint16_t inode_size = ext4_get16(sb, inode_size);
inode->osd2.linux2.checksum_lo =
to_le16((checksum << 16) >> 16);
if (inode_size > EXT4_GOOD_OLD_INODE_SIZE)
inode->checksum_hi = to_le16(checksum >> 16);
}
uint32_t ext4_inode_get_access_time(struct ext4_inode *inode)
{
return to_le32(inode->access_time);
}
void ext4_inode_set_access_time(struct ext4_inode *inode, uint32_t time)
{
inode->access_time = to_le32(time);
}
uint32_t ext4_inode_get_change_inode_time(struct ext4_inode *inode)
{
return to_le32(inode->change_inode_time);
}
void ext4_inode_set_change_inode_time(struct ext4_inode *inode, uint32_t time)
{
inode->change_inode_time = to_le32(time);
}
uint32_t ext4_inode_get_modif_time(struct ext4_inode *inode)
{
return to_le32(inode->modification_time);
}
void ext4_inode_set_modif_time(struct ext4_inode *inode, uint32_t time)
{
inode->modification_time = to_le32(time);
}
uint32_t ext4_inode_get_del_time(struct ext4_inode *inode)
{
return to_le32(inode->deletion_time);
}
void ext4_inode_set_del_time(struct ext4_inode *inode, uint32_t time)
{
inode->deletion_time = to_le32(time);
}
uint32_t ext4_inode_get_gid(struct ext4_inode *inode)
{
return to_le32(inode->gid);
}
void ext4_inode_set_gid(struct ext4_inode *inode, uint32_t gid)
{
inode->gid = to_le32(gid);
}
uint16_t ext4_inode_get_links_cnt(struct ext4_inode *inode)
{
return to_le16(inode->links_count);
}
void ext4_inode_set_links_cnt(struct ext4_inode *inode, uint16_t cnt)
{
inode->links_count = to_le16(cnt);
}
uint64_t ext4_inode_get_blocks_count(struct ext4_sblock *sb,
struct ext4_inode *inode)
{
uint64_t cnt = to_le32(inode->blocks_count_lo);
if (ext4_sb_feature_ro_com(sb, EXT4_FRO_COM_HUGE_FILE)) {
/* 48-bit field */
cnt |= (uint64_t)to_le16(inode->osd2.linux2.blocks_high) << 32;
if (ext4_inode_has_flag(inode, EXT4_INODE_FLAG_HUGE_FILE)) {
uint32_t block_count = ext4_sb_get_block_size(sb);
uint32_t b = ext4_inode_block_bits_count(block_count);
return cnt << (b - 9);
}
}
return cnt;
}
int ext4_inode_set_blocks_count(struct ext4_sblock *sb,
struct ext4_inode *inode, uint64_t count)
{
/* 32-bit maximum */
uint64_t max = 0;
max = ~max >> 32;
if (count <= max) {
inode->blocks_count_lo = to_le32((uint32_t)count);
inode->osd2.linux2.blocks_high = 0;
ext4_inode_clear_flag(inode, EXT4_INODE_FLAG_HUGE_FILE);
return EOK;
}
/* Check if there can be used huge files (many blocks) */
if (!ext4_sb_feature_ro_com(sb, EXT4_FRO_COM_HUGE_FILE))
return EINVAL;
/* 48-bit maximum */
max = 0;
max = ~max >> 16;
if (count <= max) {
inode->blocks_count_lo = to_le32((uint32_t)count);
inode->osd2.linux2.blocks_high = to_le16((uint16_t)(count >> 32));
ext4_inode_clear_flag(inode, EXT4_INODE_FLAG_HUGE_FILE);
} else {
uint32_t block_count = ext4_sb_get_block_size(sb);
uint32_t block_bits =ext4_inode_block_bits_count(block_count);
ext4_inode_set_flag(inode, EXT4_INODE_FLAG_HUGE_FILE);
count = count >> (block_bits - 9);
inode->blocks_count_lo = to_le32((uint32_t)count);
inode->osd2.linux2.blocks_high = to_le16((uint16_t)(count >> 32));
}
return EOK;
}
uint32_t ext4_inode_get_flags(struct ext4_inode *inode)
{
return to_le32(inode->flags);
}
void ext4_inode_set_flags(struct ext4_inode *inode, uint32_t flags)
{
inode->flags = to_le32(flags);
}
uint32_t ext4_inode_get_generation(struct ext4_inode *inode)
{
return to_le32(inode->generation);
}
void ext4_inode_set_generation(struct ext4_inode *inode, uint32_t gen)
{
inode->generation = to_le32(gen);
}
uint16_t ext4_inode_get_extra_isize(struct ext4_sblock *sb,
struct ext4_inode *inode)
{
uint16_t inode_size = ext4_get16(sb, inode_size);
if (inode_size > EXT4_GOOD_OLD_INODE_SIZE)
return to_le16(inode->extra_isize);
else
return 0;
}
void ext4_inode_set_extra_isize(struct ext4_sblock *sb,
struct ext4_inode *inode,
uint16_t size)
{
uint16_t inode_size = ext4_get16(sb, inode_size);
if (inode_size > EXT4_GOOD_OLD_INODE_SIZE)
inode->extra_isize = to_le16(size);
}
uint64_t ext4_inode_get_file_acl(struct ext4_inode *inode,
struct ext4_sblock *sb)
{
uint64_t v = to_le32(inode->file_acl_lo);
if (ext4_get32(sb, creator_os) == EXT4_SUPERBLOCK_OS_LINUX)
v |= (uint32_t)to_le16(inode->osd2.linux2.file_acl_high) << 16;
return v;
}
void ext4_inode_set_file_acl(struct ext4_inode *inode, struct ext4_sblock *sb,
uint64_t acl)
{
inode->file_acl_lo = to_le32((acl << 32) >> 32);
if (ext4_get32(sb, creator_os) == EXT4_SUPERBLOCK_OS_LINUX)
inode->osd2.linux2.file_acl_high = to_le16((uint16_t)(acl >> 32));
}
uint32_t ext4_inode_get_direct_block(struct ext4_inode *inode, uint32_t idx)
{
return to_le32(inode->blocks[idx]);
}
void ext4_inode_set_direct_block(struct ext4_inode *inode, uint32_t idx,
uint32_t block)
{
inode->blocks[idx] = to_le32(block);
}
uint32_t ext4_inode_get_indirect_block(struct ext4_inode *inode, uint32_t idx)
{
return to_le32(inode->blocks[idx + EXT4_INODE_INDIRECT_BLOCK]);
}
void ext4_inode_set_indirect_block(struct ext4_inode *inode, uint32_t idx,
uint32_t block)
{
inode->blocks[idx + EXT4_INODE_INDIRECT_BLOCK] = to_le32(block);
}
uint32_t ext4_inode_get_dev(struct ext4_inode *inode)
{
uint32_t dev_0, dev_1;
dev_0 = ext4_inode_get_direct_block(inode, 0);
dev_1 = ext4_inode_get_direct_block(inode, 1);
if (dev_0)
return dev_0;
else
return dev_1;
}
void ext4_inode_set_dev(struct ext4_inode *inode, uint32_t dev)
{
if (dev & ~0xFFFF)
ext4_inode_set_direct_block(inode, 1, dev);
else
ext4_inode_set_direct_block(inode, 0, dev);
}
uint32_t ext4_inode_type(struct ext4_sblock *sb, struct ext4_inode *inode)
{
return (ext4_inode_get_mode(sb, inode) & EXT4_INODE_MODE_TYPE_MASK);
}
bool ext4_inode_is_type(struct ext4_sblock *sb, struct ext4_inode *inode,
uint32_t type)
{
return ext4_inode_type(sb, inode) == type;
}
bool ext4_inode_has_flag(struct ext4_inode *inode, uint32_t f)
{
return ext4_inode_get_flags(inode) & f;
}
void ext4_inode_clear_flag(struct ext4_inode *inode, uint32_t f)
{
uint32_t flags = ext4_inode_get_flags(inode);
flags = flags & (~f);
ext4_inode_set_flags(inode, flags);
}
void ext4_inode_set_flag(struct ext4_inode *inode, uint32_t f)
{
uint32_t flags = ext4_inode_get_flags(inode);
flags = flags | f;
ext4_inode_set_flags(inode, flags);
}
bool ext4_inode_can_truncate(struct ext4_sblock *sb, struct ext4_inode *inode)
{
if ((ext4_inode_has_flag(inode, EXT4_INODE_FLAG_APPEND)) ||
(ext4_inode_has_flag(inode, EXT4_INODE_FLAG_IMMUTABLE)))
return false;
if ((ext4_inode_is_type(sb, inode, EXT4_INODE_MODE_FILE)) ||
(ext4_inode_is_type(sb, inode, EXT4_INODE_MODE_DIRECTORY)) ||
(ext4_inode_is_type(sb, inode, EXT4_INODE_MODE_SOFTLINK)))
return true;
return false;
}
struct ext4_extent_header *
ext4_inode_get_extent_header(struct ext4_inode *inode)
{
return (struct ext4_extent_header *)inode->blocks;
}
/**
* @}
*/