h&,u      !"#$%&'()*+,-./0123456789:;<=>?@ A B C D E F G H I JKLMNOP Q R S T U V W X Y Z [ \ ] ^ _ ` a b cdefghijklmnopqrstuvwxyz{|}~                                                                                                !!!!"""###$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&''''()))))))))))))))))))))))*********************************+++++++++++++++++++++++++++++++5"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) Trustworthy unixA literal POSIX file pathunixas 9, but exceptions include the given path when appropriate.unixas <, but exceptions include the given path when appropriate.unixas <, but exceptions include the given path when appropriate.unixas <, but exceptions include the given path when appropriate.unixas <, but exceptions include the given path when appropriate.unixas <, but exceptions include the given path when appropriate.unixas 4, but exceptions include two paths when appropriate.unixThis mimics the filepath decoder base uses on unix, with the small distinction that we're not truncating at NUL bytes (because we're not at the outer FFI layer).unixWrapper around , checking the encoded FilePath for internal NUL octets as these are disallowed in POSIX filepaths. See 1https://gitlab.haskell.org/ghc/ghc/-/issues/13660  ,"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe unixCall  fdopendir" to obtain a directory stream for fd. fd( must not be otherwise used after this.(On success, it is owned by the returned , which should be closed via  when no longer needed. On error, the file descriptor is automatically closed and then an exception is thrown. There is no code path in which the file descriptor remains open and yet not owned by a returned .7The input file descriptor must not have been used with threadWaitRead or threadWaitWrite.unixrewindDirStream dp calls  rewinddir' to reposition the directory stream dp# at the beginning of the directory.unixcloseDirStream dp calls closedir" to close the directory stream dp.  !""(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe  #unixcreateDirectory dir mode calls mkdir to create a new directory, dir, with permissions based on mode.$unixopenDirStream dir calls opendir% to obtain a directory stream for dir.%unixreadDirStream dp calls readdir( to obtain the next directory entry ( struct dirent#) for the open directory stream dp, and returns the d_name member of that structure.Note that this function returns an empty filepath if the end of the directory stream is reached. For a safer alternative use &.&unixreadDirStreamMaybe dp calls readdir( to obtain the next directory entry ( struct dirent#) for the open directory stream dp. It returns the d_name) member of that structure wrapped in a  Just d_name if an entry was read and Nothing2 if the end of the directory stream was reached.'unixgetWorkingDirectory calls getcwd8 to obtain the name of the current working directory.(unixchangeWorkingDirectory dir calls chdir/ to change the current working directory to dir. !"#$%&'()#)$%&! '(" Safe-Inferredb"(c) The University of Glasgow 2022/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) Safe-Inferred$(c) Volker Stolz 2003/BSD-style (see the file libraries/base/LICENSE) vs@foldr.org provisionalnon-portable (requires POSIX) Trustworthy *unix Flags for  -. Notice that ,; might not be available on your particular platform! Use 8.If  RTLD_DEFAULT" is not defined on your platform, ; - reduces to ./unix Flags for  ..8unix+On some hosts (e.g. SuSe and Ubuntu Linux)  RTLD_NEXT (and  RTLD_DEFAULT-) are not visible without setting the macro  _GNU_SOURCE. Since we don't want to define this macro, you can use the function 8 to check whether the flag , is available. Ideally, this will be optimized by the compiler so that it should be as efficient as an #ifdef.If you fail to test the flag and use it although it is undefined, ; will throw an error.*,-+./0123456789:;765489:/0123;*,-+./$(c) Volker Stolz 2003/BSD-style (see the file libraries/base/LICENSE) vs@foldr.org provisionalnon-portable (requires POSIX)Safe"BunixB8 returns the address binding of the symbol described in symbol3, as it occurs in the shared object identified by source.CunixC8 obtains the raw handle. You mustn't do something like -withDL mod flags $ liftM undl >>= p -> use p*.+,-/3201456789:;?@ABC $(c) Volker Stolz 2003/BSD-style (see the file libraries/base/LICENSE) vs@foldr.org provisionalnon-portable (requires POSIX)Safe#Z*.+,-/3201456789:;@ABCDEFDBA@EFC $(c) Volker Stolz 2003/BSD-style (see the file libraries/base/LICENSE) vs@foldr.org provisionalnon-portable (requires POSIX)Safe$#*.+,-/3201456789:;@ABCGHIGBA@HIC$(c) Volker Stolz 2003/BSD-style (see the file libraries/base/LICENSE) vs@foldr.org provisionalnon-portable (requires POSIX)Safe$?JKLMNO?JKLMNO $(c) Volker Stolz 2003/BSD-style (see the file libraries/base/LICENSE) vs@foldr.org provisionalnon-portable (requires POSIX)Safe%?KLMNOP?PKLMNO0 Safe-Inferred% "(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe ,JQunixQ( looks up a variable in the environment.RunixR is a wrapper around Q where the programmer can specify a fallback if the variable is not found in the environment.TunixT0 retrieves the entire environment as a list of  (key,value) pairs.UunixU5 resets the entire environment to the given list of  (key,value) pairs.VunixThe V function deletes all instances of the variable name from the environment.WunixW( function takes an argument of the form  name=value and is equivalent to #setEnv(key,value,True{-overwrite-}).XunixThe X function inserts or resets the environment variable name in the current environment list. If the variable name does not exist in the list, it is inserted with the given value. If the variable does exist, the argument  overwrite is tested; if  overwrite is False, the variable is not reset, otherwise it is reset to the given value.YunixThe Y9 function clears the environment of all name-value pairs.Qunixvariable name unixvariable value Runix!variable name unix!fallback value unix!variable value or fallback value Tunix  [(key,value)]Uunix  [(key,value)]Vunixvariable name Wunix "key=value" Xunixvariable name unixvariable value unixoverwrite QRSTUVWXY QRSTUWXVY "(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) Trustworthy 4ZunixZ( looks up a variable in the environment.[unix[ is a wrapper around Z where the programmer can specify a fallback as the second argument, which will be used if the variable is not found in the environment.]unix]0 retrieves the entire environment as a list of  (key,value) pairs.^unix^5 resets the entire environment to the given list of  (key,value) pairs._unixThe _ function deletes all instances of the variable name from the environment.`unix`( function takes an argument of the form  name=value and is equivalent to #setEnv(key,value,True{-overwrite-}).aunixThe a function inserts or resets the environment variable name in the current environment list. If the variable name does not exist in the list, it is inserted with the given value. If the variable does exist, the argument  overwrite is tested; if  overwrite is False, the variable is not reset, otherwise it is reset to the given value.bunix Computation b returns a list of the program's command line arguments (not including the program name), as s.Unlike 12, this function does no Unicode decoding of the arguments; you get the exact bytes that were passed to the program by the OS. To interpret the arguments as text, some Unicode decoding should be applied.Zunixvariable name unixvariable value [unix!variable name unix!fallback value unix!variable value or fallback value ]unix  [(key,value)]^unix  [(key,value)]_unixvariable name `unix "key=value" aunixvariable name unixvariable value unixoverwrite YZ[\]^_`ab Z[\]^`a_Yb"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) Safe-Inferred ;cunixc( looks up a variable in the environment.dunixd is a wrapper around c where the programmer can specify a fallback as the second argument, which will be used if the variable is not found in the environment.funixf0 retrieves the entire environment as a list of  (key,value) pairs.gunixg5 resets the entire environment to the given list of  (key,value) pairs.hunixThe h function deletes all instances of the variable name from the environment.iunixi( function takes an argument of the form  name=value and is equivalent to #setEnv(key,value,True{-overwrite-}).junixThe j function inserts or resets the environment variable name in the current environment list. If the variable name does not exist in the list, it is inserted with the given value. If the variable does exist, the argument  overwrite is tested; if  overwrite is False, the variable is not reset, otherwise it is reset to the given value.kunix Computation k returns a list of the program's command line arguments (not including the program name), as s.Unlike 12, this function does no Unicode decoding of the arguments; you get the exact bytes that were passed to the program by the OS. To interpret the arguments as text, some Unicode decoding should be applied.cunixvariable name unixvariable value dunix!variable name unix!fallback value unix!variable value or fallback value funix  [(key,value)]gunix  [(key,value)]hunixvariable name iunix "key=value" junixvariable name unixvariable value unixoverwrite Ycdefghijk cdefgijhYk"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe< lmno onlm"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe BpunixcreateDirectory dir mode calls mkdir to create a new directory, dir, with permissions based on mode.qunixopenDirStream dir calls opendir% to obtain a directory stream for dir.runixreadDirStream dp calls readdir( to obtain the next directory entry ( struct dirent#) for the open directory stream dp, and returns the d_name member of that structure.Note that this function returns an empty filepath if the end of the directory stream is reached. For a safer alternative use s.sunixreadDirStreamMaybe dp calls readdir( to obtain the next directory entry ( struct dirent#) for the open directory stream dp. It returns the d_name) member of that structure wrapped in a  Just d_name if an entry was read and Nothing2 if the end of the directory stream was reached.tunixgetWorkingDirectory calls getcwd8 to obtain the name of the current working directory.uunixchangeWorkingDirectory dir calls chdir/ to change the current working directory to dir. !"pqrstuvpvqrs! tu""(c) The University of Glasgow 2014 BSD-style (see the file LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe E#wunixAdvice parameter for ~ operation.'For more details, see documentation of posix_fadvise(2).~unix Performs posix_fadvise(2) operation on file-descriptor.If platform does not provide posix_fadvise(2) ~ becomes a no-op.(use #if HAVE_POSIX_FADVISE" CPP guard to detect availability)unix Performs posix_fallocate(2) operation on file-descriptor.Throws 9 ("unsupported operation") if platform does not provide posix_fallocate(2).(use #if HAVE_POSIX_FALLOCATE# CPP guard to detect availability). wxyz{|}~ wxyz{|}~3"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) Trustworthy Y4unixPOSIX defines operations to get information, such as owner, permissions, size and access times, about a file. This information is represented by the  type. Note: see chmod.Limitations: Support for high resolution timestamps is filesystem dependent:5HFS+ volumes on OS X only support whole-second times.unix6The constructor is considered internal and may change.unixNo permissions.unixOwner has read permission.unixOwner has write permission.unixOwner has execute permission.unixGroup has read permission.unixGroup has write permission.unixGroup has execute permission.unixOthers have read permission.unixOthers have write permission.unixOthers have execute permission.unixSet user ID on execution.unixSet group ID on execution.unix7Owner, group and others have read and write permission.unix-Owner has read, write and execute permission.unix-Group has read, write and execute permission.unix/Others have read, write and execute permission.unixOwner, group and others have read, write and execute permission.unixCombines the two file modes into one that contains modes that appear in either.unixCombines two file modes into one that only contains modes that appear in both.unixsetFdMode fd mode acts like  setFileMode but uses a file descriptor fd instead of a . Note: calls fchmod.unixsetFileCreationMask 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.unix,ID of the device on which this file resides.unix inode numberunix File mode (such as permissions).unix"Number of hard links to this file.unix ID of owner.unix ID of group.unix/Describes the device that this file represents.unixSize of the file in bytes. If this file is a symbolic link the size is the length of the pathname it contains.unixTime of last access.unixTime of last modification.unixTime of last status change (i.e. owner, group, link count, mode, etc.).unixNumber of blocks allocated for this file, in units of 512-bytes. Returns Nothing if  st_blocks$ is not supported on this platform.unixGives the preferred block size for efficient filesystem I/O in bytes. Returns Nothing if  st_blocksize$ is not supported on this platform.unixTime of last access in sub-second resolution. Depends on the timestamp resolution of the underlying filesystem.unixTime of last modification in sub-second resolution. Depends on the timestamp resolution of the underlying filesystem.unixTime 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.unix&Checks if this file is a block device.unix*Checks if this file is a character device.unix+Checks if this file is a named pipe device.unix-Checks if this file is a regular file device.unix*Checks if this file is a directory device.unix.Checks if this file is a symbolic link device.unix'Checks if this file is a socket device.unixgetFdStatus fd acts as  getFileStatus but uses a file descriptor fd. Note: calls fstat.unixLike 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.unixLike  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.unixActs as setOwnerAndGroup* but uses a file descriptor instead of a . Note: calls fchown.unixActs as  setFileSize) but uses a file descriptor instead of a . Note: calls  ftruncate.unixgetFdPathVar 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."(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe lunixsetFileMode path mode) changes permission of the file given by path to mode. This operation may fail with  if path doesn't exist or if the effective user ID of the current process is not that of the file's owner. Note: calls chmod.unixfileAccess name read write exec3 checks if the file (or other file system object) name can be accessed for reading, writing and/or executing. To check a permission set the corresponding argument to . Note: calls access.unix%Checks for the existence of the file. Note: calls access.unixgetFileStatus path calls gets the  FileStatus? information (user ID, size, access times, etc.) for the file path. Note: calls stat.unixActs as  except when the . refers to a symbolic link. In that case the  FileStatus information of the symbolic link itself is returned instead of that of the file it points to. Note: calls lstat.unixcreateNamedPipe fifo mode creates a new named pipe, fifo, with permissions based on mode. May fail with  if a file named name already exists or if the effective user ID of the current process doesn't have permission to create the pipe. Note: calls mkfifo.unixcreateDevice path mode dev creates either a regular or a special file depending on the value of mode (and dev). mode will normally be either  or . May fail with  if a file named name already exists or if the effective user ID of the current process doesn't have permission to create the file. Note: calls mknod.unixcreateLink old new creates a new path, new, linked to an existing file, old. Note: calls link.unixremoveLink path removes the link named path. Note: calls unlink.unixcreateSymbolicLink file1 file2 creates a symbolic link named file2 which points to the file file1.Symbolic links are interpreted at run-time as if the contents of the link had been substituted into the path being followed to find a file or directory. Note: calls symlink.unix Reads the  RawFilePath0 pointed to by the symbolic link and returns it. Note: calls readlink.unixrename old new" renames a file or directory from old to new. Note: calls rename.unixsetOwnerAndGroup path uid gid changes the owner and group of path to uid and gid, respectively.If uid or gid1 is specified as -1, then that ID is not changed. Note: calls chown.unixActs as  but does not follow symlinks (and thus changes permissions on the link itself). Note: calls lchown.unixsetFileTimes path atime mtime> sets the access and modification times associated with file path to atime and mtime, respectively. Note: calls utime.unixLike / but timestamps can have sub-second resolution. Note: calls  utimensat or utimes. 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.unixLike  but does not follow symbolic links. This operation is not supported on all platforms. On these platforms, this function will raise an exception. Note: calls  utimensat or lutimes. 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.unixtouchFile path> sets the access and modification times associated with file path to the current time. Note: calls utime.unixLike  but does not follow symbolic links. This operation is not supported on all platforms. On these platforms, this function will raise an exception. Note: calls lutimes.unixTruncates the file down to the specified length. If the file was larger than the given length before this operation was performed the extra is lost. Note: calls truncate.unixgetPathVar var path obtains the dynamic value of the requested configurable file limit or option associated with file or directory path. For defined file limits,  getPathVar returns the associated value. For defined file options, the result of  getPathVar is undefined, but not failure. Note: calls pathconf."(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe unix=For operations that require two paths (e.g., renaming a file)unixsetFileMode path mode) changes permission of the file given by path to mode. This operation may fail with  if path doesn't exist or if the effective user ID of the current process is not that of the file's owner. Note: calls chmod.unixfileAccess name read write exec3 checks if the file (or other file system object) name can be accessed for reading, writing and/or executing. To check a permission set the corresponding argument to . Note: calls access.unix%Checks for the existence of the file. Note: calls access.unixgetFileStatus path calls gets the  FileStatus? information (user ID, size, access times, etc.) for the file path. Note: calls stat.unixActs as  except when the . refers to a symbolic link. In that case the  FileStatus information of the symbolic link itself is returned instead of that of the file it points to. Note: calls lstat.unixcreateNamedPipe fifo mode creates a new named pipe, fifo, with permissions based on mode. May fail with  if a file named name already exists or if the effective user ID of the current process doesn't have permission to create the pipe. Note: calls mkfifo.unixcreateDevice path mode dev creates either a regular or a special file depending on the value of mode (and dev). mode will normally be either  or . May fail with  if a file named name already exists or if the effective user ID of the current process doesn't have permission to create the file. Note: calls mknod.unixcreateLink old new creates a new path, new, linked to an existing file, old. Note: calls link.unixremoveLink path removes the link named path. Note: calls unlink.unixcreateSymbolicLink name1 name2 creates a symbolic link named name2 which points to the file name1.Symbolic links are interpreted at run-time as if the contents of the link had been substituted into the path being followed to find a file or directory. Note: calls symlink.unix Reads the FilePath0 pointed to by the symbolic link and returns it. Note: calls readlink.unixrename old new" renames a file or directory from old to new. Note: calls rename.unixsetOwnerAndGroup path uid gid changes the owner and group of path to uid and gid, respectively.If uid or gid1 is specified as -1, then that ID is not changed. Note: calls chown.unixActs as  but does not follow symlinks (and thus changes permissions on the link itself). Note: calls lchown.unixsetFileTimes path atime mtime> sets the access and modification times associated with file path to atime and mtime, respectively. Note: calls utime.unixLike / but timestamps can have sub-second resolution. Note: calls  utimensat or utimes. 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.unixLike  but does not follow symbolic links. This operation is not supported on all platforms. On these platforms, this function will raise an exception. Note: calls  utimensat or lutimes. 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.unixtouchFile path> sets the access and modification times associated with file path to the current time. Note: calls utime.unixLike  but does not follow symbolic links. This operation is not supported on all platforms. On these platforms, this function will raise an exception. Note: calls lutimes.unixTruncates the file down to the specified length. If the file was larger than the given length before this operation was performed the extra is lost. Note: calls truncate.unixgetPathVar var path obtains the dynamic value of the requested configurable file limit or option associated with file or directory path. For defined file limits,  getPathVar returns the associated value. For defined file options, the result of  getPathVar is undefined, but not failure. Note: calls pathconf.4"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe %&unixO_APPENDunix FD_CLOEXECunix O_NONBLOCKunixO_SYNCunix5Correspond to some of the int flags from C's fcntl.h.unixO_APPENDunix/O_EXCL, result is undefined if O_CREAT is FalseNOTE: Result is undefined if  is .unixO_NOCTTYunix O_NONBLOCKunixO_TRUNCunix O_NOFOLLOWunixO_CREATunix O_CLOEXECunix O_DIRECTORYunixO_SYNCunixThe  function creates a pair of connected file descriptors. The first component is the fd to read from, the second is the write end. Although pipes may be bidirectional, this behaviour is not portable and programmers should use two separate pipes for this purpose. May throw an exception if this is an invalid descriptor.unix8May throw an exception if this is an invalid descriptor.unix8May throw an exception if this is an invalid descriptor.unixDefault values for the  type.Each field of  is either  or  respectively.unixOpen and optionally create a file relative to an optional directory file descriptor.unixClose this file descriptor. May throw an exception if this is an invalid descriptor.unix Converts an  into a = that can be used with the standard Haskell IO library (see  System.IO).unix Extracts the  from a 5. This function has the side effect of closing the  (and flushing its write buffer, if necessary), without closing the underlying .Warning:6 This means you take over ownership of the underlying .  on the  will no longer have any effect. This will break common patterns to avoid file descriptor leaks, such as using  in the cleanup action of Control.Exception.bracket<, making it a silent no-op. Be sure to close the returned  yourself to not leak it.unix8May throw an exception if this is an invalid descriptor.unix8May throw an exception if this is an invalid descriptor.unix8May throw an exception if this is an invalid descriptor.unix8May throw an exception if this is an invalid descriptor.unix8May throw an exception if this is an invalid descriptor.unix8May throw an exception if this is an invalid descriptor.unixRead data from an 8 into memory. This is exactly equivalent to the POSIX read function.unixWrite data from memory to an ,. This is exactly equivalent to the POSIX write function.unix"Optional directory file descriptorunixPathname to openunix#Read-only, read-write or write-onlyunixAppend, exclusive, etc.unixMemory in which to put the dataunixMaximum number of bytes to readunix#Number of bytes read (zero for EOF)unix#Memory containing the data to writeunix Maximum number of bytes to writeunixNumber of bytes written-"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) Trustworthyunix+Open and optionally create this file. See 56$ for information on how to use the  type.unix>Open a file relative to an optional directory file descriptor.Directory file descriptors can be used to avoid some race conditions when navigating changing directory trees, or to retain access to a portion of the directory tree that would otherwise become inaccessible after dropping privileges.unixCreate and open this file in WriteOnly mode. A special case of . See 56$ for information on how to use the  type.unixCreate and open a file for write-only, with default flags, relative an optional directory file-descriptor.Directory file descriptors can be used to avoid some race conditions when navigating changing directory trees, or to retain access to a portion of the directory tree that would otherwise become inaccessible after dropping privileges.unixRead data from an  and return it as a . Throws an exception if this is an invalid descriptor, or EOF has been reached.unixWrite a  to an .unix"Optional directory file descriptorunixPathname to openunix#Read-only, read-write or write-onlyunix!Append, exclusive, truncate, etc.unix"Optional directory file descriptorunixPathname to createunix#File permission bits (before umask)unixHow many bytes to readunixThe bytes read22"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)SafeHunix+Open and optionally create this file. See 56$ for information on how to use the  type.unix>Open a file relative to an optional directory file descriptor.Directory file descriptors can be used to avoid some race conditions when navigating changing directory trees, or to retain access to a portion of the directory tree that would otherwise become inaccessible after dropping privileges.unixCreate and open this file in WriteOnly mode. A special case of . See 56$ for information on how to use the  type.unixCreate and open a file for write-only, with default flags, relative an optional directory file-descriptor.Directory file descriptors can be used to avoid some race conditions when navigating changing directory trees, or to retain access to a portion of the directory tree that would otherwise become inaccessible after dropping privileges.unixRead data from an  and convert it to a  using the locale encoding. Throws an exception if this is an invalid descriptor, or EOF has been reached.unixWrite a  to an  using the locale encoding.unix"Optional directory file descriptorunixPathname to openunix#Read-only, read-write or write-onlyunix!Append, exclusive, truncate, etc.unix"Optional directory file descriptorunixPathname to createunix#File permission bits (before umask)unixHow many bytes to readunix)The bytes read, how many bytes were read.22"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) Safe-Inferredunixas 9, but exceptions include the given path when appropriate.unixas <, but exceptions include the given path when appropriate.unixas <, but exceptions include the given path when appropriate.unixas <, but exceptions include the given path when appropriate.unixas <, but exceptions include the given path when appropriate.unixas <, but exceptions include the given path when appropriate.unixas 4, but exceptions include two paths when appropriate.unixWrapper around , checking the encoded FilePath for internal NUL octets as these are disallowed in POSIX filepaths. See 1https://gitlab.haskell.org/ghc/ghc/-/issues/13660"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) Safe-Inferredunix+Open and optionally create this file. See 56$ for information on how to use the  type.unix>Open a file relative to an optional directory file descriptor.Directory file descriptors can be used to avoid some race conditions when navigating changing directory trees, or to retain access to a portion of the directory tree that would otherwise become inaccessible after dropping privileges.unixCreate and open this file in WriteOnly mode. A special case of . See 56$ for information on how to use the  type.unixCreate and open a file for write-only, with default flags, relative an optional directory file-descriptor.Directory file descriptors can be used to avoid some race conditions when navigating changing directory trees, or to retain access to a portion of the directory tree that would otherwise become inaccessible after dropping privileges.unix"Optional directory file descriptorunixPathname to openunix#Read-only, read-write or write-onlyunix!Append, exclusive, truncate, etc.unix"Optional directory file descriptorunixPathname to createunix#File permission bits (before umask)22"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) Safe-Inferred unixsetFileMode path mode) changes permission of the file given by path to mode. This operation may fail with  if path doesn't exist or if the effective user ID of the current process is not that of the file's owner. Note: calls chmod.unixfileAccess name read write exec3 checks if the file (or other file system object) name can be accessed for reading, writing and/or executing. To check a permission set the corresponding argument to . Note: calls access.unix%Checks for the existence of the file. Note: calls access.unixgetFileStatus path calls gets the  FileStatus? information (user ID, size, access times, etc.) for the file path. Note: calls stat.unixActs as  except when the . refers to a symbolic link. In that case the  FileStatus information of the symbolic link itself is returned instead of that of the file it points to. Note: calls lstat.unixcreateNamedPipe fifo mode creates a new named pipe, fifo, with permissions based on mode. May fail with  if a file named name already exists or if the effective user ID of the current process doesn't have permission to create the pipe. Note: calls mkfifo.unixcreateDevice path mode dev creates either a regular or a special file depending on the value of mode (and dev). mode will normally be either  or . May fail with  if a file named name already exists or if the effective user ID of the current process doesn't have permission to create the file. Note: calls mknod.unixcreateLink old new creates a new path, new, linked to an existing file, old. Note: calls link.unixremoveLink path removes the link named path. Note: calls unlink.unixcreateSymbolicLink file1 file2 creates a symbolic link named file2 which points to the file file1.Symbolic links are interpreted at run-time as if the contents of the link had been substituted into the path being followed to find a file or directory. Note: calls symlink.unix Reads the  PosixPath0 pointed to by the symbolic link and returns it. Note: calls readlink.unixrename old new" renames a file or directory from old to new. Note: calls rename.unixsetOwnerAndGroup path uid gid changes the owner and group of path to uid and gid, respectively.If uid or gid1 is specified as -1, then that ID is not changed. Note: calls chown.unixActs as  but does not follow symlinks (and thus changes permissions on the link itself). Note: calls lchown.unixsetFileTimes path atime mtime> sets the access and modification times associated with file path to atime and mtime, respectively. Note: calls utime.unixLike / but timestamps can have sub-second resolution. Note: calls  utimensat or utimes. 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.unixLike  but does not follow symbolic links. This operation is not supported on all platforms. On these platforms, this function will raise an exception. Note: calls  utimensat or lutimes. 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.unixtouchFile path> sets the access and modification times associated with file path to the current time. Note: calls utime.unixLike  but does not follow symbolic links. This operation is not supported on all platforms. On these platforms, this function will raise an exception. Note: calls lutimes.unixTruncates the file down to the specified length. If the file was larger than the given length before this operation was performed the extra is lost. Note: calls truncate.unixgetPathVar var path obtains the dynamic value of the requested configurable file limit or option associated with file or directory path. For defined file limits,  getPathVar returns the associated value. For defined file options, the result of  getPathVar is undefined, but not failure. Note: calls pathconf."(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) Safe-Inferred bunixcreateDirectory dir mode calls mkdir to create a new directory, dir, with permissions based on mode.unixopenDirStream dir calls opendir% to obtain a directory stream for dir.unixreadDirStream dp calls readdir( to obtain the next directory entry ( struct dirent#) for the open directory stream dp, and returns the d_name member of that structure.unixgetWorkingDirectory calls getcwd8 to obtain the name of the current working directory.unixchangeWorkingDirectory dir calls chdir/ to change the current working directory to dir.  !" ! " Trustworthy unixThe exit status of a processunixthe process exited by calling exit() or returning from mainunix-the process was terminated by a signal, the Bool is True if a core dump was producedunix#the process was stopped by a signal7"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) Trustworthy ԭunix calls getpid to obtain the  for the current process.unix calls getppid to obtain the * for the parent of the current process.unix calls getpgrp to obtain the  for the current process.unix pid calls getpgid to obtain the  for process pid.unix pid calls setpgid to make process pid a new process group leader.unix pgid calls setpgid to set the  of the current process to pgid.unix pid pgid calls setpgid to set the ProcessGroupIDOf for process pid to pgid.unix calls setsid to create a new session with the current process as session leader.unix calls times to obtain time-accounting information for the current process and its children.unixReturns the value from the  CLOCK_PER_SEC# macro, which is required by POSIX.unix corresponds to the POSIX fork system call. The  action passed as an argument is executed in the child process; no other threads will be copied to the child process. On success,  returns the child's  to the parent process; in case of an error, an exception is thrown.The exception masking state of the executed action is inherited (c.f. forkIO ), see also  (since: 2.7.0.0). comes with a giant warning: since any other running threads are not copied into the child process, it's easy to go wrong: e.g. by accessing some shared resource that was held by another thread in the parent. GHC note:  is not currently very well supported when using multiple capabilities (+RTS -N!), although it is supported with  -threaded. as long as only one capability is being used.unix Variant of  in the style of forkIOWithUnmask.unix blk stopped pid calls waitpid, returning  tc, the  for process pid if it is available,  otherwise. If blk is  , then WNOHANG is set in the options for waitpid, otherwise not. If stopped is , then  WUNTRACED is set in the options for waitpid, otherwise not.unix blk stopped pgid calls waitpid, returning  (pid, tc), the  and  for any process in group pgid if one is available, or  if there are child processes but none have exited. If there are no child processes, then  raises an isDoesNotExistError exception.If blk is , then WNOHANG is set in the options for waitpid, otherwise not. If stopped is  , then  WUNTRACED is set in the options for waitpid, otherwise not.unix blk stopped calls waitpid, returning  (pid, tc), the  and < for any child process if a child process has exited, or  if there are child processes but none have exited. If there are no child processes, then  raises an isDoesNotExistError exception.If blk is , then WNOHANG is set in the options for waitpid, otherwise not. If stopped is  , then  WUNTRACED is set in the options for waitpid, otherwise not.unix status calls _exit5 to terminate the process with the indicated exit status. The operation never returns. Since it does not use the Haskell exception system and it cannot be caught.Note: Prior to  unix-2.8.0.0 the type-signature of  was ExitCode -> IO ().unix pid calls setpgid to make process pid a new process group leader. This function is currently deprecated, and might be changed to making the current process a new process group leader in future versions.unix pid pgid calls setpgid to set the  for process pid to pgid. This function is currently deprecated, and might be changed to setting the / for the current process in future versions.$"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safeunix cmd args env calls one of the execv* family, depending on whether or not the current PATH is to be searched for the command, and whether or not an environment is provided to supersede the process's current environment. The basename (leading directory names suppressed) of the command is passed to execv* as arg[0]!; the argument list passed to  therefore begins with arg[1].unixCommandunix Search PATH?unix Argumentsunix Environment$$"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safeunix cmd args env calls one of the execv* family, depending on whether or not the current PATH is to be searched for the command, and whether or not an environment is provided to supersede the process's current environment. The basename (leading directory names suppressed) of the command is passed to execv* as arg[0]!; the argument list passed to  therefore begins with arg[1].unixCommandunix Search PATH?unix Argumentsunix Environment$$"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) Safe-Inferredރunix cmd args env calls one of the execv* family, depending on whether or not the current PATH is to be searched for the command, and whether or not an environment is provided to supersede the process's current environment. The basename (leading directory names suppressed) of the command is passed to execv* as arg[0]!; the argument list passed to  therefore begins with arg[1].unixCommandunix Search PATH?unix Argumentsunix Environment$$"(c) The University of Glasgow 2003/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe (c) Daniel Franke 2007/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires POSIX)Safe  unix:If true, create the semaphore if it does not yet exist.unix?If true, throw an exception if the semaphore already exists.unixOpen a named semaphore with the given name, flags, mode, and initial value.unix)Delete the semaphore with the given name.unixLock the semaphore, blocking until it becomes available. Since this is done through a system call, this will block the *entire runtime*, not just the current thread. If this is not the behaviour you want, use semThreadWait instead.unix8Lock the semaphore, blocking until it becomes available.Unlike , this wait operation can be interrupted with an asynchronous exception (e.g. a call to  from another thread).unixAttempt to lock the semaphore without blocking. Immediately return False if it is not available.unixPoll the semaphore until it is available, then lock it. Unlike semWait, this will block only the current thread rather than the entire process.unixUnlock the semaphore.unix%Return the semaphore's current value.  (c) Daniel Franke 2007/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires POSIX)Safeunix>If true, open the shm object read-write rather than read-only.unix4If true, create the shm object if it does not exist.unix=If true, throw an exception if the shm object already exists.unix>If true, wipe the contents of the shm object after opening it.unixOpen a shared memory object with the given name, flags, and mode.unix4Delete the shared memory object with the given name. "(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) Trustworthy 6+unixInformation specific to a particular type of signal (derived from  siginfo_t).unix2Information about a received signal (derived from  siginfo_t).unix1The actions to perform when a signal is received.unix&Sets the disposition of the signal to SIG_DFL, which means we want the default action associated with the signal. For example, the default action for SIGTERM: (and various other signals) is to terminate the process.unix%Set the disposition of the signal to SIG_IGN, which means we want to ignore the signal. Ignored signals will not be delivered to the process, and if also blocked will not be added to the pending set for later delivery (if/when unblocked). Some signals (e.g. SIGSTOP and SIGKILL0) cannot be caught or ignored. not yet: | Holdunixsignal handler is not resetunix+signal handler is automatically reset (via  SA_RESETHAND)unixunixunixProcess abort signal.unix Alarm clock.unix2Access to an undefined portion of a memory object.unix0Child process terminated, stopped, or continued.unixContinue executing, if stopped.unixErroneous arithmetic operation.unixHangup.unixIllegal instruction.unixTerminal interrupt signal.unix#Kill (cannot be caught or ignored).unix'Write on a pipe with no one to read it.unixTerminal quit signal.unixInvalid memory reference.unix-Stop executing (cannot be caught or ignored).unixTermination signal.unixTerminal stop signal.unix#Background process attempting read.unix$Background process attempting write.unixUser-defined signal 1.unixUser-defined signal 2.unixPollable event.unixProfiling timer expired.unixBad system call.unixTrace/breakpoint trap.unix-High bandwidth data is available at a socket.unixVirtual timer expired.unixCPU time limit exceeded.unixFile size limit exceeded.unix Alias for .unix Alias for .unix Alias for .unix Alias for .unix Alias for .unix Alias for .unix Alias for .unix Alias for .unix Alias for .unix Alias for .unix Alias for .unix Alias for .unix Alias for .unix Alias for .unix Alias for .unix Alias for .unix Alias for .unix Alias for .unix Alias for .unix Alias for .unix Alias for .unix Alias for .unix Alias for .unix Alias for .unix Alias for .unix Alias for .unix Alias for .unix Alias for .unixsignalProcess int pid calls kill to signal process pid with interrupt signal int.unixsignalProcessGroup int pgid calls kill$ to signal all processes in group pgid with interrupt signal int.unixraiseSignal int calls kill8 to signal the current process with interrupt signal int.unixinstallHandler int handler iset calls  sigaction/ to install an interrupt handler for signal int. If handler is Default, SIG_DFL is installed; if handler is Ignore, SIG_IGN is installed; if handler is  Catch action., a handler is installed which will invoke action in a new thread when (or shortly after) the signal is received. If iset is Just s , then the sa_mask of the  sigaction structure is set to s; otherwise it is cleared. The previously installed signal handler for int is returnedunixscheduleAlarm i calls alarm+ to schedule a real time alarm at least i seconds in the future.unix+Tells the system whether or not to set the  SA_NOCLDSTOP+ flag when installing new signal handlers.unix4Queries the current state of the stopped child flag.unixA set of signals reserved for use by the implementation. In GHC, this will normally include either  or .unix getSignalMask calls  sigprocmask to determine the set of interrupts which are currently being blocked.unixsetSignalMask mask calls  sigprocmask with  SIG_SETMASK to block all interrupts in mask.unixblockSignals mask calls  sigprocmask with  SIG_BLOCK to add all interrupts in mask$ to the set of blocked interrupts.unixunblockSignals mask calls  sigprocmask with  SIG_UNBLOCK to remove all interrupts in mask' from the set of blocked interrupts.unixgetPendingSignals calls  sigpending to obtain the set of interrupts which have been received but are currently blocked.unixawaitSignal iset8 suspends execution until an interrupt is received. If iset is Just s,  awaitSignal calls  sigsuspend, installing s as the new signal mask before suspending execution; otherwise, it calls  sigsuspend with current signal mask. Note that RTS scheduler signal (either  or ) could cause premature termination of this call. It might be necessary to block that signal before invocation of  awaitSignal with  . awaitSignal returns when signal was received and processed by a signal handler, or if the signal could not be caught. If you have installed any signal handlers with installHandler, it may be wise to call yield directly after  awaitSignal to ensure that the signal handler runs as promptly as possible.unixother signals to blockunix old handler  !"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisional9non-portable (requires POSIX, includes Linuxisms/BSDisms)Safe"(c) Volker Stolz Deian Stefan /BSD-style (see the file libraries/base/LICENSE):libraries@haskell.org, vs@foldr.org, deian@cs.stanford.edu provisionalnon-portable (requires POSIX)Safe  unixMake a unique filename and open it for reading/writing. The returned  is the (possibly relative) path of the created file, which is padded with 6 random characters. The argument is the desired prefix of the filepath of the temporary file to be created.If you aren't using GHC or Hugs then this function simply wraps mktemp and so shouldn't be considered safe.unixMake a unique filename with a given prefix and suffix and open it for reading/writing. The returned  is the (possibly relative) path of the created file, which contains 6 random characters in between the prefix and suffix. The first argument is the desired prefix of the filepath of the temporary file to be created. The second argument is the suffix of the temporary file to be created.If you are using as system that doesn't support the mkstemps glibc function (supported in glibc > 2.11) then this function simply throws an error.unix&Make a unique directory. The returned  is the path of the created directory, which is padded with 6 random characters. The argument is the desired prefix of the filepath of the temporary directory to be created.If you are using as system that doesn't support the mkdtemp glibc function (supported in glibc > 2.1.91) then this function uses mktemp and so shouldn't be considered safe.#(c) Volker Stolz Deian Stefan /BSD-style (see the file libraries/base/LICENSE):libraries@haskell.org, vs@foldr.org, deian@cs.stanford.edu provisionalnon-portable (requires POSIX)Safe unixMake a unique filename and open it for reading/writing. The returned  is the (possibly relative) path of the created file, which is padded with 6 random characters. The argument is the desired prefix of the filepath of the temporary file to be created.If you aren't using GHC or Hugs then this function simply wraps mktemp and so shouldn't be considered safe.unix - make a unique filename with a given prefix and suffix and open it for reading/writing (only safe on GHC & Hugs). The returned  is the (possibly relative) path of the created file, which contains 6 random characters in between the prefix and suffix.unix&Make a unique directory. The returned  is the path of the created directory, which is padded with 6 random characters. The argument is the desired prefix of the filepath of the temporary directory to be created.If you aren't using GHC or Hugs then this function simply wraps mktemp and so shouldn't be considered safe.$(c) Volker Stolz Deian Stefan /BSD-style (see the file libraries/base/LICENSE):libraries@haskell.org, vs@foldr.org, deian@cs.stanford.edu provisionalnon-portable (requires POSIX) Safe-Inferred unixMake a unique filename and open it for reading/writing. The returned  is the (possibly relative) path of the created file, which is padded with 6 random characters. The argument is the desired prefix of the filepath of the temporary file to be created.If you aren't using GHC or Hugs then this function simply wraps mktemp and so shouldn't be considered safe.unix - make a unique filename with a given prefix and suffix and open it for reading/writing (only safe on GHC & Hugs). The returned  is the (possibly relative) path of the created file, which contains 6 random characters in between the prefix and suffix.unix&Make a unique directory. The returned  is the path of the created directory, which is padded with 6 random characters. The argument is the desired prefix of the filepath of the temporary directory to be created.If you aren't using GHC or Hugs then this function simply wraps mktemp and so shouldn't be considered safe.8"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) Trustworthy *BunixTCOOFFunixTCOONunixTCIOFFunixTCIONunixSerial line baudrate. The set of supported speeds is system-dependent. Portable use of the provided pattern synonyms that are outside the list mandated by POSIX requires #ifdef guards.Applications may need to be prepared to encounter speeds not known at compile time, these can be handled generically via the  constructor. In other words, the provided pattern synonyms are not necessarily a COMPLETE set. All non-zero pseudo-terminal2 baud rates are functionally equivalent, and the pty driver may accept any speed within a suitable range. Requested speeds may be rounded up or down to fit into the supported range.unixBRKINT - Signal interrupt on breakunixICRNL - Map CR to NL on inputunixIGNBRK - Ignore break conditionunixIGNCR - Ignore CRunixIGNPAR' - Ignore characters with parity errorsunixINLCR - Map NL to CR on inputunixINPCK - Enable input parity checkunixISTRIP - Strip characterunixIXANY) - Enable any character to restart outputunixIXOFF" - Enable start/stop input controlunixIXON# - Enable start/stop output controlunixPARMRK - Mark parity errorsunixOPOST - Post-process outputunixONLCR" - (XSI) Map NL to CR-NL on outputunixOCRNL - (XSI) Map CR to NL on outputunixONOCR! - (XSI) No CR output at column 0unixONLRET - (XSI) NL performs CR functionunix TABDLY(TAB0)- - (XSI) Select horizontal-tab delays: type 0unix TABDLY(TAB3)- - (XSI) Select horizontal-tab delays: type 3unixCLOCAL - Ignore modem status linesunixCREAD - Enable receiverunixCSTOPB - Send two stop bits, else oneunixHUPCL - Hang up on last closeunixPARENB - Parity enableunixPARODD - Odd parity, else evenunixECHO - Enable echounixECHOE5 - Echo erase character as error-correcting backspaceunixECHOK - Echo KILLunixECHONL - Echo NLunixICANON. - Canonical input (erase and kill processing)unixIEXTEN- - Enable extended input character processingunixISIG - Enable signalsunixNOFLSH( - Disable flush after interrupt or quitunixTOSTOP - Send SIGTTOU for background outputunix24000000 baud, non-POSIX system-dependent extensionunix23500000 baud, non-POSIX system-dependent extensionunix23000000 baud, non-POSIX system-dependent extensionunix22500000 baud, non-POSIX system-dependent extensionunix22000000 baud, non-POSIX system-dependent extensionunix21500000 baud, non-POSIX system-dependent extensionunix21152000 baud, non-POSIX system-dependent extensionunix21000000 baud, non-POSIX system-dependent extensionunix1921600 baud, non-POSIX system-dependent extensionunix1576000 baud, non-POSIX system-dependent extensionunix1500000 baud, non-POSIX system-dependent extensionunix1460800 baud, non-POSIX system-dependent extensionunix1230400 baud, non-POSIX system-dependent extensionunix1115200 baud, non-POSIX system-dependent extensionunix057600 baud, non-POSIX system-dependent extensionunix 38400 baudunix 19200 baudunix 9600 baudunix 4800 baudunix 2400 baudunix 1800 baudunix 1200 baudunix600 baudunix300 baudunix200 baudunix150 baudunix 5 baudunix110 baudunix75 baudunix50 baudunixHang upunixgetTerminalAttributes fd calls  tcgetattr to obtain the TerminalAttributes associated with Fd fd.unix setTerminalAttributes fd attr ts calls  tcsetattr to change the TerminalAttributes associated with Fd fd to attr1, when the terminal is in the state indicated by ts.unixsendBreak fd duration calls  tcsendbreak; to transmit a continuous stream of zero-valued bits on Fd fd/ for the specified implementation-dependent duration.unixdrainOutput fd calls tcdrain) to block until all output written to Fd fd has been transmitted.Throws 9 ("unsupported operation") if platform does not provide  tcdrain(3) (use #if HAVE_TCDRAIN$ CPP guard to detect availability).unixdiscardData fd queues calls tcflush/ to discard pending input and/or output for Fd fd, as indicated by the  QueueSelector queues.unixcontrolFlow fd action calls tcflow# to control the flow of data on Fd fd, as indicated by action.unixgetTerminalProcessGroupID fd calls  tcgetpgrp to obtain the ProcessGroupID of the foreground process group associated with the terminal attached to Fd fd.unix!setTerminalProcessGroupID fd pgid calls  tcsetpgrp to set the ProcessGroupID of the foreground process group associated with the terminal attached to Fd fd to pgid.unixqueryTerminal fd calls isatty to determine whether or not Fd fd is associated with a terminal.%"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe /unixgetTerminalName fd calls ttyname6 to obtain a name associated with the terminal for Fd fd. If fd# is associated with a terminal, getTerminalName% returns the name of the terminal.unixgetControllingTerminalName calls ctermid to obtain a name associated with the controlling terminal for the process. If a controlling terminal exists, getControllingTerminalName1 returns the name of the controlling terminal.Throws 9 ("unsupported operation") if platform does not provide  ctermid(3) (use #if HAVE_CTERMID$ CPP guard to detect availability).unixgetSlaveTerminalName calls ptsname to obtain the name of the slave terminal associated with a pseudoterminal pair. The file descriptor to pass in must be that of the master.unixopenPseudoTerminal creates a pseudoterminal (pty) pair, and returns the newly created pair as a (master, slave) tuple.&"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe 6unixgetTerminalName fd calls ttyname6 to obtain a name associated with the terminal for Fd fd. If fd# is associated with a terminal, getTerminalName% returns the name of the terminal.unixgetControllingTerminalName calls ctermid to obtain a name associated with the controlling terminal for the process. If a controlling terminal exists, getControllingTerminalName1 returns the name of the controlling terminal.Throws 9 ("unsupported operation") if platform does not provide  ctermid(3) (use #if HAVE_CTERMID$ CPP guard to detect availability).unixgetSlaveTerminalName calls ptsname to obtain the name of the slave terminal associated with a pseudoterminal pair. The file descriptor to pass in must be that of the master.unixopenPseudoTerminal creates a pseudoterminal (pty) pair, and returns the newly created pair as a (master, slave) tuple.'"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) Safe-Inferred =junixgetTerminalName fd calls ttyname6 to obtain a name associated with the terminal for Fd fd. If fd# is associated with a terminal, getTerminalName% returns the name of the terminal.unixgetControllingTerminalName calls ctermid to obtain a name associated with the controlling terminal for the process. If a controlling terminal exists, getControllingTerminalName1 returns the name of the controlling terminal.Throws 9 ("unsupported operation") if platform does not provide  ctermid(3) (use #if HAVE_CTERMID$ CPP guard to detect availability).unixgetSlaveTerminalName calls ptsname to obtain the name of the slave terminal associated with a pseudoterminal pair. The file descriptor to pass in must be that of the master.unixopenPseudoTerminal creates a pseudoterminal (pty) pair, and returns the newly created pair as a (master, slave) tuple.("(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe @unix epochTime calls time to obtain the number of seconds that have elapsed since the epoch (Jan 01 00:00:00 GMT 1970).)"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe GunixSleep for the specified duration (in seconds). Returns the time remaining (if the sleep was interrupted by a signal, for example).GHC Note: 9: is a better choice. Since GHC uses signals for its internal clock, a call to 7 will usually be interrupted immediately. That makes  unusable in a program compiled with GHC, unless the RTS timer is disabled (with +RTS -V0). Furthermore, without the  -threaded option, 3 will block all other user threads. Even with the  -threaded option, ( requires a full OS thread to itself. 9: has none of these shortcomings.unix3Sleep for the specified duration (in microseconds).GHC Note: 9:" is a better choice. Without the  -threaded option, 4 will block all other user threads. Even with the  -threaded option, ( requires a full OS thread to itself. 9:$ has neither of these shortcomings.unix1Sleep for the specified duration (in nanoseconds)GHC Note: the comment for  also applies here.unix Performs fsync(2) operation on file-descriptor.Throws 9 ("unsupported operation") if platform does not provide fsync(2) (use #if HAVE_FSYNC$ CPP guard to detect availability).unix Performs  fdatasync(2) operation on file-descriptor.Throws 9 ("unsupported operation") if platform does not provide  fdatasync(2) (use #if HAVE_FDATASYNC$ CPP guard to detect availability).;"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)SafeJ unix The name of this group (gr_name)unix'The password for this group (gr_passwd)unix-The unique numeric ID for this group (gr_gid)unix:A list of zero or more usernames that are members (gr_mem)unix#Textual name of this user (pw_name)unixPassword -- may be empty or fake if shadow is in use (pw_passwd)unix!Numeric ID for this user (pw_uid)unixPrimary group ID (pw_gid)unix-Usually the real name for the user (pw_gecos)unixHome directory (pw_dir)unixDefault shell (pw_shell)*"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) Trustworthy (Vunix getRealUserID calls getuid to obtain the real UserID( associated with the current process.unixgetRealGroupID calls getgid to obtain the real GroupID( associated with the current process.unixgetEffectiveUserID calls geteuid to obtain the effective UserID% associated with the current process.unixgetEffectiveGroupID calls getegid to obtain the effective GroupID% associated with the current process.unix getGroups calls  getgroups( to obtain the list of supplementary GroupID&s associated with the current process.unix setGroups calls  setgroups% to set the list of supplementary GroupID&s associated with the current process.unix getLoginName calls getlogin to obtain the login name associated with the current process.unix setUserID uid calls setuid to set the real, effective, and saved set-user-id associated with the current process to uid.unixsetEffectiveUserID uid calls seteuid to set the effective user-id associated with the current process to uid:. This does not update the real user-id or set-user-id.unixsetGroupID gid calls setgid to set the real, effective, and saved set-group-id associated with the current process to gid.unixsetEffectiveGroupID uid calls setegid to set the effective group-id associated with the current process to gid<. This does not update the real group-id or set-group-id.unixgetEffectiveUserName0 gets the name associated with the effective UserID of the process.unixgetGroupEntryForID gid calls  getgrgid_r to obtain the  GroupEntry information associated with GroupID gid. This operation may fail with  if no such group exists.unixgetGroupEntryForName name calls  getgrnam_r to obtain the  GroupEntry1 information associated with the group called name. This operation may fail with  if no such group exists.unixgetAllGroupEntries returns all group entries on the system by repeatedly calling getgrentunixgetUserEntryForID uid calls  getpwuid_r to obtain the  UserEntry information associated with UserID uid. This operation may fail with  if no such user exists.unixgetUserEntryForName name calls  getpwnam_r to obtain the  UserEntry/ information associated with the user login name. This operation may fail with  if no such user exists.unixgetAllUserEntries returns all user entries on the system by repeatedly calling getpwent!!+"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) Trustworthy (ffunixManually constructing  in String modules is discouraged. It will truncate Chars to 8bit. Use +< instead.unixManually constructing  in String modules is discouraged. It will truncate Chars to 8bit. Use +< instead.unix getRealUserID calls getuid to obtain the real UserID( associated with the current process.unixgetRealGroupID calls getgid to obtain the real GroupID( associated with the current process.unixgetEffectiveUserID calls geteuid to obtain the effective UserID% associated with the current process.unixgetEffectiveGroupID calls getegid to obtain the effective GroupID% associated with the current process.unix getGroups calls  getgroups( to obtain the list of supplementary GroupID&s associated with the current process.unix setGroups calls  setgroups% to set the list of supplementary GroupID&s associated with the current process.unix getLoginName calls getlogin to obtain the login name associated with the current process.unix setUserID uid calls setuid to set the real, effective, and saved set-user-id associated with the current process to uid.unixsetEffectiveUserID uid calls seteuid to set the effective user-id associated with the current process to uid:. This does not update the real user-id or set-user-id.unixsetGroupID gid calls setgid to set the real, effective, and saved set-group-id associated with the current process to gid.unixsetEffectiveGroupID uid calls setegid to set the effective group-id associated with the current process to gid<. This does not update the real group-id or set-group-id.unixgetEffectiveUserName0 gets the name associated with the effective UserID of the process.unixgetGroupEntryForID gid calls  getgrgid_r to obtain the  GroupEntry information associated with GroupID gid. This operation may fail with  if no such group exists.unixgetGroupEntryForName name calls  getgrnam_r to obtain the  GroupEntry1 information associated with the group called name. This operation may fail with  if no such group exists.unixgetAllGroupEntries returns all group entries on the system by repeatedly calling getgrentunixgetUserEntryForID uid calls  getpwuid_r to obtain the  UserEntry information associated with UserID uid. This operation may fail with  if no such user exists.unixgetUserEntryForName name calls  getpwnam_r to obtain the  UserEntry/ information associated with the user login name. This operation may fail with  if no such user exists.unixgetAllUserEntries returns all user entries on the system by repeatedly calling getpwentunix#Textual name of this user (pw_name)unixPassword -- may be empty or fake if shadow is in use (pw_passwd)unix!Numeric ID for this user (pw_uid)unixPrimary group ID (pw_gid)unix-Usually the real name for the user (pw_gecos)unixHome directory (pw_dir)unixDefault shell (pw_shell)unix The name of this group (gr_name)unix'The password for this group (gr_passwd)unix-The unique numeric ID for this group (gr_gid)unix:A list of zero or more usernames that are members (gr_mem)"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) Safe-Inferredg !"Ycdefghijk="(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safek !"#$%&'()*.,+/3201456789:;@ABCDEFYZ[\]^_`ab*.,+/3201456789:;@ABCDEF5"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safeq# !"*.,+/3201456789:;@ABCGHIQRSTUVWXYpqrstuv*.,+/3201456789:;@ABCGHI>?@>?A>?B>?C>?D>?EFGHFIJKLMNOPQRED@ACBS,T,T,U,V,W,W,X,Y,Z,[,\,]^_`abcdefghijklmnopqrstuvwxy/z/{/|/-/} . ~  . ~                    22OPQR^_`abcd33333333333333333333333333333333333333333333333333333333333333333333333333344444444444444444444444444444444444444444444LMNOPQRED@ACBS^_`bcd7777777777777777777777777777777              h                                                                                  !!!!"""###$$$888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888%%%%&&&&''''()))))))))))))))))))))));;;;;;;;;;;;;;;******************+++++++++++++++++++++++++++++++>?>?>?>?>?>?>/z/000<>>3333333333S>4>>>>>>>7>>>;;;;;;;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>unix-2.8.2.1-inplaceSystem.Posix.ErrorSystem.Posix.PosixString System.Posix.ByteString.FilePath!System.Posix.Directory.ByteString System.Posix.Directory.InternalsSystem.Posix.Directory.FdSystem.Posix.DynamicLinker.Prim!System.Posix.DynamicLinker.Module%System.Posix.DynamicLinker.ByteStringSystem.Posix.DynamicLinker,System.Posix.DynamicLinker.Module.ByteStringSystem.Posix.EnvSystem.Posix.Env.ByteStringSystem.Posix.Env.PosixStringSystem.Posix.DirectorySystem.Posix.FcntlSystem.Posix.Files.ByteStringSystem.Posix.FilesSystem.Posix.IO.ByteStringSystem.Posix.IOSystem.Posix.PosixPath.FilePathSystem.Posix.IO.PosixStringSystem.Posix.Files.PosixString System.Posix.Directory.PosixPathSystem.Posix.Process.InternalsSystem.Posix.Process.ByteStringSystem.Posix.Process System.Posix.Process.PosixStringSystem.Posix.ResourceSystem.Posix.SemaphoreSystem.Posix.SharedMemSystem.Posix.SignalsSystem.Posix.Signals.ExtsSystem.Posix.TempSystem.Posix.Temp.ByteStringSystem.Posix.Temp.PosixString System.Posix.Terminal.ByteStringSystem.Posix.Terminal!System.Posix.Terminal.PosixStringSystem.Posix.TimeSystem.Posix.UnistdSystem.Posix.User.ByteStringSystem.Posix.UserSystem.Posix.Directory.Commondlsymdlopen!System.Posix.DynamicLinker.CommonSystem.Posix.Env.InternalSystem.EnvironmentgetArgsSystem.Posix.Files.CommonSystem.Posix.IO.Common System.PosixFilesSystem.Posix.Process.CommonSystem.Posix.Terminal.CommonControl.Concurrent threadDelaySystem.Posix.User.Common ByteStringSystem.Posix.ByteStringbaseForeign.C.ErrorthrowErrnoPathIf_throwErrnoPathIfNullthrowErrnoPathIfMinus1_throwErrnoPathIfMinus1throwErrnoPathIfthrowErrnoPathfilepath-1.4.100.4-a57c384096d97e35969f7ebbc0082efd8983890b802ed40073811a2a84491a53System.OsPath.Types PosixPathSystem.OsString.Internal.Types PosixString RawFilePath withFilePath peekFilePathpeekFilePathLenthrowErrnoPathIfMinus1RetrythrowErrnoPathIfMinus1Retry_throwErrnoPathIfNullRetrythrowErrnoPathIfRetrythrowErrnoTwoPathsIfMinus1_DirStreamOffsetCDirentCDir DirStreamunsafeOpenDirStreamFdrewindDirStreamcloseDirStream seekDirStream tellDirStreamchangeWorkingDirectoryFdcreateDirectory openDirStream readDirStreamreadDirStreamMaybegetWorkingDirectorychangeWorkingDirectoryremoveDirectoryDLNullNextDefaultDLHandle RTLDFlags RTLD_LAZYRTLD_NOW RTLD_GLOBAL RTLD_LOCAL c_dlclose c_dlerrorc_dlsymc_dlopen haveRtldNext haveRtldLocal packRTLDFlagspackDL$fShowDL$fShowRTLDFlags$fReadRTLDFlagsModuledlclosedlerrorundlwithDLwithDL_ moduleOpen moduleSymbol moduleClose moduleError withModule withModule_getEnv getEnvDefaultgetEnvironmentPrimgetEnvironmentsetEnvironmentunsetEnvputEnvsetEnvclearEnvAdvice AdviceNormal AdviceRandomAdviceSequentialAdviceWillNeedAdviceDontNeed AdviceNoReuse fileAdvise fileAllocate $fEqAdvicePathVar FileSizeBits LinkLimitInputLineLimitInputQueueLimit FileNameLimit PathNameLimitPipeBufferLimitSymbolicLinkLimitSetOwnerAndGroupIsRestrictedFileNamesAreNotTruncated VDisableCharAsyncIOAvailablePrioIOAvailableSyncIOAvailable FileStatus nullFileMode ownerReadModeownerWriteModeownerExecuteMode groupReadModegroupWriteModegroupExecuteMode otherReadModeotherWriteModeotherExecuteMode setUserIDModesetGroupIDMode stdFileMode ownerModes groupModes otherModes accessModesunionFileModesintersectFileModes fileTypeModesblockSpecialModecharacterSpecialMode namedPipeModeregularFileMode directoryModesymbolicLinkMode socketMode setFdModesetFileCreationMaskdeviceIDfileIDfileMode linkCount fileOwner fileGroupspecialDeviceIDfileSize accessTimemodificationTimestatusChangeTime fileBlocks fileBlockSizeaccessTimeHiResmodificationTimeHiResstatusChangeTimeHiRes isBlockDeviceisCharacterDevice isNamedPipe isRegularFile isDirectoryisSymbolicLinkisSocket getFdStatussetFdTimesHiRestouchFdsetFdOwnerAndGroup setFdSize getFdPathVar setFileMode fileAccess fileExist getFileStatusgetSymbolicLinkStatuscreateNamedPipe createDevice createLink removeLinkcreateSymbolicLinkreadSymbolicLinkrenamesetOwnerAndGroupsetSymbolicLinkOwnerAndGroup setFileTimessetFileTimesHiRessetSymbolicLinkTimesHiRes touchFiletouchSymbolicLink setFileSize getPathVarFileLock LockRequestReadLock WriteLockUnlockFdOption AppendOnWrite CloseOnExecNonBlockingReadSynchronousWrites OpenFileFlagsappend exclusivenocttynonBlocktruncnofollowcreatcloexec directorysyncOpenModeReadOnly WriteOnly ReadWrite createPipedupdupTostdInput stdOutputstdErrordefaultFileFlagscloseFd fdToHandle handleToFd queryFdOption setFdOptionfdSeekgetLocksetLock waitToSetLock fdReadBuf fdWriteBufopenFdopenFdAt createFile createFileAtfdReadfdWrite ProcessStatusExited TerminatedStopped c_execvpepPrPr_disableITimersdecipherWaitStatus$fEqProcessStatus$fOrdProcessStatus$fShowProcessStatus ProcessTimes elapsedTimeuserTime systemTime childUserTimechildSystemTime getProcessIDgetParentProcessIDgetProcessGroupIDgetProcessGroupIDOfcreateProcessGroupForjoinProcessGroupsetProcessGroupIDOf createSessiongetProcessTimesnicegetProcessPrioritygetProcessGroupPrioritygetUserPrioritysetProcessPrioritysetProcessGroupPrioritysetUserPriority forkProcessforkProcessWithUnmaskgetProcessStatusgetGroupProcessStatusgetAnyProcessStatusexitImmediatelycreateProcessGroupsetProcessGroupID executeFile ResourceLimitResourceLimitInfinityResourceLimitUnknownResourceLimits softLimit hardLimitResourceResourceCoreFileSizeResourceCPUTimeResourceDataSizeResourceFileSizeResourceOpenFilesResourceStackSizeResourceTotalMemorygetResourceLimitsetResourceLimit$fEqResourceLimits$fShowResourceLimits$fEqResourceLimit$fShowResourceLimit $fEqResource$fShowResource Semaphore OpenSemFlags semCreate semExclusivesemOpen semUnlinksemWaitsemWaitInterruptible semTryWait semThreadWaitsemPost semGetValue ShmOpenFlags shmReadWrite shmCreate shmExclusiveshmTruncshmOpen shmUnlink SignalSetSignalSpecificInfoNoSignalSpecificInfo SigChldInfo siginfoPid siginfoUid siginfoStatus SignalInfo siginfoSignal siginfoErrorsiginfoSpecificHandlerIgnoreCatch CatchOnce CatchInfo CatchInfoOnceSignal nullSignalsigABRTsigALRMsigBUSsigCHLDsigCONTsigFPEsigHUPsigILLsigINTsigKILLsigPIPEsigQUITsigSEGVsigSTOPsigTERMsigTSTPsigTTINsigTTOUsigUSR1sigUSR2sigPOLLsigPROFsigSYSsigTRAPsigURG sigVTALRMsigXCPUsigXFSZ internalAbort realTimeAlarmbusErrorprocessStatusChangedcontinueProcessfloatingPointExceptionlostConnectionillegalInstructionkeyboardSignal killProcess openEndedPipekeyboardTerminationsegmentationViolation softwareStopsoftwareTermination keyboardStopbackgroundReadbackgroundWriteuserDefinedSignal1userDefinedSignal2 pollableEventprofilingTimerExpired badSystemCallbreakpointTrapurgentDataAvailablevirtualTimerExpiredcpuTimeLimitExceededfileSizeLimitExceeded signalProcesssignalProcessGroup raiseSignalinstallHandler scheduleAlarmsetStoppedChildFlagqueryStoppedChildFlagemptySignalSet fullSignalSetreservedSignals addSignal deleteSignal inSignalSet getSignalMask setSignalMask blockSignalsunblockSignalsgetPendingSignals awaitSignalsigINFOsigWINCH infoEvent windowChangemkstempmkstempsmkdtemp FlowAction SuspendOutput RestartOutput TransmitStop TransmitStart QueueSelector InputQueue OutputQueue BothQueues TerminalState Immediately WhenDrained WhenFlushedBaudRateControlCharacter EndOfFile EndOfLineErase InterruptKillQuitStartStopSuspend TerminalModeInterruptOnBreak MapCRtoLF IgnoreBreakIgnoreCRIgnoreParityErrors MapLFtoCR CheckParity StripHighBit RestartOnAnyStartStopInputStartStopOutputMarkParityErrors ProcessOutput MapLFtoCRLFOutputMapCRtoLFNoCRAtColumnZero ReturnMeansLF TabDelayMask0 TabDelayMask3 LocalMode ReadEnable TwoStopBits HangupOnClose EnableParity OddParity EnableEcho EchoEraseEchoKillEchoLF ProcessInputExtendedFunctionsKeyboardInterruptsNoFlushOnInterruptBackgroundWriteInterruptTerminalAttributesB4000000B3500000B3000000B2500000B2000000B1500000B1152000B1000000B921600B576000B500000B460800B230400B115200B57600B38400B19200B9600B4800B2400B1800B1200B600B300B200B150B134B110B75B50B0 withoutModewithMode terminalMode bitsPerBytewithBits controlCharwithCC withoutCC inputTimewithTimeminInput withMinInput inputSpeedwithInputSpeed outputSpeedwithOutputSpeedgetTerminalAttributessetTerminalAttributes sendBreak drainOutput discardData controlFlowgetTerminalProcessGroupIDsetTerminalProcessGroupID queryTerminalgetTerminalNamegetControllingTerminalNamegetSlaveTerminalNameopenPseudoTerminal epochTimeSysVar ArgumentLimit ChildLimit ClockTick GroupLimit OpenFileLimit PosixVersion HasSavedIDs HasJobControlSystemID systemNamenodeNamereleaseversionmachine getSystemIDsleepusleep nanosleep getSysVarfileSynchronisefileSynchroniseDataOnly GroupEntry groupName groupPasswordgroupID groupMembers UserEntryuserName userPassworduserID userGroupID userGecos homeDirectory userShell getRealUserIDgetRealGroupIDgetEffectiveUserIDgetEffectiveGroupID getGroups setGroups getLoginName setUserIDsetEffectiveUserID setGroupIDsetEffectiveGroupIDgetEffectiveUserNamegetGroupEntryForIDgetGroupEntryForNamegetAllGroupEntriesgetUserEntryForIDgetUserEntryForNamegetAllUserEntries throwErrno throwErrnoIf throwErrnoIf_throwErrnoIfNullthrowErrnoIfMinus1throwErrnoIfMinus1_decodeWithBasePosixuseAsCStringSafebytestring-0.11.4.0Data.ByteString useAsCStringGHC.PtrnullPtrthrowDLErrorIf c_environ_p getCEnvironData.ByteString.Internal.TypeGHC.IO.ExceptionIOErrorGHC.IOFilePathCTimeVal CTimeSpec c_lutimesc_utimes c_utimensat toCTimeSpec toCTimeVal pathVarConstghc-prim GHC.TypesTrue GHC.MaybeNothingFalseopenat_System.Posix.TypesFdGHC.IO.Handle.TypesHandle GHC.IO.HandlehCloseFileModeGHC.BaseStringData.ByteString.Short.Internal ProcessIDProcessGroupID clocksPerSecIOJust GHC.Conc.SyncthrowToSystem.Posix.InternalsCTermiosLKUPTYPEGETALLGETONECGroupCPasswdunpackGroupEntryunpackUserEntrySystem.IO.ErrorisDoesNotExistErrorUserID LinkCountLimitGroupID FileOffsetFileID EpochTimeDeviceIDCUidCTimerCTcflagCSsizeCSpeedCSocklenCRLimCPidCOffCNlinkCNfdsCModeCKeyCInoCIdCGid CFsFilCnt CFsBlkCntCDevCClockIdCCcCBlkSizeCBlkCnt ByteCount