255 lines
7.4 KiB
C
255 lines
7.4 KiB
C
/*
|
|
* 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.
|
|
*/
|
|
|
|
#ifndef _UFS_H_
|
|
#define _UFS_H_
|
|
|
|
#include <stdint.h>
|
|
|
|
/* Sector addresses */
|
|
#define UFS1_SBLOCK_OFFSET 8192
|
|
#define UFS2_SBLOCK_OFFSET 65536
|
|
#define UFS2_SBLOCK2_OFFSET 262144
|
|
|
|
#define UFS1_ADDR_SHIFT 2
|
|
#define UFS2_ADDR_SHIFT 3
|
|
|
|
/* Super magic numbers */
|
|
#define UFS1_SUPER_MAGIC (0x011954)
|
|
#define UFS2_SUPER_MAGIC (0x19540119)
|
|
|
|
#define UFS_ROOT_INODE 2
|
|
|
|
#define UFS_DIRECT_BLOCKS 12
|
|
#define UFS_INDIRECT_BLOCK 1
|
|
#define UFS_DOUBLE_INDIRECT_BLOCK 1
|
|
#define UFS_TRIPLE_INDIRECT_BLOCK 1
|
|
/* Total number of block addr hold by inodes */
|
|
#define UFS_NBLOCKS 15
|
|
|
|
/* Blocks span 8 fragments */
|
|
#define FRAGMENTS_PER_BLK 8
|
|
|
|
/* UFS types */
|
|
typedef enum {
|
|
NONE,
|
|
UFS1,
|
|
UFS2,
|
|
UFS2_PIGGY,
|
|
} ufs_t;
|
|
|
|
/*
|
|
* UFS1/UFS2 SUPERBLOCK structure
|
|
* CG stands for Cylinder Group.
|
|
*
|
|
* Variables prepended with off store offsets relative to
|
|
* base address of a Cylinder Group (CG).
|
|
*/
|
|
struct ufs_super_block { // supporting either ufs1 or ufs2
|
|
uint8_t unused[8];
|
|
/* Offset values */
|
|
uint32_t off_backup_sb; // Backup super block
|
|
uint32_t off_group_desc; // Group Descriptor
|
|
uint32_t off_inode_tbl; // Inode table
|
|
uint32_t off_data_block; // First data block
|
|
union {
|
|
struct { /* Used for UFS1 */
|
|
uint32_t delta_value; // For calc staggering offset
|
|
uint32_t cycle_mask; // Mask for staggering offset
|
|
uint32_t last_written; // Last written time
|
|
uint32_t nr_frags; // Number of frags in FS
|
|
uint32_t storable_frags_nr; // Nr of frags that can store data
|
|
} ufs1;
|
|
uint8_t unused1[20];
|
|
};
|
|
uint32_t nr_cyl_groups; // Number of cylinder groups.
|
|
uint32_t block_size; // Block size in bytes.
|
|
uint32_t fragment_size; // Fragment size in bytes.
|
|
uint8_t unused2[16];
|
|
uint32_t block_addr_mask; // to calculate the address
|
|
uint32_t frag_addr_mask;
|
|
uint32_t block_shift; // to calculate byte address
|
|
uint32_t frag_shift;
|
|
uint32_t nr_contiguous_blk; // max number of continuous blks to alloc
|
|
uint32_t nr_blks_per_cg; // max number of blks per cylinder group
|
|
uint32_t c_blk_frag_shift; // Bits to convert blk and frag address.
|
|
uint32_t c_frag_sect_shift; // Bits to convert frag and sect address.
|
|
uint32_t superblk_size; // Superblock size.
|
|
uint8_t unused3[76];
|
|
uint32_t inodes_per_cg; // Inodes per cylinder group
|
|
uint32_t frags_per_cg; // Fragments per cylinder group
|
|
union {
|
|
struct { /* Used for UFS2 */
|
|
uint8_t unused[888];
|
|
uint64_t nr_frags; // Number of fragments in FS
|
|
uint8_t unused1[232];
|
|
} ufs2;
|
|
uint8_t unused4[1128];
|
|
};
|
|
uint32_t maxlen_isymlink; // Max length of internal symlink
|
|
uint32_t inodes_format; // Format of inodes
|
|
uint8_t unused5[44];
|
|
uint32_t magic; // Magic value
|
|
uint8_t pad[160]; // padding up to sector (512 bytes) boundary
|
|
} __attribute__((__packed__));
|
|
|
|
/*
|
|
* Info about UFS1/2 super block.
|
|
*/
|
|
struct ufs_sb_info {
|
|
uint32_t blocks_per_cg; // Blocks per cylinder group
|
|
uint32_t inodes_per_cg; // Inodes per cylinder group
|
|
uint32_t inode_size;
|
|
uint32_t inodes_per_block; // Inodes per block
|
|
struct { /* UFS1 only! */
|
|
/* Values for calculating staggering offset */
|
|
uint32_t delta_value;
|
|
uint32_t cycle_mask;
|
|
} ufs1;
|
|
uint32_t off_inode_tbl; // Inode table offset.
|
|
uint32_t groups_count; // Number of groups in the fs
|
|
uint32_t addr_shift; // 2 ^ addr_shift = size in bytes of default addr.
|
|
uint32_t c_blk_frag_shift; // Convert blk/frag addr (vice-versa)
|
|
uint32_t maxlen_isymlink; // Max length of internal symlink
|
|
struct inode *(*ufs_iget_by_inr)(struct fs_info *, uint32_t);
|
|
void (*ufs_read_blkaddrs)(struct inode *, char *);
|
|
ufs_t fs_type; // { UFS1, UFS2, UFS2_PIGGY }
|
|
};
|
|
|
|
/*
|
|
* Get super block info struct
|
|
*/
|
|
static inline struct ufs_sb_info *UFS_SB(struct fs_info *fs)
|
|
{
|
|
return fs->fs_info;
|
|
}
|
|
|
|
/*
|
|
* Convert frag addr to blk addr
|
|
*/
|
|
static inline block_t frag_to_blk(struct fs_info *fs, uint64_t frag)
|
|
{
|
|
return frag >> UFS_SB(fs)->c_blk_frag_shift;
|
|
}
|
|
|
|
/*
|
|
* UFS1 inode structures
|
|
*/
|
|
struct ufs1_inode {
|
|
uint16_t file_mode;
|
|
uint16_t link_count;
|
|
uint8_t unused[4];
|
|
uint64_t size;
|
|
uint32_t a_time; // Access time
|
|
uint32_t a_time_nanosec;
|
|
uint32_t m_time; // Modified time
|
|
uint32_t m_time_nanosec;
|
|
uint32_t ch_time; // Change time
|
|
uint32_t ch_time_nanosec;
|
|
uint32_t direct_blk_ptr[12];
|
|
uint32_t indirect_blk_ptr;
|
|
uint32_t double_indirect_blk_ptr;
|
|
uint32_t triple_indirect_blk_ptr;
|
|
uint32_t flags; // Status flags
|
|
uint32_t blocks_held; // Blocks held
|
|
uint32_t generation_nrb; // (NFS)
|
|
uint32_t used_id;
|
|
uint32_t group_id;
|
|
uint8_t unused1[8];
|
|
} __attribute__((__packed__));
|
|
|
|
/*
|
|
* UFS2 inode structures
|
|
*/
|
|
struct ufs2_inode {
|
|
uint16_t file_mode;
|
|
uint16_t link_count;
|
|
uint32_t user_id;
|
|
uint32_t group_id;
|
|
uint32_t inode_blocksize;
|
|
uint64_t size;
|
|
uint64_t bytes_held;
|
|
uint64_t a_time; // Access time
|
|
uint64_t m_time; // Modified time
|
|
uint64_t ch_time; // Change time
|
|
uint64_t creat_time; // Creation time
|
|
uint32_t a_time_nanosec;
|
|
uint32_t m_time_nanosec;
|
|
uint32_t ch_time_nanosec;
|
|
uint32_t creat_time_nanosec;
|
|
uint32_t generation_nrb; // (NFS)
|
|
uint32_t kernel_flags;
|
|
uint32_t flags;
|
|
uint32_t ext_attr_size; // Extended attrib size.
|
|
uint64_t ext_direct_blk_ptrs[2]; // Ext. attrib blk pointers.
|
|
uint64_t direct_blk_ptr[12];
|
|
uint64_t indirect_blk_ptr;
|
|
uint64_t double_indirect_blk_ptr;
|
|
uint64_t triple_indirect_blk_ptr;
|
|
uint8_t unused[24];
|
|
} __attribute__((__packed__));
|
|
|
|
#define PVT(p) ((struct ufs_inode_pvt *) p->pvt)
|
|
|
|
struct ufs_inode_pvt {
|
|
uint64_t direct_blk_ptr[12];
|
|
uint64_t indirect_blk_ptr;
|
|
uint64_t double_indirect_blk_ptr;
|
|
uint64_t triple_indirect_blk_ptr;
|
|
};
|
|
|
|
struct ufs_dir_entry {
|
|
uint32_t inode_value;
|
|
uint16_t dir_entry_len;
|
|
uint8_t file_type;
|
|
uint8_t name_length;
|
|
uint8_t name[1]; // Dir names are null terminated!!!
|
|
} __attribute__((__packed__));
|
|
|
|
enum inode_type_flags {
|
|
UFS_INO_FIFO = 0x1000,
|
|
UFS_INO_CHARDEV = 0x2000,
|
|
UFS_INO_DIRECTORY = 0x4000,
|
|
UFS_INO_BLOCKDEV = 0x6000,
|
|
UFS_INO_RFILE = 0x8000,
|
|
UFS_INO_SYMLINK = 0xA000,
|
|
UFS_INO_UNIXSOCKET = 0xC000,
|
|
};
|
|
|
|
enum dir_type_flags {
|
|
UFS_DTYPE_UNKNOWN = 0,
|
|
UFS_DTYPE_FIFO = 1,
|
|
UFS_DTYPE_CHARDEV = 2,
|
|
UFS_DTYPE_DIR = 4,
|
|
UFS_DTYPE_BLOCK = 6,
|
|
UFS_DTYPE_RFILE = 8,
|
|
UFS_DTYPE_SYMLINK = 10,
|
|
UFS_DTYPE_SOCKET = 12,
|
|
UFS_DTYPE_WHITEOUT = 14,
|
|
};
|
|
|
|
/* Functions from bmap.c */
|
|
extern uint64_t ufs_bmap (struct inode *, block_t, size_t *);
|
|
extern int ufs_next_extent(struct inode *, uint32_t);
|
|
|
|
#define ufs_debug dprintf
|
|
//extern void ufs_checking (struct fs_info *);
|
|
|
|
#endif /* _UFS_H_ */
|