Subversion Repositories or1k

#ifndef _LINUX_FS_H

#define _LINUX_FS_H

/*

 * This file has definitions for some important file table

 * structures etc.

 */

#include <linux/config.h>

#include <linux/linkage.h>

#include <linux/limits.h>

#include <linux/wait.h>

#include <linux/types.h>

#include <linux/vfs.h>

#include <linux/net.h>

#include <linux/kdev_t.h>

#include <linux/ioctl.h>

#include <linux/list.h>

#include <linux/dcache.h>

#include <linux/stat.h>

#include <linux/cache.h>

#include <linux/stddef.h>

#include <linux/string.h>

#include <asm/atomic.h>

#include <asm/bitops.h>

struct poll_table_struct;

/*

 * It's silly to have NR_OPEN bigger than NR_FILE, but you can change

 * the file limit at runtime and only root can increase the per-process

 * nr_file rlimit, so it's safe to set up a ridiculously high absolute

 * upper limit on files-per-process.

 *

 * Some programs (notably those using select()) may have to be

 * recompiled to take full advantage of the new limits..

 */

/* Fixed constants first: */

#undef NR_OPEN

#define NR_OPEN (1024*1024)     /* Absolute upper limit on fd num */

#define INR_OPEN 1024           /* Initial setting for nfile rlimits */

#define BLOCK_SIZE_BITS 10

#define BLOCK_SIZE (1<<BLOCK_SIZE_BITS)

/* And dynamically-tunable limits and defaults: */

struct files_stat_struct {

        int nr_files;           /* read only */

        int nr_free_files;      /* read only */

        int max_files;          /* tunable */

};

extern struct files_stat_struct files_stat;

struct inodes_stat_t {

        int nr_inodes;

        int nr_unused;

        int dummy[5];

};

extern struct inodes_stat_t inodes_stat;

extern int leases_enable, dir_notify_enable, lease_break_time;

#define NR_FILE  8192   /* this can well be larger on a larger system */

#define NR_RESERVED_FILES 10 /* reserved for root */

#define NR_SUPER 256

#define MAY_EXEC 1

#define MAY_WRITE 2

#define MAY_READ 4

#define FMODE_READ 1

#define FMODE_WRITE 2

#define READ 0

#define WRITE 1

#define READA 2         /* read-ahead  - don't block if no resources */

#define SPECIAL 4       /* For non-blockdevice requests in request queue */

#define SEL_IN          1

#define SEL_OUT         2

#define SEL_EX          4

/* public flags for file_system_type */

#define FS_REQUIRES_DEV 1 

#define FS_NO_DCACHE    2 /* Only dcache the necessary things. */

#define FS_NO_PRELIM    4 /* prevent preloading of dentries, even if

                           * FS_NO_DCACHE is not set.

                           */

#define FS_SINGLE       8 /* Filesystem that can have only one superblock */

#define FS_NOMOUNT      16 /* Never mount from userland */

#define FS_LITTER       32 /* Keeps the tree in dcache */

#define FS_ODD_RENAME   32768   /* Temporary stuff; will go away as soon

                                  * as nfs_rename() will be cleaned up

                                  */

/*

 * These are the fs-independent mount-flags: up to 32 flags are supported

 */

#define MS_RDONLY        1      /* Mount read-only */

#define MS_NOSUID        2      /* Ignore suid and sgid bits */

#define MS_NODEV         4      /* Disallow access to device special files */

#define MS_NOEXEC        8      /* Disallow program execution */

#define MS_SYNCHRONOUS  16      /* Writes are synced at once */

#define MS_REMOUNT      32      /* Alter flags of a mounted FS */

#define MS_MANDLOCK     64      /* Allow mandatory locks on an FS */

#define MS_NOATIME      1024    /* Do not update access times. */

#define MS_NODIRATIME   2048    /* Do not update directory access times */

#define MS_BIND         4096

#define MS_MOVE         8192

#define MS_REC          16384

#define MS_VERBOSE      32768

#define MS_ACTIVE       (1<<30)

#define MS_NOUSER       (1<<31)

/*

 * Superblock flags that can be altered by MS_REMOUNT

 */

#define MS_RMT_MASK     (MS_RDONLY|MS_SYNCHRONOUS|MS_MANDLOCK|MS_NOATIME|\

                         MS_NODIRATIME)

/*

 * Old magic mount flag and mask

 */

#define MS_MGC_VAL 0xC0ED0000

#define MS_MGC_MSK 0xffff0000

/* Inode flags - they have nothing to superblock flags now */

#define S_SYNC          1       /* Writes are synced at once */

#define S_NOATIME       2       /* Do not update access times */

#define S_QUOTA         4       /* Quota initialized for file */

#define S_APPEND        8       /* Append-only file */

#define S_IMMUTABLE     16      /* Immutable file */

#define S_DEAD          32      /* removed, but still open directory */

#define S_NOQUOTA       64      /* Inode is not counted to quota */

/*

 * Note that nosuid etc flags are inode-specific: setting some file-system

 * flags just means all the inodes inherit those flags by default. It might be

 * possible to override it selectively if you really wanted to with some

 * ioctl() that is not currently implemented.

 *

 * Exception: MS_RDONLY is always applied to the entire file system.

 *

 * Unfortunately, it is possible to change a filesystems flags with it mounted

 * with files in use.  This means that all of the inodes will not have their

 * i_flags updated.  Hence, i_flags no longer inherit the superblock mount

 * flags, so these have to be checked separately. -- rmk@arm.uk.linux.org

 */

#define __IS_FLG(inode,flg) ((inode)->i_sb->s_flags & (flg))

#define IS_RDONLY(inode) ((inode)->i_sb->s_flags & MS_RDONLY)

#define IS_SYNC(inode)          (__IS_FLG(inode, MS_SYNCHRONOUS) || ((inode)->i_flags & S_SYNC))

#define IS_MANDLOCK(inode)      __IS_FLG(inode, MS_MANDLOCK)

#define IS_QUOTAINIT(inode)     ((inode)->i_flags & S_QUOTA)

#define IS_NOQUOTA(inode)       ((inode)->i_flags & S_NOQUOTA)

#define IS_APPEND(inode)        ((inode)->i_flags & S_APPEND)

#define IS_IMMUTABLE(inode)     ((inode)->i_flags & S_IMMUTABLE)

#define IS_NOATIME(inode)       (__IS_FLG(inode, MS_NOATIME) || ((inode)->i_flags & S_NOATIME))

#define IS_NODIRATIME(inode)    __IS_FLG(inode, MS_NODIRATIME)

#define IS_DEADDIR(inode)       ((inode)->i_flags & S_DEAD)

/* the read-only stuff doesn't really belong here, but any other place is

   probably as bad and I don't want to create yet another include file. */

#define BLKROSET   _IO(0x12,93) /* set device read-only (0 = read-write) */

#define BLKROGET   _IO(0x12,94) /* get read-only status (0 = read_write) */

#define BLKRRPART  _IO(0x12,95) /* re-read partition table */

#define BLKGETSIZE _IO(0x12,96) /* return device size /512 (long *arg) */

#define BLKFLSBUF  _IO(0x12,97) /* flush buffer cache */

#define BLKRASET   _IO(0x12,98) /* Set read ahead for block device */

#define BLKRAGET   _IO(0x12,99) /* get current read ahead setting */

#define BLKFRASET  _IO(0x12,100)/* set filesystem (mm/filemap.c) read-ahead */

#define BLKFRAGET  _IO(0x12,101)/* get filesystem (mm/filemap.c) read-ahead */

#define BLKSECTSET _IO(0x12,102)/* set max sectors per request (ll_rw_blk.c) */

#define BLKSECTGET _IO(0x12,103)/* get max sectors per request (ll_rw_blk.c) */

#define BLKSSZGET  _IO(0x12,104)/* get block device sector size */

#if 0

#define BLKPG      _IO(0x12,105)/* See blkpg.h */

#define BLKELVGET  _IOR(0x12,106,sizeof(blkelv_ioctl_arg_t))/* elevator get */

#define BLKELVSET  _IOW(0x12,107,sizeof(blkelv_ioctl_arg_t))/* elevator set */

/* This was here just to show that the number is taken -

   probably all these _IO(0x12,*) ioctls should be moved to blkpg.h. */

#endif

/* A jump here: 108-111 have been used for various private purposes. */

#define BLKBSZGET  _IOR(0x12,112,sizeof(int))

#define BLKBSZSET  _IOW(0x12,113,sizeof(int))

#define BLKGETSIZE64 _IOR(0x12,114,sizeof(u64)) /* return device size in bytes (u64 *arg) */

#define BMAP_IOCTL 1            /* obsolete - kept for compatibility */

#define FIBMAP     _IO(0x00,1)  /* bmap access */

#define FIGETBSZ   _IO(0x00,2)  /* get the block size used for bmap */

#ifdef __KERNEL__

#include <asm/semaphore.h>

#include <asm/byteorder.h>

extern void update_atime (struct inode *);

extern void update_mctime (struct inode *);

#define UPDATE_ATIME(inode) update_atime (inode)

extern void buffer_init(unsigned long);

extern void inode_init(unsigned long);

extern void mnt_init(unsigned long);

extern void files_init(unsigned long mempages);

/* bh state bits */

enum bh_state_bits {

        BH_Uptodate,    /* 1 if the buffer contains valid data */

        BH_Dirty,       /* 1 if the buffer is dirty */

        BH_Lock,        /* 1 if the buffer is locked */

        BH_Req,         /* 0 if the buffer has been invalidated */

        BH_Mapped,      /* 1 if the buffer has a disk mapping */

        BH_New,         /* 1 if the buffer is new and not yet written out */

        BH_Async,       /* 1 if the buffer is under end_buffer_io_async I/O */

        BH_Wait_IO,     /* 1 if we should write out this buffer */

        BH_Launder,     /* 1 if we can throttle on this buffer */

        BH_Attached,    /* 1 if b_inode_buffers is linked into a list */

        BH_JBD,         /* 1 if it has an attached journal_head */

        BH_Sync,        /* 1 if the buffer is a sync read */

        BH_Delay,       /* 1 if the buffer is delayed allocate */

        BH_PrivateStart,/* not a state bit, but the first bit available

                         * for private allocation by other entities

                         */

};

#define MAX_BUF_PER_PAGE (PAGE_CACHE_SIZE / 512)

/*

 * Try to keep the most commonly used fields in single cache lines (16

 * bytes) to improve performance.  This ordering should be

 * particularly beneficial on 32-bit processors.

 *

 * We use the first 16 bytes for the data which is used in searches

 * over the block hash lists (ie. getblk() and friends).

 *

 * The second 16 bytes we use for lru buffer scans, as used by

 * sync_buffers() and refill_freelist().  -- sct

 */

struct buffer_head {

        /* First cache line: */

        struct buffer_head *b_next;     /* Hash queue list */

        unsigned long b_blocknr;        /* block number */

        unsigned short b_size;          /* block size */

        unsigned short b_list;          /* List that this buffer appears */

        kdev_t b_dev;                   /* device (B_FREE = free) */

        atomic_t b_count;               /* users using this block */

        kdev_t b_rdev;                  /* Real device */

        unsigned long b_state;          /* buffer state bitmap (see above) */

        unsigned long b_flushtime;      /* Time when (dirty) buffer should be written */

        struct buffer_head *b_next_free;/* lru/free list linkage */

        struct buffer_head *b_prev_free;/* doubly linked list of buffers */

        struct buffer_head *b_this_page;/* circular list of buffers in one page */

        struct buffer_head *b_reqnext;  /* request queue */

        struct buffer_head **b_pprev;   /* doubly linked list of hash-queue */

        char * b_data;                  /* pointer to data block */

        struct page *b_page;            /* the page this bh is mapped to */

        void (*b_end_io)(struct buffer_head *bh, int uptodate); /* I/O completion */

        void *b_private;                /* reserved for b_end_io */

        unsigned long b_rsector;        /* Real buffer location on disk */

        wait_queue_head_t b_wait;

        struct list_head     b_inode_buffers;   /* doubly linked list of inode dirty buffers */

};

typedef void (bh_end_io_t)(struct buffer_head *bh, int uptodate);

void init_buffer(struct buffer_head *, bh_end_io_t *, void *);

#define __buffer_state(bh, state)       (((bh)->b_state & (1UL << BH_##state)) != 0)

#define buffer_uptodate(bh)     __buffer_state(bh,Uptodate)

#define buffer_dirty(bh)        __buffer_state(bh,Dirty)

#define buffer_locked(bh)       __buffer_state(bh,Lock)

#define buffer_req(bh)          __buffer_state(bh,Req)

#define buffer_mapped(bh)       __buffer_state(bh,Mapped)

#define buffer_new(bh)          __buffer_state(bh,New)

#define buffer_async(bh)        __buffer_state(bh,Async)

#define buffer_launder(bh)      __buffer_state(bh,Launder)

#define buffer_delay(bh)        __buffer_state(bh,Delay)

#define bh_offset(bh)           ((unsigned long)(bh)->b_data & ~PAGE_MASK)

extern void set_bh_page(struct buffer_head *bh, struct page *page, unsigned long offset);

#define touch_buffer(bh)        mark_page_accessed(bh->b_page)

#include <linux/pipe_fs_i.h>

#include <linux/minix_fs_i.h>

#include <linux/ext2_fs_i.h>

#include <linux/ext3_fs_i.h>

#include <linux/hpfs_fs_i.h>

#include <linux/ntfs_fs_i.h>

#include <linux/msdos_fs_i.h>

#include <linux/umsdos_fs_i.h>

#include <linux/iso_fs_i.h>

#include <linux/nfs_fs_i.h>

#include <linux/sysv_fs_i.h>

#include <linux/affs_fs_i.h>

#include <linux/ufs_fs_i.h>

#include <linux/efs_fs_i.h>

#include <linux/coda_fs_i.h>

#include <linux/romfs_fs_i.h>

#include <linux/shmem_fs.h>

#include <linux/smb_fs_i.h>

#include <linux/hfs_fs_i.h>

#include <linux/adfs_fs_i.h>

#include <linux/qnx4_fs_i.h>

#include <linux/reiserfs_fs_i.h>

#include <linux/bfs_fs_i.h>

#include <linux/udf_fs_i.h>

#include <linux/ncp_fs_i.h>

#include <linux/proc_fs_i.h>

#include <linux/usbdev_fs_i.h>

#include <linux/jffs2_fs_i.h>

#include <linux/cramfs_fs_sb.h>

/*

 * Attribute flags.  These should be or-ed together to figure out what

 * has been changed!

 */

#define ATTR_MODE       1

#define ATTR_UID        2

#define ATTR_GID        4

#define ATTR_SIZE       8

#define ATTR_ATIME      16

#define ATTR_MTIME      32

#define ATTR_CTIME      64

#define ATTR_ATIME_SET  128

#define ATTR_MTIME_SET  256

#define ATTR_FORCE      512     /* Not a change, but a change it */

#define ATTR_ATTR_FLAG  1024

/*

 * This is the Inode Attributes structure, used for notify_change().  It

 * uses the above definitions as flags, to know which values have changed.

 * Also, in this manner, a Filesystem can look at only the values it cares

 * about.  Basically, these are the attributes that the VFS layer can

 * request to change from the FS layer.

 *

 * Derek Atkins <warlord@MIT.EDU> 94-10-20

 */

struct iattr {

        unsigned int    ia_valid;

        umode_t         ia_mode;

        uid_t           ia_uid;

        gid_t           ia_gid;

        loff_t          ia_size;

        time_t          ia_atime;

        time_t          ia_mtime;

        time_t          ia_ctime;

        unsigned int    ia_attr_flags;

};

/*

 * This is the inode attributes flag definitions

 */

#define ATTR_FLAG_SYNCRONOUS    1       /* Syncronous write */

#define ATTR_FLAG_NOATIME       2       /* Don't update atime */

#define ATTR_FLAG_APPEND        4       /* Append-only file */

#define ATTR_FLAG_IMMUTABLE     8       /* Immutable file */

#define ATTR_FLAG_NODIRATIME    16      /* Don't update atime for directory */

/*

 * Includes for diskquotas and mount structures.

 */

#include <linux/quota.h>

#include <linux/mount.h>

/*

 * oh the beauties of C type declarations.

 */

struct page;

struct address_space;

struct kiobuf;

struct address_space_operations {

        int (*writepage)(struct page *);

        int (*readpage)(struct file *, struct page *);

        int (*sync_page)(struct page *);

        /*

         * ext3 requires that a successful prepare_write() call be followed

         * by a commit_write() call - they must be balanced

         */

        int (*prepare_write)(struct file *, struct page *, unsigned, unsigned);

        int (*commit_write)(struct file *, struct page *, unsigned, unsigned);

        /* Unfortunately this kludge is needed for FIBMAP. Don't use it */

        int (*bmap)(struct address_space *, long);

        int (*flushpage) (struct page *, unsigned long);

        int (*releasepage) (struct page *, int);

#define KERNEL_HAS_O_DIRECT /* this is for modules out of the kernel */

        int (*direct_IO)(int, struct inode *, struct kiobuf *, unsigned long, int);

#define KERNEL_HAS_DIRECT_FILEIO /* Unfortunate kludge due to lack of foresight */

        int (*direct_fileIO)(int, struct file *, struct kiobuf *, unsigned long, int);

        void (*removepage)(struct page *); /* called when page gets removed from the inode */

};

struct address_space {

        struct list_head        clean_pages;    /* list of clean pages */

        struct list_head        dirty_pages;    /* list of dirty pages */

        struct list_head        locked_pages;   /* list of locked pages */

        unsigned long           nrpages;        /* number of total pages */

        struct address_space_operations *a_ops; /* methods */

        struct inode            *host;          /* owner: inode, block_device */

        struct vm_area_struct   *i_mmap;        /* list of private mappings */

        struct vm_area_struct   *i_mmap_shared; /* list of shared mappings */

        spinlock_t              i_shared_lock;  /* and spinlock protecting it */

        int                     gfp_mask;       /* how to allocate the pages */

};

struct char_device {

        struct list_head        hash;

        atomic_t                count;

        dev_t                   dev;

        atomic_t                openers;

        struct semaphore        sem;

};

struct block_device {

        struct list_head        bd_hash;

        atomic_t                bd_count;

        struct inode *          bd_inode;

        dev_t                   bd_dev;  /* not a kdev_t - it's a search key */

        int                     bd_openers;

        const struct block_device_operations *bd_op;

        struct semaphore        bd_sem; /* open/close mutex */

        struct list_head        bd_inodes;

};

struct inode {

        struct list_head        i_hash;

        struct list_head        i_list;

        struct list_head        i_dentry;

        struct list_head        i_dirty_buffers;

        struct list_head        i_dirty_data_buffers;

        unsigned long           i_ino;

        atomic_t                i_count;

        kdev_t                  i_dev;

        umode_t                 i_mode;

        nlink_t                 i_nlink;

        uid_t                   i_uid;

        gid_t                   i_gid;

        kdev_t                  i_rdev;

        loff_t                  i_size;

        time_t                  i_atime;

        time_t                  i_mtime;

        time_t                  i_ctime;

        unsigned int            i_blkbits;

        unsigned long           i_blksize;

        unsigned long           i_blocks;

        unsigned long           i_version;

        unsigned short          i_bytes;

        struct semaphore        i_sem;

        struct rw_semaphore     i_alloc_sem;

        struct semaphore        i_zombie;

        struct inode_operations *i_op;

        struct file_operations  *i_fop; /* former ->i_op->default_file_ops */

        struct super_block      *i_sb;

        wait_queue_head_t       i_wait;

        struct file_lock        *i_flock;

        struct address_space    *i_mapping;

        struct address_space    i_data;

        struct dquot            *i_dquot[MAXQUOTAS];

        /* These three should probably be a union */

        struct list_head        i_devices;

        struct pipe_inode_info  *i_pipe;

        struct block_device     *i_bdev;

        struct char_device      *i_cdev;

        unsigned long           i_dnotify_mask; /* Directory notify events */

        struct dnotify_struct   *i_dnotify; /* for directory notifications */

        unsigned long           i_state;

        unsigned int            i_flags;

        unsigned char           i_sock;

        atomic_t                i_writecount;

        unsigned int            i_attr_flags;

        __u32                   i_generation;

        union {

                struct minix_inode_info         minix_i;

                struct ext2_inode_info          ext2_i;

                struct ext3_inode_info          ext3_i;

                struct hpfs_inode_info          hpfs_i;

                struct ntfs_inode_info          ntfs_i;

                struct msdos_inode_info         msdos_i;

                struct umsdos_inode_info        umsdos_i;

                struct iso_inode_info           isofs_i;

                struct nfs_inode_info           nfs_i;

                struct sysv_inode_info          sysv_i;

                struct affs_inode_info          affs_i;

                struct ufs_inode_info           ufs_i;

                struct efs_inode_info           efs_i;

                struct romfs_inode_info         romfs_i;

                struct shmem_inode_info         shmem_i;

                struct coda_inode_info          coda_i;

                struct smb_inode_info           smbfs_i;

                struct hfs_inode_info           hfs_i;

                struct adfs_inode_info          adfs_i;

                struct qnx4_inode_info          qnx4_i;

                struct reiserfs_inode_info      reiserfs_i;

                struct bfs_inode_info           bfs_i;

                struct udf_inode_info           udf_i;

                struct ncp_inode_info           ncpfs_i;

                struct proc_inode_info          proc_i;

                struct socket                   socket_i;

                struct usbdev_inode_info        usbdev_i;

                struct jffs2_inode_info         jffs2_i;

                void                            *generic_ip;

        } u;

};

static inline void inode_add_bytes(struct inode *inode, loff_t bytes)

{

        inode->i_blocks += bytes >> 9;

        bytes &= 511;

        inode->i_bytes += bytes;

        if (inode->i_bytes >= 512) {

                inode->i_blocks++;

                inode->i_bytes -= 512;

        }

}

static inline void inode_sub_bytes(struct inode *inode, loff_t bytes)

{

        inode->i_blocks -= bytes >> 9;

        bytes &= 511;

        if (inode->i_bytes < bytes) {

                inode->i_blocks--;

                inode->i_bytes += 512;

        }

        inode->i_bytes -= bytes;

}

static inline loff_t inode_get_bytes(struct inode *inode)

{

        return (((loff_t)inode->i_blocks) << 9) + inode->i_bytes;

}

static inline void inode_set_bytes(struct inode *inode, loff_t bytes)

{

        inode->i_blocks = bytes >> 9;

        inode->i_bytes = bytes & 511;

}

struct fown_struct {

        int pid;                /* pid or -pgrp where SIGIO should be sent */

        uid_t uid, euid;        /* uid/euid of process setting the owner */

        int signum;             /* posix.1b rt signal to be delivered on IO */

};

struct file {

        struct list_head        f_list;

        struct dentry           *f_dentry;

        struct vfsmount         *f_vfsmnt;

        struct file_operations  *f_op;

        atomic_t                f_count;

        unsigned int            f_flags;

        mode_t                  f_mode;

        loff_t                  f_pos;

        unsigned long           f_reada, f_ramax, f_raend, f_ralen, f_rawin;

        struct fown_struct      f_owner;

        unsigned int            f_uid, f_gid;

        int                     f_error;

        unsigned long           f_version;

        /* needed for tty driver, and maybe others */

        void                    *private_data;

        /* preallocated helper kiobuf to speedup O_DIRECT */

        struct kiobuf           *f_iobuf;

        long                    f_iobuf_lock;

};

extern spinlock_t files_lock;

#define file_list_lock() spin_lock(&files_lock);

#define file_list_unlock() spin_unlock(&files_lock);

#define get_file(x)     atomic_inc(&(x)->f_count)

#define file_count(x)   atomic_read(&(x)->f_count)

extern int init_private_file(struct file *, struct dentry *, int);

#define MAX_NON_LFS     ((1UL<<31) - 1)

/* Page cache limit. The filesystems should put that into their s_maxbytes

   limits, otherwise bad things can happen in VM. */

#if BITS_PER_LONG==32

#define MAX_LFS_FILESIZE        (((u64)PAGE_CACHE_SIZE << (BITS_PER_LONG-1))-1) 

#elif BITS_PER_LONG==64

#define MAX_LFS_FILESIZE        0x7fffffffffffffff

#endif

#define FL_POSIX        1

#define FL_FLOCK        2

#define FL_BROKEN       4       /* broken flock() emulation */

#define FL_ACCESS       8       /* for processes suspended by mandatory locking */

#define FL_LOCKD        16      /* lock held by rpc.lockd */

#define FL_LEASE        32      /* lease held on this file */

/*

 * The POSIX file lock owner is determined by

 * the "struct files_struct" in the thread group

 * (or NULL for no owner - BSD locks).

 *

 * Lockd stuffs a "host" pointer into this.

 */

typedef struct files_struct *fl_owner_t;

struct file_lock {

        struct file_lock *fl_next;      /* singly linked list for this inode  */

        struct list_head fl_link;       /* doubly linked list of all locks */

        struct list_head fl_block;      /* circular list of blocked processes */

        fl_owner_t fl_owner;

        unsigned int fl_pid;

        wait_queue_head_t fl_wait;

        struct file *fl_file;

        unsigned char fl_flags;

        unsigned char fl_type;

        loff_t fl_start;

        loff_t fl_end;

        void (*fl_notify)(struct file_lock *);  /* unblock callback */

        void (*fl_insert)(struct file_lock *);  /* lock insertion callback */

        void (*fl_remove)(struct file_lock *);  /* lock removal callback */

        struct fasync_struct *  fl_fasync; /* for lease break notifications */

        unsigned long fl_break_time;    /* for nonblocking lease breaks */

        union {

                struct nfs_lock_info    nfs_fl;

        } fl_u;

};

/* The following constant reflects the upper bound of the file/locking space */

#ifndef OFFSET_MAX

#define INT_LIMIT(x)    (~((x)1 << (sizeof(x)*8 - 1)))

#define OFFSET_MAX      INT_LIMIT(loff_t)

#define OFFT_OFFSET_MAX INT_LIMIT(off_t)

#endif

extern struct list_head file_lock_list;

#include <linux/fcntl.h>

extern int fcntl_getlk(unsigned int, struct flock *);

extern int fcntl_setlk(unsigned int, unsigned int, struct flock *);

extern int fcntl_getlk64(unsigned int, struct flock64 *);

extern int fcntl_setlk64(unsigned int, unsigned int, struct flock64 *);

/* fs/locks.c */

extern void locks_init_lock(struct file_lock *);

extern void locks_copy_lock(struct file_lock *, struct file_lock *);

extern void locks_remove_posix(struct file *, fl_owner_t);

extern void locks_remove_flock(struct file *);

extern struct file_lock *posix_test_lock(struct file *, struct file_lock *);

extern int posix_lock_file(struct file *, struct file_lock *, unsigned int);

extern void posix_block_lock(struct file_lock *, struct file_lock *);

extern void posix_unblock_lock(struct file_lock *);

extern int posix_locks_deadlock(struct file_lock *, struct file_lock *);

extern int __get_lease(struct inode *inode, unsigned int flags);

extern time_t lease_get_mtime(struct inode *);

extern int lock_may_read(struct inode *, loff_t start, unsigned long count);

extern int lock_may_write(struct inode *, loff_t start, unsigned long count);

extern void steal_locks(fl_owner_t from);

struct fasync_struct {

        int     magic;

        int     fa_fd;

        struct  fasync_struct   *fa_next; /* singly linked list */

        struct  file            *fa_file;

};

#define FASYNC_MAGIC 0x4601

/* SMP safe fasync helpers: */

extern int fasync_helper(int, struct file *, int, struct fasync_struct **);

/* can be called from interrupts */

extern void kill_fasync(struct fasync_struct **, int, int);

/* only for net: no internal synchronization */

extern void __kill_fasync(struct fasync_struct *, int, int);

struct nameidata {

        struct dentry *dentry;

        struct vfsmount *mnt;

        struct qstr last;

        unsigned int flags;

        int last_type;

};

/*

 *      Umount options

 */

#define MNT_FORCE       0x00000001      /* Attempt to forcibily umount */

#define MNT_DETACH      0x00000002      /* Just detach from the tree */

#include <linux/minix_fs_sb.h>

#include <linux/ext2_fs_sb.h>

#include <linux/ext3_fs_sb.h>

#include <linux/hpfs_fs_sb.h>

#include <linux/ntfs_fs_sb.h>

#include <linux/msdos_fs_sb.h>

#include <linux/iso_fs_sb.h>

#include <linux/nfs_fs_sb.h>

#include <linux/sysv_fs_sb.h>

#include <linux/affs_fs_sb.h>

#include <linux/ufs_fs_sb.h>

#include <linux/efs_fs_sb.h>

#include <linux/romfs_fs_sb.h>

#include <linux/smb_fs_sb.h>

#include <linux/hfs_fs_sb.h>

#include <linux/adfs_fs_sb.h>

#include <linux/qnx4_fs_sb.h>

#include <linux/reiserfs_fs_sb.h>

#include <linux/bfs_fs_sb.h>

#include <linux/udf_fs_sb.h>

#include <linux/ncp_fs_sb.h>

#include <linux/usbdev_fs_sb.h>

#include <linux/cramfs_fs_sb.h>

#include <linux/jffs2_fs_sb.h>

extern struct list_head super_blocks;

extern spinlock_t sb_lock;

#define sb_entry(list)  list_entry((list), struct super_block, s_list)

#define S_BIAS (1<<30)