fd.h

Go to the documentation of this file.

/*
** fd.h for lseos in lseos-lib/libc/sysinterf
** 
** Copyright (c)2004 Vianney Rancurel, Julien Quintard
** Login   <vianney@epita.fr>
** 
** Started on  Tue Oct  5 11:41:00 2004 Mycure
** Last update Wed Dec  8 09:56:06 2004 Vianney Rancurel
*/
#ifndef __SYSINTERF_FD_H__
#define __SYSINTERF_FD_H__      1
/*-
 * Copyright (c) 1982, 1986, 1990, 1993, 1994
 *      The Regents of the University of California.  All rights reserved.
 * (c) UNIX System Laboratories, Inc.
 * Some portions of this file are derived from material licensed
 * to the University of California by American Telephone and Telegraph
 * Co. or Unix System Laboratories, Inc. 
 */

/*
 * note from the conceptors of LSE/OS: we tried to keep the Unix semantics
 * in order to keep compatibility with the original unix code, it explains
 * why we kept all these structures.
 */

/*
 * file descriptor syscalls interface
 */
#define SYSFD_ACCESS    128
#define SYSFD_CHDIR     129
#define SYSFD_CHMOD     130
#define SYSFD_CHOWN     131
#define SYSFD_CHROOT    132
#define SYSFD_CLOSE     133
#define SYSFD_MKFS      134
#define SYSFD_FCHDIR    135
#define SYSFD_FCHMOD    136
#define SYSFD_FCHOWN    137
#define SYSFD_FCNTL     138
#define SYSFD_FSTAT     139
#define SYSFD_FSTATFS   140
#define SYSFD_FSYNC     141
#define SYSFD_FTIME     142
#define SYSFD_FTRUNCATE 143
#define SYSFD_GETCWD    144
#define SYSFD_GETDENTS  145
#define SYSFD_LCHOWN    145
#define SYSFD_LINK      146
#define SYSFD_LSEEK     147
#define SYSFD_LSTAT     148
#define SYSFD_MKDIR     149
#define SYSFD_MKNOD     150
#define SYSFD_MOUNT     151
#define SYSFD_OPEN      152
#define SYSFD_READDIR   153
#define SYSFD_READLINK  154
#define SYSFD_READ      155
#define SYSFD_RENAME    156
#define SYSFD_RMDIR     157
#define SYSFD_STAT      158
#define SYSFD_STATFS    159
#define SYSFD_TRUNCATE  160
#define SYSFD_UMOUNT    161
#define SYSFD_UNLINK    162
#define SYSFD_WRITE     163
#define SYSFD_IOCTL     164
#define SYSFD_DUMP      165
#define SYSFD_POLL      166
#define SYSFD_SUBMOUNT  167
#define SYSFD_SUBUMOUNT 168
#define SYSFD_CHMBR     169
#define SYSFD_SYMLINK   170
#define SYSFD_GETERR    171

/*
 * fd syscallargs.h
 */
typedef struct  s_sys_fd_lseek_args
{
  int           gate_id;
  off_t         offset;
  int           whence;
  pid_t         pid;
}               t_sys_fd_lseek_args;

typedef struct  s_sys_fd_mount_args
{
  char          *type;
  char          *dir;
  int           flags;
  void          *data;
  pid_t         pid;
}               t_sys_fd_mount_args;

/*
 * fd specific ioctls
 */
#define FIOATTACH       _IOW('f', 42, pid_t)
#define FIODETACH       _IOW('f', 43, pid_t)

/*
 * for utime(2)
 */
struct utimbuf 
{
        time_t  actime;
        time_t  modtime;
};

/*
 * File status flags: these are used by open(2), fcntl(2).
 * They are also used (indirectly) in the kernel file structure f_flags,
 * which is a superset of the open/fcntl flags.  Open flags and f_flags
 * are inter-convertible using OFLAGS(fflags) and FFLAGS(oflags).
 * Open/fcntl flags begin with O_; kernel-internal flags begin with F.
 */
/* open-only flags */
#define O_RDONLY        0x00000000      /* open for reading only */
#define O_WRONLY        0x00000001      /* open for writing only */
#define O_RDWR          0x00000002      /* open for reading and writing */
#define O_ACCMODE       0x00000003      /* mask for above modes */

/*
 * Kernel encoding of open mode; separate read and write bits that are
 * independently testable: 1 greater than the above.
 *
 * XXX
 * FREAD and FWRITE are excluded from the #ifdef _KERNEL so that TIOCFLUSH,
 * which was documented to use FREAD/FWRITE, continues to work.
 */
#if !defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)
#define FREAD           0x00000001
#define FWRITE          0x00000002
#endif
#define O_NONBLOCK      0x00000004      /* no delay */
#define O_APPEND        0x00000008      /* set append mode */
#if !defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)
#define O_SHLOCK        0x00000010      /* open with shared file lock */
#define O_EXLOCK        0x00000020      /* open with exclusive file lock */
#define O_ASYNC         0x00000040      /* signal pgrp when data ready */
#endif
#if (!defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)) || \
    (_POSIX_C_SOURCE - 0) >= 199309L || \
    (defined(_XOPEN_SOURCE) && defined(_XOPEN_SOURCE_EXTENDED)) || \
    (_XOPEN_SOURCE - 0) >= 500
#define O_SYNC          0x00000080              /* synchronous writes */
#endif
#define O_CREAT         0x00000200              /* create if nonexistent */
#define O_TRUNC         0x00000400              /* truncate to zero length */
#define O_EXCL          0x00000800              /* error if already exists */

#if (!defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)) || \
    (_POSIX_C_SOURCE - 0) >= 199309L || (_XOPEN_SOURCE - 0) >= 500
#define O_DSYNC         0x00010000      /* write: I/O data completion */
#define O_RSYNC         0x00020000      /* read: I/O completion as for write */
#endif

#if !defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)
#define O_ALT_IO        0x00040000      /* use alternate i/o semantics */
#endif

/* defined by POSIX 1003.1; BSD default, but required to be bitwise distinct */
#define O_NOCTTY        0x008000        /* don't assign controlling terminal */

/*
 * The O_* flags used to have only F* names, which were used in the kernel
 * and by fcntl.  We retain the F* names for the kernel f_flags field
 * and for backward compatibility for fcntl.
 */
#if !defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)
#define FAPPEND         O_APPEND        /* kernel/compat */
#define FASYNC          O_ASYNC         /* kernel/compat */
#define O_FSYNC         O_SYNC          /* compat */
#define FNDELAY         O_NONBLOCK      /* compat */
#define O_NDELAY        O_NONBLOCK      /* compat */
#endif
#if defined(_KERNEL)
#define FNONBLOCK       O_NONBLOCK      /* kernel */
#define FFSYNC          O_SYNC          /* kernel */
#define FDSYNC          O_DSYNC         /* kernel */
#define FRSYNC          O_RSYNC         /* kernel */
#define FALTIO          O_ALT_IO        /* kernel */
#endif

/*
 * Constants used for fcntl(2)
 */

/* command values */
#define F_DUPFD         0               /* duplicate file descriptor */
#define F_GETFD         1               /* get file descriptor flags */
#define F_SETFD         2               /* set file descriptor flags */
#define F_GETFL         3               /* get file status flags */
#define F_SETFL         4               /* set file status flags */
#if !defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)
#define F_GETOWN        5               /* get SIGIO/SIGURG proc/pgrp */
#define F_SETOWN        6               /* set SIGIO/SIGURG proc/pgrp */
#endif
#define F_GETLK         7               /* get record locking information */
#define F_SETLK         8               /* set record locking information */
#define F_SETLKW        9               /* F_SETLK; wait if blocked */

/* file descriptor flags (F_GETFD, F_SETFD) */
#define FD_CLOEXEC      1               /* close-on-exec flag */

/* record locking flags (F_GETLK, F_SETLK, F_SETLKW) */
#define F_RDLCK         1               /* shared or read lock */
#define F_UNLCK         2               /* unlock */
#define F_WRLCK         3               /* exclusive or write lock */

/* Constants for fcntl's passed to the underlying fs - like ioctl's. */
#if !defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)
#define F_PARAM_MASK    0xfff
#define F_PARAM_LEN(x)  (((x) >> 16) & F_PARAM_MASK)
#define F_PARAM_MAX     4095
#define F_FSCTL         (int)0x80000000 /* This fcntl goes to the fs */
#define F_FSVOID        (int)0x40000000 /* no parameters */
#define F_FSOUT         (int)0x20000000 /* copy out parameter */
#define F_FSIN          (int)0x10000000 /* copy in parameter */
#define F_FSINOUT       (F_FSIN | F_FSOUT)
#define F_FSDIRMASK     (int)0x70000000 /* mask for IN/OUT/VOID */
#define F_FSPRIV        (int)0x00008000 /* command is fs-specific */

/*
 * Define command macros for operations which, if implemented, must be
 * the same for all fs's.
 */
#define _FCN(inout, num, len) \
                (F_FSCTL | inout | ((len & F_PARAM_MASK) << 16) | (num))
#define _FCNO(c)        _FCN(F_FSVOID,  (c), 0)
#define _FCNR(c, t)     _FCN(F_FSIN,    (c), (int)sizeof(t))
#define _FCNW(c, t)     _FCN(F_FSOUT,   (c), (int)sizeof(t))
#define _FCNRW(c, t)    _FCN(F_FSINOUT, (c), (int)sizeof(t))

/*
 * Define command macros for fs-specific commands.
 */
#define _FCN_FSPRIV(inout, num, len) \
        (F_FSCTL | F_FSPRIV | inout | ((len & F_PARAM_MASK) << 16) | (num))
#define _FCNO_FSPRIV(c)         _FCN_FSPRIV(F_FSVOID,   (c), 0)
#define _FCNR_FSPRIV(c, t)      _FCN_FSPRIV(F_FSIN,     (c), (int)sizeof(t))
#define _FCNW_FSPRIV(c, t)      _FCN_FSPRIV(F_FSOUT,    (c), (int)sizeof(t))
#define _FCNRW_FSPRIV(c, t)     _FCN_FSPRIV(F_FSINOUT,  (c), (int)sizeof(t))

#endif /* neither POSIX nor _XOPEN_SOURCE */

/*
 * Advisory file segment locking data type -
 * information passed to system by user
 */
struct flock {
        off_t   l_start;        /* starting offset */
        off_t   l_len;          /* len = 0 means until end of file */
        pid_t   l_pid;          /* lock owner */
        short   l_type;         /* lock type: read/write, etc. */
        short   l_whence;       /* type of l_start */
};

/* lock operations for flock(2) */
#define LOCK_SH         0x01            /* shared file lock */
#define LOCK_EX         0x02            /* exclusive file lock */
#define LOCK_NB         0x04            /* don't block when locking */
#define LOCK_UN         0x08            /* unlock file */

/* Always ensure that these are consistent with <stdio.h> and <unistd.h>! */
#ifndef SEEK_SET
#define SEEK_SET        0       /* set file offset to offset */
#endif
#ifndef SEEK_CUR
#define SEEK_CUR        1       /* set file offset to current plus offset */
#endif
#ifndef SEEK_END
#define SEEK_END        2       /* set file offset to EOF plus offset */
#endif

/*
 * old select() interface
 */
#define __NBBY  8               /* number of bits in a byte */
typedef int32_t __fd_mask;
#define __NFDBITS       (sizeof(__fd_mask) * __NBBY)    /* bits per mask */

#ifndef howmany
#define __howmany(x, y) (((x) + ((y) - 1)) / (y))
#else
#define __howmany(x, y) howmany(x, y)
#endif

/*
 * Select uses bit masks of file descriptors in longs.  These macros
 * manipulate such bit fields (the filesystem macros use chars).
 * FD_SETSIZE may be defined by the user, but the default here should
 * be enough for most uses.
 */
#ifndef FD_SETSIZE
#define FD_SETSIZE      256
#endif

typedef struct fd_set 
{
  __fd_mask       fds_bits[__howmany(FD_SETSIZE, __NFDBITS)];
} fd_set;

#define FD_SET(n, p)    \
    ((p)->fds_bits[(n)/__NFDBITS] |= (1 << ((n) % __NFDBITS)))
#define FD_CLR(n, p)    \
    ((p)->fds_bits[(n)/__NFDBITS] &= ~(1 << ((n) % __NFDBITS)))
#define FD_ISSET(n, p)  \
    ((p)->fds_bits[(n)/__NFDBITS] & (1 << ((n) % __NFDBITS)))
#define FD_ZERO(p)      (void)memset((p), 0, sizeof(*(p)))

/*
 * poll interface
 */
typedef unsigned int    nfds_t;

struct pollfd {
  int     fd;             /* file descriptor */
  short   events;         /* events to look for */
  short   revents;        /* events returned */
};

/*
 * Testable events (may be specified in events field).
 */
#define POLLIN          0x0001
#define POLLPRI         0x0002
#define POLLOUT         0x0004
#define POLLRDNORM      0x0040
#define POLLWRNORM      POLLOUT
#define POLLRDBAND      0x0080
#define POLLWRBAND      0x0100

/*
 * Non-testable events (may not be specified in events field).
 */
#define POLLERR         0x0008
#define POLLHUP         0x0010
#define POLLNVAL        0x0020

/*
 * Infinite timeout value.
 */
#define INFTIM          -1

/*
 * lseos poll interface
 */
typedef struct  s_pollrec
{
  int           fd;
  int           gate;
  int           gate_id;
  short         events;
  short         revents;
}               t_pollrec;

/*
 * Ioctl's have the command encoded in the lower word, and the size of
 * any in or out parameters in the upper word.  The high 3 bits of the
 * upper word are used to encode the in/out status of the parameter.
 */
#define IOCPARM_MASK    0x1fff          /* parameter length, at most 13 bits */
#define IOCPARM_LEN(x)  (((x) >> 16) & IOCPARM_MASK)
#define IOCBASECMD(x)   ((x) & ~(IOCPARM_MASK << 16))
#define IOCGROUP(x)     (((x) >> 8) & 0xff)

#define IOCPARM_MAX     NBPG    /* max size of ioctl args, mult. of NBPG */
                                /* no parameters */
#define IOC_VOID        (unsigned long)0x20000000
                                /* copy parameters out */
#define IOC_OUT         (unsigned long)0x40000000
                                /* copy parameters in */
#define IOC_IN          (unsigned long)0x80000000
                                /* copy paramters in and out */
#define IOC_INOUT       (IOC_IN|IOC_OUT)
                                /* mask for IN/OUT/VOID */
#define IOC_DIRMASK     (unsigned long)0xe0000000

#define _IOC(inout,group,num,len) \
        (inout | ((len & IOCPARM_MASK) << 16) | ((group) << 8) | (num))
#define _IO(g,n)        _IOC(IOC_VOID,  (g), (n), 0)
#define _IOR(g,n,t)     _IOC(IOC_OUT,   (g), (n), sizeof(t))
#define _IOW(g,n,t)     _IOC(IOC_IN,    (g), (n), sizeof(t))
/* this should be _IORW, but stdio got there first */
#define _IOWR(g,n,t)    _IOC(IOC_INOUT, (g), (n), sizeof(t))

struct stat
{
  dev_t                 st_dev;
  ino_t                 st_ino;
  mode_t                st_mode;
  nlink_t               st_nlink;
  uid_t                 st_uid;
  gid_t                 st_gid;
  dev_t                 st_rdev;
  off_t                 st_size;
  blksize_t             st_blksize;
  blkcnt_t              st_blocks;
  time_t                st_atime;
  time_t                st_mtime;
  time_t                st_ctime;
};
#define S_ISUID 0004000                 /* set user id on execution */
#define S_ISGID 0002000                 /* set group id on execution */
#define S_ISTXT 0001000                 /* sticky bit */

#define S_IRWXU 0000700                 /* RWX mask for owner */
#define S_IRUSR 0000400                 /* R for owner */
#define S_IWUSR 0000200                 /* W for owner */
#define S_IXUSR 0000100                 /* X for owner */

#define S_IREAD         S_IRUSR
#define S_IWRITE        S_IWUSR
#define S_IEXEC         S_IXUSR

#define S_IRWXG 0000070                 /* RWX mask for group */
#define S_IRGRP 0000040                 /* R for group */
#define S_IWGRP 0000020                 /* W for group */
#define S_IXGRP 0000010                 /* X for group */

#define S_IRWXO 0000007                 /* RWX mask for other */
#define S_IROTH 0000004                 /* R for other */
#define S_IWOTH 0000002                 /* W for other */
#define S_IXOTH 0000001                 /* X for other */

#define _S_IFMT   0170000               /* type of file mask */
#define _S_IFIFO  0010000               /* named pipe (fifo) */
#define _S_IFCHR  0020000               /* character special */
#define _S_IFDIR  0040000               /* directory */
#define _S_IFBLK  0060000               /* block special */
#define _S_IFREG  0100000               /* regular */
#define _S_IFLNK  0120000               /* symbolic link */
#define _S_ISVTX  0001000               /* save swapped text even after use */
#define _S_IFSOCK 0140000               /* socket */
#define _S_IFWHT  0160000               /* whiteout */
#define _S_ARCH1  0200000               /* Archive state 1, ls -l shows 'a' */
#define _S_ARCH2  0400000               /* Archive state 2, ls -l shows 'A' */

#define S_IFMT   _S_IFMT
#define S_IFIFO  _S_IFIFO
#define S_IFCHR  _S_IFCHR
#define S_IFDIR  _S_IFDIR
#define S_IFBLK  _S_IFBLK
#define S_IFREG  _S_IFREG
#define S_IFLNK  _S_IFLNK
#define S_ISVTX  _S_ISVTX

#define S_IFSOCK _S_IFSOCK
#define S_IFWHT  _S_IFWHT

#define S_ARCH1 _S_ARCH1
#define S_ARCH2 _S_ARCH2

#define S_ISDIR(m)      ((m & _S_IFMT) == _S_IFDIR)     /* directory */
#define S_ISCHR(m)      ((m & _S_IFMT) == _S_IFCHR)     /* char special */
#define S_ISBLK(m)      ((m & _S_IFMT) == _S_IFBLK)     /* block special */
#define S_ISREG(m)      ((m & _S_IFMT) == _S_IFREG)     /* regular file */
#define S_ISFIFO(m)     ((m & _S_IFMT) == _S_IFIFO)     /* fifo */
#define S_ISLNK(m)      ((m & _S_IFMT) == _S_IFLNK)     /* symbolic link */
#define S_ISSOCK(m)     ((m & _S_IFMT) == _S_IFSOCK)    /* socket */
#define S_ISWHT(m)      ((m & _S_IFMT) == _S_IFWHT)     /* whiteout */


#define ACCESSPERMS     (S_IRWXU|S_IRWXG|S_IRWXO)       /* 0777 */
                                                        /* 7777 */
#define ALLPERMS        (S_ISUID|S_ISGID|S_ISTXT|S_IRWXU|S_IRWXG|S_IRWXO)
                                                        /* 0666 */
#define DEFFILEMODE     (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH)

#define S_BLKSIZE       512             /* block size used in the stat struct */

/*
 * Definitions of flags stored in file flags word.
 *
 * Super-user and owner changeable flags.
 */
#define UF_SETTABLE     0x0000ffff      /* mask of owner changeable flags */
#define UF_NODUMP       0x00000001      /* do not dump file */
#define UF_IMMUTABLE    0x00000002      /* file may not be changed */
#define UF_APPEND       0x00000004      /* writes to file may only append */
#define UF_OPAQUE       0x00000008      /* directory is opaque wrt. union */
/*
 * Super-user changeable flags.
 */
#define SF_SETTABLE     0xffff0000      /* mask of superuser changeable flags */
#define SF_ARCHIVED     0x00010000      /* file is archived */
#define SF_IMMUTABLE    0x00020000      /* file may not be changed */
#define SF_APPEND       0x00040000      /* writes to file may only append */

/*
 * some constants
 */
#define MAXPATHLEN              PATH_MAX
#define MAXFSTYPELEN            32
#define MAXSYMLINKS             32

/*
 * one day we should have an interface like this:
enum 
{
ASYNC_OPEN,
ASYNC_READ,
ASYNC_WRITE,
ASYNC_CLOSE,
etc ...
ASYNC_STATUS, returns the status of operation
ASYNC_DESTROY, destroy operation
} asyncop_t;

enum
{
  ASYNCSTAT_UNKNOWN,
  ASYNCSTAT_COMPLETED,
  ASYNCSTAT_INPROGRESS,
  ASYNCSTAT_ERROR,
} asyncstatus_t;

asyncid_t       async(asyncop_t op, void *buf, int len, pid_t pid);

*/

/* PROTO fd.c */
/* fd.c */
int gate_ftruncate(int gate, int gate_id, off_t length, pid_t pid);
int gate_truncate(int gate, const char *path, off_t length, pid_t pid);
ssize_t gate_write(int gate, int gate_id, const void *buf, size_t len, pid_t pid);
ssize_t gate_read(int gate, int gate_id, void *buf, size_t len, pid_t pid);
int gate_open(int gate, const char *path, int flags, mode_t mode, pid_t pid);
int gate_close(int gate, int gate_id, pid_t pid);
int gate_access(int gate, const char *path, int mode, pid_t pid);
int gate_chmod(int gate, const char *path, mode_t mode, pid_t pid);
int gate_getdents(int gate, int gate_id, char *buf, size_t nbytes, pid_t pid);
int gate_chdir(int gate, const char *path, pid_t pid);
int gate_mkdir(int gate, const char *path, mode_t mode, pid_t pid);
int gate_rmdir(int gate, const char *path, pid_t pid);
int gate_poll(int gate, t_pollrec *pollrecs, nfds_t npollrecs, pid_t pid);
int gate_link(int gate, const char *path1, const char *path2, pid_t pid);
int gate_symlink(int gate, const char *path1, const char *path2, pid_t pid);
int gate_unlink(int gate, const char *path, pid_t pid);
int gate_readlink(int gate, const char *path, char *buf, size_t bufsiz, pid_t pid);
off_t gate_lseek(int gate, int gate_id, off_t offset, int whence, pid_t pid);
int gate_mount(int gate, const char *type, const char *dir, int flags, void *data, pid_t pid);
int gate_umount(int gate, const char *dir, pid_t pid);
int gate_rename(int gate, char *path1, char *path2, pid_t pid);
int gate_fstat(int gate, int gate_id, struct stat *sb, pid_t pid);
int gate_stat(int gate, const char *path, struct stat *sb, pid_t pid);
int gate_lstat(int gate, const char *path, struct stat *sb, pid_t pid);
int gate_ioctl(int gate, int gate_id, unsigned long request, void *argp, pid_t pid);
int gate_mkfs(int gate, int pdev, pid_t pid);
int gate_writembr(int gate, int pdev, pid_t pid);
#endif

---