{-# LANGUAGE CApiFFI #-} {-# LANGUAGE RecordWildCards #-} {-# LANGUAGE Trustworthy #-} {-# LANGUAGE PatternSynonyms #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE NumDecimals #-} ----------------------------------------------------------------------------- -- | -- Module : System.Posix.Files.Common -- Copyright : (c) The University of Glasgow 2002 -- License : BSD-style (see the file libraries/base/LICENSE) -- -- Maintainer : libraries@haskell.org -- Stability : provisional -- Portability : non-portable (requires POSIX) -- -- Functions defined by the POSIX standards for manipulating and querying the -- file system. Names of underlying POSIX functions are indicated whenever -- possible. A more complete documentation of the POSIX functions together -- with a more detailed description of different error conditions are usually -- available in the system's manual pages or from -- (free registration required). -- -- When a function that calls an underlying POSIX function fails, the errno -- code is converted to an 'IOError' using 'Foreign.C.Error.errnoToIOError'. -- For a list of which errno codes may be generated, consult the POSIX -- documentation for the underlying function. -- ----------------------------------------------------------------------------- #include "HsUnix.h" module System.Posix.Files.Common ( -- * File modes -- FileMode exported by System.Posix.Types unionFileModes, intersectFileModes, nullFileMode, ownerReadMode, ownerWriteMode, ownerExecuteMode, ownerModes, groupReadMode, groupWriteMode, groupExecuteMode, groupModes, otherReadMode, otherWriteMode, otherExecuteMode, otherModes, setUserIDMode, setGroupIDMode, stdFileMode, accessModes, fileTypeModes, blockSpecialMode, characterSpecialMode, namedPipeMode, regularFileMode, directoryMode, symbolicLinkMode, socketMode, -- ** Setting file modes setFdMode, setFileCreationMask, -- * File status FileStatus(..), -- ** Obtaining file status getFdStatus, -- ** Querying file status deviceID, fileID, fileMode, linkCount, fileOwner, fileGroup, specialDeviceID, fileSize, accessTime, modificationTime, statusChangeTime, accessTimeHiRes, modificationTimeHiRes, statusChangeTimeHiRes, setFdTimesHiRes, touchFd, isBlockDevice, isCharacterDevice, isNamedPipe, isRegularFile, isDirectory, isSymbolicLink, isSocket, fileBlockSize, fileBlocks, -- * Extended file status StatxFlags(..), pattern EmptyPath, pattern NoAutoMount, pattern SymlinkNoFollow, pattern SyncAsStat, pattern ForceSync, pattern DontSync, defaultStatxFlags, StatxMask(..), pattern StatxType, pattern StatxMode, pattern StatxNlink, pattern StatxUid, pattern StatxGid, pattern StatxAtime, pattern StatxMtime, pattern StatxCtime, pattern StatxBtime, pattern StatxIno, pattern StatxSize, pattern StatxBlocks, pattern StatxMntId, pattern StatxBasicStats, pattern StatxAll, defaultStatxMask, ExtendedFileStatus(..), CAttributes(..), getExtendedFileStatus_, fileBlockSizeX, linkCountX, fileOwnerX, fileGroupX, fileModeX, fileIDX, fileSizeX, fileBlocksX, accessTimeHiResX, creationTimeHiResX, statusChangeTimeHiResX, modificationTimeHiResX, deviceIDX, specialDeviceIDX, mountIDX, fileCompressedX, fileImmutableX, fileAppendX, fileNoDumpX, fileEncryptedX, fileVerityX, fileDaxX, isBlockDeviceX, isCharacterDeviceX, isNamedPipeX, isRegularFileX, isDirectoryX, isSymbolicLinkX, isSocketX, haveStatx, -- * Setting file sizes setFdSize, -- * Changing file ownership setFdOwnerAndGroup, -- * Find system-specific limits for a file PathVar(..), getFdPathVar, pathVarConst, -- * Low level types and functions #ifdef HAVE_UTIMENSAT CTimeSpec(..), toCTimeSpec, c_utimensat, #endif #if defined(javascript_HOST_ARCH) js_futimes, js_utimes, js_lutimes, #endif CTimeVal(..), toCTimeVal, c_utimes, #ifdef HAVE_LUTIMES c_lutimes, #endif ) where import System.Posix.Types import System.IO.Unsafe import Data.Bits import Data.Int import Data.Ratio import Data.Word #ifdef HAVE_STATX import Data.Time.Clock (secondsToNominalDiffTime) import Data.Fixed (Fixed(..)) #endif import Data.Time.Clock.POSIX (POSIXTime) import System.Posix.Internals import Foreign.C import Foreign.ForeignPtr #if defined(HAVE_FUTIMES) || defined(HAVE_FUTIMENS) import Foreign.Marshal (withArray) #endif import Foreign.Ptr import Foreign.Storable #if !defined(HAVE_FCHMOD) || !defined(HAVE_CHOWN) || !defined(HAVE_STATX) import System.IO.Error ( ioeSetLocation ) import GHC.IO.Exception ( unsupportedOperation ) #endif -- ----------------------------------------------------------------------------- -- POSIX file modes -- The abstract type 'FileMode', constants and operators for -- manipulating the file modes defined by POSIX. -- | No permissions. nullFileMode :: FileMode nullFileMode = 0 -- | Owner has read permission. ownerReadMode :: FileMode ownerReadMode = (#const S_IRUSR) -- | Owner has write permission. ownerWriteMode :: FileMode ownerWriteMode = (#const S_IWUSR) -- | Owner has execute permission. ownerExecuteMode :: FileMode ownerExecuteMode = (#const S_IXUSR) -- | Group has read permission. groupReadMode :: FileMode groupReadMode = (#const S_IRGRP) -- | Group has write permission. groupWriteMode :: FileMode groupWriteMode = (#const S_IWGRP) -- | Group has execute permission. groupExecuteMode :: FileMode groupExecuteMode = (#const S_IXGRP) -- | Others have read permission. otherReadMode :: FileMode otherReadMode = (#const S_IROTH) -- | Others have write permission. otherWriteMode :: FileMode otherWriteMode = (#const S_IWOTH) -- | Others have execute permission. otherExecuteMode :: FileMode otherExecuteMode = (#const S_IXOTH) -- | Set user ID on execution. setUserIDMode :: FileMode setUserIDMode = (#const S_ISUID) -- | Set group ID on execution. setGroupIDMode :: FileMode setGroupIDMode = (#const S_ISGID) -- | Owner, group and others have read and write permission. stdFileMode :: FileMode stdFileMode = ownerReadMode .|. ownerWriteMode .|. groupReadMode .|. groupWriteMode .|. otherReadMode .|. otherWriteMode -- | Owner has read, write and execute permission. ownerModes :: FileMode ownerModes = (#const S_IRWXU) -- | Group has read, write and execute permission. groupModes :: FileMode groupModes = (#const S_IRWXG) -- | Others have read, write and execute permission. otherModes :: FileMode otherModes = (#const S_IRWXO) -- | Owner, group and others have read, write and execute permission. accessModes :: FileMode accessModes = ownerModes .|. groupModes .|. otherModes -- | Combines the two file modes into one that contains modes that appear in -- either. unionFileModes :: FileMode -> FileMode -> FileMode unionFileModes m1 m2 = m1 .|. m2 -- | Combines two file modes into one that only contains modes that appear in -- both. intersectFileModes :: FileMode -> FileMode -> FileMode intersectFileModes m1 m2 = m1 .&. m2 fileTypeModes :: FileMode fileTypeModes = (#const S_IFMT) blockSpecialMode :: FileMode blockSpecialMode = (#const S_IFBLK) characterSpecialMode :: FileMode characterSpecialMode = (#const S_IFCHR) namedPipeMode :: FileMode namedPipeMode = (#const S_IFIFO) regularFileMode :: FileMode regularFileMode = (#const S_IFREG) directoryMode :: FileMode directoryMode = (#const S_IFDIR) symbolicLinkMode :: FileMode symbolicLinkMode = (#const S_IFLNK) socketMode :: FileMode socketMode = (#const S_IFSOCK) #if defined(HAVE_FCHMOD) -- | @setFdMode fd mode@ acts like 'setFileMode' but uses a file descriptor -- @fd@ instead of a 'FilePath'. -- -- Note: calls @fchmod@. setFdMode :: Fd -> FileMode -> IO () setFdMode (Fd fd) m = throwErrnoIfMinus1_ "setFdMode" (c_fchmod fd m) foreign import ccall unsafe "fchmod" c_fchmod :: CInt -> CMode -> IO CInt #else {-# WARNING setFdMode "operation will throw 'IOError' \"unsupported operation\" (CPP guard: @#if HAVE_FCHMOD@)" #-} setFdMode :: Fd -> FileMode -> IO () setFdMode _ _ = ioError (ioeSetLocation unsupportedOperation "setFdMode") #endif // HAVE_FCHMOD -- | @setFileCreationMask mode@ sets the file mode creation mask to @mode@. -- Modes set by this operation are subtracted from files and directories upon -- creation. The previous file creation mask is returned. -- -- Note: calls @umask@. setFileCreationMask :: FileMode -> IO FileMode setFileCreationMask mask = c_umask mask -- ----------------------------------------------------------------------------- -- stat() support -- | POSIX defines operations to get information, such as owner, permissions, -- size and access times, about a file. This information is represented by the -- 'FileStatus' type. -- -- Note: see @chmod@. -- -- Limitations: Support for high resolution timestamps is filesystem dependent: -- -- - HFS+ volumes on OS X only support whole-second times. -- newtype FileStatus = FileStatus (ForeignPtr CStat) -- ^ The constructor is considered internal and may change. -- | ID of the device on which this file resides. deviceID :: FileStatus -> DeviceID -- | inode number fileID :: FileStatus -> FileID -- | File mode (such as permissions). fileMode :: FileStatus -> FileMode -- | Number of hard links to this file. linkCount :: FileStatus -> LinkCount -- | ID of owner. fileOwner :: FileStatus -> UserID -- | ID of group. fileGroup :: FileStatus -> GroupID -- | Describes the device that this file represents. specialDeviceID :: FileStatus -> DeviceID -- | Size of the file in bytes. If this file is a symbolic link the size is -- the length of the pathname it contains. fileSize :: FileStatus -> FileOffset -- | Number of blocks allocated for this file, in units of -- 512-bytes. Returns @Nothing@ if @st_blocks@ is not supported on this -- platform. fileBlocks :: FileStatus -> Maybe CBlkCnt -- | Gives the preferred block size for efficient filesystem I/O in -- bytes. Returns @Nothing@ if @st_blocksize@ is not supported on this -- platform. fileBlockSize :: FileStatus -> Maybe CBlkSize -- | Time of last access. accessTime :: FileStatus -> EpochTime -- | Time of last access in sub-second resolution. Depends on the timestamp resolution of the -- underlying filesystem. accessTimeHiRes :: FileStatus -> POSIXTime -- | Time of last modification. modificationTime :: FileStatus -> EpochTime -- | Time of last modification in sub-second resolution. Depends on the timestamp resolution of the -- underlying filesystem. modificationTimeHiRes :: FileStatus -> POSIXTime -- | Time of last status change (i.e. owner, group, link count, mode, etc.). statusChangeTime :: FileStatus -> EpochTime -- | Time of last status change (i.e. owner, group, link count, mode, etc.) in sub-second resolution. -- Depends on the timestamp resolution of the underlying filesystem. statusChangeTimeHiRes :: FileStatus -> POSIXTime deviceID (FileStatus stat) = unsafePerformIO $ withForeignPtr stat $ (#peek struct stat, st_dev) fileID (FileStatus stat) = unsafePerformIO $ withForeignPtr stat $ (#peek struct stat, st_ino) fileMode (FileStatus stat) = unsafePerformIO $ withForeignPtr stat $ (#peek struct stat, st_mode) linkCount (FileStatus stat) = unsafePerformIO $ withForeignPtr stat $ (#peek struct stat, st_nlink) fileOwner (FileStatus stat) = unsafePerformIO $ withForeignPtr stat $ (#peek struct stat, st_uid) fileGroup (FileStatus stat) = unsafePerformIO $ withForeignPtr stat $ (#peek struct stat, st_gid) specialDeviceID (FileStatus stat) = unsafePerformIO $ withForeignPtr stat $ (#peek struct stat, st_rdev) fileSize (FileStatus stat) = unsafePerformIO $ withForeignPtr stat $ (#peek struct stat, st_size) accessTime (FileStatus stat) = unsafePerformIO $ withForeignPtr stat $ (#peek struct stat, st_atime) modificationTime (FileStatus stat) = unsafePerformIO $ withForeignPtr stat $ (#peek struct stat, st_mtime) statusChangeTime (FileStatus stat) = unsafePerformIO $ withForeignPtr stat $ (#peek struct stat, st_ctime) #ifdef HAVE_STRUCT_STAT_ST_BLOCKS fileBlocks (FileStatus stat) = Just $ unsafePerformIO $ withForeignPtr stat $ (#peek struct stat, st_blocks) #else fileBlocks _ = Nothing #endif #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE fileBlockSize (FileStatus stat) = Just $ unsafePerformIO $ withForeignPtr stat $ (#peek struct stat, st_blksize) #else fileBlockSize _ = Nothing #endif accessTimeHiRes (FileStatus stat) = unsafePerformIO $ withForeignPtr stat $ \stat_ptr -> do sec <- (#peek struct stat, st_atime) stat_ptr :: IO EpochTime #ifdef HAVE_STRUCT_STAT_ST_ATIM nsec <- (#peek struct stat, st_atim.tv_nsec) stat_ptr :: IO (#type long) let frac = toInteger nsec % 10^(9::Int) #elif HAVE_STRUCT_STAT_ST_ATIMESPEC nsec <- (#peek struct stat, st_atimespec.tv_nsec) stat_ptr :: IO (#type long) let frac = toInteger nsec % 10^(9::Int) #elif HAVE_STRUCT_STAT_ST_ATIMENSEC nsec <- (#peek struct stat, st_atimensec) stat_ptr :: IO (#type long) let frac = toInteger nsec % 10^(9::Int) #elif HAVE_STRUCT_STAT_ST_ATIME_N nsec <- (#peek struct stat, st_atime_n) stat_ptr :: IO (#type int) let frac = toInteger nsec % 10^(9::Int) #elif HAVE_STRUCT_STAT_ST_UATIME usec <- (#peek struct stat, st_uatime) stat_ptr :: IO (#type int) let frac = toInteger usec % 10^(6::Int) #else let frac = 0 #endif return $ fromRational $ toRational sec + frac modificationTimeHiRes (FileStatus stat) = unsafePerformIO $ withForeignPtr stat $ \stat_ptr -> do sec <- (#peek struct stat, st_mtime) stat_ptr :: IO EpochTime #ifdef HAVE_STRUCT_STAT_ST_MTIM nsec <- (#peek struct stat, st_mtim.tv_nsec) stat_ptr :: IO (#type long) let frac = toInteger nsec % 10^(9::Int) #elif HAVE_STRUCT_STAT_ST_MTIMESPEC nsec <- (#peek struct stat, st_mtimespec.tv_nsec) stat_ptr :: IO (#type long) let frac = toInteger nsec % 10^(9::Int) #elif HAVE_STRUCT_STAT_ST_MTIMENSEC nsec <- (#peek struct stat, st_mtimensec) stat_ptr :: IO (#type long) let frac = toInteger nsec % 10^(9::Int) #elif HAVE_STRUCT_STAT_ST_MTIME_N nsec <- (#peek struct stat, st_mtime_n) stat_ptr :: IO (#type int) let frac = toInteger nsec % 10^(9::Int) #elif HAVE_STRUCT_STAT_ST_UMTIME usec <- (#peek struct stat, st_umtime) stat_ptr :: IO (#type int) let frac = toInteger usec % 10^(6::Int) #else let frac = 0 #endif return $ fromRational $ toRational sec + frac statusChangeTimeHiRes (FileStatus stat) = unsafePerformIO $ withForeignPtr stat $ \stat_ptr -> do sec <- (#peek struct stat, st_ctime) stat_ptr :: IO EpochTime #ifdef HAVE_STRUCT_STAT_ST_CTIM nsec <- (#peek struct stat, st_ctim.tv_nsec) stat_ptr :: IO (#type long) let frac = toInteger nsec % 10^(9::Int) #elif HAVE_STRUCT_STAT_ST_CTIMESPEC nsec <- (#peek struct stat, st_ctimespec.tv_nsec) stat_ptr :: IO (#type long) let frac = toInteger nsec % 10^(9::Int) #elif HAVE_STRUCT_STAT_ST_CTIMENSEC nsec <- (#peek struct stat, st_ctimensec) stat_ptr :: IO (#type long) let frac = toInteger nsec % 10^(9::Int) #elif HAVE_STRUCT_STAT_ST_CTIME_N nsec <- (#peek struct stat, st_ctime_n) stat_ptr :: IO (#type int) let frac = toInteger nsec % 10^(9::Int) #elif HAVE_STRUCT_STAT_ST_UCTIME usec <- (#peek struct stat, st_uctime) stat_ptr :: IO (#type int) let frac = toInteger usec % 10^(6::Int) #else let frac = 0 #endif return $ fromRational $ toRational sec + frac -- | Checks if this file is a block device. isBlockDevice :: FileStatus -> Bool -- | Checks if this file is a character device. isCharacterDevice :: FileStatus -> Bool -- | Checks if this file is a named pipe device. isNamedPipe :: FileStatus -> Bool -- | Checks if this file is a regular file device. isRegularFile :: FileStatus -> Bool -- | Checks if this file is a directory device. isDirectory :: FileStatus -> Bool -- | Checks if this file is a symbolic link device. isSymbolicLink :: FileStatus -> Bool -- | Checks if this file is a socket device. isSocket :: FileStatus -> Bool isBlockDevice stat = (fileMode stat `intersectFileModes` fileTypeModes) == blockSpecialMode isCharacterDevice stat = (fileMode stat `intersectFileModes` fileTypeModes) == characterSpecialMode isNamedPipe stat = (fileMode stat `intersectFileModes` fileTypeModes) == namedPipeMode isRegularFile stat = (fileMode stat `intersectFileModes` fileTypeModes) == regularFileMode isDirectory stat = (fileMode stat `intersectFileModes` fileTypeModes) == directoryMode isSymbolicLink stat = (fileMode stat `intersectFileModes` fileTypeModes) == symbolicLinkMode isSocket stat = (fileMode stat `intersectFileModes` fileTypeModes) == socketMode -- | @getFdStatus fd@ acts as 'getFileStatus' but uses a file descriptor @fd@. -- -- Note: calls @fstat@. getFdStatus :: Fd -> IO FileStatus getFdStatus (Fd fd) = do fp <- mallocForeignPtrBytes (#const sizeof(struct stat)) withForeignPtr fp $ \p -> throwErrnoIfMinus1_ "getFdStatus" (c_fstat fd p) return (FileStatus fp) -- ----------------------------------------------------------------------------- -- Setting file times #if HAVE_UTIMENSAT || HAVE_FUTIMENS data CTimeSpec = CTimeSpec EpochTime CLong instance Storable CTimeSpec where sizeOf _ = #size struct timespec alignment _ = alignment (undefined :: CInt) poke p (CTimeSpec sec nsec) = do (#poke struct timespec, tv_sec ) p sec (#poke struct timespec, tv_nsec) p nsec peek p = do sec <- #{peek struct timespec, tv_sec } p nsec <- #{peek struct timespec, tv_nsec} p return $ CTimeSpec sec nsec toCTimeSpec :: POSIXTime -> CTimeSpec toCTimeSpec t = CTimeSpec (CTime sec) (truncate $ 10^(9::Int) * frac) where (sec, frac) = if (frac' < 0) then (sec' - 1, frac' + 1) else (sec', frac') (sec', frac') = properFraction $ toRational t #endif #ifdef HAVE_UTIMENSAT foreign import capi unsafe "sys/stat.h utimensat" c_utimensat :: CInt -> CString -> Ptr CTimeSpec -> CInt -> IO CInt #endif #if HAVE_FUTIMENS foreign import capi unsafe "sys/stat.h futimens" c_futimens :: CInt -> Ptr CTimeSpec -> IO CInt #endif data CTimeVal = CTimeVal CLong CLong instance Storable CTimeVal where sizeOf _ = #size struct timeval alignment _ = alignment (undefined :: CInt) poke p (CTimeVal sec usec) = do (#poke struct timeval, tv_sec ) p sec (#poke struct timeval, tv_usec) p usec peek p = do sec <- #{peek struct timeval, tv_sec } p usec <- #{peek struct timeval, tv_usec} p return $ CTimeVal sec usec toCTimeVal :: POSIXTime -> CTimeVal toCTimeVal t = CTimeVal sec (truncate $ 10^(6::Int) * frac) where (sec, frac) = if (frac' < 0) then (sec' - 1, frac' + 1) else (sec', frac') (sec', frac') = properFraction $ toRational t foreign import capi unsafe "sys/time.h utimes" c_utimes :: CString -> Ptr CTimeVal -> IO CInt #ifdef HAVE_LUTIMES foreign import capi unsafe "sys/time.h lutimes" c_lutimes :: CString -> Ptr CTimeVal -> IO CInt #endif #if HAVE_FUTIMES foreign import capi unsafe "sys/time.h futimes" c_futimes :: CInt -> Ptr CTimeVal -> IO CInt #endif #if defined(javascript_HOST_ARCH) foreign import ccall unsafe "js_futimes" js_futimes :: CInt -> CDouble -> CDouble -> IO CInt foreign import ccall unsafe "js_lutimes" js_lutimes :: CFilePath -> CDouble -> CDouble -> IO CInt foreign import ccall unsafe "js_utimes" js_utimes :: CFilePath -> CDouble -> CDouble -> IO CInt #endif -- | Like 'setFileTimesHiRes' but uses a file descriptor instead of a path. -- This operation is not supported on all platforms. On these platforms, -- this function will raise an exception. -- -- Note: calls @futimens@ or @futimes@. Support for high resolution timestamps -- is filesystem dependent with the following limitations: -- -- - HFS+ volumes on OS X truncate the sub-second part of the timestamp. -- -- -- @since 2.7.0.0 setFdTimesHiRes :: Fd -> POSIXTime -> POSIXTime -> IO () #if defined(javascript_HOST_ARCH) setFdTimesHiRes (Fd fd) atime mtime = throwErrnoIfMinus1_ "setFdTimesHiRes" (js_futimes fd (realToFrac atime) (realToFrac mtime)) #elif HAVE_FUTIMENS setFdTimesHiRes (Fd fd) atime mtime = withArray [toCTimeSpec atime, toCTimeSpec mtime] $ \times -> throwErrnoIfMinus1_ "setFdTimesHiRes" (c_futimens fd times) #elif HAVE_FUTIMES setFdTimesHiRes (Fd fd) atime mtime = withArray [toCTimeVal atime, toCTimeVal mtime] $ \times -> throwErrnoIfMinus1_ "setFdTimesHiRes" (c_futimes fd times) #else {-# WARNING setFdTimesHiRes "setFdTimesHiRes: not available on this platform" #-} setFdTimesHiRes = error "setSymbolicLinkTimesHiRes: not available on this platform" #endif -- | Like 'touchFile' but uses a file descriptor instead of a path. -- This operation is not supported on all platforms. On these platforms, -- this function will raise an exception. -- -- Note: calls @futimes@. -- -- @since 2.7.0.0 touchFd :: Fd -> IO () #if defined(javascript_HOST_ARCH) touchFd (Fd fd) = -- (-1) indicates that current time must be used throwErrnoIfMinus1_ "touchFd" (js_futimes fd (-1) (-1)) #elif HAVE_FUTIMES touchFd (Fd fd) = throwErrnoIfMinus1_ "touchFd" (c_futimes fd nullPtr) #else {-# WARNING touchFd "touchFd: not available on this platform" #-} touchFd = error "touchFd: not available on this platform" #endif -- ----------------------------------------------------------------------------- -- fchown() #if defined(HAVE_CHOWN) -- | Acts as 'setOwnerAndGroup' but uses a file descriptor instead of a -- 'FilePath'. -- -- Note: calls @fchown@. setFdOwnerAndGroup :: Fd -> UserID -> GroupID -> IO () setFdOwnerAndGroup (Fd fd) uid gid = throwErrnoIfMinus1_ "setFdOwnerAndGroup" (c_fchown fd uid gid) foreign import ccall unsafe "fchown" c_fchown :: CInt -> CUid -> CGid -> IO CInt #else {-# WARNING setFdOwnerAndGroup "operation will throw 'IOError' \"unsupported operation\" (CPP guard: @#if HAVE_CHOWN@)" #-} setFdOwnerAndGroup :: Fd -> UserID -> GroupID -> IO () setFdOwnerAndGroup _ _ _ = ioError (ioeSetLocation unsupportedOperation "setFdOwnerAndGroup") #endif // HAVE_CHOWN -- ----------------------------------------------------------------------------- -- ftruncate() -- | Acts as 'setFileSize' but uses a file descriptor instead of a 'FilePath'. -- -- Note: calls @ftruncate@. setFdSize :: Fd -> FileOffset -> IO () setFdSize (Fd fd) off = throwErrnoIfMinus1_ "setFdSize" (c_ftruncate fd off) -- ----------------------------------------------------------------------------- -- pathconf()/fpathconf() support data PathVar = FileSizeBits {- _PC_FILESIZEBITS -} | LinkLimit {- _PC_LINK_MAX -} | InputLineLimit {- _PC_MAX_CANON -} | InputQueueLimit {- _PC_MAX_INPUT -} | FileNameLimit {- _PC_NAME_MAX -} | PathNameLimit {- _PC_PATH_MAX -} | PipeBufferLimit {- _PC_PIPE_BUF -} -- These are described as optional in POSIX: {- _PC_ALLOC_SIZE_MIN -} {- _PC_REC_INCR_XFER_SIZE -} {- _PC_REC_MAX_XFER_SIZE -} {- _PC_REC_MIN_XFER_SIZE -} {- _PC_REC_XFER_ALIGN -} | SymbolicLinkLimit {- _PC_SYMLINK_MAX -} | SetOwnerAndGroupIsRestricted {- _PC_CHOWN_RESTRICTED -} | FileNamesAreNotTruncated {- _PC_NO_TRUNC -} | VDisableChar {- _PC_VDISABLE -} | AsyncIOAvailable {- _PC_ASYNC_IO -} | PrioIOAvailable {- _PC_PRIO_IO -} | SyncIOAvailable {- _PC_SYNC_IO -} pathVarConst :: PathVar -> CInt pathVarConst v = case v of LinkLimit -> (#const _PC_LINK_MAX) InputLineLimit -> (#const _PC_MAX_CANON) InputQueueLimit -> (#const _PC_MAX_INPUT) FileNameLimit -> (#const _PC_NAME_MAX) PathNameLimit -> (#const _PC_PATH_MAX) PipeBufferLimit -> (#const _PC_PIPE_BUF) SetOwnerAndGroupIsRestricted -> (#const _PC_CHOWN_RESTRICTED) FileNamesAreNotTruncated -> (#const _PC_NO_TRUNC) VDisableChar -> (#const _PC_VDISABLE) #ifdef _PC_SYNC_IO SyncIOAvailable -> (#const _PC_SYNC_IO) #else SyncIOAvailable -> error "_PC_SYNC_IO not available" #endif #ifdef _PC_ASYNC_IO AsyncIOAvailable -> (#const _PC_ASYNC_IO) #else AsyncIOAvailable -> error "_PC_ASYNC_IO not available" #endif #ifdef _PC_PRIO_IO PrioIOAvailable -> (#const _PC_PRIO_IO) #else PrioIOAvailable -> error "_PC_PRIO_IO not available" #endif #if _PC_FILESIZEBITS FileSizeBits -> (#const _PC_FILESIZEBITS) #else FileSizeBits -> error "_PC_FILESIZEBITS not available" #endif #if _PC_SYMLINK_MAX SymbolicLinkLimit -> (#const _PC_SYMLINK_MAX) #else SymbolicLinkLimit -> error "_PC_SYMLINK_MAX not available" #endif -- | @getFdPathVar var fd@ obtains the dynamic value of the requested -- configurable file limit or option associated with the file or directory -- attached to the open channel @fd@. For defined file limits, @getFdPathVar@ -- returns the associated value. For defined file options, the result of -- @getFdPathVar@ is undefined, but not failure. -- -- Note: calls @fpathconf@. getFdPathVar :: Fd -> PathVar -> IO Limit getFdPathVar (Fd fd) v = throwErrnoIfMinus1 "getFdPathVar" $ c_fpathconf fd (pathVarConst v) foreign import ccall unsafe "fpathconf" c_fpathconf :: CInt -> CInt -> IO CLong -- ----------------------------------------------------------------------------- -- statx -- newtype {-# CTYPE "__u64" #-} CAttributes = CAttributes Word64 deriving (Read, Show, Eq, Ord, Storable, Num, Bits) -- | Statx flags. -- -- See the pattern synonyms for possible flags. These are combined via `(<>)`. -- Flags can be tested via `(.&.)`. -- -- The following flags influence pathname-based lookup: -- -- - 'EmptyPath' -- - 'NoAutoMount' -- - 'SymlinkNoFollow' -- -- The following flags can be used to control what sort of synchronization the kernel will do when querying a file on a remote filesystem: -- -- - 'SyncAsStat' -- - 'ForceSync' -- - 'DontSync' newtype StatxFlags = StatxFlags CInt deriving (Read, Show, Eq, Ord, Integral, Num, Enum, Bits, Real) -- | ORs the flags. instance Semigroup StatxFlags where a <> b = a .|. b instance Monoid StatxFlags where mappend = (<>) mempty = 0 -- | If pathname to 'getExtendedFileStatus' is an empty string, operate on the file referred to by -- the 'Maybe Fd' argument. -- -- In this case, it can refer to any type of file, not just a directory. pattern EmptyPath :: StatxFlags #ifdef AT_EMPTY_PATH pattern EmptyPath = StatxFlags (#const AT_EMPTY_PATH) #else pattern EmptyPath = StatxFlags 0 #endif -- | Don't automount the terminal ("basename") component of pathname if it is a directory that is an automount point. -- This allows the caller to gather attributes of an automount point (rather than the location it would mount). -- This flag can be used in tools that scan directories to prevent mass-automounting of a directory of automount points. -- This flag has no effect if the mount point has already been mounted over. pattern NoAutoMount :: StatxFlags #ifdef AT_NO_AUTOMOUNT pattern NoAutoMount = StatxFlags (#const AT_NO_AUTOMOUNT) #else pattern NoAutoMount = StatxFlags 0 #endif -- | If pathname is a symbolic link, do not dereference it: instead return information about the link itself, like @lstat(2)@. pattern SymlinkNoFollow :: StatxFlags #ifdef AT_SYMLINK_NOFOLLOW pattern SymlinkNoFollow = StatxFlags (#const AT_SYMLINK_NOFOLLOW) #else pattern SymlinkNoFollow = StatxFlags 0 #endif -- | Do whatever @stat(2)@ does. This is the default and is very much filesystem-specific. pattern SyncAsStat :: StatxFlags #ifdef AT_STATX_SYNC_AS_STAT pattern SyncAsStat = StatxFlags (#const AT_STATX_SYNC_AS_STAT) #else pattern SyncAsStat = StatxFlags 0 #endif -- | Force the attributes to be synchronized with the server. -- This may require that a network filesystem perform a data writeback to get the timestamps correct. pattern ForceSync :: StatxFlags #ifdef AT_STATX_FORCE_SYNC pattern ForceSync = StatxFlags (#const AT_STATX_FORCE_SYNC) #else pattern ForceSync = StatxFlags 0 #endif -- | Don't synchronize anything, but rather just take whatever the system has cached if possible. -- This may mean that the information returned is approximate, but, on a network filesystem, -- it may not involve a round trip to the server - even if no lease is held. pattern DontSync :: StatxFlags #ifdef AT_STATX_DONT_SYNC pattern DontSync = StatxFlags (#const AT_STATX_DONT_SYNC) #else pattern DontSync = StatxFlags 0 #endif defaultStatxFlags :: StatxFlags defaultStatxFlags = mempty -- | Mask argument to 'statx'. It's used to tell the kernel which fields the caller is interested in. -- -- See the pattern synonyms for possible masks. These are combined via @(<>)@. -- Masks can be tested via `(.&.)`. newtype StatxMask = StatxMask CInt deriving (Read, Show, Eq, Ord, Integral, Num, Enum, Bits, Real) -- | ORs the masks. instance Semigroup StatxMask where a <> b = a .|. b instance Monoid StatxMask where mappend = (<>) mempty = 0 -- | Want @stx_mode & S_IFMT@. pattern StatxType :: StatxMask #ifdef STATX_TYPE pattern StatxType = StatxMask (#const STATX_TYPE) #else pattern StatxType = StatxMask 0 #endif -- | Want @stx_mode & ~S_IFMT@. pattern StatxMode :: StatxMask #ifdef STATX_MODE pattern StatxMode = StatxMask (#const STATX_MODE) #else pattern StatxMode = StatxMask 0 #endif -- | Want @stx_nlink@. pattern StatxNlink :: StatxMask #ifdef STATX_NLINK pattern StatxNlink = StatxMask (#const STATX_NLINK) #else pattern StatxNlink = StatxMask 0 #endif -- | Want @stx_uid@. pattern StatxUid :: StatxMask #ifdef STATX_UID pattern StatxUid = StatxMask (#const STATX_UID) #else pattern StatxUid = StatxMask 0 #endif -- | Want @stx_gid@. pattern StatxGid :: StatxMask #ifdef STATX_GID pattern StatxGid = StatxMask (#const STATX_GID) #else pattern StatxGid = StatxMask 0 #endif -- | Want @stx_atime@. pattern StatxAtime :: StatxMask #ifdef STATX_ATIME pattern StatxAtime = StatxMask (#const STATX_ATIME) #else pattern StatxAtime = StatxMask 0 #endif -- | Want @stx_mtime@. pattern StatxMtime :: StatxMask #ifdef STATX_MTIME pattern StatxMtime = StatxMask (#const STATX_MTIME) #else pattern StatxMtime = StatxMask 0 #endif -- | Want @stx_ctime@. pattern StatxCtime :: StatxMask #ifdef STATX_CTIME pattern StatxCtime = StatxMask (#const STATX_CTIME) #else pattern StatxCtime = StatxMask 0 #endif -- | Want @stx_btime@. pattern StatxBtime :: StatxMask #ifdef STATX_BTIME pattern StatxBtime = StatxMask (#const STATX_BTIME) #else pattern StatxBtime = StatxMask 0 #endif -- | Want @stx_mnt_id@. pattern StatxMntId :: StatxMask #ifdef HAVE_STATX_MNT_ID pattern StatxMntId = StatxMask (#const STATX_MNT_ID) #else pattern StatxMntId = StatxMask 0 #endif -- | Want @stx_ino@. pattern StatxIno :: StatxMask #ifdef STATX_INO pattern StatxIno = StatxMask (#const STATX_INO) #else pattern StatxIno = StatxMask 0 #endif -- | Want @stx_size@. pattern StatxSize :: StatxMask #ifdef STATX_SIZE pattern StatxSize = StatxMask (#const STATX_SIZE) #else pattern StatxSize = StatxMask 0 #endif -- | Want @stx_blocks@. pattern StatxBlocks :: StatxMask #ifdef STATX_BLOCKS pattern StatxBlocks = StatxMask (#const STATX_BLOCKS) #else pattern StatxBlocks = StatxMask 0 #endif -- | Want all of the above. pattern StatxBasicStats :: StatxMask #ifdef STATX_BASIC_STATS pattern StatxBasicStats = StatxMask (#const STATX_BASIC_STATS) #else pattern StatxBasicStats = StatxMask 0 #endif -- | Want all currently available fields. pattern StatxAll :: StatxMask #ifdef STATX_ALL pattern StatxAll = StatxMask (#const STATX_ALL) #else pattern StatxAll = StatxMask 0 #endif defaultStatxMask :: StatxMask defaultStatxMask = mempty newtype ExtendedFileStatus = ExtendedFileStatus (ForeignPtr CStatx) -- ^ The constructor is considered internal and may change. -- | The "preferred" block size for efficient filesystem I/O. -- (Writing to a file in smaller chunks may cause an inefficient read-mod‐ify-rewrite.) fileBlockSizeX :: ExtendedFileStatus -> CBlkSize #if HAVE_STATX -- | Further status information about the file. fileAttributesX :: ExtendedFileStatus -> CAttributes #endif -- | The number of hard links on a file. linkCountX :: ExtendedFileStatus -> CNlink -- | Te user ID of the owner of the file. fileOwnerX :: ExtendedFileStatus -> UserID -- | The ID of the group owner of the file. fileGroupX :: ExtendedFileStatus -> GroupID -- | The file type and mode. See @inode(7)@ for details. fileModeX :: ExtendedFileStatus -> FileMode -- | The inode number of the file. fileIDX :: ExtendedFileStatus -> FileID -- | The size of the file (if it is a regular file or a symbolic link) in bytes. -- The size of a symbolic link is the length of the pathname it contains, -- without a terminating null byte. fileSizeX :: ExtendedFileStatus -> Word64 -- | The number of blocks allocated to the file on the medium, in 512-byte units. -- (This may be smaller than stx_size/512 when the file has holes.) fileBlocksX :: ExtendedFileStatus -> Word64 #if HAVE_STATX -- | A mask indicating which bits in 'fileAttributesX' are supported by the VFS and the filesystem. fileAttributesMaskX :: ExtendedFileStatus -> CAttributes #endif -- | The file's last access timestamp. accessTimeHiResX :: ExtendedFileStatus -> POSIXTime -- | The file's creation timestamp. creationTimeHiResX :: ExtendedFileStatus -> POSIXTime -- | The file's last status change timestamp. statusChangeTimeHiResX :: ExtendedFileStatus -> POSIXTime -- | The file's last modification timestamp. modificationTimeHiResX :: ExtendedFileStatus -> POSIXTime -- | ID of the device on which this file resides. deviceIDX :: ExtendedFileStatus -> DeviceID -- | Describes the device that this file represents. specialDeviceIDX :: ExtendedFileStatus -> DeviceID -- | The mount ID of the mount containing the file. This is the same number -- reported by name_to_handle_at(2) and corresponds to the number in the -- first field in one of the records in /proc/self/mountinfo. mountIDX :: ExtendedFileStatus -> Word64 -- | The file is compressed by the filesystem and may take extra resources to access. -- This is an extended attribute. fileCompressedX :: ExtendedFileStatus -> Bool -- | The file cannot be modified: it cannot be deleted or renamed, no hard links can -- be created to this file and no data can be written to it. See @chattr(1)@. -- This is an extended attribute. fileImmutableX :: ExtendedFileStatus -> Bool -- | The file can only be opened in append mode for writing. Random access writing is not permitted. See @chattr(1)@. -- This is an extended attribute. fileAppendX :: ExtendedFileStatus -> Bool -- | File is not a candidate for backup when a backup program such as @dump(8)@ is run. See @chattr(1)@. -- This is an extended attribute. fileNoDumpX :: ExtendedFileStatus -> Bool -- | A key is required for the file to be encrypted by the filesystem. -- This is an extended attribute. fileEncryptedX :: ExtendedFileStatus -> Bool -- | The file has fs-verity enabled. It cannot be written to, and all reads from it -- will be verified against a cryptographic hash that covers the entire file (e.g., via a Merkle tree). -- This is an extended attribute. -- Since Linux 5.5. fileVerityX :: ExtendedFileStatus -> Bool -- | The file is in the DAX (cpu direct access) state. -- This is an extended attribute. -- Since Linux 5.8. fileDaxX :: ExtendedFileStatus -> Bool -- | Checks if this file is a block device. isBlockDeviceX :: ExtendedFileStatus -> Bool -- | Checks if this file is a character device. isCharacterDeviceX :: ExtendedFileStatus -> Bool -- | Checks if this file is a named pipe device. isNamedPipeX :: ExtendedFileStatus -> Bool -- | Checks if this file is a regular file device. isRegularFileX :: ExtendedFileStatus -> Bool -- | Checks if this file is a directory device. isDirectoryX :: ExtendedFileStatus -> Bool -- | Checks if this file is a symbolic link device. isSymbolicLinkX :: ExtendedFileStatus -> Bool -- | Checks if this file is a socket device. isSocketX :: ExtendedFileStatus -> Bool isBlockDeviceX statx = (fileModeX statx `intersectFileModes` fileTypeModes) == blockSpecialMode isCharacterDeviceX statx = (fileModeX statx `intersectFileModes` fileTypeModes) == characterSpecialMode isNamedPipeX statx = (fileModeX statx `intersectFileModes` fileTypeModes) == namedPipeMode isRegularFileX statx = (fileModeX statx `intersectFileModes` fileTypeModes) == regularFileMode isDirectoryX statx = (fileModeX statx `intersectFileModes` fileTypeModes) == directoryMode isSymbolicLinkX statx = (fileModeX statx `intersectFileModes` fileTypeModes) == symbolicLinkMode isSocketX statx = (fileModeX statx `intersectFileModes` fileTypeModes) == socketMode #if HAVE_STATX testFlag :: ExtendedFileStatus -> CAttributes -> Bool testFlag ex flag = let attributes = fileAttributesX ex attributes_mask = fileAttributesMaskX ex in (attributes .&. attributes_mask .&. flag) /= 0 #ifdef STATX_ATTR_COMPRESSED fileCompressedX ex = testFlag ex (#const STATX_ATTR_COMPRESSED) #else {-# WARNING fileCompressedX "fileCompressedX: not available on this platform, will default to 'False' (CPP guard: @#if STATX_ATTR_COMPRESSED@)" #-} fileCompressedX _ = False #endif #ifdef STATX_ATTR_IMMUTABLE fileImmutableX ex = testFlag ex (#const STATX_ATTR_IMMUTABLE) #else {-# WARNING fileImmutableX "fileImmutableX: not available on this platform, will default to 'False' (CPP guard: @#if STATX_ATTR_IMMUTABLE@)" #-} fileImmutableX _ = False #endif #ifdef STATX_ATTR_APPEND fileAppendX ex = testFlag ex (#const STATX_ATTR_APPEND) #else {-# WARNING fileAppendX "fileAppendX: not available on this platform, will default to 'False' (CPP guard: @#if STATX_ATTR_APPEND@)" #-} fileAppendX _ = False #endif #ifdef STATX_ATTR_NODUMP fileNoDumpX ex = testFlag ex (#const STATX_ATTR_NODUMP) #else {-# WARNING fileNoDumpX "fileNoDumpX: not available on this platform, will default to 'False' (CPP guard: @#if STATX_ATTR_NODUMP@)" #-} fileNoDumpX _ = False #endif #ifdef STATX_ATTR_ENCRYPTED fileEncryptedX ex = testFlag ex (#const STATX_ATTR_ENCRYPTED) #else {-# WARNING fileEncryptedX "fileEncryptedX: not available on this platform, will default to 'False' (CPP guard: @#if STATX_ATTR_ENCRYPTED@)" #-} fileEncryptedX _ = False #endif #ifdef STATX_ATTR_VERITY fileVerityX ex = testFlag ex (#const STATX_ATTR_VERITY) #else {-# WARNING fileVerityX "fileVerityX: not available on this platform, will default to 'False' (CPP guard: @#if STATX_ATTR_VERITY@)" #-} fileVerityX _ = False #endif #ifdef STATX_ATTR_DAX fileDaxX ex = testFlag ex (#const STATX_ATTR_DAX) #else {-# WARNING fileDaxX "fileDaxX: not available on this platform, will default to 'False' (CPP guard: @#if STATX_ATTR_DAX@)" #-} fileDaxX _ = False #endif #ifdef HAVE_SYS_SYSMACROS_H deviceIDX (ExtendedFileStatus statx) = unsafePerformIO $ do major <- withForeignPtr statx $ (#peek struct statx, stx_dev_major) :: IO CUInt minor <- withForeignPtr statx $ (#peek struct statx, stx_dev_minor) :: IO CUInt c_makedev major minor #else {-# WARNING deviceIDX "deviceIDX: not available on this platform, will throw error (CPP guard: @#if HAVE_SYS_SYSMACROS_H@)" #-} deviceIDX _ = error "deviceIDX not available on this platform" #endif #ifdef HAVE_SYS_SYSMACROS_H specialDeviceIDX (ExtendedFileStatus statx) = unsafePerformIO $ do major <- withForeignPtr statx $ (#peek struct statx, stx_rdev_major) :: IO CUInt minor <- withForeignPtr statx $ (#peek struct statx, stx_rdev_minor) :: IO CUInt c_makedev major minor #else {-# WARNING specialDeviceIDX "specialDeviceIDX: not available on this platform, will throw error (CPP guard: @#if HAVE_SYS_SYSMACROS_H@)" #-} specialDeviceIDX _ = error "specialDeviceIDX not available on this platform" #endif #ifdef HAVE_STATX_MNT_ID mountIDX (ExtendedFileStatus statx) = unsafePerformIO $ withForeignPtr statx $ (#peek struct statx, stx_mnt_id) #else {-# WARNING mountIDX "mountIDX: not available on this platform, will throw error (CPP guard: @#if HAVE_STATX_MNT_ID@)" #-} mountIDX _ = error "mountIDX not available on this platform" #endif fileBlockSizeX (ExtendedFileStatus statx) = unsafePerformIO $ do r <- withForeignPtr statx $ (#peek struct statx, stx_blksize) :: IO Word32 return $ CBlkSize (fromIntegral r) fileAttributesX (ExtendedFileStatus statx) = unsafePerformIO $ withForeignPtr statx $ (#peek struct statx, stx_attributes) #ifdef STATX_NLINK linkCountX (ExtendedFileStatus statx) = unsafePerformIO $ do links <- withForeignPtr statx $ (#peek struct statx, stx_nlink) :: IO Word32 return $ CNlink (fromIntegral links) #else {-# WARNING linkCountX "linkCountX: not available on this platform, will throw error (CPP guard: @#if STATX_NLINK@)" #-} linkCountX _ = error "linkCountX not available on this platform" #endif #ifdef STATX_UID fileOwnerX (ExtendedFileStatus statx) = unsafePerformIO $ withForeignPtr statx $ (#peek struct statx, stx_uid) #else {-# WARNING fileOwnerX "fileOwnerX: not available on this platform, will throw error (CPP guard: @#if STATX_UID@)" #-} fileOwnerX _ = error "fileOwnerX not available on this platform" #endif #ifdef STATX_GID fileGroupX (ExtendedFileStatus statx) = unsafePerformIO $ withForeignPtr statx $ (#peek struct statx, stx_gid) #else {-# WARNING fileGroupX "fileGroupX: not available on this platform, will throw error (CPP guard: @#if STATX_GID@)" #-} fileGroupX _ = error "fileGroupX not available on this platform" #endif #ifdef STATX_MODE fileModeX (ExtendedFileStatus statx) = unsafePerformIO $ do r <- withForeignPtr statx $ (#peek struct statx, stx_mode) :: IO Word16 return $ CMode $ fromIntegral r #else {-# WARNING fileModeX "fileModeX: not available on this platform, will throw error (CPP guard: @#if STATX_MODE@)" #-} fileModeX _ = error "fileModeX not available on this platform" #endif #ifdef STATX_INO fileIDX (ExtendedFileStatus statx) = unsafePerformIO $ withForeignPtr statx $ (#peek struct statx, stx_ino) #else {-# WARNING fileIDX "fileIDX: not available on this platform, will throw error (CPP guard: @#if STATX_INO@)" #-} fileIDX _ = error "fileIDX not available on this platform" #endif #ifdef STATX_SIZE fileSizeX (ExtendedFileStatus statx) = unsafePerformIO $ withForeignPtr statx $ (#peek struct statx, stx_size) :: Word64 #else {-# WARNING fileSizeX "fileSizeX: not available on this platform, will throw error (CPP guard: @#if STATX_SIZE@)" #-} fileSizeX _ = error "fileSizeX not available on this platform" #endif #ifdef STATX_BLOCKS fileBlocksX (ExtendedFileStatus statx) = unsafePerformIO $ withForeignPtr statx $ (#peek struct statx, stx_blocks) :: Word64 #else {-# WARNING fileBlocksX "fileBlocksX: not available on this platform, will throw error (CPP guard: @#if STATX_BLOCKS@)" #-} fileBlocksX _ = error "fileBlocksX not available on this platform" #endif fileAttributesMaskX (ExtendedFileStatus statx) = unsafePerformIO $ withForeignPtr statx $ (#peek struct statx, stx_attributes_mask) #ifdef STATX_ATIME accessTimeHiResX (ExtendedFileStatus statx) = unsafePerformIO $ withForeignPtr statx $ \statx_ptr -> do sec <- (#peek struct statx, stx_atime.tv_sec) statx_ptr :: IO EpochTime nsec <- (#peek struct statx, stx_atime.tv_nsec) statx_ptr :: IO (#type int) return $ timeHiResToNominalDiffTime sec nsec #else {-# WARNING accessTimeHiResX "accessTimeHiResX: not available on this platform, will throw error (CPP guard: @#if STATX_ATIME@)" #-} accessTimeHiResX _ = error "accessTimeHiResX not available on this platform" #endif #ifdef STATX_BTIME creationTimeHiResX (ExtendedFileStatus statx) = unsafePerformIO $ withForeignPtr statx $ \statx_ptr -> do sec <- (#peek struct statx, stx_btime.tv_sec) statx_ptr :: IO EpochTime nsec <- (#peek struct statx, stx_btime.tv_nsec) statx_ptr :: IO (#type int) return $ timeHiResToNominalDiffTime sec nsec #else {-# WARNING creationTimeHiResX "creationTimeHiResX: not available on this platform, will throw error (CPP guard: @#if STATX_BTIME@)" #-} creationTimeHiResX _ = error "creationTimeHiResX not available on this platform" #endif #ifdef STATX_CTIME statusChangeTimeHiResX (ExtendedFileStatus statx) = unsafePerformIO $ withForeignPtr statx $ \statx_ptr -> do sec <- (#peek struct statx, stx_ctime.tv_sec) statx_ptr :: IO EpochTime nsec <- (#peek struct statx, stx_ctime.tv_nsec) statx_ptr :: IO (#type int) return $ timeHiResToNominalDiffTime sec nsec #else {-# WARNING statusChangeTimeHiResX "statusChangeTimeHiResX: not available on this platform, will throw error (CPP guard: @#if STATX_CTIME@)" #-} statusChangeTimeHiResX _ = error "statusChangeTimeHiResX not available on this platform" #endif #ifdef STATX_MTIME modificationTimeHiResX (ExtendedFileStatus statx) = unsafePerformIO $ withForeignPtr statx $ \statx_ptr -> do sec <- (#peek struct statx, stx_mtime.tv_sec) statx_ptr :: IO EpochTime nsec <- (#peek struct statx, stx_mtime.tv_nsec) statx_ptr :: IO (#type int) return $ timeHiResToNominalDiffTime sec nsec #else {-# WARNING modificationTimeHiResX "modificationTimeHiResX: not available on this platform, will throw error (CPP guard: @#if STATX_MTIME@)" #-} modificationTimeHiResX _ = error "modificationTimeHiResX not available on this platform" #endif timeHiResToNominalDiffTime :: EpochTime -> Int32 -> POSIXTime timeHiResToNominalDiffTime (CTime sec) nsec = secondsToNominalDiffTime $ MkFixed $ toInteger sec * 1e12 + toInteger nsec * 1e3 #else {-# WARNING linkCountX "linkCountX: not available on this platform, will throw error (CPP guard: @#if HAVE_STATX@)" #-} linkCountX _ = error "linkCountX not available on this platform" {-# WARNING fileBlockSizeX "fileBlockSizeX: not available on this platform, will throw error (CPP guard: @#if HAVE_STATX@)" #-} fileBlockSizeX _ = error "fileBlockSizeX not available on this platform" {-# WARNING deviceIDX "deviceIDX: not available on this platform, will throw error (CPP guard: @#if HAVE_STATX@)" #-} deviceIDX _ = error "deviceIDX not available on this platform" {-# WARNING specialDeviceIDX "specialDeviceIDX: not available on this platform, will throw error (CPP guard: @#if HAVE_STATX@)" #-} specialDeviceIDX _ = error "specialDeviceIDX not available on this platform" {-# WARNING mountIDX "mountIDX: not available on this platform, will throw error (CPP guard: @#if HAVE_STATX@)" #-} mountIDX _ = error "mountIDX not available on this platform" {-# WARNING fileOwnerX "fileOwnerX: not available on this platform, will throw error (CPP guard: @#if HAVE_STATX@)" #-} fileOwnerX _ = error "fileOwnerX not available on this platform" {-# WARNING fileGroupX "fileGroupX: not available on this platform, will throw error (CPP guard: @#if HAVE_STATX@)" #-} fileGroupX _ = error "fileGroupX not available on this platform" {-# WARNING fileModeX "fileModeX: not available on this platform, will throw error (CPP guard: @#if HAVE_STATX@)" #-} fileModeX _ = error "fileModeX not available on this platform" {-# WARNING fileIDX "fileIDX: not available on this platform, will throw error (CPP guard: @#if HAVE_STATX@)" #-} fileIDX _ = error "fileIDX not available on this platform" {-# WARNING fileSizeX "fileSizeX: not available on this platform, will throw error (CPP guard: @#if HAVE_STATX@)" #-} fileSizeX _ = error "fileSizeX not available on this platform" {-# WARNING fileBlocksX "fileBlocksX: not available on this platform, will throw error (CPP guard: @#if HAVE_STATX@)" #-} fileBlocksX _ = error "fileBlocksX not available on this platform" {-# WARNING accessTimeHiResX "accessTimeHiResX: not available on this platform, will throw error (CPP guard: @#if HAVE_STATX@)" #-} accessTimeHiResX _ = error "accessTimeHiResX not available on this platform" {-# WARNING creationTimeHiResX "creationTimeHiResX: not available on this platform, will throw error (CPP guard: @#if HAVE_STATX@)" #-} creationTimeHiResX _ = error "creationTimeHiResX not available on this platform" {-# WARNING statusChangeTimeHiResX "statusChangeTimeHiResX: not available on this platform, will throw error (CPP guard: @#if HAVE_STATX@)" #-} statusChangeTimeHiResX _ = error "statusChangeTimeHiResX not available on this platform" {-# WARNING modificationTimeHiResX "modificationTimeHiResX: not available on this platform, will throw error (CPP guard: @#if HAVE_STATX@)" #-} modificationTimeHiResX _ = error "modificationTimeHiResX not available on this platform" {-# WARNING fileCompressedX "fileCompressedX: not available on this platform, will default to 'False' (CPP guard: @#if HAVE_STATX@)" #-} fileCompressedX _ = False {-# WARNING fileImmutableX "fileImmutableX: not available on this platform, will default to 'False' (CPP guard: @#if HAVE_STATX@)" #-} fileImmutableX _ = False {-# WARNING fileAppendX "fileAppendX: not available on this platform, will default to 'False' (CPP guard: @#if HAVE_STATX@)" #-} fileAppendX _ = False {-# WARNING fileNoDumpX "fileNoDumpX: not available on this platform, will default to 'False' (CPP guard: @#if HAVE_STATX@)" #-} fileNoDumpX _ = False {-# WARNING fileEncryptedX "fileEncryptedX: not available on this platform, will default to 'False' (CPP guard: @#if HAVE_STATX@)" #-} fileEncryptedX _ = False {-# WARNING fileVerityX "fileVerityX: not available on this platform, will default to 'False' (CPP guard: @#if HAVE_STATX@)" #-} fileVerityX _ = False {-# WARNING fileDaxX "fileDaxX: not available on this platform, will default to 'False' (CPP guard: @#if HAVE_STATX@)" #-} fileDaxX _ = False #endif data {-# CTYPE "struct statx" #-} CStatx #ifdef HAVE_STATX foreign import capi unsafe "sys/stat.h statx" c_statx :: CInt -> CFilePath -> CInt -> CInt -> Ptr CStatx -> IO CInt #ifdef HAVE_SYS_SYSMACROS_H foreign import capi unsafe "sys/sysmacros.h makedev" c_makedev :: CUInt -> CUInt -> IO CDev #endif #endif getExtendedFileStatus_ :: Maybe Fd -- ^ Optional directory file descriptor -> CString -- ^ Pathname to open -> StatxFlags -> StatxMask -> IO ExtendedFileStatus #ifdef HAVE_STATX getExtendedFileStatus_ fdMay str (StatxFlags flags) (StatxMask masks) = do fp <- mallocForeignPtrBytes (#const sizeof(struct statx)) withForeignPtr fp $ \p -> throwErrnoIfMinus1_ "getExtendedFileStatus_" (c_statx c_fd str flags masks p) return (ExtendedFileStatus fp) where c_fd = maybe (#const AT_FDCWD) (\ (Fd fd) -> fd) fdMay #else {-# WARNING getExtendedFileStatus_ "operation will throw 'IOError' \"unsupported operation\" (CPP guard: @#if HAVE_STATX@)" #-} getExtendedFileStatus_ _ _ _ _ = ioError (ioeSetLocation unsupportedOperation "getExtendedFileStatus") #endif -- | Whether 'statx' is available on this platform and 'getExtendedFileStatus' and -- related functions will work. haveStatx :: Bool #ifdef HAVE_STATX haveStatx = True #else haveStatx = False #endif