#ifndef _LINUX_FS_H#define _LINUX_FS_H/* * This file has definitions for some important file table * structures etc. */#include <linux/limits.h>#include <linux/ioctl.h>/* * 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 INR_OPEN 1024/* Initial setting for nfile rlimits */#define BLOCK_SIZE_BITS 10#define BLOCK_SIZE (1<<BLOCK_SIZE_BITS)#define SEEK_SET0/* seek relative to beginning of file */#define SEEK_CUR1/* seek relative to current file position */#define SEEK_END2/* seek relative to end of file */#define SEEK_MAXSEEK_END/* 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 */};struct inodes_stat_t {int nr_inodes;int nr_unused;int dummy[5];/* padding for sysctl ABI compatibility */};#define NR_FILE 8192/* this can well be larger on a larger system */#define MAY_EXEC 1#define MAY_WRITE 2#define MAY_READ 4#define MAY_APPEND 8#define MAY_ACCESS 16#define MAY_OPEN 32/* * flags in file.f_mode. Note that FMODE_READ and FMODE_WRITE must correspond * to O_WRONLY and O_RDWR via the strange trick in __dentry_open() *//* file is open for reading */#define FMODE_READ((__force fmode_t)1)/* file is open for writing */#define FMODE_WRITE((__force fmode_t)2)/* file is seekable */#define FMODE_LSEEK((__force fmode_t)4)/* file can be accessed using pread */#define FMODE_PREAD((__force fmode_t)8)/* file can be accessed using pwrite */#define FMODE_PWRITE((__force fmode_t)16)/* File is opened for execution with sys_execve / sys_uselib */#define FMODE_EXEC((__force fmode_t)32)/* File is opened with O_NDELAY (only set for block devices) */#define FMODE_NDELAY((__force fmode_t)64)/* File is opened with O_EXCL (only set for block devices) */#define FMODE_EXCL((__force fmode_t)128)/* File is opened using open(.., 3, ..) and is writeable only for ioctls (specialy hack for floppy.c) */#define FMODE_WRITE_IOCTL((__force fmode_t)256)/* * Don't update ctime and mtime. * * Currently a special hack for the XFS open_by_handle ioctl, but we'll * hopefully graduate it to a proper O_CMTIME flag supported by open(2) soon. */#define FMODE_NOCMTIME((__force fmode_t)2048)/* Expect random access pattern */#define FMODE_RANDOM((__force fmode_t)4096)/* * The below are the various read and write types that we support. Some of * them include behavioral modifiers that send information down to the * block layer and IO scheduler. Terminology: * *The block layer uses device plugging to defer IO a little bit, in *the hope that we will see more IO very shortly. This increases *coalescing of adjacent IO and thus reduces the number of IOs we *have to send to the device. It also allows for better queuing, *if the IO isn't mergeable. If the caller is going to be waiting *for the IO, then he must ensure that the device is unplugged so *that the IO is dispatched to the driver. * *All IO is handled async in Linux. This is fine for background *writes, but for reads or writes that someone waits for completion *on, we want to notify the block layer and IO scheduler so that they *know about it. That allows them to make better scheduling *decisions. So when the below references 'sync' and 'async', it *is referencing this priority hint. * * With that in mind, the available types are: * * READA normal read operation. Device will be plugged. * READ_SYNCA synchronous read. Device is not plugged, caller can *immediately wait on this read without caring about *unplugging. * READAUsed for read-ahead operations. Lower priority, and the * block layer could (in theory) choose to ignore this *request if it runs into resource problems. * WRITEA normal async write. Device will be plugged. * SWRITELike WRITE, but a special case for ll_rw_block() that *tells it to lock the buffer first. Normally a buffer *must be locked before doing IO. * WRITE_SYNC_PLUGSynchronous write. Identical to WRITE, but passes down *the hint that someone will be waiting on this IO *shortly. The device must still be unplugged explicitly, *WRITE_SYNC_PLUG does not do this as we could be *submitting more writes before we actually wait on any *of them. * WRITE_SYNCLike WRITE_SYNC_PLUG, but also unplugs the device *immediately after submission. The write equivalent *of READ_SYNC. * WRITE_ODIRECT_PLUGSpecial case write for O_DIRECT only. * SWRITE_SYNC * SWRITE_SYNC_PLUGLike WRITE_SYNC/WRITE_SYNC_PLUG, but locks the buffer. *See SWRITE. * WRITE_BARRIERLike WRITE, but tells the block layer that all *previously submitted writes must be safely on storage *before this one is started. Also guarantees that when *this write is complete, it itself is also safely on *storage. Prevents reordering of writes on both sides *of this IO. * */#define RW_MASK1#define RWA_MASK2#define READ 0#define WRITE 1#define READA 2/* read-ahead - don't block if no resources */#define SWRITE 3/* for ll_rw_block() - wait for buffer lock */#define READ_SYNC(READ | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_UNPLUG))#define READ_META(READ | (1 << BIO_RW_META))#define WRITE_SYNC_PLUG(WRITE | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_NOIDLE))#define WRITE_SYNC(WRITE_SYNC_PLUG | (1 << BIO_RW_UNPLUG))#define WRITE_ODIRECT_PLUG(WRITE | (1 << BIO_RW_SYNCIO))#define WRITE_META(WRITE | (1 << BIO_RW_META))#define SWRITE_SYNC_PLUG\(SWRITE | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_NOIDLE))#define SWRITE_SYNC(SWRITE_SYNC_PLUG | (1 << BIO_RW_UNPLUG))#define WRITE_BARRIER(WRITE | (1 << BIO_RW_BARRIER))/* * These aren't really reads or writes, they pass down information about * parts of device that are now unused by the file system. */#define DISCARD_NOBARRIER (WRITE | (1 << BIO_RW_DISCARD))#define DISCARD_BARRIER (DISCARD_NOBARRIER | (1 << BIO_RW_BARRIER))#define SEL_IN1#define SEL_OUT2#define SEL_EX4/* public flags for file_system_type */#define FS_REQUIRES_DEV 1 #define FS_BINARY_MOUNTDATA 2#define FS_HAS_SUBTYPE 4#define FS_REVAL_DOT16384/* Check the paths ".", ".." for staleness */#define FS_RENAME_DOES_D_MOVE32768/* FS will handle d_move() * during rename() internally. *//* * 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_SYNCHRONOUS16/* Writes are synced at once */#define MS_REMOUNT32/* Alter flags of a mounted FS */#define MS_MANDLOCK64/* Allow mandatory locks on an FS */#define MS_DIRSYNC128/* Directory modifications are synchronous */#define MS_NOATIME1024/* Do not update access times. */#define MS_NODIRATIME2048/* Do not update directory access times */#define MS_BIND4096#define MS_MOVE8192#define MS_REC16384#define MS_VERBOSE32768/* War is peace. Verbosity is silence. MS_VERBOSE is deprecated. */#define MS_SILENT32768#define MS_POSIXACL(1<<16)/* VFS does not apply the umask */#define MS_UNBINDABLE(1<<17)/* change to unbindable */#define MS_PRIVATE(1<<18)/* change to private */#define MS_SLAVE(1<<19)/* change to slave */#define MS_SHARED(1<<20)/* change to shared */#define MS_RELATIME(1<<21)/* Update atime relative to mtime/ctime. */#define MS_KERNMOUNT(1<<22) /* this is a kern_mount call */#define MS_I_VERSION(1<<23) /* Update inode I_version field */#define MS_STRICTATIME(1<<24) /* Always perform atime updates */#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_I_VERSION)/* * 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_SYNC1/* Writes are synced at once */#define S_NOATIME2/* Do not update access times */#define S_APPEND4/* Append-only file */#define S_IMMUTABLE8/* Immutable file */#define S_DEAD16/* removed, but still open directory */#define S_NOQUOTA32/* Inode is not counted to quota */#define S_DIRSYNC64/* Directory modifications are synchronous */#define S_NOCMTIME128/* Do not update file c/mtime */#define S_SWAPFILE256/* Do not truncate: swapon got its bmaps */#define S_PRIVATE512/* Inode is fs-internal *//* * 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_NOATIME(inode) __IS_FLG(inode, MS_RDONLY|MS_NOATIME)#define IS_I_VERSION(inode) __IS_FLG(inode, MS_I_VERSION)#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_POSIXACL(inode)__IS_FLG(inode, MS_POSIXACL)#define IS_DEADDIR(inode)((inode)->i_flags & S_DEAD)#define IS_NOCMTIME(inode)((inode)->i_flags & S_NOCMTIME)#define IS_SWAPFILE(inode)((inode)->i_flags & S_SWAPFILE)#define IS_PRIVATE(inode)((inode)->i_flags & S_PRIVATE)/* 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 BLKTRACESETUP _IOWR(0x12,115,struct blk_user_trace_setup)#define BLKTRACESTART _IO(0x12,116)#define BLKTRACESTOP _IO(0x12,117)#define BLKTRACETEARDOWN _IO(0x12,118)#define BLKDISCARD _IO(0x12,119)#define BLKIOMIN _IO(0x12,120)#define BLKIOOPT _IO(0x12,121)#define BLKALIGNOFF _IO(0x12,122)#define BLKPBSZGET _IO(0x12,123)#define BLKDISCARDZEROES _IO(0x12,124)#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 */#define FIFREEZE_IOWR('X', 119, int)/* Freeze */#define FITHAW_IOWR('X', 120, int)/* Thaw */#defineFS_IOC_GETFLAGS_IOR('f', 1, long)#defineFS_IOC_SETFLAGS_IOW('f', 2, long)#defineFS_IOC_GETVERSION_IOR('v', 1, long)#defineFS_IOC_SETVERSION_IOW('v', 2, long)#define FS_IOC_FIEMAP_IOWR('f', 11, struct fiemap)#define FS_IOC32_GETFLAGS_IOR('f', 1, int)#define FS_IOC32_SETFLAGS_IOW('f', 2, int)#define FS_IOC32_GETVERSION_IOR('v', 1, int)#define FS_IOC32_SETVERSION_IOW('v', 2, int)/* * Inode flags (FS_IOC_GETFLAGS / FS_IOC_SETFLAGS) */#defineFS_SECRM_FL0x00000001 /* Secure deletion */#defineFS_UNRM_FL0x00000002 /* Undelete */#defineFS_COMPR_FL0x00000004 /* Compress file */#define FS_SYNC_FL0x00000008 /* Synchronous updates */#define FS_IMMUTABLE_FL0x00000010 /* Immutable file */#define FS_APPEND_FL0x00000020 /* writes to file may only append */#define FS_NODUMP_FL0x00000040 /* do not dump file */#define FS_NOATIME_FL0x00000080 /* do not update atime *//* Reserved for compression usage... */#define FS_DIRTY_FL0x00000100#define FS_COMPRBLK_FL0x00000200 /* One or more compressed clusters */#define FS_NOCOMP_FL0x00000400 /* Don't compress */#define FS_ECOMPR_FL0x00000800 /* Compression error *//* End compression flags --- maybe not all used */#define FS_BTREE_FL0x00001000 /* btree format dir */#define FS_INDEX_FL0x00001000 /* hash-indexed directory */#define FS_IMAGIC_FL0x00002000 /* AFS directory */#define FS_JOURNAL_DATA_FL0x00004000 /* Reserved for ext3 */#define FS_NOTAIL_FL0x00008000 /* file tail should not be merged */#define FS_DIRSYNC_FL0x00010000 /* dirsync behaviour (directories only) */#define FS_TOPDIR_FL0x00020000 /* Top of directory hierarchies*/#define FS_EXTENT_FL0x00080000 /* Extents */#define FS_DIRECTIO_FL0x00100000 /* Use direct i/o */#define FS_RESERVED_FL0x80000000 /* reserved for ext2 lib */#define FS_FL_USER_VISIBLE0x0003DFFF /* User visible flags */#define FS_FL_USER_MODIFIABLE0x000380FF /* User modifiable flags */#define SYNC_FILE_RANGE_WAIT_BEFORE1#define SYNC_FILE_RANGE_WRITE2#define SYNC_FILE_RANGE_WAIT_AFTER4#ifdef __KERNEL__#include <linux/linkage.h>#include <linux/wait.h>#include <linux/types.h>#include <linux/kdev_t.h>#include <linux/dcache.h>#include <linux/path.h>#include <linux/stat.h>#include <linux/cache.h>#include <linux/kobject.h>#include <linux/list.h>#include <linux/radix-tree.h>#include <linux/prio_tree.h>#include <linux/init.h>#include <linux/pid.h>#include <linux/mutex.h>#include <linux/capability.h>#include <linux/semaphore.h>#include <linux/fiemap.h>#include <asm/atomic.h>#include <asm/byteorder.h>struct export_operations;struct hd_geometry;struct iovec;struct nameidata;struct kiocb;struct pipe_inode_info;struct poll_table_struct;struct kstatfs;struct vm_area_struct;struct vfsmount;struct cred;extern void __init inode_init(void);extern void __init inode_init_early(void);extern void __init files_init(unsigned long);extern struct files_stat_struct files_stat;extern int get_max_files(void);extern int sysctl_nr_open;extern struct inodes_stat_t inodes_stat;extern int leases_enable, lease_break_time;#ifdef CONFIG_DNOTIFYextern int dir_notify_enable;#endifstruct buffer_head;typedef int (get_block_t)(struct inode *inode, sector_t iblock,struct buffer_head *bh_result, int create);typedef void (dio_iodone_t)(struct kiocb *iocb, 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 << 0)#define ATTR_UID(1 << 1)#define ATTR_GID(1 << 2)#define ATTR_SIZE(1 << 3)#define ATTR_ATIME(1 << 4)#define ATTR_MTIME(1 << 5)#define ATTR_CTIME(1 << 6)#define ATTR_ATIME_SET(1 << 7)#define ATTR_MTIME_SET(1 << 8)#define ATTR_FORCE(1 << 9) /* Not a change, but a change it */#define ATTR_ATTR_FLAG(1 << 10)#define ATTR_KILL_SUID(1 << 11)#define ATTR_KILL_SGID(1 << 12)#define ATTR_FILE(1 << 13)#define ATTR_KILL_PRIV(1 << 14)#define ATTR_OPEN(1 << 15) /* Truncating from open(O_TRUNC) */#define ATTR_TIMES_SET(1 << 16)/* * 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 intia_valid;umode_tia_mode;uid_tia_uid;gid_tia_gid;loff_tia_size;struct timespecia_atime;struct timespecia_mtime;struct timespecia_ctime;/* * Not an attribute, but an auxilary info for filesystems wanting to * implement an ftruncate() like method. NOTE: filesystem should * check for (ia_valid & ATTR_FILE), and not for (ia_file != NULL). */struct file*ia_file;};/* * Includes for diskquotas. */#include <linux/quota.h>/** * enum positive_aop_returns - aop return codes with specific semantics * * @AOP_WRITEPAGE_ACTIVATE: Informs the caller that page writeback has * completed, that the page is still locked, and * should be considered active. The VM uses this hint * to return the page to the active list -- it won't * be a candidate for writeback again in the near * future. Other callers must be careful to unlock * the page if they get this return. Returned by * writepage(); * * @AOP_TRUNCATED_PAGE: The AOP method that was handed a locked page has * unlocked it and the page might have been truncated. * The caller should back up to acquiring a new page and * trying again. The aop will be taking reasonable * precautions not to livelock. If the caller held a page * reference, it should drop it before retrying. Returned * by readpage(). * * address_space_operation functions return these large constants to indicate * special semantics to the caller. These are much larger than the bytes in a * page to allow for functions that return the number of bytes operated on in a * given page. */enum positive_aop_returns {AOP_WRITEPAGE_ACTIVATE= 0x80000,AOP_TRUNCATED_PAGE= 0x80001,};#define AOP_FLAG_UNINTERRUPTIBLE0x0001 /* will not do a short write */#define AOP_FLAG_CONT_EXPAND0x0002 /* called from cont_expand */#define AOP_FLAG_NOFS0x0004 /* used by filesystem to direct* helper code (eg buffer layer)* to clear GFP_FS from alloc *//* * oh the beauties of C type declarations. */struct page;struct address_space;struct writeback_control;struct iov_iter {const struct iovec *iov;unsigned long nr_segs;size_t iov_offset;size_t count;};size_t iov_iter_copy_from_user_atomic(struct page *page,struct iov_iter *i, unsigned long offset, size_t bytes);size_t iov_iter_copy_from_user(struct page *page,struct iov_iter *i, unsigned long offset, size_t bytes);void iov_iter_advance(struct iov_iter *i, size_t bytes);int iov_iter_fault_in_readable(struct iov_iter *i, size_t bytes);size_t iov_iter_single_seg_count(struct iov_iter *i);static inline void iov_iter_init(struct iov_iter *i,const struct iovec *iov, unsigned long nr_segs,size_t count, size_t written){i->iov = iov;i->nr_segs = nr_segs;i->iov_offset = 0;i->count = count + written;iov_iter_advance(i, written);}static inline size_t iov_iter_count(struct iov_iter *i){return i->count;}/* * "descriptor" for what we're up to with a read. * 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;union {char __user *buf;void *data;} arg;int error;} read_descriptor_t;typedef int (*read_actor_t)(read_descriptor_t *, struct page *,unsigned long, unsigned long);struct address_space_operations {int (*writepage)(struct page *page, struct writeback_control *wbc);int (*readpage)(struct file *, struct page *);void (*sync_page)(struct page *);/* Write back some dirty pages from this mapping. */int (*writepages)(struct address_space *, struct writeback_control *);/* Set a page dirty. Return true if this dirtied it */int (*set_page_dirty)(struct page *page);int (*readpages)(struct file *filp, struct address_space *mapping,struct list_head *pages, unsigned nr_pages);int (*write_begin)(struct file *, struct address_space *mapping,loff_t pos, unsigned len, unsigned flags,struct page **pagep, void **fsdata);int (*write_end)(struct file *, struct address_space *mapping,loff_t pos, unsigned len, unsigned copied,struct page *page, void *fsdata);/* Unfortunately this kludge is needed for FIBMAP. Don't use it */sector_t (*bmap)(struct address_space *, sector_t);void (*invalidatepage) (struct page *, unsigned long);int (*releasepage) (struct page *, gfp_t);ssize_t (*direct_IO)(int, struct kiocb *, const struct iovec *iov,loff_t offset, unsigned long nr_segs);int (*get_xip_mem)(struct address_space *, pgoff_t, int,void **, unsigned long *);/* migrate the contents of a page to the specified target */int (*migratepage) (struct address_space *,struct page *, struct page *);int (*launder_page) (struct page *);int (*is_partially_uptodate) (struct page *, read_descriptor_t *,unsigned long);int (*error_remove_page)(struct address_space *, struct page *);};/* * pagecache_write_begin/pagecache_write_end must be used by general code * to write into the pagecache. */int pagecache_write_begin(struct file *, struct address_space *mapping,loff_t pos, unsigned len, unsigned flags,struct page **pagep, void **fsdata);int pagecache_write_end(struct file *, struct address_space *mapping,loff_t pos, unsigned len, unsigned copied,struct page *page, void *fsdata);struct backing_dev_info;struct address_space {struct inode*host;/* owner: inode, block_device */struct radix_tree_rootpage_tree;/* radix tree of all pages */spinlock_ttree_lock;/* and lock protecting it */unsigned inti_mmap_writable;/* count VM_SHARED mappings */struct prio_tree_rooti_mmap;/* tree of private and shared mappings */struct list_headi_mmap_nonlinear;/*list VM_NONLINEAR mappings */spinlock_ti_mmap_lock;/* protect tree, count, list */unsigned inttruncate_count;/* Cover race condition with truncate */unsigned longnrpages;/* number of total pages */pgoff_twriteback_index;/* writeback starts here */const struct address_space_operations *a_ops;/* methods */unsigned longflags;/* error bits/gfp mask */struct backing_dev_info *backing_dev_info; /* device readahead, etc */spinlock_tprivate_lock;/* for use by the address_space */struct list_headprivate_list;/* ditto */struct address_space*assoc_mapping;/* ditto */} __attribute__((aligned(sizeof(long))));/* * On most architectures that alignment is already the case; but * must be enforced here for CRIS, to let the least signficant bit * of struct page's "mapping" pointer be used for PAGE_MAPPING_ANON. */struct block_device {dev_tbd_dev; /* not a kdev_t - it's a search key */struct inode *bd_inode;/* will die */struct super_block *bd_super;intbd_openers;struct mutexbd_mutex;/* open/close mutex */struct list_headbd_inodes;void *bd_holder;intbd_holders;#ifdef CONFIG_SYSFSstruct list_headbd_holder_list;#endifstruct block_device *bd_contains;unsignedbd_block_size;struct hd_struct *bd_part;/* number of times partitions within this device have been opened. */unsignedbd_part_count;intbd_invalidated;struct gendisk *bd_disk;struct list_headbd_list;/* * Private data. You must have bd_claim'ed the block_device * to use this. NOTE: bd_claim allows an owner to claim * the same device multiple times, the owner must take special * care to not mess up bd_private for that case. */unsigned longbd_private;/* The counter of freeze processes */intbd_fsfreeze_count;/* Mutex for freeze */struct mutexbd_fsfreeze_mutex;};/* * Radix-tree tags, for tagging dirty and writeback pages within the pagecache * radix trees */#define PAGECACHE_TAG_DIRTY0#define PAGECACHE_TAG_WRITEBACK1int mapping_tagged(struct address_space *mapping, int tag);/* * Might pages of this file be mapped into userspace? */static inline int mapping_mapped(struct address_space *mapping){return!prio_tree_empty(&mapping->i_mmap) ||!list_empty(&mapping->i_mmap_nonlinear);}/* * Might pages of this file have been modified in userspace? * Note that i_mmap_writable counts all VM_SHARED vmas: do_mmap_pgoff * marks vma as VM_SHARED if it is shared, and the file was opened for * writing i.e. vma may be mprotected writable even if now readonly. */static inline int mapping_writably_mapped(struct address_space *mapping){return mapping->i_mmap_writable != 0;}/* * 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)#endifstruct posix_acl;#define ACL_NOT_CACHED ((void *)(-1))struct inode {struct hlist_nodei_hash;struct list_headi_list;/* backing dev IO list */struct list_headi_sb_list;struct list_headi_dentry;unsigned longi_ino;atomic_ti_count;unsigned inti_nlink;uid_ti_uid;gid_ti_gid;dev_ti_rdev;unsigned inti_blkbits;u64i_version;loff_ti_size;#ifdef __NEED_I_SIZE_ORDEREDseqcount_ti_size_seqcount;#endifstruct timespeci_atime;struct timespeci_mtime;struct timespeci_ctime;blkcnt_ti_blocks;unsigned short i_bytes;umode_ti_mode;spinlock_ti_lock;/* i_blocks, i_bytes, maybe i_size */struct mutexi_mutex;struct rw_semaphorei_alloc_sem;const struct inode_operations*i_op;const 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_spacei_data;#ifdef CONFIG_QUOTAstruct dquot*i_dquot[MAXQUOTAS];#endifstruct list_headi_devices;union {struct pipe_inode_info*i_pipe;struct block_device*i_bdev;struct cdev*i_cdev;};__u32i_generation;#ifdef CONFIG_FSNOTIFY__u32i_fsnotify_mask; /* all events this inode cares about */struct hlist_headi_fsnotify_mark_entries; /* fsnotify mark entries */#endif#ifdef CONFIG_INOTIFYstruct list_headinotify_watches; /* watches on this inode */struct mutexinotify_mutex;/* protects the watches list */#endifunsigned longi_state;unsigned longdirtied_when;/* jiffies of first dirtying */unsigned inti_flags;atomic_ti_writecount;#ifdef CONFIG_SECURITYvoid*i_security;#endif#ifdef CONFIG_FS_POSIX_ACLstruct posix_acl*i_acl;struct posix_acl*i_default_acl;#endifvoid*i_private; /* fs or device private pointer */};/* * inode->i_mutex nesting subclasses for the lock validator: * * 0: the object of the current VFS operation * 1: parent * 2: child/target * 3: quota file * * The locking order between these classes is * parent -> child -> normal -> xattr -> quota */enum inode_i_mutex_lock_class{I_MUTEX_NORMAL,I_MUTEX_PARENT,I_MUTEX_CHILD,I_MUTEX_XATTR,I_MUTEX_QUOTA};/* * 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(const 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;#elsereturn inode->i_size;#endif}/* * NOTE: unlike i_size_read(), i_size_write() does need locking around it * (normally i_mutex), otherwise on 32bit/SMP an update of i_size_seqcount * can be lost, resulting in subsequent i_size_read() calls spinning forever. */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();#elseinode->i_size = i_size;#endif}static inline unsigned iminor(const struct inode *inode){return MINOR(inode->i_rdev);}static inline unsigned imajor(const struct inode *inode){return MAJOR(inode->i_rdev);}extern struct block_device *I_BDEV(struct inode *inode);struct fown_struct {rwlock_t lock; /* protects pid, uid, euid fields */struct pid *pid;/* pid or -pgrp where SIGIO should be sent */enum pid_type pid_type;/* Kind of process group SIGIO should be sent to */uid_t uid, euid;/* uid/euid of process setting the owner */int signum;/* posix.1b rt signal to be delivered on IO */};/* * Track a single file's readahead state */struct file_ra_state {pgoff_t start;/* where readahead started */unsigned int size;/* # of readahead pages */unsigned int async_size;/* do asynchronous readahead when there are only # of pages ahead */unsigned int ra_pages;/* Maximum readahead window */unsigned int mmap_miss;/* Cache miss stat for mmap accesses */loff_t prev_pos;/* Cache last read() position */};/* * Check if @index falls in the readahead windows. */static inline int ra_has_index(struct file_ra_state *ra, pgoff_t index){return (index >= ra->start &&index < ra->start + ra->size);}#define FILE_MNT_WRITE_TAKEN1#define FILE_MNT_WRITE_RELEASED2struct file {/* * fu_list becomes invalid after file_free is called and queued via * fu_rcuhead for RCU freeing */union {struct list_headfu_list;struct rcu_head fu_rcuhead;} f_u;struct pathf_path;#define f_dentryf_path.dentry#define f_vfsmntf_path.mntconst struct file_operations*f_op;spinlock_tf_lock; /* f_ep_links, f_flags, no IRQ */atomic_long_tf_count;unsigned int f_flags;fmode_tf_mode;loff_tf_pos;struct fown_structf_owner;const struct cred*f_cred;struct file_ra_statef_ra;u64f_version;#ifdef CONFIG_SECURITYvoid*f_security;#endif/* needed for tty driver, and maybe others */void*private_data;#ifdef CONFIG_EPOLL/* Used by fs/eventpoll.c to link all the hooks to this file */struct list_headf_ep_links;#endif /* #ifdef CONFIG_EPOLL */struct address_space*f_mapping;#ifdef CONFIG_DEBUG_WRITECOUNTunsigned long f_mnt_write_state;#endif};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_long_inc(&(x)->f_count)#define file_count(x)atomic_long_read(&(x)->f_count)#ifdef CONFIG_DEBUG_WRITECOUNTstatic inline void file_take_write(struct file *f){WARN_ON(f->f_mnt_write_state != 0);f->f_mnt_write_state = FILE_MNT_WRITE_TAKEN;}static inline void file_release_write(struct file *f){f->f_mnt_write_state |= FILE_MNT_WRITE_RELEASED;}static inline void file_reset_write(struct file *f){f->f_mnt_write_state = 0;}static inline void file_check_state(struct file *f){/* * At this point, either both or neither of these bits * should be set. */WARN_ON(f->f_mnt_write_state == FILE_MNT_WRITE_TAKEN);WARN_ON(f->f_mnt_write_state == FILE_MNT_WRITE_RELEASED);}static inline int file_check_writeable(struct file *f){if (f->f_mnt_write_state == FILE_MNT_WRITE_TAKEN)return 0;printk(KERN_WARNING "writeable file with no " "mnt_want_write()\n");WARN_ON(1);return -EINVAL;}#else /* !CONFIG_DEBUG_WRITECOUNT */static inline void file_take_write(struct file *filp) {}static inline void file_release_write(struct file *filp) {}static inline void file_reset_write(struct file *filp) {}static inline void file_check_state(struct file *filp) {}static inline int file_check_writeable(struct file *filp){return 0;}#endif /* CONFIG_DEBUG_WRITECOUNT */#defineMAX_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 0x7fffffffffffffffUL#endif#define FL_POSIX1#define FL_FLOCK2#define FL_ACCESS8/* not trying to lock, just looking */#define FL_EXISTS16/* when unlocking, test for existence */#define FL_LEASE32/* lease held on this file */#define FL_CLOSE64/* unlock on close */#define FL_SLEEP128/* A blocking lock *//* * Special return value from posix_lock_file() and vfs_lock_file() for * asynchronous locking. */#define FILE_LOCK_DEFERRED 1/* * 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_operations {void (*fl_copy_lock)(struct file_lock *, struct file_lock *);void (*fl_release_private)(struct file_lock *);};struct lock_manager_operations {int (*fl_compare_owner)(struct file_lock *, struct file_lock *);void (*fl_notify)(struct file_lock *);/* unblock callback */int (*fl_grant)(struct file_lock *, struct file_lock *, int);void (*fl_copy_lock)(struct file_lock *, struct file_lock *);void (*fl_release_private)(struct file_lock *);void (*fl_break)(struct file_lock *);int (*fl_mylease)(struct file_lock *, struct file_lock *);int (*fl_change)(struct file_lock **, int);};struct lock_manager {struct list_head list;};void locks_start_grace(struct lock_manager *);void locks_end_grace(struct lock_manager *);int locks_in_grace(void);/* 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 char fl_flags;unsigned char fl_type;unsigned int fl_pid;struct pid *fl_nspid;wait_queue_head_t fl_wait;struct file *fl_file;loff_t fl_start;loff_t fl_end;struct fasync_struct *fl_fasync; /* for lease break notifications */unsigned long fl_break_time;/* for nonblocking lease breaks */const struct file_lock_operations *fl_ops;/* Callbacks for filesystems */const struct lock_manager_operations *fl_lmops;/* Callbacks for lockmanagers */union {struct nfs_lock_infonfs_fl;struct nfs4_lock_infonfs4_fl;struct {struct list_head link;/* link in AFS vnode's pending_locks list */int state;/* state of grant or error if -ve */} afs;} 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_MAXINT_LIMIT(loff_t)#define OFFT_OFFSET_MAXINT_LIMIT(off_t)#endif#include <linux/fcntl.h>extern void send_sigio(struct fown_struct *fown, int fd, int band);#ifdef CONFIG_FILE_LOCKINGextern int fcntl_getlk(struct file *, struct flock __user *);extern int fcntl_setlk(unsigned int, struct file *, unsigned int,struct flock __user *);#if BITS_PER_LONG == 32extern int fcntl_getlk64(struct file *, struct flock64 __user *);extern int fcntl_setlk64(unsigned int, struct file *, unsigned int,struct flock64 __user *);#endifextern 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_copy_lock(struct file_lock *, const struct file_lock *);extern void locks_remove_posix(struct file *, fl_owner_t);extern void locks_remove_flock(struct file *);extern void locks_release_private(struct file_lock *);extern void posix_test_lock(struct file *, struct file_lock *);extern int posix_lock_file(struct file *, struct file_lock *, struct file_lock *);extern int posix_lock_file_wait(struct file *, struct file_lock *);extern int posix_unblock_lock(struct file *, struct file_lock *);extern int vfs_test_lock(struct file *, struct file_lock *);extern int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *);extern int vfs_cancel_lock(struct file *filp, struct file_lock *fl);extern int flock_lock_file_wait(struct file *filp, struct file_lock *fl);extern int __break_lease(struct inode *inode, unsigned int flags);extern void lease_get_mtime(struct inode *, struct timespec *time);extern int generic_setlease(struct file *, long, struct file_lock **);extern int vfs_setlease(struct file *, long, struct file_lock **);extern int lease_modify(struct file_lock **, int);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);#else /* !CONFIG_FILE_LOCKING */static inline int fcntl_getlk(struct file *file, struct flock __user *user){return -EINVAL;}static inline int fcntl_setlk(unsigned int fd, struct file *file, unsigned int cmd, struct flock __user *user){return -EACCES;}#if BITS_PER_LONG == 32static inline int fcntl_getlk64(struct file *file, struct flock64 __user *user){return -EINVAL;}static inline int fcntl_setlk64(unsigned int fd, struct file *file,unsigned int cmd, struct flock64 __user *user){return -EACCES;}#endifstatic inline int fcntl_setlease(unsigned int fd, struct file *filp, long arg){return 0;}static inline int fcntl_getlease(struct file *filp){return 0;}static inline void locks_init_lock(struct file_lock *fl){return;}static inline void __locks_copy_lock(struct file_lock *new, struct file_lock *fl){return;}static inline void locks_copy_lock(struct file_lock *new, struct file_lock *fl){return;}static inline void locks_remove_posix(struct file *filp, fl_owner_t owner){return;}static inline void locks_remove_flock(struct file *filp){return;}static inline void posix_test_lock(struct file *filp, struct file_lock *fl){return;}static inline int posix_lock_file(struct file *filp, struct file_lock *fl, struct file_lock *conflock){return -ENOLCK;}static inline int posix_lock_file_wait(struct file *filp, struct file_lock *fl){return -ENOLCK;}static inline int posix_unblock_lock(struct file *filp, struct file_lock *waiter){return -ENOENT;}static inline int vfs_test_lock(struct file *filp, struct file_lock *fl){return 0;}static inline int vfs_lock_file(struct file *filp, unsigned int cmd,struct file_lock *fl, struct file_lock *conf){return -ENOLCK;}static inline int vfs_cancel_lock(struct file *filp, struct file_lock *fl){return 0;}static inline int flock_lock_file_wait(struct file *filp, struct file_lock *request){return -ENOLCK;}static inline int __break_lease(struct inode *inode, unsigned int mode){return 0;}static inline void lease_get_mtime(struct inode *inode, struct timespec *time){return;}static inline int generic_setlease(struct file *filp, long arg, struct file_lock **flp){return -EINVAL;}static inline int vfs_setlease(struct file *filp, long arg, struct file_lock **lease){return -EINVAL;}static inline int lease_modify(struct file_lock **before, int arg){return -EINVAL;}static inline int lock_may_read(struct inode *inode, loff_t start,unsigned long len){return 1;}static inline int lock_may_write(struct inode *inode, loff_t start, unsigned long len){return 1;}#endif /* !CONFIG_FILE_LOCKING */struct fasync_struct {intmagic;intfa_fd;structfasync_struct*fa_next; /* singly linked list */structfile *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, struct pid *, enum pid_type, int force);extern int f_setown(struct file *filp, unsigned long arg, int force);extern void f_delown(struct file *filp);extern pid_t f_getown(struct file *filp);extern int send_sigurg(struct fown_struct *fown);/* *Umount options */#define MNT_FORCE0x00000001/* Attempt to forcibily umount */#define MNT_DETACH0x00000002/* Just detach from the tree */#define MNT_EXPIRE0x00000004/* Mark for expiry */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_heads_list;/* Keep this first */dev_ts_dev;/* search index; _not_ kdev_t */unsigned longs_blocksize;unsigned chars_blocksize_bits;unsigned chars_dirt;loff_ts_maxbytes;/* Max file size */struct file_system_type*s_type;const struct super_operations*s_op;const struct dquot_operations*dq_op;const struct quotactl_ops*s_qcop;const struct export_operations *s_export_op;unsigned longs_flags;unsigned longs_magic;struct dentry*s_root;struct rw_semaphores_umount;struct mutexs_lock;ints_count;ints_need_sync;atomic_ts_active;#ifdef CONFIG_SECURITYvoid *s_security;#endifstruct xattr_handler**s_xattr;struct list_heads_inodes;/* all inodes */struct hlist_heads_anon;/* anonymous dentries for (nfs) exporting */struct list_heads_files;/* s_dentry_lru and s_nr_dentry_unused are protected by dcache_lock */struct list_heads_dentry_lru;/* unused dentry lru */ints_nr_dentry_unused;/* # of dentry on lru */struct block_device*s_bdev;struct backing_dev_info *s_bdi;struct mtd_info*s_mtd;struct list_heads_instances;struct quota_infos_dquot;/* Diskquota specific options */ints_frozen;wait_queue_head_ts_wait_unfrozen;char s_id[32];/* Informational name */void *s_fs_info;/* Filesystem private info */fmode_ts_mode;/* * The next field is for VFS *only*. No filesystems have any business * even looking at it. You had been warned. */struct mutex s_vfs_rename_mutex;/* Kludge *//* Granularity of c/m/atime in ns. Cannot be worse than a second */u32 s_time_gran;/* * Filesystem subtype. If non-empty the filesystem type field * in /proc/mounts will be "type.subtype" */char *s_subtype;/* * Saved mount options for lazy filesystems using * generic_show_options() */char *s_options;};extern struct timespec current_fs_time(struct super_block *sb);/* * Snapshotting support. */enum {SB_UNFROZEN = 0,SB_FREEZE_WRITE= 1,SB_FREEZE_TRANS = 2,};#define vfs_check_frozen(sb, level) \wait_event((sb)->s_wait_unfrozen, ((sb)->s_frozen < (level)))#define get_fs_excl() atomic_inc(¤t->fs_excl)#define put_fs_excl() atomic_dec(¤t->fs_excl)#define has_fs_excl() atomic_read(¤t->fs_excl)#define is_owner_or_cap(inode)\((current_fsuid() == (inode)->i_uid) || capable(CAP_FOWNER))/* not quite ready to be deprecated, but... */extern void lock_super(struct super_block *);extern void unlock_super(struct super_block *);/* * 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 *);/* * VFS dentry helper functions. */extern void dentry_unhash(struct dentry *dentry);/* * VFS file helper functions. */extern int file_permission(struct file *, int);/* * VFS FS_IOC_FIEMAP helper definitions. */struct fiemap_extent_info {unsigned int fi_flags;/* Flags as passed from user */unsigned int fi_extents_mapped;/* Number of mapped extents */unsigned int fi_extents_max;/* Size of fiemap_extent array */struct fiemap_extent *fi_extents_start; /* Start of fiemap_extent * array */};int fiemap_fill_next_extent(struct fiemap_extent_info *info, u64 logical, u64 phys, u64 len, u32 flags);int fiemap_check_flags(struct fiemap_extent_info *fieinfo, u32 fs_flags);/* * File types * * NOTE! These match bits 12..15 of stat.st_mode * (ie "(i_mode >> 12) & 15"). */#define DT_UNKNOWN0#define DT_FIFO1#define DT_CHR2#define DT_DIR4#define DT_BLK6#define DT_REG8#define DT_LNK10#define DT_SOCK12#define DT_WHT14/* * 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, u64, unsigned);struct block_device_operations;/* These macros are for out of kernel modules to test that * the kernel supports the unlocked_ioctl and compat_ioctl * fields in struct file_operations. */#define HAVE_COMPAT_IOCTL 1#define HAVE_UNLOCKED_IOCTL 1/* * NOTE: * read, write, poll, fsync, readv, writev, unlocked_ioctl and compat_ioctl * 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 (*write) (struct file *, const char __user *, size_t, loff_t *);ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, 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);long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);long (*compat_ioctl) (struct file *, unsigned int, unsigned long);int (*mmap) (struct file *, struct vm_area_struct *);int (*open) (struct inode *, struct file *);int (*flush) (struct file *, fl_owner_t id);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 (*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);int (*check_flags)(int);int (*flock) (struct file *, int, struct file_lock *);ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);int (*setlease)(struct file *, long, struct file_lock **);};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);void * (*follow_link) (struct dentry *, struct nameidata *);void (*put_link) (struct dentry *, struct nameidata *, void *);void (*truncate) (struct inode *);int (*permission) (struct inode *, int);int (*check_acl)(struct inode *, int);int (*setattr) (struct dentry *, struct iattr *);int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *);int (*setxattr) (struct dentry *, const char *,const void *,size_t,int);ssize_t (*getxattr) (struct dentry *, const char *, void *, size_t);ssize_t (*listxattr) (struct dentry *, char *, size_t);int (*removexattr) (struct dentry *, const char *);void (*truncate_range)(struct inode *, loff_t, loff_t);long (*fallocate)(struct inode *inode, int mode, loff_t offset, loff_t len);int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start, u64 len);};struct seq_file;ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,unsigned long nr_segs, unsigned long fast_segs,struct iovec *fast_pointer,struct iovec **ret_pointer);extern ssize_t vfs_read(struct file *, char __user *, size_t, loff_t *);extern ssize_t vfs_write(struct file *, const char __user *, size_t, loff_t *);extern ssize_t vfs_readv(struct file *, const struct iovec __user *,unsigned long, loff_t *);extern ssize_t vfs_writev(struct file *, const struct iovec __user *,unsigned long, loff_t *);struct super_operations { struct inode *(*alloc_inode)(struct super_block *sb);void (*destroy_inode)(struct inode *); void (*dirty_inode) (struct inode *);int (*write_inode) (struct inode *, int);void (*drop_inode) (struct inode *);void (*delete_inode) (struct inode *);void (*put_super) (struct super_block *);void (*write_super) (struct super_block *);int (*sync_fs)(struct super_block *sb, int wait);int (*freeze_fs) (struct super_block *);int (*unfreeze_fs) (struct super_block *);int (*statfs) (struct dentry *, struct kstatfs *);int (*remount_fs) (struct super_block *, int *, char *);void (*clear_inode) (struct inode *);void (*umount_begin) (struct super_block *);int (*show_options)(struct seq_file *, struct vfsmount *);int (*show_stats)(struct seq_file *, struct vfsmount *);#ifdef CONFIG_QUOTAssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);#endifint (*bdev_try_to_free_page)(struct super_block*, struct page*, gfp_t);};/* * Inode state bits. Protected by inode_lock. * * Three bits determine the dirty state of the inode, I_DIRTY_SYNC, * I_DIRTY_DATASYNC and I_DIRTY_PAGES. * * Four bits define the lifetime of an inode. Initially, inodes are I_NEW, * until that flag is cleared. I_WILL_FREE, I_FREEING and I_CLEAR are set at * various stages of removing an inode. * * Two bits are used for locking and completion notification, I_NEW and I_SYNC. * * I_DIRTY_SYNCInode is dirty, but doesn't have to be written on *fdatasync(). i_atime is the usual cause. * I_DIRTY_DATASYNCData-related inode changes pending. We keep track of *these changes separately from I_DIRTY_SYNC so that we *don't have to write inode on fdatasync() when only *mtime has changed in it. * I_DIRTY_PAGESInode has dirty pages. Inode itself may be clean. * I_NEWServes as both a mutex and completion notification. *New inodes set I_NEW. If two processes both create *the same inode, one of them will release its inode and *wait for I_NEW to be released before returning. *Inodes in I_WILL_FREE, I_FREEING or I_CLEAR state can *also cause waiting on I_NEW, without I_NEW actually *being set. find_inode() uses this to prevent returning *nearly-dead inodes. * I_WILL_FREEMust be set when calling write_inode_now() if i_count *is zero. I_FREEING must be set when I_WILL_FREE is *cleared. * I_FREEINGSet when inode is about to be freed but still has dirty *pages or buffers attached or the inode itself is still *dirty. * I_CLEARSet by clear_inode(). In this state the inode is clean *and can be destroyed. * *Inodes that are I_WILL_FREE, I_FREEING or I_CLEAR are *prohibited for many purposes. iget() must wait for *the inode to be completely released, then create it *anew. Other functions will just ignore such inodes, *if appropriate. I_NEW is used for waiting. * * I_SYNCSynchonized write of dirty inode data. The bits is *set during data writeback, and cleared with a wakeup *on the bit address once it is done. * * Q: What is the difference between I_WILL_FREE and I_FREEING? */#define I_DIRTY_SYNC1#define I_DIRTY_DATASYNC2#define I_DIRTY_PAGES4#define __I_NEW3#define I_NEW(1 << __I_NEW)#define I_WILL_FREE16#define I_FREEING32#define I_CLEAR64#define __I_SYNC7#define I_SYNC(1 << __I_SYNC)#define I_DIRTY (I_DIRTY_SYNC | I_DIRTY_DATASYNC | I_DIRTY_PAGES)extern void __mark_inode_dirty(struct inode *, int);static inline void mark_inode_dirty(struct inode *inode){__mark_inode_dirty(inode, I_DIRTY);}static inline void mark_inode_dirty_sync(struct inode *inode){__mark_inode_dirty(inode, I_DIRTY_SYNC);}/** * inc_nlink - directly increment an inode's link count * @inode: inode * * This is a low-level filesystem helper to replace any * direct filesystem manipulation of i_nlink. Currently, * it is only here for parity with dec_nlink(). */static inline void inc_nlink(struct inode *inode){inode->i_nlink++;}static inline void inode_inc_link_count(struct inode *inode){inc_nlink(inode);mark_inode_dirty(inode);}/** * drop_nlink - directly drop an inode's link count * @inode: inode * * This is a low-level filesystem helper to replace any * direct filesystem manipulation of i_nlink. In cases * where we are attempting to track writes to the * filesystem, a decrement to zero means an imminent * write when the file is truncated and actually unlinked * on the filesystem. */static inline void drop_nlink(struct inode *inode){inode->i_nlink--;}/** * clear_nlink - directly zero an inode's link count * @inode: inode * * This is a low-level filesystem helper to replace any * direct filesystem manipulation of i_nlink. See * drop_nlink() for why we care about i_nlink hitting zero. */static inline void clear_nlink(struct inode *inode){inode->i_nlink = 0;}static inline void inode_dec_link_count(struct inode *inode){drop_nlink(inode);mark_inode_dirty(inode);}/** * inode_inc_iversion - increments i_version * @inode: inode that need to be updated * * Every time the inode is modified, the i_version field will be incremented. * The filesystem has to be mounted with i_version flag */static inline void inode_inc_iversion(struct inode *inode){ spin_lock(&inode->i_lock); inode->i_version++; spin_unlock(&inode->i_lock);}extern void touch_atime(struct vfsmount *mnt, struct dentry *dentry);static inline void file_accessed(struct file *file){if (!(file->f_flags & O_NOATIME))touch_atime(file->f_path.mnt, file->f_path.dentry);}int sync_inode(struct inode *inode, struct writeback_control *wbc);struct file_system_type {const char *name;int fs_flags;int (*get_sb) (struct file_system_type *, int, const char *, void *, struct vfsmount *);void (*kill_sb) (struct super_block *);struct module *owner;struct file_system_type * next;struct list_head fs_supers;struct lock_class_key s_lock_key;struct lock_class_key s_umount_key;struct lock_class_key i_lock_key;struct lock_class_key i_mutex_key;struct lock_class_key i_mutex_dir_key;struct lock_class_key i_alloc_sem_key;};extern int get_sb_ns(struct file_system_type *fs_type, int flags, void *data,int (*fill_super)(struct super_block *, void *, int),struct vfsmount *mnt);extern int get_sb_bdev(struct file_system_type *fs_type,int flags, const char *dev_name, void *data,int (*fill_super)(struct super_block *, void *, int),struct vfsmount *mnt);extern int get_sb_single(struct file_system_type *fs_type,int flags, void *data,int (*fill_super)(struct super_block *, void *, int),struct vfsmount *mnt);extern int get_sb_nodev(struct file_system_type *fs_type,int flags, void *data,int (*fill_super)(struct super_block *, void *, int),struct vfsmount *mnt);void generic_shutdown_super(struct super_block *sb);void kill_block_super(struct super_block *sb);void kill_anon_super(struct super_block *sb);void kill_litter_super(struct super_block *sb);void deactivate_super(struct super_block *sb);void deactivate_locked_super(struct super_block *sb);int set_anon_super(struct super_block *s, void *data);struct super_block *sget(struct file_system_type *type,int (*test)(struct super_block *,void *),int (*set)(struct super_block *,void *),void *data);extern int get_sb_pseudo(struct file_system_type *, char *,const struct super_operations *ops, unsigned long,struct vfsmount *mnt);extern void simple_set_mnt(struct vfsmount *mnt, struct super_block *sb);int __put_super_and_need_restart(struct super_block *sb);void put_super(struct super_block *sb);/* Alas, no aliases. Too much hassle with bringing module.h everywhere */#define fops_get(fops) \(((fops) && try_module_get((fops)->owner) ? (fops) : NULL))#define fops_put(fops) \do { if (fops) module_put((fops)->owner); } while(0)extern int register_filesystem(struct file_system_type *);extern int unregister_filesystem(struct file_system_type *);extern struct vfsmount *kern_mount_data(struct file_system_type *, void *data);#define kern_mount(type) kern_mount_data(type, NULL)extern int may_umount_tree(struct vfsmount *);extern int may_umount(struct vfsmount *);extern long do_mount(char *, char *, char *, unsigned long, void *);extern struct vfsmount *collect_mounts(struct path *);extern void drop_collected_mounts(struct vfsmount *);extern int vfs_statfs(struct dentry *, struct kstatfs *);extern int current_umask(void);/* /sys/fs */extern struct kobject *fs_kobj;extern int rw_verify_area(int, struct file *, loff_t *, size_t);#define FLOCK_VERIFY_READ 1#define FLOCK_VERIFY_WRITE 2#ifdef CONFIG_FILE_LOCKINGextern int locks_mandatory_locked(struct inode *);extern int locks_mandatory_area(int, struct inode *, struct file *, loff_t, size_t);/* * Candidates for mandatory locking have the setgid bit set * but no group execute bit - an otherwise meaningless combination. */static inline int __mandatory_lock(struct inode *ino){return (ino->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID;}/* * ... and these candidates should be on MS_MANDLOCK mounted fs, * otherwise these will be advisory locks */static inline int mandatory_lock(struct inode *ino){return IS_MANDLOCK(ino) && __mandatory_lock(ino);}static inline int locks_verify_locked(struct inode *inode){if (mandatory_lock(inode))return locks_mandatory_locked(inode);return 0;}static inline int locks_verify_truncate(struct inode *inode, struct file *filp, loff_t size){if (inode->i_flock && mandatory_lock(inode))return locks_mandatory_area(FLOCK_VERIFY_WRITE, inode, filp,size < inode->i_size ? size : inode->i_size,(size < inode->i_size ? inode->i_size - size : size - inode->i_size));return 0;}static inline int break_lease(struct inode *inode, unsigned int mode){if (inode->i_flock)return __break_lease(inode, mode);return 0;}#else /* !CONFIG_FILE_LOCKING */static inline int locks_mandatory_locked(struct inode *inode){return 0;}static inline int locks_mandatory_area(int rw, struct inode *inode, struct file *filp, loff_t offset, size_t count){return 0;}static inline int __mandatory_lock(struct inode *inode){return 0;}static inline int mandatory_lock(struct inode *inode){return 0;}static inline int locks_verify_locked(struct inode *inode){return 0;}static inline int locks_verify_truncate(struct inode *inode, struct file *filp,size_t size){return 0;}static inline int break_lease(struct inode *inode, unsigned int mode){return 0;}#endif /* CONFIG_FILE_LOCKING *//* fs/open.c */extern int do_truncate(struct dentry *, loff_t start, unsigned int time_attrs, struct file *filp);extern int do_fallocate(struct file *file, int mode, loff_t offset,loff_t len);extern long do_sys_open(int dfd, const char __user *filename, int flags,int mode);extern struct file *filp_open(const char *, int, int);extern struct file * dentry_open(struct dentry *, struct vfsmount *, int, const struct cred *);extern int filp_close(struct file *, fl_owner_t id);extern char * getname(const char __user *);/* fs/ioctl.c */extern int ioctl_preallocate(struct file *filp, void __user *argp);/* fs/dcache.c */extern void __init vfs_caches_init_early(void);extern void __init vfs_caches_init(unsigned long);extern struct kmem_cache *names_cachep;#define __getname_gfp(gfp)kmem_cache_alloc(names_cachep, (gfp))#define __getname()__getname_gfp(GFP_KERNEL)#define __putname(name)kmem_cache_free(names_cachep, (void *)(name))#ifndef CONFIG_AUDITSYSCALL#define putname(name) __putname(name)#elseextern void putname(const char *name);#endif#ifdef CONFIG_BLOCKextern int register_blkdev(unsigned int, const char *);extern void unregister_blkdev(unsigned int, const char *);extern struct block_device *bdget(dev_t);extern struct block_device *bdgrab(struct block_device *bdev);extern void bd_set_size(struct block_device *, loff_t size);extern void bd_forget(struct inode *inode);extern void bdput(struct block_device *);extern struct block_device *open_by_devnum(dev_t, fmode_t);extern void invalidate_bdev(struct block_device *);extern int sync_blockdev(struct block_device *bdev);extern struct super_block *freeze_bdev(struct block_device *);extern void emergency_thaw_all(void);extern int thaw_bdev(struct block_device *bdev, struct super_block *sb);extern int fsync_bdev(struct block_device *);#elsestatic inline void bd_forget(struct inode *inode) {}static inline int sync_blockdev(struct block_device *bdev) { return 0; }static inline void invalidate_bdev(struct block_device *bdev) {}static inline struct super_block *freeze_bdev(struct block_device *sb){return NULL;}static inline int thaw_bdev(struct block_device *bdev, struct super_block *sb){return 0;}#endifextern int sync_filesystem(struct super_block *);extern const struct file_operations def_blk_fops;extern const struct file_operations def_chr_fops;extern const struct file_operations bad_sock_fops;extern const struct file_operations def_fifo_fops;#ifdef CONFIG_BLOCKextern int ioctl_by_bdev(struct block_device *, unsigned, unsigned long);extern int blkdev_ioctl(struct block_device *, fmode_t, unsigned, unsigned long);extern long compat_blkdev_ioctl(struct file *, unsigned, unsigned long);extern int blkdev_get(struct block_device *, fmode_t);extern int blkdev_put(struct block_device *, fmode_t);extern int bd_claim(struct block_device *, void *);extern void bd_release(struct block_device *);#ifdef CONFIG_SYSFSextern int bd_claim_by_disk(struct block_device *, void *, struct gendisk *);extern void bd_release_from_disk(struct block_device *, struct gendisk *);#else#define bd_claim_by_disk(bdev, holder, disk)bd_claim(bdev, holder)#define bd_release_from_disk(bdev, disk)bd_release(bdev)#endif#endif/* fs/char_dev.c */#define CHRDEV_MAJOR_HASH_SIZE255extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);extern int register_chrdev_region(dev_t, unsigned, const char *);extern int __register_chrdev(unsigned int major, unsigned int baseminor, unsigned int count, const char *name, const struct file_operations *fops);extern void __unregister_chrdev(unsigned int major, unsigned int baseminor,unsigned int count, const char *name);extern void unregister_chrdev_region(dev_t, unsigned);extern void chrdev_show(struct seq_file *,off_t);static inline int register_chrdev(unsigned int major, const char *name, const struct file_operations *fops){return __register_chrdev(major, 0, 256, name, fops);}static inline void unregister_chrdev(unsigned int major, const char *name){__unregister_chrdev(major, 0, 256, name);}/* fs/block_dev.c */#define BDEVNAME_SIZE32/* Largest string for a blockdev identifier */#define BDEVT_SIZE10/* Largest string for MAJ:MIN for blkdev */#ifdef CONFIG_BLOCK#define BLKDEV_MAJOR_HASH_SIZE255extern const char *__bdevname(dev_t, char *buffer);extern const char *bdevname(struct block_device *bdev, char *buffer);extern struct block_device *lookup_bdev(const char *);extern struct block_device *open_bdev_exclusive(const char *, fmode_t, void *);extern void close_bdev_exclusive(struct block_device *, fmode_t);extern void blkdev_show(struct seq_file *,off_t);#else#define BLKDEV_MAJOR_HASH_SIZE0#endifextern void init_special_inode(struct inode *, umode_t, dev_t);/* Invalid inode operations -- fs/bad_inode.c */extern void make_bad_inode(struct inode *);extern int is_bad_inode(struct inode *);extern const struct file_operations read_pipefifo_fops;extern const struct file_operations write_pipefifo_fops;extern const struct file_operations rdwr_pipefifo_fops;extern int fs_may_remount_ro(struct super_block *);#ifdef CONFIG_BLOCK/* * return READ, READA, or WRITE */#define bio_rw(bio)((bio)->bi_rw & (RW_MASK | RWA_MASK))/* * return data direction, READ or WRITE */#define bio_data_dir(bio)((bio)->bi_rw & 1)extern void check_disk_size_change(struct gendisk *disk, struct block_device *bdev);extern int revalidate_disk(struct gendisk *);extern int check_disk_change(struct block_device *);extern int __invalidate_device(struct block_device *);extern int invalidate_partition(struct gendisk *, int);#endifextern int invalidate_inodes(struct super_block *);unsigned long invalidate_mapping_pages(struct address_space *mapping,pgoff_t start, pgoff_t end);static inline unsigned long __deprecatedinvalidate_inode_pages(struct address_space *mapping){return invalidate_mapping_pages(mapping, 0, ~0UL);}static inline void invalidate_remote_inode(struct inode *inode){if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))invalidate_mapping_pages(inode->i_mapping, 0, -1);}extern int invalidate_inode_pages2(struct address_space *mapping);extern int invalidate_inode_pages2_range(struct address_space *mapping, pgoff_t start, pgoff_t end);extern int write_inode_now(struct inode *, int);extern int filemap_fdatawrite(struct address_space *);extern int filemap_flush(struct address_space *);extern int filemap_fdatawait(struct address_space *);extern int filemap_fdatawait_range(struct address_space *, loff_t lstart, loff_t lend);extern int filemap_write_and_wait(struct address_space *mapping);extern int filemap_write_and_wait_range(struct address_space *mapping, loff_t lstart, loff_t lend);extern int __filemap_fdatawrite_range(struct address_space *mapping,loff_t start, loff_t end, int sync_mode);extern int filemap_fdatawrite_range(struct address_space *mapping,loff_t start, loff_t end);extern int vfs_fsync_range(struct file *file, struct dentry *dentry, loff_t start, loff_t end, int datasync);extern int vfs_fsync(struct file *file, struct dentry *dentry, int datasync);extern int generic_write_sync(struct file *file, loff_t pos, loff_t count);extern void sync_supers(void);extern void emergency_sync(void);extern void emergency_remount(void);#ifdef CONFIG_BLOCKextern sector_t bmap(struct inode *, sector_t);#endifextern int notify_change(struct dentry *, struct iattr *);extern int inode_permission(struct inode *, int);extern int generic_permission(struct inode *, int,int (*check_acl)(struct inode *, int));static inline bool execute_ok(struct inode *inode){return (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode);}extern int get_write_access(struct inode *);extern int deny_write_access(struct file *);static inline void put_write_access(struct inode * inode){atomic_dec(&inode->i_writecount);}static inline void allow_write_access(struct file *file){if (file)atomic_inc(&file->f_path.dentry->d_inode->i_writecount);}extern int do_pipe_flags(int *, int);extern struct file *create_read_pipe(struct file *f, int flags);extern struct file *create_write_pipe(int flags);extern void free_write_pipe(struct file *);extern struct file *do_filp_open(int dfd, const char *pathname,int open_flag, int mode, int acc_mode);extern int may_open(struct path *, int, int);extern int kernel_read(struct file *, loff_t, char *, unsigned long);extern struct file * open_exec(const char *); /* fs/dcache.c -- generic fs support functions */extern int is_subdir(struct dentry *, struct dentry *);extern ino_t find_inode_number(struct dentry *, struct qstr *);#include <linux/err.h>/* needed for stackable file system support */extern loff_t default_llseek(struct file *file, loff_t offset, int origin);extern loff_t vfs_llseek(struct file *file, loff_t offset, int origin);extern int inode_init_always(struct super_block *, struct inode *);extern void inode_init_once(struct inode *);extern void inode_add_to_lists(struct super_block *, struct inode *);extern void iput(struct inode *);extern struct inode * igrab(struct inode *);extern ino_t iunique(struct super_block *, ino_t);extern int inode_needs_sync(struct inode *inode);extern void generic_delete_inode(struct inode *inode);extern void generic_drop_inode(struct inode *inode);extern int generic_detach_inode(struct inode *inode);extern struct inode *ilookup5_nowait(struct super_block *sb,unsigned long hashval, int (*test)(struct inode *, void *),void *data);extern struct inode *ilookup5(struct super_block *sb, unsigned long hashval,int (*test)(struct inode *, void *), void *data);extern struct inode *ilookup(struct super_block *sb, unsigned long ino);extern struct inode * iget5_locked(struct super_block *, unsigned long, int (*test)(struct inode *, void *), int (*set)(struct inode *, void *), void *);extern struct inode * iget_locked(struct super_block *, unsigned long);extern int insert_inode_locked4(struct inode *, unsigned long, int (*test)(struct inode *, void *), void *);extern int insert_inode_locked(struct inode *);extern void unlock_new_inode(struct inode *);extern void __iget(struct inode * inode);extern void iget_failed(struct inode *);extern void clear_inode(struct inode *);extern void destroy_inode(struct inode *);extern void __destroy_inode(struct inode *);extern struct inode *new_inode(struct super_block *);extern int should_remove_suid(struct dentry *);extern int file_remove_suid(struct file *);extern void __insert_inode_hash(struct inode *, unsigned long hashval);extern void remove_inode_hash(struct inode *);static inline void insert_inode_hash(struct inode *inode) {__insert_inode_hash(inode, inode->i_ino);}extern void file_move(struct file *f, struct list_head *list);extern void file_kill(struct file *f);#ifdef CONFIG_BLOCKstruct bio;extern void submit_bio(int, struct bio *);extern int bdev_read_only(struct block_device *);#endifextern int set_blocksize(struct block_device *, int);extern int sb_set_blocksize(struct super_block *, int);extern int sb_min_blocksize(struct super_block *, int);extern int generic_file_mmap(struct file *, struct vm_area_struct *);extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *);extern int file_read_actor(read_descriptor_t * desc, struct page *page, unsigned long offset, unsigned long size);int generic_write_checks(struct file *file, loff_t *pos, size_t *count, int isblk);extern ssize_t generic_file_aio_read(struct kiocb *, const struct iovec *, unsigned long, loff_t);extern ssize_t __generic_file_aio_write(struct kiocb *, const struct iovec *, unsigned long,loff_t *);extern ssize_t generic_file_aio_write(struct kiocb *, const struct iovec *, unsigned long, loff_t);extern ssize_t generic_file_direct_write(struct kiocb *, const struct iovec *,unsigned long *, loff_t, loff_t *, size_t, size_t);extern ssize_t generic_file_buffered_write(struct kiocb *, const struct iovec *,unsigned long, loff_t, loff_t *, size_t, ssize_t);extern ssize_t do_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos);extern ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos);extern int generic_segment_checks(const struct iovec *iov,unsigned long *nr_segs, size_t *count, int access_flags);/* fs/block_dev.c */extern ssize_t blkdev_aio_write(struct kiocb *iocb, const struct iovec *iov,unsigned long nr_segs, loff_t pos);extern int block_fsync(struct file *filp, struct dentry *dentry, int datasync);/* fs/splice.c */extern ssize_t generic_file_splice_read(struct file *, loff_t *,struct pipe_inode_info *, size_t, unsigned int);extern ssize_t default_file_splice_read(struct file *, loff_t *,struct pipe_inode_info *, size_t, unsigned int);extern ssize_t generic_file_splice_write(struct pipe_inode_info *,struct file *, loff_t *, size_t, unsigned int);extern ssize_t generic_splice_sendpage(struct pipe_inode_info *pipe,struct file *out, loff_t *, size_t len, unsigned int flags);extern long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,size_t len, unsigned int flags);extern voidfile_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);extern loff_t no_llseek(struct file *file, loff_t offset, int origin);extern loff_t generic_file_llseek(struct file *file, loff_t offset, int origin);extern loff_t generic_file_llseek_unlocked(struct file *file, loff_t offset,int origin);extern int generic_file_open(struct inode * inode, struct file * filp);extern int nonseekable_open(struct inode * inode, struct file * filp);#ifdef CONFIG_FS_XIPextern ssize_t xip_file_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos);extern int xip_file_mmap(struct file * file, struct vm_area_struct * vma);extern ssize_t xip_file_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos);extern int xip_truncate_page(struct address_space *mapping, loff_t from);#elsestatic inline int xip_truncate_page(struct address_space *mapping, loff_t from){return 0;}#endif#ifdef CONFIG_BLOCKssize_t __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,struct block_device *bdev, const struct iovec *iov, loff_t offset,unsigned long nr_segs, get_block_t get_block, dio_iodone_t end_io,int lock_type);enum {/* need locking between buffered and direct access */DIO_LOCKING= 0x01,/* filesystem does not support filling holes */DIO_SKIP_HOLES= 0x02,};static inline ssize_t blockdev_direct_IO(int rw, struct kiocb *iocb,struct inode *inode, struct block_device *bdev, const struct iovec *iov,loff_t offset, unsigned long nr_segs, get_block_t get_block,dio_iodone_t end_io){return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset, nr_segs, get_block, end_io, DIO_LOCKING | DIO_SKIP_HOLES);}static inline ssize_t blockdev_direct_IO_no_locking(int rw, struct kiocb *iocb,struct inode *inode, struct block_device *bdev, const struct iovec *iov,loff_t offset, unsigned long nr_segs, get_block_t get_block,dio_iodone_t end_io){return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,nr_segs, get_block, end_io, 0);}#endifextern const struct file_operations generic_ro_fops;#define special_file(m) (S_ISCHR(m)||S_ISBLK(m)||S_ISFIFO(m)||S_ISSOCK(m))extern int vfs_readlink(struct dentry *, char __user *, int, const char *);extern int vfs_follow_link(struct nameidata *, const char *);extern int page_readlink(struct dentry *, char __user *, int);extern void *page_follow_link_light(struct dentry *, struct nameidata *);extern void page_put_link(struct dentry *, struct nameidata *, void *);extern int __page_symlink(struct inode *inode, const char *symname, int len,int nofs);extern int page_symlink(struct inode *inode, const char *symname, int len);extern const struct inode_operations page_symlink_inode_operations;extern int generic_readlink(struct dentry *, char __user *, int);extern void generic_fillattr(struct inode *, struct kstat *);extern int vfs_getattr(struct vfsmount *, struct dentry *, struct kstat *);void __inode_add_bytes(struct inode *inode, loff_t bytes);void inode_add_bytes(struct inode *inode, loff_t bytes);void inode_sub_bytes(struct inode *inode, loff_t bytes);loff_t inode_get_bytes(struct inode *inode);void inode_set_bytes(struct inode *inode, loff_t bytes);extern int vfs_readdir(struct file *, filldir_t, void *);extern int vfs_stat(char __user *, struct kstat *);extern int vfs_lstat(char __user *, struct kstat *);extern int vfs_fstat(unsigned int, struct kstat *);extern int vfs_fstatat(int , char __user *, struct kstat *, int);extern int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd, unsigned long arg);extern int __generic_block_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, u64 start, u64 len, get_block_t *get_block);extern int generic_block_fiemap(struct inode *inode,struct fiemap_extent_info *fieinfo, u64 start,u64 len, get_block_t *get_block);extern void get_filesystem(struct file_system_type *fs);extern void put_filesystem(struct file_system_type *fs);extern struct file_system_type *get_fs_type(const char *name);extern struct super_block *get_super(struct block_device *);extern struct super_block *get_active_super(struct block_device *bdev);extern struct super_block *user_get_super(dev_t);extern void drop_super(struct super_block *sb);extern int dcache_dir_open(struct inode *, struct file *);extern int dcache_dir_close(struct inode *, struct file *);extern loff_t dcache_dir_lseek(struct file *, loff_t, int);extern int dcache_readdir(struct file *, void *, filldir_t);extern int simple_getattr(struct vfsmount *, struct dentry *, struct kstat *);extern int simple_statfs(struct dentry *, struct kstatfs *);extern int simple_link(struct dentry *, struct inode *, struct dentry *);extern int simple_unlink(struct inode *, struct dentry *);extern int simple_rmdir(struct inode *, struct dentry *);extern int simple_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);extern int simple_sync_file(struct file *, struct dentry *, int);extern int simple_empty(struct dentry *);extern int simple_readpage(struct file *file, struct page *page);extern int simple_prepare_write(struct file *file, struct page *page,unsigned offset, unsigned to);extern int simple_write_begin(struct file *file, struct address_space *mapping,loff_t pos, unsigned len, unsigned flags,struct page **pagep, void **fsdata);extern int simple_write_end(struct file *file, struct address_space *mapping,loff_t pos, unsigned len, unsigned copied,struct page *page, void *fsdata);extern struct dentry *simple_lookup(struct inode *, struct dentry *, struct nameidata *);extern ssize_t generic_read_dir(struct file *, char __user *, size_t, loff_t *);extern const struct file_operations simple_dir_operations;extern const struct inode_operations simple_dir_inode_operations;struct tree_descr { char *name; const struct file_operations *ops; int mode; };struct dentry *d_alloc_name(struct dentry *, const char *);extern int simple_fill_super(struct super_block *, int, struct tree_descr *);extern int simple_pin_fs(struct file_system_type *, struct vfsmount **mount, int *count);extern void simple_release_fs(struct vfsmount **mount, int *count);extern ssize_t simple_read_from_buffer(void __user *to, size_t count,loff_t *ppos, const void *from, size_t available);extern int simple_fsync(struct file *, struct dentry *, int);#ifdef CONFIG_MIGRATIONextern int buffer_migrate_page(struct address_space *,struct page *, struct page *);#else#define buffer_migrate_page NULL#endifextern int inode_change_ok(const struct inode *, struct iattr *);extern int inode_newsize_ok(const struct inode *, loff_t offset);extern int __must_check inode_setattr(struct inode *, struct iattr *);extern void file_update_time(struct file *file);extern int generic_show_options(struct seq_file *m, struct vfsmount *mnt);extern void save_mount_options(struct super_block *sb, char *options);extern void replace_mount_options(struct super_block *sb, char *options);static inline ino_t parent_ino(struct dentry *dentry){ino_t res;spin_lock(&dentry->d_lock);res = dentry->d_parent->d_inode->i_ino;spin_unlock(&dentry->d_lock);return res;}/* Transaction based IO helpers *//* * An argresp is stored in an allocated page and holds the * size of the argument or response, along with its content */struct simple_transaction_argresp {ssize_t size;char data[0];};#define SIMPLE_TRANSACTION_LIMIT (PAGE_SIZE - sizeof(struct simple_transaction_argresp))char *simple_transaction_get(struct file *file, const char __user *buf,size_t size);ssize_t simple_transaction_read(struct file *file, char __user *buf,size_t size, loff_t *pos);int simple_transaction_release(struct inode *inode, struct file *file);void simple_transaction_set(struct file *file, size_t n);/* * simple attribute files * * These attributes behave similar to those in sysfs: * * Writing to an attribute immediately sets a value, an open file can be * written to multiple times. * * Reading from an attribute creates a buffer from the value that might get * read with multiple read calls. When the attribute has been read * completely, no further read calls are possible until the file is opened * again. * * All attributes contain a text representation of a numeric value * that are accessed with the get() and set() functions. */#define DEFINE_SIMPLE_ATTRIBUTE(__fops, __get, __set, __fmt)\static int __fops ## _open(struct inode *inode, struct file *file)\{\__simple_attr_check_format(__fmt, 0ull);\return simple_attr_open(inode, file, __get, __set, __fmt);\}\static const struct file_operations __fops = {\.owner = THIS_MODULE,\.open = __fops ## _open,\.release = simple_attr_release,\.read = simple_attr_read,\.write = simple_attr_write,\};static inline void __attribute__((format(printf, 1, 2)))__simple_attr_check_format(const char *fmt, ...){/* don't do anything, just let the compiler check the arguments; */}int simple_attr_open(struct inode *inode, struct file *file, int (*get)(void *, u64 *), int (*set)(void *, u64), const char *fmt);int simple_attr_release(struct inode *inode, struct file *file);ssize_t simple_attr_read(struct file *file, char __user *buf, size_t len, loff_t *ppos);ssize_t simple_attr_write(struct file *file, const char __user *buf, size_t len, loff_t *ppos);struct ctl_table;int proc_nr_files(struct ctl_table *table, int write, void __user *buffer, size_t *lenp, loff_t *ppos);int __init get_filesystem_list(char *buf);#define ACC_MODE(x) ("\004\002\006\006"[(x)&O_ACCMODE])#define OPEN_FMODE(flag) ((__force fmode_t)((flag + 1) & O_ACCMODE))#endif /* __KERNEL__ */#endif /* _LINUX_FS_H */
