/* $Id: fsw_core.h 33540 2010-10-28 09:27:05Z vboxsync $ */ /** @file * fsw_core.h - Core file system wrapper abstraction layer header. */ /* * Copyright (C) 2010-2012 Oracle Corporation * * This file is part of VirtualBox Open Source Edition (OSE), as * available from http://www.virtualbox.org. This file is free software; * you can redistribute it and/or modify it under the terms of the GNU * General Public License (GPL) as published by the Free Software * Foundation, in version 2 as it comes in the "COPYING" file of the * VirtualBox OSE distribution. VirtualBox OSE is distributed in the * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. */ /*- * This code is based on: * * Copyright (c) 2006 Christoph Pfisterer * Portions Copyright (c) The Regents of the University of California. * Portions Copyright (c) UNIX System Laboratories, Inc. * * 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. * * * Neither the name of Christoph Pfisterer nor the names of the * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "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 COPYRIGHT * OWNER OR CONTRIBUTORS 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. */ #ifndef _FSW_CORE_H_ #define _FSW_CORE_H_ #include "fsw_base.h" extern const char* fsw_errors[]; #ifndef FSW_DNODE_CACHE_SIZE #define FSW_DNODE_CACHE_SIZE (0) #endif /** Maximum size for a path, specifically symlink target paths. */ #ifndef VBOX #define FSW_PATH_MAX (4096) #else /* Too big allocations are handled with alloca() */ #define FSW_PATH_MAX (2048) #endif /** Helper macro for token concatenation. */ #define FSW_CONCAT3(a,b,c) a##b##c /** Expands to the name of a fstype dispatch table (fsw_fstype_table) for a named file system type. */ #define FSW_FSTYPE_TABLE_NAME(t) FSW_CONCAT3(fsw_,t,_table) /** Indicates that the block cache entry is empty. */ #define FSW_INVALID_BNO (~0UL) #define USE_FULL_LOWERCASE 0 // // Byte-swapping macros // /** * \name Byte Order Macros * Implements big endian vs. little endian awareness and conversion. */ /*@{*/ typedef fsw_u16 fsw_u16_le; typedef fsw_u16 fsw_u16_be; typedef fsw_u32 fsw_u32_le; typedef fsw_u32 fsw_u32_be; typedef fsw_u64 fsw_u64_le; typedef fsw_u64 fsw_u64_be; #define FSW_SWAPVALUE_U16(v) ((((fsw_u16)(v) & 0xff00) >> 8) | \ (((fsw_u16)(v) & 0x00ff) << 8)) #define FSW_SWAPVALUE_U32(v) ((((fsw_u32)(v) & 0xff000000UL) >> 24) | \ (((fsw_u32)(v) & 0x00ff0000UL) >> 8) | \ (((fsw_u32)(v) & 0x0000ff00UL) << 8) | \ (((fsw_u32)(v) & 0x000000ffUL) << 24)) #define FSW_SWAPVALUE_U64(v) ((((fsw_u64)(v) & 0xff00000000000000ULL) >> 56) | \ (((fsw_u64)(v) & 0x00ff000000000000ULL) >> 40) | \ (((fsw_u64)(v) & 0x0000ff0000000000ULL) >> 24) | \ (((fsw_u64)(v) & 0x000000ff00000000ULL) >> 8) | \ (((fsw_u64)(v) & 0x00000000ff000000ULL) << 8) | \ (((fsw_u64)(v) & 0x0000000000ff0000ULL) << 24) | \ (((fsw_u64)(v) & 0x000000000000ff00ULL) << 40) | \ (((fsw_u64)(v) & 0x00000000000000ffULL) << 56)) #ifdef FSW_LITTLE_ENDIAN #define fsw_u16_le_swap(v) (v) #define fsw_u16_be_swap(v) FSW_SWAPVALUE_U16(v) #define fsw_u32_le_swap(v) (v) #define fsw_u32_be_swap(v) FSW_SWAPVALUE_U32(v) #define fsw_u64_le_swap(v) (v) #define fsw_u64_be_swap(v) FSW_SWAPVALUE_U64(v) #define fsw_u16_le_sip(var) #define fsw_u16_be_sip(var) (var = FSW_SWAPVALUE_U16(var)) #define fsw_u32_le_sip(var) #define fsw_u32_be_sip(var) (var = FSW_SWAPVALUE_U32(var)) #define fsw_u64_le_sip(var) #define fsw_u64_be_sip(var) (var = FSW_SWAPVALUE_U64(var)) #else #ifdef FSW_BIG_ENDIAN #define fsw_u16_le_swap(v) FSW_SWAPVALUE_U16(v) #define fsw_u16_be_swap(v) (v) #define fsw_u32_le_swap(v) FSW_SWAPVALUE_U32(v) #define fsw_u32_be_swap(v) (v) #define fsw_u64_le_swap(v) FSW_SWAPVALUE_U64(v) #define fsw_u64_be_swap(v) (v) #define fsw_u16_le_sip(var) (var = FSW_SWAPVALUE_U16(var)) #define fsw_u16_be_sip(var) #define fsw_u32_le_sip(var) (var = FSW_SWAPVALUE_U32(var)) #define fsw_u32_be_sip(var) #define fsw_u64_le_sip(var) (var = FSW_SWAPVALUE_U64(var)) #define fsw_u64_be_sip(var) #else #fail Neither FSW_BIG_ENDIAN nor FSW_LITTLE_ENDIAN are defined #endif #endif /*@}*/ // // The following evil hack avoids a lot of casts between generic and fstype-specific // structures. // #ifndef VOLSTRUCTNAME #define VOLSTRUCTNAME fsw_volume #else struct VOLSTRUCTNAME; #endif #ifndef DNODESTRUCTNAME #define DNODESTRUCTNAME fsw_dnode #else struct DNODESTRUCTNAME; #endif /** * Status code type, returned from all functions that can fail. */ typedef int fsw_status_t; /** * Possible status codes. */ enum { FSW_SUCCESS, FSW_OUT_OF_MEMORY = 1, FSW_IO_ERROR = 2, FSW_UNSUPPORTED = 3, FSW_NOT_FOUND = 4, FSW_VOLUME_CORRUPTED = 5, FSW_UNKNOWN_ERROR }; //#define RETURN_WARN_UNKNOWN_GLYPH ENCODE_WARNING (1) //#define RETURN_WARN_DELETE_FAILURE ENCODE_WARNING (2) //#define RETURN_WARN_WRITE_FAILURE ENCODE_WARNING (3) //#define RETURN_WARN_BUFFER_TOO_SMALL ENCODE_WARNING (4) //#define RETURN_WARN_STALE_DATA ENCODE_WARNING (5) //#define RETURN_SUCCESS 0 //#define RETURN_LOAD_ERROR ENCODE_ERROR (1) //#define RETURN_INVALID_PARAMETER ENCODE_ERROR (2) //#define RETURN_UNSUPPORTED ENCODE_ERROR (3) //#define RETURN_BAD_BUFFER_SIZE ENCODE_ERROR (4) //#define RETURN_BUFFER_TOO_SMALL ENCODE_ERROR (5) //#define RETURN_NOT_READY ENCODE_ERROR (6) //#define RETURN_DEVICE_ERROR ENCODE_ERROR (7) //#define RETURN_WRITE_PROTECTED ENCODE_ERROR (8) //#define RETURN_OUT_OF_RESOURCES ENCODE_ERROR (9) //#define RETURN_VOLUME_CORRUPTED ENCODE_ERROR (10) //#define RETURN_END_OF_FILE ENCODE_ERROR (31) //#define RETURN_NOT_FOUND ENCODE_ERROR (14) //#define RETURN_ACCESS_DENIED ENCODE_ERROR (15) /** * Core: A string with explicit length and encoding information. */ struct fsw_string { int type; //!< Encoding of the string - empty, ISO-8859-1, UTF8, UTF16 int len; //!< Length in characters int size; //!< Total data size in bytes void *data; //!< Data pointer (may be NULL if type is EMPTY or len is zero) }; /** * Possible string types / encodings. In the case of FSW_STRING_TYPE_EMPTY, * all other members of the fsw_string structure may be invalid. */ enum { FSW_STRING_TYPE_EMPTY, FSW_STRING_TYPE_ISO88591, FSW_STRING_TYPE_UTF8, FSW_STRING_TYPE_UTF16, FSW_STRING_TYPE_UTF16_SWAPPED }; #ifdef FSW_LITTLE_ENDIAN #define FSW_STRING_TYPE_UTF16_LE FSW_STRING_TYPE_UTF16 #define FSW_STRING_TYPE_UTF16_BE FSW_STRING_TYPE_UTF16_SWAPPED #else #define FSW_STRING_TYPE_UTF16_LE FSW_STRING_TYPE_UTF16_SWAPPED #define FSW_STRING_TYPE_UTF16_BE FSW_STRING_TYPE_UTF16 #endif /** Static initializer for an empty string. */ #define FSW_STRING_INIT { FSW_STRING_TYPE_EMPTY, 0, 0, NULL } /* forward declarations */ struct fsw_dnode; struct fsw_host_table; struct fsw_fstype_table; struct fsw_blockcache { fsw_u32 refcount; //!< Reference count fsw_u32 cache_level; //!< Level of importance of this block fsw_u32 phys_bno; //!< Physical block number void *data; //!< Block data buffer }; /** * Core: Represents a mounted volume. */ struct fsw_volume { fsw_u32 phys_blocksize; //!< Block size for disk access / file system structures fsw_u32 log_blocksize; //!< Block size for logical file data struct DNODESTRUCTNAME *root; //!< Root directory dnode struct fsw_string label; //!< Volume label struct fsw_dnode *dnode_head; //!< List of all dnodes allocated for this volume struct fsw_blockcache *bcache; //!< Array of block cache entries fsw_u32 bcache_size; //!< Number of entries in the block cache array void *host_data; //!< Hook for a host-specific data structure struct fsw_host_table *host_table; //!< Dispatch table for host-specific functions struct fsw_fstype_table *fstype_table; //!< Dispatch table for file system specific functions int host_string_type; //!< String type used by the host environment }; /** * Core: Represents a "directory node" - a file, directory, symlink, whatever. */ struct fsw_dnode { fsw_u32 refcount; //!< Reference count struct VOLSTRUCTNAME *vol; //!< The volume this dnode belongs to struct DNODESTRUCTNAME *parent; //!< Parent directory dnode struct fsw_string name; //!< Name of this item in the parent directory fsw_u32 dnode_id; //!< Unique id number (usually the inode number) int type; //!< Type of the dnode - file, dir, symlink, special fsw_u64 size; //!< Data size in bytes struct fsw_dnode *next; //!< Doubly-linked list of all dnodes: previous dnode struct fsw_dnode *prev; //!< Doubly-linked list of all dnodes: next dnode fsw_u32 numcslots; //!< Number of slots occupied #if defined(FSW_DNODE_CACHE_SIZE) && (FSW_DNODE_CACHE_SIZE > 0) struct fsw_dnode *cache[FSW_DNODE_CACHE_SIZE]; //!< Rudimentary cache for directory lookups #endif }; /** * Possible dnode types. FSW_DNODE_TYPE_UNKNOWN may only be used before * fsw_dnode_fill has been called on the dnode. */ enum { FSW_DNODE_TYPE_UNKNOWN, FSW_DNODE_TYPE_FILE, FSW_DNODE_TYPE_DIR, FSW_DNODE_TYPE_SYMLINK, FSW_DNODE_TYPE_SPECIAL }; /** * Core: Stores the mapping of a region of a file to the data on disk. */ struct fsw_extent { int type; //!< Type of extent specification fsw_u32 log_start; //!< Starting logical block number fsw_u32 log_count; //!< Logical block count fsw_u32 phys_start; //!< Starting physical block number (for FSW_EXTENT_TYPE_PHYSBLOCK only) void *buffer; //!< Allocated buffer pointer (for FSW_EXTENT_TYPE_BUFFER only) }; /** * Possible extent representation types. FSW_EXTENT_TYPE_INVALID is for shandle's * internal use only, it must not be returned from a get_extent function. */ enum { FSW_EXTENT_TYPE_INVALID, FSW_EXTENT_TYPE_SPARSE, FSW_EXTENT_TYPE_PHYSBLOCK, FSW_EXTENT_TYPE_BUFFER }; /** * Core: An access structure to a dnode's raw data. There can be multiple * shandles per dnode, each of them has its own position pointer. */ struct fsw_shandle { struct fsw_dnode *dnode; //!< The dnode this handle reads data from fsw_u64 pos; //!< Current file pointer in bytes struct fsw_extent extent; //!< Current extent }; /** * Core: Used in gathering detailed information on a volume. */ struct fsw_volume_stat { fsw_u64 total_bytes; //!< Total size of data area size in bytes fsw_u64 free_bytes; //!< Bytes still available for storing file data }; /** * Core: Used in gathering detailed information on a dnode. */ struct fsw_dnode_stat_str { fsw_u64 used_bytes; //!< Bytes actually used by the file on disk void (*store_time_posix)(struct fsw_dnode_stat_str *sb, int which, fsw_u32 posix_time); //!< Callback for storing a Posix-style timestamp void (*store_attr_posix)(struct fsw_dnode_stat_str *sb, fsw_u16 posix_mode); //!< Callback for storing a Posix-style file mode void *host_data; //!< Hook for a host-specific data structure }; /** * Type of the timestamp passed into store_time_posix. */ enum { FSW_DNODE_STAT_CTIME, FSW_DNODE_STAT_MTIME, FSW_DNODE_STAT_ATIME }; /** * Core: Function table for a host environment. */ struct fsw_host_table { int native_string_type; //!< String type used by the host environment void (*change_blocksize)(struct fsw_volume *vol, fsw_u32 old_phys_blocksize, fsw_u32 old_log_blocksize, fsw_u32 new_phys_blocksize, fsw_u32 new_log_blocksize); fsw_status_t (*read_block)(struct fsw_volume *vol, fsw_u32 phys_bno, void *buffer); }; /** * Core: Function table for a file system driver. */ struct fsw_fstype_table { struct fsw_string name; //!< String giving the name of the file system fsw_u32 volume_struct_size; //!< Size for allocating the fsw_volume structure fsw_u32 dnode_struct_size; //!< Size for allocating the fsw_dnode structure fsw_status_t (*volume_mount)(struct VOLSTRUCTNAME *vol); void (*volume_free)(struct VOLSTRUCTNAME *vol); fsw_status_t (*volume_stat)(struct VOLSTRUCTNAME *vol, struct fsw_volume_stat *sb); fsw_status_t (*dnode_fill)(struct VOLSTRUCTNAME *vol, struct DNODESTRUCTNAME *dno); void (*dnode_free)(struct VOLSTRUCTNAME *vol, struct DNODESTRUCTNAME *dno); fsw_status_t (*dnode_stat)(struct VOLSTRUCTNAME *vol, struct DNODESTRUCTNAME *dno, struct fsw_dnode_stat_str *sb); fsw_status_t (*get_extent)(struct VOLSTRUCTNAME *vol, struct DNODESTRUCTNAME *dno, struct fsw_extent *extent); fsw_status_t (*dir_lookup)(struct VOLSTRUCTNAME *vol, struct DNODESTRUCTNAME *dno, struct fsw_string *lookup_name, struct DNODESTRUCTNAME **child_dno); fsw_status_t (*dir_read)(struct VOLSTRUCTNAME *vol, struct DNODESTRUCTNAME *dno, struct fsw_shandle *shand, struct DNODESTRUCTNAME **child_dno); fsw_status_t (*readlink)(struct VOLSTRUCTNAME *vol, struct DNODESTRUCTNAME *dno, struct fsw_string *link_target); }; /** * \name Volume Functions */ /*@{*/ fsw_status_t fsw_mount(void *host_data, struct fsw_host_table *host_table, struct fsw_fstype_table *fstype_table, struct fsw_volume **vol_out); void fsw_unmount(struct fsw_volume *vol); fsw_status_t fsw_volume_stat(struct fsw_volume *vol, struct fsw_volume_stat *sb); static inline struct fsw_volume* SafeCast1(struct VOLSTRUCTNAME* x) { return (struct fsw_volume*) x; } static inline struct fsw_dnode* SafeCast2(struct DNODESTRUCTNAME* x) { return (struct fsw_dnode*) x; } static inline struct fsw_dnode** SafeCast3(struct DNODESTRUCTNAME** x) { return (struct fsw_dnode**) x; } //void fsw_set_blocksize(struct VOLSTRUCTNAME *vol, fsw_u32 phys_blocksize, fsw_u32 log_blocksize); #define fsw_set_blocksize(x, y, z) fsw_set_blocksize_(SafeCast1(x), (y), (z)) void fsw_set_blocksize_(struct fsw_volume *vol, fsw_u32 phys_blocksize, fsw_u32 log_blocksize); //fsw_status_t fsw_block_get(struct VOLSTRUCTNAME *vol, fsw_u32 phys_bno, fsw_u32 cache_level, void **buffer_out); #define fsw_block_get(x, y, z, w) fsw_block_get_(SafeCast1(x), (y), (z), (w)) fsw_status_t fsw_block_get_(struct fsw_volume *vol, fsw_u32 phys_bno, fsw_u32 cache_level, void **buffer_out); //void fsw_block_release(struct VOLSTRUCTNAME *vol, fsw_u32 phys_bno, void *buffer); #define fsw_block_release(x, y, z) fsw_block_release_(SafeCast1(x), (y), (z)) void fsw_block_release_(struct fsw_volume *vol, fsw_u32 phys_bno, void *buffer); /*@}*/ /** * \name dnode Functions */ /*@{*/ //fsw_status_t fsw_dnode_create_root(struct VOLSTRUCTNAME *vol, fsw_u32 dnode_id, struct DNODESTRUCTNAME **dno_out); #define fsw_dnode_create_root(x, y, z) fsw_dnode_create_root_(SafeCast1(x), (y), SafeCast3(z)) fsw_status_t fsw_dnode_create_root_(struct fsw_volume *vol, fsw_u32 dnode_id, struct fsw_dnode **dno_out); //fsw_status_t fsw_dnode_create(struct DNODESTRUCTNAME *parent_dno, fsw_u32 dnode_id, int type, // struct fsw_string *name, struct DNODESTRUCTNAME **dno_out); #define fsw_dnode_create(x, y, z, w, u) fsw_dnode_create_(SafeCast2(x), (y), (z), (w), SafeCast3(u)) fsw_status_t fsw_dnode_create_(struct fsw_dnode *parent_dno, fsw_u32 dnode_id, int type, struct fsw_string *name, struct fsw_dnode **dno_out); void fsw_dnode_retain(struct fsw_dnode *dno); void fsw_dnode_release(struct fsw_dnode *dno); fsw_status_t fsw_dnode_fill(struct fsw_dnode *dno); fsw_status_t fsw_dnode_stat(struct fsw_dnode *dno, struct fsw_dnode_stat_str *sb); fsw_status_t fsw_dnode_lookup_cache(struct fsw_dnode *dno, struct fsw_string *lookup_name, struct fsw_dnode **child_dno_out); fsw_status_t fsw_dnode_lookup(struct fsw_dnode *dno, struct fsw_string *lookup_name, struct fsw_dnode **child_dno_out); fsw_status_t fsw_dnode_lookup_path(struct fsw_dnode *dno, struct fsw_string *lookup_path, char separator, struct fsw_dnode **child_dno_out); fsw_status_t fsw_dnode_dir_read(struct fsw_shandle *shand, struct fsw_dnode **child_dno_out); fsw_status_t fsw_dnode_readlink(struct fsw_dnode *dno, struct fsw_string *link_target); //fsw_status_t fsw_dnode_readlink_data(struct DNODESTRUCTNAME *dno, struct fsw_string *link_target); #define fsw_dnode_readlink_data(x, y) fsw_dnode_readlink_data_(SafeCast2(x), (y)) fsw_status_t fsw_dnode_readlink_data_(struct fsw_dnode *dno, struct fsw_string *link_target); fsw_status_t fsw_dnode_resolve(struct fsw_dnode *dno, struct fsw_dnode **target_dno_out); /*@}*/ /** * \name shandle Functions */ /*@{*/ //fsw_status_t fsw_shandle_open(struct DNODESTRUCTNAME *dno, struct fsw_shandle *shand); #define fsw_shandle_open(x, y) fsw_shandle_open_(SafeCast2(x), (y)) fsw_status_t fsw_shandle_open_(struct fsw_dnode *dno, struct fsw_shandle *shand); void fsw_shandle_close(struct fsw_shandle *shand); fsw_status_t fsw_shandle_read(struct fsw_shandle *shand, fsw_u32 *buffer_size_inout, void *buffer); /*@}*/ /** * \name Memory Functions */ /*@{*/ fsw_status_t fsw_alloc_zero(int len, void **ptr_out); fsw_status_t fsw_memdup(void **dest_out, void *src, int len); /*@}*/ /** * \name String Functions */ /*@{*/ int fsw_strlen(struct fsw_string *s); int fsw_streq(struct fsw_string *s1, struct fsw_string *s2); int fsw_streq_cstr(struct fsw_string *s1, const char *s2); fsw_status_t fsw_strdup_coerce(struct fsw_string *dest, int type, struct fsw_string *src); void fsw_strsplit(struct fsw_string *lookup_name, struct fsw_string *buffer, char separator); void fsw_strfree(struct fsw_string *s); fsw_u16 fsw_to_lower(fsw_u16 ch); /*@}*/ /** * \name Posix Mode Macros * These macros can be used globally to test fields and bits in * Posix-style modes. * * Taken from FreeBSD sys/stat.h. */ /*@{*/ #ifndef S_IRWXU // this is octal data!!!! #define S_ISUID 0004000 /* set user id on execution */ #define S_ISGID 0002000 /* set group id on execution */ #define S_ISTXT 0001000 /* sticky bit */ #define S_IRWXU 0000700 /* RWX mask for owner */ #define S_IRUSR 0000400 /* R for owner 0x0100 */ #define S_IWUSR 0000200 /* W for owner */ #define S_IXUSR 0000100 /* X for owner */ #define S_IRWXG 0000070 /* RWX mask for group */ #define S_IRGRP 0000040 /* R for group 0x0020 */ #define S_IWGRP 0000020 /* W for group */ #define S_IXGRP 0000010 /* X for group */ #define S_IRWXO 0000007 /* RWX mask for other */ #define S_IROTH 0000004 /* R for other */ #define S_IWOTH 0000002 /* W for other */ #define S_IXOTH 0000001 /* X for other */ #define S_IFMT 0170000 /* type of file mask */ #define S_IFIFO 0010000 /* named pipe (fifo) */ #define S_IFCHR 0020000 /* character special */ #define S_IFDIR 0040000 /* directory */ #define S_IFBLK 0060000 /* block special */ #define S_IFREG 0100000 /* regular 0x8000 */ #define S_IFLNK 0120000 /* symbolic link 0xA000 */ #define S_IFSOCK 0140000 /* socket */ #define S_ISVTX 0001000 /* save swapped text even after use */ #define S_IFWHT 0160000 /* whiteout */ #define S_ISDIR(m) (((m) & 0170000) == 0040000) /* directory */ #define S_ISCHR(m) (((m) & 0170000) == 0020000) /* char special */ #define S_ISBLK(m) (((m) & 0170000) == 0060000) /* block special */ #define S_ISREG(m) (((m) & 0170000) == 0100000) /* regular file */ #define S_ISFIFO(m) (((m) & 0170000) == 0010000) /* fifo or socket */ #define S_ISLNK(m) (((m) & 0170000) == 0120000) /* symbolic link */ #define S_ISSOCK(m) (((m) & 0170000) == 0140000) /* socket */ #define S_ISWHT(m) (((m) & 0170000) == 0160000) /* whiteout */ #define S_BLKSIZE 512 /* block size used in the stat struct */ #endif /*@}*/ #endif