fs.h

基于组件方式开发操作系统的OSKIT源代码

}

extern inline int locks_verify_area(int read_write, struct inode *inode,
				    struct file *filp, loff_t offset,
				    size_t count)
{
#ifndef OSKIT
	/* Candidates for mandatory locking have the setgid bit set
	 * but no group execute bit -  an otherwise meaningless combination.
	 */
	if (IS_MANDLOCK(inode) &&
	    (inode->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID)
		return (locks_mandatory_area(read_write, inode, filp, offset,
					     count));
#endif
	return (0);
}

/* fs/open.c */

asmlinkage int sys_open(const char *, int, int);
asmlinkage int sys_close(unsigned int);		/* yes, it's really unsigned */
extern int do_truncate(struct dentry *, unsigned long);
extern int get_unused_fd(void);
extern void put_unused_fd(unsigned int);

extern struct file *filp_open(const char *, int, int);
extern int filp_close(struct file *, fl_owner_t id);

extern char * getname(const char * filename);
#define __getname()	((char *) __get_free_page(GFP_KERNEL))
#ifdef OSKIT_FS
#define putname(name)
#else
#define putname(name)	free_page((unsigned long)(name))
#endif

extern void kill_fasync(struct fasync_struct *fa, int sig);
extern int register_blkdev(unsigned int, const char *, struct file_operations *);
extern int unregister_blkdev(unsigned int major, const char * name);
extern int blkdev_open(struct inode * inode, struct file * filp);
extern int blkdev_release (struct inode * inode);
extern struct file_operations def_blk_fops;
extern struct inode_operations blkdev_inode_operations;

/* fs/devices.c */
extern int register_chrdev(unsigned int, const char *, struct file_operations *);
extern int unregister_chrdev(unsigned int major, const char * name);
extern int chrdev_open(struct inode * inode, struct file * filp);
extern struct file_operations def_chr_fops;
extern struct inode_operations chrdev_inode_operations;
extern char * bdevname(kdev_t dev);
extern char * cdevname(kdev_t dev);
extern char * kdevname(kdev_t dev);


#ifdef OSKIT_FS
/* No fifos in the OSKIT. */
#define init_fifo(i)
#else
extern void init_fifo(struct inode * inode);
#endif
extern struct inode_operations fifo_inode_operations;

/* Invalid inode operations -- fs/bad_inode.c */
extern void make_bad_inode(struct inode * inode);
extern int is_bad_inode(struct inode * inode);

extern struct file_operations connecting_fifo_fops;
extern struct file_operations read_fifo_fops;
extern struct file_operations write_fifo_fops;
extern struct file_operations rdwr_fifo_fops;
extern struct file_operations read_pipe_fops;
extern struct file_operations write_pipe_fops;
extern struct file_operations rdwr_pipe_fops;

extern struct file_system_type *get_fs_type(const char *name);

extern int fs_may_remount_ro(struct super_block *);
extern int fs_may_mount(kdev_t dev);

extern struct file *inuse_filps;

extern void refile_buffer(struct buffer_head * buf);
extern void set_writetime(struct buffer_head * buf, int flag);
extern int try_to_free_buffers(struct page *);
extern void cache_drop_behind(struct buffer_head *bh);

extern int nr_buffers;
extern int buffermem;
extern int nr_buffer_heads;

#define BUF_CLEAN	0
#define BUF_LOCKED	1	/* Buffers scheduled for write */
#define BUF_DIRTY	2	/* Dirty buffers, not yet scheduled for write */
#define NR_LIST		3

#ifdef OSKIT_DEV
/*
 * This is normally in fs/buffer.c but OSKIT_DEV doesn't need that
 * whole file and plus this enables inlining.
 */
extern inline void
mark_buffer_uptodate (struct buffer_head *bh, int on)
{
	if (on)
		set_bit (BH_Uptodate, &bh->b_state);
	else
		clear_bit (BH_Uptodate, &bh->b_state);
}
#else
void mark_buffer_uptodate(struct buffer_head * bh, int on);
#endif

extern inline void mark_buffer_clean(struct buffer_head * bh)
{
#ifdef OSKIT_DEV
	/* OSKIT_DEV doesn't have any buffer lists. */
	clear_bit(BH_Dirty, &bh->b_state);
#else
	if (test_and_clear_bit(BH_Dirty, &bh->b_state)) {
		if (bh->b_list == BUF_DIRTY)
			refile_buffer(bh);
	}
#endif
}

extern inline void mark_buffer_highprio(struct buffer_head * bh)
{
	clear_bit(BH_LowPrio, &bh->b_state);
}

extern inline void mark_buffer_lowprio(struct buffer_head * bh)
{
	/*
	 * dirty buffers cannot be marked lowprio.
	 */
	if (!buffer_dirty(bh))
		set_bit(BH_LowPrio, &bh->b_state);
}

static inline int buffer_lowprio(struct buffer_head * bh)
{
	return test_bit(BH_LowPrio, &bh->b_state);
}

extern inline void mark_buffer_dirty(struct buffer_head * bh, int flag)
{
#ifdef OSKIT_DEV
	/* OSKIT_DEV doesn't have any buffer lists. */
	set_bit(BH_Dirty, &bh->b_state);
#else
	if (!test_and_set_bit(BH_Dirty, &bh->b_state)) {
		set_writetime(bh, flag);
		if (bh->b_list != BUF_DIRTY)
			refile_buffer(bh);
	}
	/*
	 * if a buffer gets marked dirty then it has to lose
	 * it's lowprio state.
	 */
	mark_buffer_highprio(bh);
#endif
}

extern inline void mark_buffer_dirty_lowprio(struct buffer_head * bh)
{
	if (!test_and_set_bit(BH_Dirty, &bh->b_state)) {
		if (bh->b_list != BUF_DIRTY)
			refile_buffer(bh);
		/*
		 * Mark it lowprio only if it was not dirty before!
		 */
		set_bit(BH_LowPrio, &bh->b_state);
	}
}

#ifdef OSKIT_FS
/* We have no way of knowing this, so we say "no". */
#define check_disk_change(d) 0
#else
extern int check_disk_change(kdev_t dev);
#endif
#ifdef OSKIT_DEV
/* OSKIT_DEV has no buffer cache stuff. */
#define invalidate_inodes(dev)
#define invalidate_inode_pages(inode)
#define invalidate_buffers(dev)
#else
extern int invalidate_inodes(struct super_block * sb);
extern void invalidate_inode_pages(struct inode *);
extern void invalidate_buffers(kdev_t dev);
#endif
extern int floppy_is_wp(int minor);
extern void sync_inodes(kdev_t dev);
extern void write_inode_now(struct inode *inode);
#ifdef OSKIT_DEV
/* OSKIT_DEV has no buffer cache stuff. */
#define sync_dev(dev) 
#define fsync_dev(dev) 
#else
extern void sync_dev(kdev_t dev);
extern int fsync_dev(kdev_t dev);
#endif
extern void sync_supers(kdev_t dev);
extern int bmap(struct inode * inode,int block);
extern int notify_change(struct dentry *, struct iattr *);
#ifdef OSKIT_DEV
/* OSKIT_DEV has no uid-type concept. */
#define permission(i,m) 0
#else
extern int permission(struct inode * inode,int mask);
#endif
extern int get_write_access(struct inode *inode);
extern void put_write_access(struct inode *inode);
extern struct dentry * open_namei(const char * pathname, int flag, int mode);
extern struct dentry * do_mknod(const char * filename, int mode, dev_t dev);
extern int do_pipe(int *);

#ifdef OSKIT_FS
/* These do_foo functions are normally static but we've undone that
   so we can use them. */
extern int do_mkdir(const char * pathname, int mode);
extern int do_rmdir(const char * name);
extern int do_unlink(const char * name);
extern int do_symlink(const char * oldname, const char * newname);
extern int do_link(struct dentry * dentry, const char * newname);
extern int do_rename(const char * oldname, const char * newname);
#endif /* OSKIT_FS */

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

/*
 * Kernel pointers have redundant information, so we can use a
 * scheme where we can return either an error code or a dentry
 * pointer with the same return value.
 *
 * This should be a per-architecture thing, to allow different
 * error and pointer decisions.
 */
#define ERR_PTR(err)	((void *)((long)(err)))
#define PTR_ERR(ptr)	((long)(ptr))
#define IS_ERR(ptr)	((unsigned long)(ptr) > (unsigned long)(-1000))

/*
 * The bitmask for a lookup event:
 *  - follow links at the end
 *  - require a directory
 *  - ending slashes ok even for nonexistent files
 *  - internal "there are more path compnents" flag
 */
#define LOOKUP_FOLLOW		(1)
#define LOOKUP_DIRECTORY	(2)
#define LOOKUP_SLASHOK		(4)
#define LOOKUP_CONTINUE		(8)

extern struct dentry * lookup_dentry(const char *, struct dentry *, unsigned int);
extern struct dentry * __namei(const char *, unsigned int);

#define namei(pathname)		__namei(pathname, 1)
#define lnamei(pathname)	__namei(pathname, 0)

extern void iput(struct inode *);
extern struct inode * igrab(struct inode *inode);
extern ino_t iunique(struct super_block *, ino_t);
extern struct inode * iget(struct super_block *, unsigned long);
extern void clear_inode(struct inode *);
extern struct inode * get_empty_inode(void);

extern void insert_inode_hash(struct inode *);
extern void remove_inode_hash(struct inode *);
extern struct file * get_empty_filp(void);
extern struct buffer_head * get_hash_table(kdev_t, int, int);
extern struct buffer_head * getblk(kdev_t, int, int);
extern struct buffer_head * find_buffer(kdev_t dev, int block, int size);
extern void ll_rw_block(int, int, struct buffer_head * bh[]);
extern int is_read_only(kdev_t);
extern int is_device_idle(kdev_t);
extern void __brelse(struct buffer_head *);
extern inline void brelse(struct buffer_head *buf)
{
	if (buf)
		__brelse(buf);
}
extern void __bforget(struct buffer_head *buf);
extern inline void bforget(struct buffer_head *buf)
{
	if (buf)
		__bforget(buf);
}
#ifdef OSKIT_DEV
/* OSKIT_DEV does not need to worry about superblocks */
#define set_blocksize(dev, size)
#else
extern void set_blocksize(kdev_t dev, int size);
#endif
extern unsigned int get_hardblocksize(kdev_t dev);
extern struct buffer_head * bread(kdev_t dev, int block, int size);
extern struct buffer_head * buffer_ready (kdev_t dev, int block, int size);
extern void bread_ahead (kdev_t dev, int block, int size);
extern struct buffer_head * breada(kdev_t dev,int block, int size, 
				   unsigned int pos, unsigned int filesize);
extern struct buffer_head * breada_blocks(kdev_t dev,int block,
						int size, int blocks);

extern int brw_page(int, struct page *, kdev_t, int [], int, int);

extern int generic_readpage(struct file *, struct page *);
#ifdef OSKIT_FS
/* generic_file_mmap is used in vtables but we make it NULL so it isn't
   ever referenced. */
#define generic_file_mmap NULL
#else
extern int generic_file_mmap(struct file *, struct vm_area_struct *);
#endif
extern ssize_t generic_file_read(struct file *, char *, size_t, loff_t *);
extern ssize_t generic_file_write(struct file *, const char*, size_t, loff_t*);

#ifdef OSKIT_DEV
/* OSKIT_DEV does not need to worry about superblocks */
#define get_super(dev) ((struct super_block *) 0)
#else
extern struct super_block *get_super(kdev_t dev);
#endif
extern void put_super(kdev_t dev);
unsigned long generate_cluster(kdev_t dev, int b[], int size);
unsigned long generate_cluster_swab32(kdev_t dev, int b[], int size);
extern kdev_t ROOT_DEV;

extern void show_buffers(void);
#ifdef OSKIT_FS
/* We use a slightly modified mount_root. */
extern int mount_root(kdev_t, int, struct super_block **);
#else
extern void mount_root(void);
#endif /* OSKIT_FS */

#ifdef CONFIG_BLK_DEV_INITRD
extern kdev_t real_root_dev;
extern int change_root(kdev_t new_root_dev,const char *put_old);
#endif

extern ssize_t char_read(struct file *, char *, size_t, loff_t *);
extern ssize_t block_read(struct file *, char *, size_t, loff_t *);
extern int read_ahead[];

extern ssize_t char_write(struct file *, const char *, size_t, loff_t *);
extern ssize_t block_write(struct file *, const char *, size_t, loff_t *);

extern int block_fsync(struct file *, struct dentry *dir);
extern int file_fsync(struct file *, struct dentry *dir);

extern int inode_change_ok(struct inode *, struct iattr *);
extern void inode_setattr(struct inode *, struct iattr *);

extern __u32 inode_generation_count;

#endif /* __KERNEL__ */

#endif