Annotation of Net2/sys/mount.h, revision 1.1.1.2

1.1       root        1: /*
                      2:  * Copyright (c) 1989 The Regents of the University of California.
                      3:  * All rights reserved.
                      4:  *
                      5:  * Redistribution and use in source and binary forms, with or without
                      6:  * modification, are permitted provided that the following conditions
                      7:  * are met:
                      8:  * 1. Redistributions of source code must retain the above copyright
                      9:  *    notice, this list of conditions and the following disclaimer.
                     10:  * 2. Redistributions in binary form must reproduce the above copyright
                     11:  *    notice, this list of conditions and the following disclaimer in the
                     12:  *    documentation and/or other materials provided with the distribution.
                     13:  * 3. All advertising materials mentioning features or use of this software
                     14:  *    must display the following acknowledgement:
                     15:  *     This product includes software developed by the University of
                     16:  *     California, Berkeley and its contributors.
                     17:  * 4. Neither the name of the University nor the names of its contributors
                     18:  *    may be used to endorse or promote products derived from this software
                     19:  *    without specific prior written permission.
                     20:  *
                     21:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
                     22:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
                     23:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                     24:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
                     25:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                     26:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
                     27:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
                     28:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
                     29:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
                     30:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
                     31:  * SUCH DAMAGE.
                     32:  *
                     33:  *     @(#)mount.h     7.22 (Berkeley) 6/3/91
                     34:  */
                     35: 
                     36: typedef quad fsid_t;                   /* file system id type */
                     37: 
                     38: /*
                     39:  * File identifier.
                     40:  * These are unique per filesystem on a single machine.
                     41:  */
                     42: #define        MAXFIDSZ        16
                     43: 
                     44: struct fid {
                     45:        u_short         fid_len;                /* length of data in bytes */
                     46:        u_short         fid_reserved;           /* force longword alignment */
                     47:        char            fid_data[MAXFIDSZ];     /* data (variable length) */
                     48: };
                     49: 
                     50: /*
                     51:  * file system statistics
                     52:  */
                     53: 
                     54: #define MNAMELEN 90    /* length of buffer for returned name */
                     55: 
                     56: struct statfs {
                     57:        short   f_type;                 /* type of filesystem (see below) */
                     58:        short   f_flags;                /* copy of mount flags */
                     59:        long    f_fsize;                /* fundamental file system block size */
                     60:        long    f_bsize;                /* optimal transfer block size */
                     61:        long    f_blocks;               /* total data blocks in file system */
                     62:        long    f_bfree;                /* free blocks in fs */
                     63:        long    f_bavail;               /* free blocks avail to non-superuser */
                     64:        long    f_files;                /* total file nodes in file system */
                     65:        long    f_ffree;                /* free file nodes in fs */
                     66:        fsid_t  f_fsid;                 /* file system id */
                     67:        long    f_spare[9];             /* spare for later */
                     68:        char    f_mntonname[MNAMELEN];  /* directory on which mounted */
                     69:        char    f_mntfromname[MNAMELEN];/* mounted filesystem */
                     70: };
                     71: 
                     72: /*
                     73:  * File system types.
                     74:  */
                     75: #define        MOUNT_NONE      0
1.1.1.2 ! root       76: #define        MOUNT_UFS       1               /* UNIX "Fast" Filesystem */
        !            77: #define        MOUNT_NFS       2               /* Network Filesystem */
        !            78: #define        MOUNT_MFS       3               /* Memory Filesystem */
        !            79: #define        MOUNT_MSDOS     4               /* MSDOS Filesystem */
        !            80: #define MOUNT_ISOFS    5               /* iso9660 cdrom */
        !            81: #define MOUNT_FDESC    6               /* /dev/fd filesystem */
        !            82: #define MOUNT_KERNFS   7               /* kernel variable filesystem */
        !            83: #define        MOUNT_MAXTYPE   7
1.1       root       84: 
                     85: /*
                     86:  * Structure per mounted file system.
                     87:  * Each mounted file system has an array of
                     88:  * operations and an instance record.
                     89:  * The file systems are put on a doubly linked list.
                     90:  */
                     91: struct mount {
                     92:        struct mount    *mnt_next;              /* next in mount list */
                     93:        struct mount    *mnt_prev;              /* prev in mount list */
                     94:        struct vfsops   *mnt_op;                /* operations on fs */
                     95:        struct vnode    *mnt_vnodecovered;      /* vnode we mounted on */
                     96:        struct vnode    *mnt_mounth;            /* list of vnodes this mount */
                     97:        int             mnt_flag;               /* flags */
                     98:        uid_t           mnt_exroot;             /* exported mapping for uid 0 */
                     99:        struct statfs   mnt_stat;               /* cache of filesystem stats */
                    100:        qaddr_t         mnt_data;               /* private data */
                    101: };
                    102: 
                    103: /*
                    104:  * Mount flags.
                    105:  */
                    106: #define        MNT_RDONLY      0x00000001      /* read only filesystem */
                    107: #define        MNT_SYNCHRONOUS 0x00000002      /* file system written synchronously */
                    108: #define        MNT_NOEXEC      0x00000004      /* can't exec from filesystem */
                    109: #define        MNT_NOSUID      0x00000008      /* don't honor setuid bits on fs */
                    110: #define        MNT_NODEV       0x00000010      /* don't interpret special files */
1.1.1.2 ! root      111: #define        MNT_UNION       0x00000020      /* union with underlying filesysem */
1.1       root      112: 
                    113: /*
                    114:  * exported mount flags.
                    115:  */
                    116: #define        MNT_EXPORTED    0x00000100      /* file system is exported */
                    117: #define        MNT_EXRDONLY    0x00000200      /* exported read only */
                    118: 
                    119: /*
                    120:  * Flags set by internal operations.
                    121:  */
                    122: #define        MNT_LOCAL       0x00001000      /* filesystem is stored locally */
                    123: #define        MNT_QUOTA       0x00002000      /* quotas are enabled on filesystem */
                    124: 
                    125: /*
                    126:  * Mask of flags that are visible to statfs()
                    127:  */
                    128: #define        MNT_VISFLAGMASK 0x0000ffff
                    129: 
                    130: /*
                    131:  * filesystem control flags.
                    132:  *
                    133:  * MNT_MLOCK lock the mount entry so that name lookup cannot proceed
                    134:  * past the mount point.  This keeps the subtree stable during mounts
                    135:  * and unmounts.
                    136:  */
                    137: #define        MNT_UPDATE      0x00010000      /* not a real mount, just an update */
                    138: #define        MNT_MLOCK       0x00100000      /* lock so that subtree is stable */
                    139: #define        MNT_MWAIT       0x00200000      /* someone is waiting for lock */
                    140: #define MNT_MPBUSY     0x00400000      /* scan of mount point in progress */
                    141: #define MNT_MPWANT     0x00800000      /* waiting for mount point */
                    142: #define MNT_UNMOUNT    0x01000000      /* unmount in progress */
                    143: 
                    144: /*
                    145:  * Operations supported on mounted file system.
                    146:  */
                    147: #ifdef KERNEL
                    148: #ifdef __STDC__
                    149: struct nameidata;
                    150: #endif
                    151: 
                    152: struct vfsops {
                    153:        int     (*vfs_mount)    __P((struct mount *mp, char *path, caddr_t data,
                    154:                                    struct nameidata *ndp, struct proc *p));
                    155:        int     (*vfs_start)    __P((struct mount *mp, int flags,
                    156:                                    struct proc *p));
                    157:        int     (*vfs_unmount)  __P((struct mount *mp, int mntflags,
                    158:                                    struct proc *p));
                    159:        int     (*vfs_root)     __P((struct mount *mp, struct vnode **vpp));
                    160:                        /* int uid,             should be uid_t */
                    161:        int     (*vfs_quotactl) __P((struct mount *mp, int cmds, int uid,
                    162:                                    caddr_t arg, struct proc *p));
                    163:        int     (*vfs_statfs)   __P((struct mount *mp, struct statfs *sbp,
                    164:                                    struct proc *p));
                    165:        int     (*vfs_sync)     __P((struct mount *mp, int waitfor));
                    166:        int     (*vfs_fhtovp)   __P((struct mount *mp, struct fid *fhp,
                    167:                                    struct vnode **vpp));
                    168:        int     (*vfs_vptofh)   __P((struct vnode *vp, struct fid *fhp));
                    169:        int     (*vfs_init)     __P(());
                    170: };
                    171: 
                    172: #define VFS_MOUNT(MP, PATH, DATA, NDP, P) \
                    173:        (*(MP)->mnt_op->vfs_mount)(MP, PATH, DATA, NDP, P)
                    174: #define VFS_START(MP, FLAGS, P)          (*(MP)->mnt_op->vfs_start)(MP, FLAGS, P)
                    175: #define VFS_UNMOUNT(MP, FORCE, P) (*(MP)->mnt_op->vfs_unmount)(MP, FORCE, P)
                    176: #define VFS_ROOT(MP, VPP)        (*(MP)->mnt_op->vfs_root)(MP, VPP)
                    177: #define VFS_QUOTACTL(MP,C,U,A,P)  (*(MP)->mnt_op->vfs_quotactl)(MP, C, U, A, P)
                    178: #define VFS_STATFS(MP, SBP, P)   (*(MP)->mnt_op->vfs_statfs)(MP, SBP, P)
                    179: #define VFS_SYNC(MP, WAITFOR)    (*(MP)->mnt_op->vfs_sync)(MP, WAITFOR)
                    180: #define VFS_FHTOVP(MP, FIDP, VPP) (*(MP)->mnt_op->vfs_fhtovp)(MP, FIDP, VPP)
                    181: #define        VFS_VPTOFH(VP, FIDP)      (*(VP)->v_mount->mnt_op->vfs_vptofh)(VP, FIDP)
                    182: #endif /* KERNEL */
                    183: 
                    184: /*
                    185:  * Flags for various system call interfaces.
                    186:  *
                    187:  * forcibly flags for vfs_umount().
                    188:  * waitfor flags to vfs_sync() and getfsstat()
                    189:  */
                    190: #define MNT_FORCE      1
                    191: #define MNT_NOFORCE    2
                    192: #define MNT_WAIT       1
                    193: #define MNT_NOWAIT     2
                    194: 
                    195: /*
                    196:  * Generic file handle
                    197:  */
                    198: struct fhandle {
                    199:        fsid_t  fh_fsid;        /* File system id of mount point */
                    200:        struct  fid fh_fid;     /* Id of file */
                    201: };
                    202: typedef struct fhandle fhandle_t;
                    203: 
                    204: /*
                    205:  * Arguments to mount UFS
                    206:  */
                    207: struct ufs_args {
                    208:        char    *fspec;         /* block special device to mount */
                    209:        int     exflags;        /* export related flags */
                    210:        uid_t   exroot;         /* mapping for root uid */
                    211: };
                    212: 
                    213: #ifdef MFS
                    214: /*
                    215:  * Arguments to mount MFS
                    216:  */
                    217: struct mfs_args {
                    218:        char    *name;          /* name to export for statfs */
                    219:        caddr_t base;           /* base address of file system in memory */
                    220:        u_long size;            /* size of file system */
                    221: };
                    222: #endif MFS
                    223: 
1.1.1.2 ! root      224: #if defined(NFSSERVER) || defined(NFSCLIENT)
1.1       root      225: /*
                    226:  * File Handle (32 bytes for version 2), variable up to 1024 for version 3
                    227:  */
                    228: union nfsv2fh {
                    229:        fhandle_t       fh_generic;
                    230:        u_char          fh_bytes[32];
                    231: };
                    232: typedef union nfsv2fh nfsv2fh_t;
                    233: 
                    234: /*
                    235:  * Arguments to mount NFS
                    236:  */
                    237: struct nfs_args {
                    238:        struct sockaddr *addr;          /* file server address */
                    239:        int             sotype;         /* Socket type */
                    240:        int             proto;          /* and Protocol */
                    241:        nfsv2fh_t       *fh;            /* File handle to be mounted */
                    242:        int             flags;          /* flags */
                    243:        int             wsize;          /* write size in bytes */
                    244:        int             rsize;          /* read size in bytes */
                    245:        int             timeo;          /* initial timeout in .1 secs */
                    246:        int             retrans;        /* times to retry send */
                    247:        char            *hostname;      /* server's name */
                    248: };
                    249: /*
                    250:  * NFS mount option flags
                    251:  */
                    252: #define        NFSMNT_SOFT     0x0001  /* soft mount (hard is default) */
                    253: #define        NFSMNT_WSIZE    0x0002  /* set write size */
                    254: #define        NFSMNT_RSIZE    0x0004  /* set read size */
                    255: #define        NFSMNT_TIMEO    0x0008  /* set initial timeout */
                    256: #define        NFSMNT_RETRANS  0x0010  /* set number of request retrys */
                    257: #define        NFSMNT_HOSTNAME 0x0020  /* set hostname for error printf */
                    258: #define        NFSMNT_INT      0x0040  /* allow interrupts on hard mount */
                    259: #define        NFSMNT_NOCONN   0x0080  /* Don't Connect the socket */
                    260: #define        NFSMNT_SCKLOCK  0x0100  /* Lock socket against others */
                    261: #define        NFSMNT_WANTSCK  0x0200  /* Want a socket lock */
                    262: #define        NFSMNT_SPONGY   0x0400  /* spongy mount (soft for stat and lookup) */
                    263: #define        NFSMNT_COMPRESS 0x0800  /* Compress nfs rpc xdr */
                    264: #define        NFSMNT_LOCKBITS (NFSMNT_SCKLOCK | NFSMNT_WANTSCK)
1.1.1.2 ! root      265: #endif /* defined(NFSSERVER || defined(NFSCLIENT) */
        !           266: 
        !           267: #ifdef PCFS
        !           268: /*
        !           269:  *  Arguments to mount MSDOS filesystems.
        !           270:  */
        !           271: struct pcfs_args {
        !           272:        char *fspec;            /* blocks special holding the fs to mount */
        !           273:        int exflags;            /* mount flags                          */
        !           274:        uid_t exroot;           /* mapping for root uid                 */
        !           275: };
        !           276: #endif /* PCFS */
1.1       root      277: 
                    278: #ifdef KERNEL
                    279: /*
                    280:  * exported vnode operations
                    281:  */
                    282: void   vfs_remove __P((struct mount *mp)); /* remove a vfs from mount list */
                    283: int    vfs_lock __P((struct mount *mp));   /* lock a vfs */
                    284: void   vfs_unlock __P((struct mount *mp)); /* unlock a vfs */
                    285: struct mount *getvfs __P((fsid_t *fsid));  /* return vfs given fsid */
                    286: struct mount *rootfs;                      /* ptr to root mount structure */
                    287: struct vfsops *vfssw[];                    /* mount filesystem type table */
                    288: 
                    289: #else /* KERNEL */
                    290: 
                    291: #include <sys/cdefs.h>
                    292: 
                    293: __BEGIN_DECLS
                    294: int    fstatfs __P((int, struct statfs *));
                    295: int    getfh __P((const char *, fhandle_t *));
                    296: int    getfsstat __P((struct statfs *, long, int));
                    297: int    getmntinfo __P((struct statfs **, int));
                    298: int    mount __P((int, const char *, int, void *));
                    299: int    statfs __P((const char *, struct statfs *));
                    300: int    unmount __P((const char *, int));
                    301: __END_DECLS
                    302: 
                    303: #endif /* KERNEL */

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.