ufs_fs.h revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
/*
* University Copyright- Copyright (c) 1982, 1986, 1988
* The Regents of the University of California
* All Rights Reserved
*
* University Acknowledgment- Portions of this document are derived from
* software developed by the University of California, Berkeley, and its
* contributors.
*/
#ifndef _SYS_FS_UFS_FS_H
#define _SYS_FS_UFS_FS_H
#pragma ident "%Z%%M% %I% %E% SMI"
#include <sys/isa_defs.h>
#ifdef __cplusplus
extern "C" {
#endif
/*
* The following values are minor release values for UFS.
* The fs_version field in the superblock will equal one of them
* if the file system's magic number is MTB_UFS_MAGIC.
*/
#define MTB_UFS_VERSION_MIN 1
#define MTB_UFS_VERSION_1 1
/*
* Each disk drive contains some number of file systems.
* A file system consists of a number of cylinder groups.
* Each cylinder group has inodes and data.
*
* A file system is described by its super-block, which in turn
* describes the cylinder groups. The super-block is critical
* data and is replicated in the first 10 cylinder groups and the
* the last 10 cylinder groups to protect against
* catastrophic loss. This is done at mkfs time and the critical
* super-block data does not change, so the copies need not be
* referenced further unless disaster strikes.
*
* For file system fs, the offsets of the various blocks of interest
* are given in the super block as:
* [fs->fs_sblkno] Super-block
* [fs->fs_cblkno] Cylinder group block
* [fs->fs_iblkno] Inode blocks
* [fs->fs_dblkno] Data blocks
* The beginning of cylinder group cg in fs, is given by
* the ``cgbase(fs, cg)'' macro.
*
* The first boot and super blocks are given in absolute disk addresses.
* The byte-offset forms are preferred, as they don't imply a sector size.
*/
#define BBSIZE 8192
#define SBSIZE 8192
/*
* Addresses stored in inodes are capable of addressing fragments
* of `blocks'. File system blocks of at most size MAXBSIZE can
* be optionally broken into 2, 4, or 8 pieces, each of which is
* addressible; these pieces may be DEV_BSIZE, or some multiple of
* a DEV_BSIZE unit.
*
* Large files consist of exclusively large data blocks. To avoid
* undue wasted disk space, the last data block of a small file may be
* allocated as only as many fragments of a large block as are
* necessary. The file system format retains only a single pointer
* to such a fragment, which is a piece of a single large block that
* has been divided. The size of such a fragment is determinable from
* information in the inode, using the ``blksize(fs, ip, lbn)'' macro.
*
* The file system records space availability at the fragment level;
* to determine block availability, aligned fragments are examined.
*
* The root inode is the root of the file system.
* Inode 0 can't be used for normal purposes and
* historically bad blocks were linked to inode 1,
* thus the root inode is 2. (inode 1 is no longer used for
* this purpose, however numerous dump tapes make this
* assumption, so we are stuck with it)
* The lost+found directory is given the next available
* inode when it is created by ``mkfs''.
*/
#ifndef _LONGLONG_TYPE
#define UFS_MAXOFFSET_T MAXOFF_T
#define UFS_FILESIZE_BITS 32
#else
- 1)
#define UFS_FILESIZE_BITS 41
#endif /* _LONGLONG_TYPE */
/*
* MINBSIZE is the smallest allowable block size.
* In order to insure that it is possible to create files of size
* 2^32 with only two levels of indirection, MINBSIZE is set to 4096.
* MINBSIZE must be big enough to hold a cylinder group block,
* thus changes to (struct cg) must keep its size within MINBSIZE.
* Note that super blocks are always of size SBSIZE,
* and that both SBSIZE and MAXBSIZE must be >= MINBSIZE.
*/
#define MINBSIZE 4096
/*
* The path name on which the file system is mounted is maintained
* in fs_fsmnt. MAXMNTLEN defines the amount of space allocated in
* the super block for this name.
* The limit on the amount of summary information per file system
* is defined by MAXCSBUFS. It is currently parameterized for a
* maximum of two million cylinders.
*/
#define MAXMNTLEN 512
#define MAXCSBUFS 32
/*
* Per cylinder group information; summarized in blocks allocated
* from first cylinder group data blocks. These blocks have to be
* read in from fs_csaddr (size fs_cssize) in addition to the
* super block.
*
* N.B. sizeof (struct csum) must be a power of two in order for
* the ``fs_cs'' macro to work (see below).
*/
struct csum {
};
/*
* In the 5.0 release, the file system state flag in the superblock (fs_clean)
* is now used. The value of fs_clean can be:
* FSACTIVE file system may have fsck inconsistencies
* FSCLEAN file system has successfully unmounted (implies
* everything is ok)
* FSSTABLE No fsck inconsistencies, no guarantee on user data
* FSBAD file system is mounted from a partition that is
* neither FSCLEAN or FSSTABLE
* FSSUSPEND Clean flag processing is temporarily disabled
* FSLOG Logging file system
* Under this scheme, fsck can safely skip file systems that
* are FSCLEAN or FSSTABLE. To provide additional safeguard,
* fs_clean information could be trusted only if
* fs_state == FSOKAY - fs_time, where FSOKAY is a constant
*
* Note: mount(2) will now return ENOSPC if fs_clean is neither FSCLEAN nor
* FSSTABLE, or fs_state is not valid. The exceptions are the root or
* the read-only partitions
*/
/*
* Super block for a file system.
*
* Most of the data in the super block is read-only data and needs
* no explicit locking to protect it. Exceptions are:
* fs_time
* fs_optim
* fs_cstotal
* fs_fmod
* fs_cgrotor
* fs_flags (largefiles flag - set when a file grows large)
* These fields require the use of fs->fs_lock.
*/
#define FS_MAGIC 0x011954
#define MTB_UFS_MAGIC 0xdecade
#define FSOKAY (0x7c269d38)
/* #define FSOKAY (0x7c269d38 + 3) */
/*
* fs_clean values
*/
#define FSACTIVE ((char)0)
#define FSCLEAN ((char)0x1)
#define FSSTABLE ((char)0x2)
/*
* fs_flags values
*/
struct fs {
/* these are configuration parameters */
/* these fields can be computed from the others */
/* these are configuration parameters */
/* these fields can be computed from the others */
/* yet another configuration parameter */
/* these fields are derived from the hardware */
/* USL SVR4 compatibility */
#ifdef _LITTLE_ENDIAN
/*
* USL SVR4 compatibility
*
* There was a significant divergence here between Solaris and
* SVR4 for x86. By swapping these two members in the superblock,
* we get read-only compatibility of SVR4 filesystems. Otherwise
* there would be no compatibility. This change was introduced
* during bootstrapping of Solaris on x86. By making this ifdef'ed
* on byte order, we provide ongoing compatibility across all
* platforms with the same byte order, the highest compatibility
* that can be achieved.
*/
#else
#endif
/* a unique id for this filesystem (currently unused and unmaintained) */
/* In 4.3 Tahoe this space is used by fs_headswitch and fs_trkseek */
/* Neither of those fields is used in the Tahoe code right now but */
/* there could be problems if they are. */
/* sizes determined by number of cylinder groups and their sizes */
/* these fields are derived from the hardware */
/* this comes from the disk driver partitioning */
/* these fields can be computed from the others */
/* this data must be re-computed after crashes */
/* these fields are cleared at mount time */
char fs_fmod; /* super block modified flag */
char fs_clean; /* file system state flag */
char fs_ronly; /* mounted read-only flag */
char fs_flags; /* largefiles flag, etc. */
/* these fields retain the current block allocation info */
/*
* The following used to be fs_csp[MAXCSBUFS]. It was not
* used anywhere except in old utilities. We removed this
* in 5.6 and expect fs_u.fs_csp to be used instead.
* We no longer limit fs_cssize based on MAXCSBUFS.
*/
union { /* fs_cs (csum) info */
} fs_u;
#ifdef _LITTLE_ENDIAN
/* USL SVR4 compatibility */
#else
#endif
/* actually longer */
};
/*
* values for fs_reclaim
*/
/*
* values for fs_rolled
*/
#define FS_PRE_FLAG 0 /* old system, prior to fs_rolled flag */
#define FS_ALL_ROLLED 1
#define FS_NEED_ROLL 2
/*
* values for fs_si, logging only
* si is the summary of the summary - a copy of the cylinder group summary
* info held in an array for perf. On a mount if this is out of date
* (FS_SI_BAD) it can be re-constructed by re-reading the cgs.
*/
#define FS_SI_OK 0 /* on-disk summary info ok */
/*
* Preference for optimization.
*/
#define FS_OPTTIME 0 /* minimize allocation time */
/*
* Rotational layout table format types
*/
/*
* Macros for access to superblock array structures
*/
#ifdef _KERNEL
#else
: ((short *)((char *)(fs) + \
(fs)->fs_postbloff) \
#endif
/*
* Convert cylinder group to base address of its global summary info.
*
* N.B. This macro assumes that sizeof (struct csum) is a power of two.
* We just index off the first entry into one big array
*/
/*
* Cylinder group block for a file system.
*
* Writable fields in the cylinder group are protected by the associated
* super block lock fs->fs_lock.
*/
#define CG_MAGIC 0x090255
struct cg {
short cg_ncyl; /* number of cyl's this cg */
short cg_niblk; /* number of inode blocks this cg */
/* actually longer */
};
/*
* Macros for access to cylinder group array structures
*/
#ifdef _KERNEL
#else
#endif
#define cg_inosused(cgp) \
#define cg_blksfree(cgp) \
#define cg_chkmagic(cgp) \
/*
* The following structure is defined
* for compatibility with old file systems.
*/
struct ocg {
short cg_ncyl; /* number of cyl's this cg */
short cg_niblk; /* number of inode blocks this cg */
/* actually longer */
};
/*
* Turn frag offsets into disk block addresses.
* This maps frags to device size blocks.
* (In the names of these macros, "fsb" refers to "frags", not
* file system blocks.)
*/
#ifdef KERNEL
#else /* KERNEL */
#endif /* KERNEL */
/*
* Get the offset of the log, in either sectors, frags, or file system
* blocks. The interpretation of the fs_logbno field depends on whether
* this is UFS or MTB UFS. (UFS stores the value as sectors. MTBUFS
* stores the value as frags.)
*/
#ifdef KERNEL
#else /* KERNEL */
#endif /* KERNEL */
(b) >> (fs)->fs_fsbtodb : (b))
(b) >> (fs)->fs_fragshift)
/*
* Cylinder group macros to locate things in cylinder groups.
* They calc file system addresses of cylinder group data structures.
*/
/*
* Macros for handling inode numbers:
* inode number to file system block offset.
* inode number to cylinder group number.
* inode number to file system block address.
*/
/*
* Give cylinder group number for a file system block.
* Give cylinder group block number for a file system block.
*/
/*
* Extract the bits for a block from a map.
* Compute the cylinder and rotational position of a cyl block addr.
*/
#ifdef _KERNEL
#else
#endif
/*
* The following macros optimize certain frequently calculated
* quantities by using shifts and masks in place of divisions
* modulos and multiplications.
*/
/*
* This macro works for 40 bit offset support in ufs because
* this calculates offset in the block and therefore no loss of
* information while casting to int.
*/
/*
* This macro works for 40 bit offset support similar to blkoff
*/
/*
* The cast to int32_t does not result in any loss of information because
* the number of logical blocks in the file system is limited to
* what fits in an int32_t anyway.
*/
/*
* The same argument as above applies here.
*/
/*
* Size can be a 64-bit value and therefore we sign extend fs_bmask
* to a 64-bit value too so that the higher 32 bits are masked
* properly. Note that the type of fs_bmask has to be signed. Otherwise
* compiler will set the higher 32 bits as zero and we don't want
* this to happen.
*/
/*
* Same argument as above.
*/
/*
* frags cannot exceed 32-bit value since we only support 40bit sizes.
*/
/*
* Determine the number of available frags given a
* percentage to hold in reserve
*/
/*
* Determining the size of a file block in the file system.
*/
/*
* Number of disk sectors per block; assumes DEV_BSIZE byte sector size.
*/
/*
* INOPB is the number of inodes in a secondary storage block.
*/
/*
* NINDIR is the number of indirects in a file system block.
*/
/*
* bit map related macros
*/
#ifdef __cplusplus
}
#endif
#endif /* _SYS_FS_UFS_FS_H */