h"F      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGH I J K L M N O P Q R S T U V W X YZ[\] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                            '"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)SafexunixA 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.   "(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe1unixrewindDirStream 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.unixgetWorkingDirectory calls getcwd8 to obtain the name of the current working directory.unixchangeWorkingDirectory dir calls chdir/ to change the current working directory to dir.   $(c) Volker Stolz 2003/BSD-style (see the file libraries/base/LICENSE) vs@foldr.org provisionalnon-portable (requires POSIX) TrustworthyA!unix Flags for !. Notice that #; might not be available on your particular platform! Use /.If  RTLD_DEFAULT" is not defined on your platform, 2 $ reduces to .&unix Flags for "./unix+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 / to check wether 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, 2 will throw an error.!#$"%&'()*+,-./012.-,+/01&'()*2!#$"%#$(c) Volker Stolz 2003/BSD-style (see the file libraries/base/LICENSE) vs@foldr.org provisionalnon-portable (requires POSIX)Safe9unix98 returns the address binding of the symbol described in symbol3, as it occurs in the shared object identified by source.:unix:8 obtains the raw handle. You mustn't do something like -withDL mod flags $ liftM undl >>= p -> use p!%"#$&*)'(+,-./0126789:$(c) Volker Stolz 2003/BSD-style (see the file libraries/base/LICENSE) vs@foldr.org provisionalnon-portable (requires POSIX)Safe!%"#$&*)'(+,-./012789:;<=;987<=:$(c) Volker Stolz 2003/BSD-style (see the file libraries/base/LICENSE) vs@foldr.org provisionalnon-portable (requires POSIX)Safe!%"#$&*)'(+,-./012789:>?@>987?@:$(c) Volker Stolz 2003/BSD-style (see the file libraries/base/LICENSE) vs@foldr.org provisionalnon-portable (requires POSIX)Safep6ABCDEF6ABCDEF$(c) Volker Stolz 2003/BSD-style (see the file libraries/base/LICENSE) vs@foldr.org provisionalnon-portable (requires POSIX)Safe'6BCDEFG6GBCDEF "(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe "HunixH( looks up a variable in the environment.IunixI is a wrapper around H where the programmer can specify a fallback if the variable is not found in the environment.KunixK0 retrieves the entire environment as a list of  (key,value) pairs.LunixL5 resets the entire environment to the given list of  (key,value) pairs.MunixThe M function deletes all instances of the variable name from the environment.NunixN( function takes an argument of the form  name=value and is equivalent to #setEnv(key,value,True{-overwrite-}).OunixThe O 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.PunixThe P9 function clears the environment of all name-value pairs.Hunixvariable name unixvariable value Iunix!variable name unix!fallback value unix!variable value or fallback value Kunix  [(key,value)]Lunix  [(key,value)]Munixvariable name Nunix "key=value" Ounixvariable name unixvariable value unixoverwrite HIJKLMNOP HIJKLNOMP "(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) Trustworthy )QunixQ( 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.UunixThe U function deletes all instances of the variable name from the environment.VunixV( function takes an argument of the form  name=value and is equivalent to #setEnv(key,value,True{-overwrite-}).WunixThe W 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.Xunix Computation X returns a list of the program's command line arguments (not including the program name), as s.Unlike $%, 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.Qunixvariable name unixvariable value Runix!variable name unix!fallback value unix!variable value or fallback value Tunix  [(key,value)]Uunixvariable name Vunix "key=value" Wunixvariable name unixvariable value unixoverwrite QRSTUVWXQRSTVWUX"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe*x YZ[\ \[YZ "(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.`unixgetWorkingDirectory calls getcwd8 to obtain the name of the current working directory.aunixchangeWorkingDirectory dir calls chdir/ to change the current working directory to dir. ]^_`ab ]b^_`a "(c) The University of Glasgow 2014 BSD-style (see the file LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe 1cunixAdvice parameter for j operation.'For more details, see documentation of posix_fadvise(2).junix Performs posix_fadvise(2) operation on file-descriptor.If platform does not provide posix_fadvise(2) j becomes a no-op.(use #if HAVE_POSIX_FADVISE" CPP guard to detect availability)kunix 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). cdefghijk cdefghijk&"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) TrustworthyAX1|unixPOSIX 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.}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.).unix-Time of last access in sub-second resolution.unix3Time of last modification in sub-second resolution.unixTime of last status change (i.e. owner, group, link count, mode, etc.) in sub-second resolution.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.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.mnopqrstuvwxyz{|}~ "(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe SunixsetFileMode 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.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.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.mnopqrstuvwxyz{|}~}~|mnopqrstuvwxyz{"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe funixsetFileMode 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 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.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.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.mnopqrstuvwxyz{|}~}~|mnopqrstuvwxyz{'"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe #$s unixO_APPENDunix FD_CLOEXECunix O_NONBLOCKunixO_SYNCunix5Correspond to some of the int flags from C's fcntl.h.unixO_APPENDunixO_EXCLunixO_NOCTTYunix O_NONBLOCKunixO_TRUNCunixThe  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. False for each of append, exclusive, noctty, nonBlock, and trunc.unix+Open and optionally create this file. See ()$ for information on how to use the  type.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.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  and convert it to a  using the locale encoding. Throws an exception if this is an invalid descriptor, or EOF has been reached.unixRead data from an 8 into memory. This is exactly equivalent to the POSIX read function.unixWrite a  to an  using the locale encoding.unixWrite data from memory to an ,. This is exactly equivalent to the POSIX write function.unixJust x => creates the file with the given modes, Nothing => the file must exist.unixHow many bytes to readunix)The bytes read, how many bytes were read.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)Safeuunix+Open and optionally create this file. See ()$ for information on how to use the  type.unixCreate and open this file in WriteOnly mode. A special case of . See ()$ for information on how to use the  type.unixJust x => creates the file with the given modes, Nothing => the file must exist.++"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)SafexIunix+Open and optionally create this file. See ()$ for information on how to use the  type.unixCreate and open this file in WriteOnly mode. A special case of . See ()$ for information on how to use the  type.unixJust x => creates the file with the given modes, Nothing => the file must exist.++ Trustworthy z9unixThe 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 signal*"(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.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.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.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)Safepunix 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.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 3unixInformation 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.unixunixunixsignalProcess 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 KunixMake 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) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) Trustworthy 0 unixTCOOFFunixTCOONunixTCIOFFunixTCIONunixgetTerminalAttributes 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 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 ˛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 ^unixSleep for the specified duration (in seconds). Returns the time remaining (if the sleep was interrupted by a signal, for example).GHC Note: ,- 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. ,- has none of these shortcomings.unix3Sleep for the specified duration (in microseconds).GHC Note: ,-" 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. ,-$ 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) Trustworthy 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)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 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 gid 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)Safe !%#"&*)'(+,-./012789:;<=QRSTUVWXm{zyxwvutsrqpno|}~!%#"&*)'(+,-./012789:;<=("(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe!%#"&*)'(+,-./012789:>?@HIJKLMNOP]^_`abm{zyxwvutsrqpno|}~!%#"&*)'(+,-./012789:>?@/01/02/03/04/05/06789:;<=>654321 ? @ A B C D EFGHIJKLMNOPQRSTUVWXYZ[\]^_`#a#b#c#!#d"ef"efghijklg m n o p q r s t u m n o p r s t %;<=> F G H I J K v w x y z { | } ~ &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&                     '''''''''''''''''''''''''''''''''''''''''*******************************O++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/0/0/0/0/0/0 ?   @/#a#//&&&&&&&&&&&'/////////////////////////////////////////////////////////////////// unix-2.7.2.2System.Posix.Error System.Posix.ByteString.FilePath!System.Posix.Directory.ByteStringSystem.Posix.DynamicLinker.Prim!System.Posix.DynamicLinker.Module%System.Posix.DynamicLinker.ByteStringSystem.Posix.DynamicLinker,System.Posix.DynamicLinker.Module.ByteStringSystem.Posix.EnvSystem.Posix.Env.ByteStringSystem.Posix.DirectorySystem.Posix.FcntlSystem.Posix.Files.ByteStringSystem.Posix.FilesSystem.Posix.IO.ByteStringSystem.Posix.IOSystem.Posix.Process.InternalsSystem.Posix.Process.ByteStringSystem.Posix.ProcessSystem.Posix.ResourceSystem.Posix.SemaphoreSystem.Posix.SharedMemSystem.Posix.SignalsSystem.Posix.Signals.ExtsSystem.Posix.TempSystem.Posix.Temp.ByteString System.Posix.Terminal.ByteStringSystem.Posix.TerminalSystem.Posix.TimeSystem.Posix.UnistdSystem.Posix.UserSystem.Posix.Directory.Commondlsymdlopen!System.Posix.DynamicLinker.CommonSystem.EnvironmentgetArgsSystem.Posix.Files.CommonSystem.Posix.IO.Common System.PosixFilesSystem.Posix.Process.CommonSystem.Posix.Terminal.CommonControl.Concurrent threadDelaySystem.Posix.ByteStringbaseForeign.C.ErrorthrowErrnoPathIfMinus1_throwErrnoPathIfMinus1throwErrnoPathIfNullthrowErrnoPathIf_throwErrnoPathIfthrowErrnoPath RawFilePath withFilePath peekFilePathpeekFilePathLenthrowErrnoPathIfMinus1RetrythrowErrnoPathIfMinus1Retry_throwErrnoPathIfNullRetrythrowErrnoPathIfRetryDirStreamOffset DirStreamrewindDirStreamcloseDirStream seekDirStream tellDirStreamchangeWorkingDirectoryFdcreateDirectory openDirStream readDirStreamgetWorkingDirectorychangeWorkingDirectoryremoveDirectoryDLNullNextDefaultDLHandle 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 accessTimemodificationTimestatusChangeTimeaccessTimeHiResmodificationTimeHiResstatusChangeTimeHiRes isBlockDeviceisCharacterDevice isNamedPipe isRegularFile isDirectoryisSymbolicLinkisSocket getFdStatussetFdTimesHiRestouchFdsetFdOwnerAndGroup setFdSize getFdPathVar setFileMode fileAccess fileExist getFileStatusgetSymbolicLinkStatuscreateNamedPipe createDevice createLink removeLinkcreateSymbolicLinkreadSymbolicLinkrenamesetOwnerAndGroupsetSymbolicLinkOwnerAndGroup setFileTimessetFileTimesHiRessetSymbolicLinkTimesHiRes touchFiletouchSymbolicLink setFileSize getPathVarFileLock LockRequestReadLock WriteLockUnlockFdOption AppendOnWrite CloseOnExecNonBlockingReadSynchronousWrites OpenFileFlagsappend exclusivenocttynonBlocktruncOpenModeReadOnly WriteOnly ReadWrite createPipedupdupTostdInput stdOutputstdErrordefaultFileFlagscloseFd fdToHandle handleToFd queryFdOption setFdOptionfdSeekgetLocksetLock waitToSetLockfdRead fdReadBuffdWrite fdWriteBufopenFd createFile ProcessStatusExited TerminatedStopped c_execvpepPrPr_disableITimersdecipherWaitStatus$fEqProcessStatus$fOrdProcessStatus$fShowProcessStatus ProcessTimes elapsedTimeuserTime systemTime childUserTimechildSystemTime getProcessIDgetParentProcessIDgetProcessGroupIDgetProcessGroupIDOfcreateProcessGroupForjoinProcessGroupsetProcessGroupIDOf createSessiongetProcessTimesnicegetProcessPrioritygetProcessGroupPrioritygetUserPrioritysetProcessPrioritysetProcessGroupPrioritysetUserPriority forkProcessforkProcessWithUnmaskgetProcessStatusgetGroupProcessStatusgetAnyProcessStatusexitImmediatelycreateProcessGroupsetProcessGroupID executeFile ResourceLimitResourceLimitInfinityResourceLimitUnknownResourceLimits softLimit hardLimitResourceResourceCoreFileSizeResourceCPUTimeResourceDataSizeResourceFileSizeResourceOpenFilesResourceStackSizeResourceTotalMemorygetResourceLimitsetResourceLimit$fEqResourceLimits$fEqResourceLimit $fEqResource Semaphore OpenSemFlags semCreate semExclusivesemOpen semUnlinksemWait 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 WhenFlushedBaudRateB0B50B75B110B134B150B200B300B600B1200B1800B2400B4800B9600B19200B38400B57600B115200ControlCharacter EndOfFile EndOfLineErase InterruptKillQuitStartStopSuspend TerminalModeInterruptOnBreak MapCRtoLF IgnoreBreakIgnoreCRIgnoreParityErrors MapLFtoCR CheckParity StripHighBitStartStopInputStartStopOutputMarkParityErrors ProcessOutput LocalMode ReadEnable TwoStopBits HangupOnClose EnableParity OddParity EnableEcho EchoEraseEchoKillEchoLF ProcessInputExtendedFunctionsKeyboardInterruptsNoFlushOnInterruptBackgroundWriteInterruptTerminalAttributes 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 UserEntryuserName userPassworduserID userGroupID userGecos homeDirectory userShell GroupEntry groupName groupPasswordgroupID groupMembers getRealUserIDgetRealGroupIDgetEffectiveUserIDgetEffectiveGroupID getGroups setGroups getLoginName setUserIDsetEffectiveUserID setGroupIDsetEffectiveGroupIDgetEffectiveUserNamegetGroupEntryForIDgetGroupEntryForNamegetAllGroupEntriesgetUserEntryForIDgetUserEntryForNamegetAllUserEntries$fShowUserEntry$fReadUserEntry $fEqUserEntry$fShowGroupEntry$fReadGroupEntry$fEqGroupEntry throwErrno throwErrnoIf throwErrnoIf_throwErrnoIfNullthrowErrnoIfMinus1throwErrnoIfMinus1_CDirentCDirGHC.PtrnullPtrthrowDLErrorIfbytestring-0.10.9.0Data.ByteString.Internal ByteStringGHC.IO.ExceptionIOErrorGHC.IOFilePathCTimeVal CTimeSpec c_lutimesc_utimes c_utimensat toCTimeSpec toCTimeVal pathVarConstghc-prim GHC.TypesTrueopen_System.Posix.TypesFileModeFdGHC.IO.Handle.TypesHandleGHC.BaseString ProcessIDProcessGroupIDIO GHC.MaybeJustNothingFalseSystem.Posix.InternalsCTermiosSystem.IO.ErrorisDoesNotExistErrorCDevCInoCModeCOffCPidCSsizeCGidCNlinkCUidCCcCSpeedCTcflagCRLimCBlkSizeCBlkCntCClockId CFsBlkCnt CFsFilCntCIdCKeyCTimerCSocklenCNfds LinkCountUserIDGroupID ByteCount EpochTimeDeviceIDFileID FileOffsetLimit