Subversion Repositories shark

#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/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/radix-tree.h>

#include <linux/kobject.h>

#include <asm/atomic.h>

struct iovec;

struct nameidata;

struct pipe_inode_info;

struct poll_table_struct;

struct kstatfs;

struct vm_area_struct;

struct vfsmount;

/*

 * 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 MAY_APPEND 8

#define FMODE_READ 1

#define FMODE_WRITE 2

#define RW_MASK         1

#define RWA_MASK        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_REVAL_DOT    16384   /* Check the paths ".", ".." for staleness */

#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_DIRSYNC      128     /* Directory modifications are synchronous */

#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_POSIXACL     (1<<16) /* VFS does not apply the umask */

#define MS_ONE_SECOND   (1<<17) /* fs has 1 sec a/m/ctime resolution */

#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 */

#define S_DIRSYNC       128     /* Directory modifications are synchronous */

/*

 * 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_DIRSYNC(inode)       (__IS_FLG(inode, MS_SYNCHRONOUS|MS_DIRSYNC) || \

                                        ((inode)->i_flags & (S_SYNC|S_DIRSYNC)))

#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_POSIXACL(inode)      __IS_FLG(inode, MS_POSIXACL)

#define IS_ONE_SECOND(inode)    __IS_FLG(inode, MS_ONE_SECOND)

#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 */

/* Some people are morons.  Do not use sizeof! */

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

#define BLKELVSET  _IOW(0x12,107,size_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,size_t)

#define BLKBSZSET  _IOW(0x12,113,size_t)

#define BLKGETSIZE64 _IOR(0x12,114,size_t)      /* 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>

/* Used to be a macro which just called the function, now just a function */

extern void update_atime (struct inode *);

extern void inode_init(unsigned long);

extern void mnt_init(unsigned long);

extern void files_init(unsigned long);

struct buffer_head;

typedef int (get_block_t)(struct inode *inode, sector_t iblock,

                        struct buffer_head *bh_result, int create);

typedef int (get_blocks_t)(struct inode *inode, sector_t iblock,

                        unsigned long max_blocks,

                        struct buffer_head *bh_result, int create);

typedef void (dio_iodone_t)(struct inode *inode, loff_t offset,

                        ssize_t bytes, void *private);

/*

 * 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

#define ATTR_KILL_SUID  2048

#define ATTR_KILL_SGID  4096

/*

 * 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;

        struct timespec ia_atime;

        struct timespec ia_mtime;

        struct timespec 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.

 */

#include <linux/quota.h>

/*

 * oh the beauties of C type declarations.

 */

struct page;

struct address_space;

struct writeback_control;

struct kiocb;

struct address_space_operations {

        int (*writepage)(struct page *page, struct writeback_control *wbc);

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

        int (*sync_page)(struct page *);

        /* Write back some dirty pages from this mapping. */

        int (*writepages)(struct address_space *, struct writeback_control *);

        /* Set a page dirty */

        int (*set_page_dirty)(struct page *page);

        int (*readpages)(struct file *filp, struct address_space *mapping,

                        struct list_head *pages, unsigned nr_pages);

        /*

         * 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 */

        sector_t (*bmap)(struct address_space *, sector_t);

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

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

        int (*direct_IO)(int, struct kiocb *, const struct iovec *iov,

                        loff_t offset, unsigned long nr_segs);

};

struct backing_dev_info;

struct address_space {

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

        struct radix_tree_root  page_tree;      /* radix tree of all pages */

        spinlock_t              page_lock;      /* and spinlock protecting it */

        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 */

        struct list_head        io_pages;       /* being prepared for I/O */

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

        struct address_space_operations *a_ops; /* methods */

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

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

        struct semaphore        i_shared_sem;   /* protect both above lists */

        atomic_t                truncate_count; /* Cover race condition with truncate */

        unsigned long           dirtied_when;   /* jiffies of first page dirtying */

        unsigned long           flags;          /* error bits/gfp mask */

        struct backing_dev_info *backing_dev_info; /* device readahead, etc */

        spinlock_t              private_lock;   /* for use by the address_space */

        struct list_head        private_list;   /* ditto */

        struct address_space    *assoc_mapping; /* ditto */

};

struct block_device {

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

        struct inode *          bd_inode;       /* will die */

        int                     bd_openers;

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

        struct list_head        bd_inodes;

        void *                  bd_holder;

        int                     bd_holders;

        struct block_device *   bd_contains;

        unsigned                bd_block_size;

        struct hd_struct *      bd_part;

        unsigned                bd_part_count;

        int                     bd_invalidated;

        struct gendisk *        bd_disk;

        struct list_head        bd_list;

};

/*

 * Use sequence counter to get consistent i_size on 32-bit processors.

 */

#if BITS_PER_LONG==32 && defined(CONFIG_SMP)

#include <linux/seqlock.h>

#define __NEED_I_SIZE_ORDERED

#define i_size_ordered_init(inode) seqcount_init(&inode->i_size_seqcount)

#else

#define i_size_ordered_init(inode) do { } while (0)

#endif

struct inode {

        struct hlist_node       i_hash;

        struct list_head        i_list;

        struct list_head        i_dentry;

        unsigned long           i_ino;

        atomic_t                i_count;

        umode_t                 i_mode;

        unsigned int            i_nlink;

        uid_t                   i_uid;

        gid_t                   i_gid;

        dev_t                   i_rdev;

        loff_t                  i_size;

        struct timespec         i_atime;

        struct timespec         i_mtime;

        struct timespec         i_ctime;

        unsigned int            i_blkbits;

        unsigned long           i_blksize;

        unsigned long           i_version;

        unsigned long           i_blocks;

        unsigned short          i_bytes;

        spinlock_t              i_lock; /* i_blocks, i_bytes, maybe i_size */

        struct semaphore        i_sem;

        struct inode_operations *i_op;

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

        struct super_block      *i_sb;

        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 cdev             *i_cdev;

        int                     i_cindex;

        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;

        void                    *i_security;

        __u32                   i_generation;

        union {

                void            *generic_ip;

        } u;

#ifdef __NEED_I_SIZE_ORDERED

        seqcount_t              i_size_seqcount;

#endif

};

/*

 * NOTE: in a 32bit arch with a preemptable kernel and

 * an UP compile the i_size_read/write must be atomic

 * with respect to the local cpu (unlike with preempt disabled),

 * but they don't need to be atomic with respect to other cpus like in

 * true SMP (so they need either to either locally disable irq around

 * the read or for example on x86 they can be still implemented as a

 * cmpxchg8b without the need of the lock prefix). For SMP compiles

 * and 64bit archs it makes no difference if preempt is enabled or not.

 */

static inline loff_t i_size_read(struct inode *inode)

{

#if BITS_PER_LONG==32 && defined(CONFIG_SMP)

        loff_t i_size;

        unsigned int seq;

        do {

                seq = read_seqcount_begin(&inode->i_size_seqcount);

                i_size = inode->i_size;

        } while (read_seqcount_retry(&inode->i_size_seqcount, seq));

        return i_size;

#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)

        loff_t i_size;

        preempt_disable();

        i_size = inode->i_size;

        preempt_enable();

        return i_size;

#else

        return inode->i_size;

#endif

}

static inline void i_size_write(struct inode *inode, loff_t i_size)

{

#if BITS_PER_LONG==32 && defined(CONFIG_SMP)

        write_seqcount_begin(&inode->i_size_seqcount);

        inode->i_size = i_size;

        write_seqcount_end(&inode->i_size_seqcount);

#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)

        preempt_disable();

        inode->i_size = i_size;

        preempt_enable();

#else

        inode->i_size = i_size;

#endif

}

static inline unsigned iminor(struct inode *inode)

{

        return MINOR(inode->i_rdev);

}

static inline unsigned imajor(struct inode *inode)

{

        return MAJOR(inode->i_rdev);

}

struct fown_struct {

        rwlock_t lock;          /* protects pid, uid, euid fields */

        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 */

        void *security;

};

/*

 * Track a single file's readahead state

 */

struct file_ra_state {

        unsigned long start;            /* Current window */

        unsigned long size;

        unsigned long next_size;        /* Next window size */

        unsigned long prev_page;        /* Cache last read() position */

        unsigned long ahead_start;      /* Ahead window */

        unsigned long ahead_size;

        unsigned long ra_pages;         /* Maximum readahead window */

        unsigned long mmap_hit;         /* Cache hit stat for mmap accesses */

        unsigned long mmap_miss;        /* Cache miss stat for mmap accesses */

};

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;

        struct fown_struct      f_owner;

        unsigned int            f_uid, f_gid;

        int                     f_error;

        struct file_ra_state    f_ra;

        unsigned long           f_version;

        void                    *f_security;

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

        void                    *private_data;

        /* Used by fs/eventpoll.c to link all the hooks to this file */

        struct list_head        f_ep_links;

        spinlock_t              f_ep_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)

/* Initialize and open a private file and allocate its security structure. */

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

/* Release a private file and free its security structure. */

extern void close_private_file(struct file *file);

#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_ACCESS       8       /* not trying to lock, just looking */

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

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

#define FL_SLEEP        128     /* A blocking lock */

/*

 * 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;

/* that will die - we need it for nfs_lock_info */

#include <linux/nfs_fs_i.h>

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(struct file *, struct flock __user *);

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

#if BITS_PER_LONG == 32

extern int fcntl_getlk64(struct file *, struct flock64 __user *);

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

#endif

extern void send_sigio(struct fown_struct *fown, int fd, int band);

extern int fcntl_setlease(unsigned int fd, struct file *filp, long arg);

extern int fcntl_getlease(struct file *filp);

/* 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 *);

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

extern void posix_unblock_lock(struct file *, struct file_lock *);

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

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

extern void lease_get_mtime(struct inode *, struct timespec *time);

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);

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);

extern int f_setown(struct file *filp, unsigned long arg, int force);

extern void f_delown(struct file *filp);

extern int send_sigurg(struct fown_struct *fown);

/*

 *      Umount options

 */

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

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

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)

struct super_block {

        struct list_head        s_list;         /* Keep this first */

        dev_t                   s_dev;          /* search index; _not_ kdev_t */

        unsigned long           s_blocksize;

        unsigned long           s_old_blocksize;

        unsigned char           s_blocksize_bits;

        unsigned char           s_dirt;

        unsigned long long      s_maxbytes;     /* Max file size */

        struct file_system_type *s_type;

        struct super_operations *s_op;

        struct dquot_operations *dq_op;

        struct quotactl_ops     *s_qcop;

        struct export_operations *s_export_op;

        unsigned long           s_flags;

        unsigned long           s_magic;

        struct dentry           *s_root;

        struct rw_semaphore     s_umount;

        struct semaphore        s_lock;

        int                     s_count;

        int                     s_syncing;

        int                     s_need_sync_fs;

        atomic_t                s_active;

        void                    *s_security;

        struct list_head        s_dirty;        /* dirty inodes */

        struct list_head        s_io;           /* parked for writeback */

        struct hlist_head       s_anon;         /* anonymous dentries for (nfs) exporting */

        struct list_head        s_files;

        struct block_device     *s_bdev;

        struct list_head        s_instances;

        struct quota_info       s_dquot;        /* Diskquota specific options */

        char s_id[32];                          /* Informational name */

        struct kobject           kobj;          /* anchor for sysfs */

        void                    *s_fs_info;     /* Filesystem private info */

        /*

         * The next field is for VFS *only*. No filesystems have any business

         * even looking at it. You had been warned.

         */

        struct semaphore s_vfs_rename_sem;      /* Kludge */

};

/*

 * Superblock locking.

 */

static inline void lock_super(struct super_block * sb)

{

        down(&sb->s_lock);

}

static inline void unlock_super(struct super_block * sb)

{

        up(&sb->s_lock);

}

/*

 * VFS helper functions..

 */

extern int vfs_create(struct inode *, struct dentry *, int, struct nameidata *);

extern int vfs_mkdir(struct inode *, struct dentry *, int);

extern int vfs_mknod(struct inode *, struct dentry *, int, dev_t);

extern int vfs_symlink(struct inode *, struct dentry *, const char *);

extern int vfs_link(struct dentry *, struct inode *, struct dentry *);

extern int vfs_rmdir(struct inode *, struct dentry *);

extern int vfs_unlink(struct inode *, struct dentry *);

extern int vfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);

/*

 * File types

 *

 * NOTE! These match bits 12..15 of stat.st_mode

 * (ie "(i_mode >> 12) & 15").

 */

#define DT_UNKNOWN      0

#define DT_FIFO         1

#define DT_CHR          2

#define DT_DIR          4

#define DT_BLK          6

#define DT_REG          8

#define DT_LNK          10

#define DT_SOCK         12

#define DT_WHT          14

/*

 * This is the "filldir" function type, used by readdir() to let

 * the kernel specify what kind of dirent layout it wants to have.

 * This allows the kernel to read directories into kernel space or

 * to have different dirent layouts depending on the binary type.

 */

typedef int (*filldir_t)(void *, const char *, int, loff_t, ino_t, unsigned);

struct block_device_operations {

        int (*open) (struct inode *, struct file *);

        int (*release) (struct inode *, struct file *);

        int (*ioctl) (struct inode *, struct file *, unsigned, unsigned long);

        int (*media_changed) (struct gendisk *);

        int (*revalidate_disk) (struct gendisk *);

        struct module *owner;

};

/*

 * "descriptor" for what we're up to with a read for sendfile().

 * This allows us to use the same read code yet

 * have multiple different users of the data that

 * we read from a file.

 *

 * The simplest case just copies the data to user

 * mode.

 */

typedef struct {

        size_t written;

        size_t count;

        char __user * buf;

        int error;

} read_descriptor_t;

typedef int (*read_actor_t)(read_descriptor_t *, struct page *, unsigned long, unsigned long);

/*

 * NOTE:

 * read, write, poll, fsync, readv, writev can be called

 *   without the big kernel lock held in all filesystems.

 */

struct file_operations {

        struct module *owner;

        loff_t (*llseek) (struct file *, loff_t, int);

        ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);

        ssize_t (*aio_read) (struct kiocb *, char __user *, size_t, loff_t);

        ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);

        ssize_t (*aio_write) (struct kiocb *, const char __user *, size_t, loff_t);

        int (*readdir) (struct file *, void *, filldir_t);

        unsigned int (*poll) (struct file *, struct poll_table_struct *);

        int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);

        int (*mmap) (struct file *, struct vm_area_struct *);

        int (*open) (struct inode *, struct file *);

        int (*flush) (struct file *);

        int (*release) (struct inode *, struct file *);

        int (*fsync) (struct file *, struct dentry *, int datasync);

        int (*aio_fsync) (struct kiocb *, int datasync);

        int (*fasync) (int, struct file *, int);

        int (*lock) (struct file *, int, struct file_lock *);

        ssize_t (*readv) (struct file *, const struct iovec *, unsigned long, loff_t *);

        ssize_t (*writev) (struct file *, const struct iovec *, unsigned long, loff_t *);

        ssize_t (*sendfile) (struct file *, loff_t *, size_t, read_actor_t, void __user *);

        ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);

        unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);

};

struct inode_operations {

        int (*create) (struct inode *,struct dentry *,int, struct nameidata *);

        struct dentry * (*lookup) (struct inode *,struct dentry *, struct nameidata *);

        int (*link) (struct dentry *,struct inode *,struct dentry *);

        int (*unlink) (struct inode *,struct dentry *);

        int (*symlink) (struct inode *,struct dentry *,const char *);

        int (*mkdir) (struct inode *,struct dentry *,int);

        int (*rmdir) (struct inode *,struct dentry *);

        int (*mknod) (struct inode *,struct dentry *,int,dev_t);

        int (*rename) (struct inode *, struct dentry *,

                        struct inode *, struct dentry *);

        int (*readlink) (struct dentry *, char __user *,int);