* changes by Thomas Schoebel-Theuer
*/
+#include <linux/module.h>
#include <linux/time.h>
#include <linux/mm.h>
#include <linux/string.h>
return retval;
}
+EXPORT_SYMBOL(inode_change_ok);
+
int inode_setattr(struct inode * inode, struct iattr * attr)
{
unsigned int ia_valid = attr->ia_valid;
return error;
}
+EXPORT_SYMBOL(inode_setattr);
+
int setattr_mask(unsigned int ia_valid)
{
unsigned long dn_mask = 0;
}
return error;
}
+
+EXPORT_SYMBOL(notify_change);
*/
#include <linux/fs.h>
+#include <linux/module.h>
#include <linux/stat.h>
#include <linux/time.h>
#include <linux/smp_lock.h>
inode->i_op = &bad_inode_ops;
inode->i_fop = &bad_file_ops;
}
+EXPORT_SYMBOL(make_bad_inode);
/*
* This tests whether an inode has been flagged as bad. The test uses
{
return (inode->i_op == &bad_inode_ops);
}
+
+EXPORT_SYMBOL(is_bad_inode);
*/
#include <linux/kernel.h>
+#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/mm.h>
out:
return retval;
}
+
+EXPORT_SYMBOL(blockdev_direct_IO);
* General Public License for more details.
*/
#include <linux/fs.h>
+#include <linux/module.h>
#include <linux/sched.h>
#include <linux/dnotify.h>
#include <linux/init.h>
write_unlock(&dn_lock);
}
+EXPORT_SYMBOL(__inode_dir_notify);
+
/*
* This is hopelessly wrong, but unfixable without API changes. At
* least it doesn't oops the kernel...
return 0;
}
+EXPORT_SYMBOL(f_setown);
+
void f_delown(struct file *filp)
{
f_modown(filp, 0, 0, 0, 1);
}
+EXPORT_SYMBOL(f_delown);
+
static long do_fcntl(unsigned int fd, unsigned int cmd,
unsigned long arg, struct file * filp)
{
return result;
}
+EXPORT_SYMBOL(fasync_helper);
+
void __kill_fasync(struct fasync_struct *fa, int sig, int band)
{
while (fa) {
}
}
+EXPORT_SYMBOL(__kill_fasync);
+
void kill_fasync(struct fasync_struct **fp, int sig, int band)
{
read_lock(&fasync_lock);
read_unlock(&fasync_lock);
}
+EXPORT_SYMBOL(kill_fasync);
+
static int __init fasync_init(void)
{
fasync_cache = kmem_cache_create("fasync_cache",
}
module_init(fasync_init)
-
-EXPORT_SYMBOL(f_setown);
-EXPORT_SYMBOL(f_delown);
-#ifdef CONFIG_NET
-EXPORT_SYMBOL(__kill_fasync);
-#endif
.max_files = NR_FILE
};
+EXPORT_SYMBOL(files_stat); /* Needed by unix.o */
+
/* public *and* exported. Not pretty! */
spinlock_t __cacheline_aligned_in_smp files_lock = SPIN_LOCK_UNLOCKED;
+EXPORT_SYMBOL(files_lock);
+
static spinlock_t filp_count_lock = SPIN_LOCK_UNLOCKED;
/* slab constructors and destructors are called from arbitrary
return NULL;
}
+EXPORT_SYMBOL(get_empty_filp);
+
/*
* Clear and initialize a (private) struct file for the given dentry,
* allocate the security structure, and call the open function (if any).
return error;
}
+EXPORT_SYMBOL(open_private_file);
+
/*
* Release a private file by calling the release function (if any) and
* freeing the security structure.
security_file_free(file);
}
+EXPORT_SYMBOL(close_private_file);
+
void fput(struct file *file)
{
if (atomic_dec_and_test(&file->f_count))
__fput(file);
}
+EXPORT_SYMBOL(fput);
+
/* __fput is called from task context when aio completion releases the last
* last use of a struct file *. Do not use otherwise.
*/
return file;
}
+EXPORT_SYMBOL(fget);
+
/*
* Lightweight file lookup - no refcnt increment if fd table isn't shared.
* You can use this only if it is guranteed that the current task already
}
}
+EXPORT_SYMBOL(put_filp);
+
void file_move(struct file *file, struct list_head *list)
{
if (!list)
if (files_stat.max_files < NR_FILE)
files_stat.max_files = NR_FILE;
}
-
-/* Needed by unix.o */
-EXPORT_SYMBOL(files_stat);
return res;
}
+EXPORT_SYMBOL(register_filesystem);
+
/**
* unregister_filesystem - unregister a file system
* @fs: filesystem to unregister
return -EINVAL;
}
+EXPORT_SYMBOL(unregister_filesystem);
+
static int fs_index(const char __user * __name)
{
struct file_system_type * tmp;
}
return fs;
}
+
+EXPORT_SYMBOL(get_fs_type);
spin_unlock(&inode_lock);
}
+EXPORT_SYMBOL(__mark_inode_dirty);
+
static void write_inode(struct inode *inode, int sync)
{
if (inode->i_sb->s_op->write_inode && !is_bad_inode(inode))
wait_on_inode(inode);
}
+EXPORT_SYMBOL(write_inode_now);
+
/**
* generic_osync_inode - flush all dirty data for a given inode to disk
* @inode: inode to write
return err;
}
+EXPORT_SYMBOL(generic_osync_inode);
+
/**
* writeback_acquire: attempt to get exclusive writeback access to a device
* @bdi: the device's backing_dev_info structure
for (lockp = &inode->i_flock; *lockp != NULL; lockp = &(*lockp)->fl_next)
LIST_HEAD(file_lock_list);
+
+EXPORT_SYMBOL(file_lock_list);
+
static LIST_HEAD(blocked_list);
static kmem_cache_t *filelock_cache;
fl->fl_remove = NULL;
}
+EXPORT_SYMBOL(locks_init_lock);
+
/*
* Initialises the fields of the file lock which are invariant for
* free file_locks.
new->fl_u = fl->fl_u;
}
+EXPORT_SYMBOL(locks_copy_lock);
+
static inline int flock_translate_cmd(int cmd) {
if (cmd & LOCK_MAND)
return cmd & (LOCK_MAND | LOCK_RW);
return (cfl);
}
+EXPORT_SYMBOL(posix_test_lock);
+
/* This function tests for deadlock condition before putting a process to
* sleep. The detection scheme is no longer recursive. Recursive was neat,
* but dangerous - we risked stack corruption if the lock data was bad, or
return 0;
}
+EXPORT_SYMBOL(posix_locks_deadlock);
+
/* Try to create a FLOCK lock on filp. We always insert new FLOCK locks
* at the head of the list, but that's secret knowledge known only to
* flock_lock_file and posix_lock_file.
return error;
}
+EXPORT_SYMBOL(posix_lock_file);
+
static int __posix_lock_file(struct inode *inode, struct file_lock *request)
{
struct file_lock *fl;
return error;
}
+EXPORT_SYMBOL(locks_mandatory_area);
+
/* We already had a lease on this file; just change its type */
static int lease_modify(struct file_lock **before, int arg)
{
return error;
}
+EXPORT_SYMBOL(__break_lease);
+
/**
* lease_get_mtime
* @inode: the inode
*time = inode->i_mtime;
}
+EXPORT_SYMBOL(lease_get_mtime);
+
/**
* fcntl_getlease - Enquire what lease is currently active
* @filp: the file
locks_insert_block(blocker, waiter);
}
+EXPORT_SYMBOL(posix_block_lock);
+
/**
* posix_unblock_lock - stop waiting for a file lock
* @filp: how the file was opened
}
}
+EXPORT_SYMBOL(posix_unblock_lock);
+
static void lock_get_status(char* out, struct file_lock *fl, int id, char *pfx)
{
struct inode *inode = NULL;
return result;
}
+EXPORT_SYMBOL(lock_may_read);
+
/**
* lock_may_write - checks that the region is free of locks
* @inode: the inode that is being written
return result;
}
+EXPORT_SYMBOL(lock_may_write);
+
static int __init filelock_init(void)
{
filelock_cache = kmem_cache_create("file_lock_cache",
}
module_init(filelock_init)
-
-EXPORT_SYMBOL(file_lock_list);
-EXPORT_SYMBOL(locks_init_lock);
-EXPORT_SYMBOL(locks_copy_lock);
-EXPORT_SYMBOL(posix_lock_file);
-EXPORT_SYMBOL(posix_test_lock);
-EXPORT_SYMBOL(posix_block_lock);
-EXPORT_SYMBOL(posix_unblock_lock);
-EXPORT_SYMBOL(posix_locks_deadlock);
-EXPORT_SYMBOL(locks_mandatory_area);
return found;
}
+EXPORT_SYMBOL(lookup_mnt);
+
static int check_mnt(struct vfsmount *mnt)
{
spin_lock(&vfsmount_lock);
deactivate_super(sb);
}
+EXPORT_SYMBOL(__mntput);
+
/* iterator */
static void *m_start(struct seq_file *m, loff_t *pos)
{
return 0;
}
+EXPORT_SYMBOL(may_umount);
+
void umount_tree(struct vfsmount *mnt)
{
struct vfsmount *p;
}
}
+EXPORT_SYMBOL(set_fs_root);
+
/*
* Replace the fs->{pwdmnt,pwd} with {mnt,dentry}. Put the old values.
* It can block. Requires the big lock held.
}
}
+EXPORT_SYMBOL(set_fs_pwd);
+
static void chroot_fs_refs(struct nameidata *old_nd, struct nameidata *new_nd)
{
struct task_struct *g, *p;
return retval;
}
+EXPORT_SYMBOL(vfs_statfs);
+
static int vfs_statfs_native(struct super_block *sb, struct statfs *buf)
{
struct kstatfs st;
return ERR_PTR(error);
}
+EXPORT_SYMBOL(filp_open);
+
struct file *dentry_open(struct dentry *dentry, struct vfsmount *mnt, int flags)
{
struct file * f;
return ERR_PTR(error);
}
+EXPORT_SYMBOL(dentry_open);
+
/*
* Find an empty file descriptor entry, and mark it busy.
*/
return error;
}
+EXPORT_SYMBOL(get_unused_fd);
+
static inline void __put_unused_fd(struct files_struct *files, unsigned int fd)
{
__FD_CLR(fd, files->open_fds);
spin_unlock(&files->file_lock);
}
+EXPORT_SYMBOL(put_unused_fd);
+
/*
* Install a file pointer in the fd array.
*
spin_unlock(&files->file_lock);
}
+EXPORT_SYMBOL(fd_install);
+
asmlinkage long sys_open(const char __user * filename, int flags, int mode)
{
char * tmp;
return retval;
}
+EXPORT_SYMBOL(filp_close);
+
/*
* Careful here! We test whether the file pointer is NULL before
* releasing the fd. This ensures that one clone task can't release
return -EBADF;
}
+EXPORT_SYMBOL(sys_close);
+
/*
* This routine simulates a hangup on the tty, to arrange that users
* are given clean terminals at login time.
return disk_name(bdev->bd_disk, part, buf);
}
+EXPORT_SYMBOL(bdevname);
+
/*
* NOTE: this cannot be called from interrupt context.
*
return buffer;
}
+EXPORT_SYMBOL(__bdevname);
+
static struct parsed_partitions *
check_partition(struct gendisk *hd, struct block_device *bdev)
{
return NULL;
}
+EXPORT_SYMBOL(read_dev_sector);
+
void del_gendisk(struct gendisk *disk)
{
int p;
.sendfile = generic_file_sendfile,
};
+EXPORT_SYMBOL(generic_ro_fops);
+
loff_t generic_file_llseek(struct file *file, loff_t offset, int origin)
{
long long retval;
return retval;
}
+EXPORT_SYMBOL(generic_file_llseek);
+
loff_t remote_llseek(struct file *file, loff_t offset, int origin)
{
long long retval;
return retval;
}
+EXPORT_SYMBOL(remote_llseek);
+
loff_t no_llseek(struct file *file, loff_t offset, int origin)
{
return -ESPIPE;
}
+EXPORT_SYMBOL(no_llseek);
+
loff_t default_llseek(struct file *file, loff_t offset, int origin)
{
long long retval;
return retval;
}
+EXPORT_SYMBOL(default_llseek);
+
static inline loff_t llseek(struct file *file, loff_t offset, int origin)
{
loff_t (*fn)(struct file *, loff_t, int);
return ret;
}
+EXPORT_SYMBOL(do_sync_read);
+
ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
{
struct inode *inode = file->f_dentry->d_inode;
return ret;
}
+EXPORT_SYMBOL(vfs_read);
+
ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos)
{
struct kiocb kiocb;
return ret;
}
+EXPORT_SYMBOL(do_sync_write);
+
ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
{
struct inode *inode = file->f_dentry->d_inode;
return ret;
}
+EXPORT_SYMBOL(vfs_write);
+
asmlinkage ssize_t sys_read(unsigned int fd, char __user * buf, size_t count)
{
struct file *file;
return seg;
}
+EXPORT_SYMBOL(iov_shorten);
+
static ssize_t do_readv_writev(int type, struct file *file,
const struct iovec __user * uvector,
unsigned long nr_segs, loff_t *pos)
return do_readv_writev(READ, file, vec, vlen, pos);
}
+EXPORT_SYMBOL(vfs_readv);
+
ssize_t vfs_writev(struct file *file, const struct iovec __user *vec,
unsigned long vlen, loff_t *pos)
{
return do_readv_writev(WRITE, file, vec, vlen, pos);
}
+EXPORT_SYMBOL(vfs_writev);
asmlinkage ssize_t
sys_readv(unsigned long fd, const struct iovec __user *vec, unsigned long vlen)
return do_sendfile(out_fd, in_fd, NULL, count, 0);
}
-
-EXPORT_SYMBOL(do_sync_read);
-EXPORT_SYMBOL(do_sync_write);
* Copyright (C) 1995 Linus Torvalds
*/
+#include <linux/module.h>
#include <linux/time.h>
#include <linux/mm.h>
#include <linux/errno.h>
return res;
}
+EXPORT_SYMBOL(vfs_readdir);
+
/*
* Traditional linux readdir() handling..
*
* of fds to overcome nfds < 16390 descriptors limit (Tigran Aivazian).
*/
+#include <linux/module.h>
#include <linux/slab.h>
#include <linux/smp_lock.h>
#include <linux/poll.h>
pwq->table = NULL;
}
+EXPORT_SYMBOL(poll_initwait);
+
void poll_freewait(struct poll_wqueues *pwq)
{
struct poll_table_page * p = pwq->table;
}
}
+EXPORT_SYMBOL(poll_freewait);
+
void __pollwait(struct file *filp, wait_queue_head_t *wait_address, poll_table *_p)
{
struct poll_wqueues *p = container_of(_p, struct poll_wqueues, pt);
return retval;
}
+EXPORT_SYMBOL(do_select);
+
static void *select_bits_alloc(int size)
{
return kmalloc(6 * size, GFP_KERNEL);
*/
#include <linux/config.h>
+#include <linux/module.h>
#include <linux/mm.h>
#include <linux/errno.h>
#include <linux/file.h>
stat->blksize = inode->i_blksize;
}
+EXPORT_SYMBOL(generic_fillattr);
+
int vfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
{
struct inode *inode = dentry->d_inode;
return 0;
}
+EXPORT_SYMBOL(vfs_getattr);
+
int vfs_stat(char __user *name, struct kstat *stat)
{
struct nameidata nd;
return error;
}
+EXPORT_SYMBOL(vfs_stat);
+
int vfs_lstat(char __user *name, struct kstat *stat)
{
struct nameidata nd;
return error;
}
+EXPORT_SYMBOL(vfs_lstat);
+
int vfs_fstat(unsigned int fd, struct kstat *stat)
{
struct file *f = fget(fd);
return error;
}
+EXPORT_SYMBOL(vfs_fstat);
+
#if !defined(__alpha__) && !defined(__sparc__) && !defined(__ia64__) \
&& !defined(CONFIG_ARCH_S390) && !defined(__hppa__) && !defined(__x86_64__) \
&& !defined(__arm__) && !defined(CONFIG_V850) && !defined(__powerpc64__)
spin_unlock(&inode->i_lock);
}
+EXPORT_SYMBOL(inode_add_bytes);
+
void inode_sub_bytes(struct inode *inode, loff_t bytes)
{
spin_lock(&inode->i_lock);
spin_unlock(&inode->i_lock);
}
+EXPORT_SYMBOL(inode_sub_bytes);
+
loff_t inode_get_bytes(struct inode *inode)
{
loff_t ret;
return ret;
}
+EXPORT_SYMBOL(inode_get_bytes);
+
void inode_set_bytes(struct inode *inode, loff_t bytes)
{
inode->i_blocks = bytes >> 9;
inode->i_bytes = bytes & 511;
}
+
+EXPORT_SYMBOL(inode_set_bytes);
#include <linux/mm.h>
#include <linux/capability.h>
#include <linux/highuid.h>
-#include <linux/fs.h>
-#include <linux/fs_struct.h>
#include <linux/uio.h>
#include <linux/tty.h>
#include <linux/in6.h>
EXPORT_SYMBOL(get_user_pages);
/* filesystem internal functions */
-EXPORT_SYMBOL(get_fs_type);
-EXPORT_SYMBOL(fput);
-EXPORT_SYMBOL(fget);
-EXPORT_SYMBOL(lookup_mnt);
-EXPORT_SYMBOL(sys_close);
EXPORT_SYMBOL(dcache_lock);
-EXPORT_SYMBOL(__mark_inode_dirty);
-EXPORT_SYMBOL(get_empty_filp);
-EXPORT_SYMBOL(open_private_file);
-EXPORT_SYMBOL(close_private_file);
-EXPORT_SYMBOL(filp_open);
-EXPORT_SYMBOL(filp_close);
-EXPORT_SYMBOL(put_filp);
-EXPORT_SYMBOL(files_lock);
EXPORT_SYMBOL(invalidate_inode_pages);
EXPORT_SYMBOL_GPL(invalidate_inode_pages2);
EXPORT_SYMBOL(truncate_inode_pages);
-EXPORT_SYMBOL(inode_setattr);
-EXPORT_SYMBOL(inode_change_ok);
-EXPORT_SYMBOL(write_inode_now);
-EXPORT_SYMBOL(notify_change);
-EXPORT_SYMBOL(blockdev_direct_IO);
EXPORT_SYMBOL(file_ra_state_init);
-EXPORT_SYMBOL(generic_ro_fops);
-EXPORT_SYMBOL(get_unused_fd);
-EXPORT_SYMBOL(vfs_read);
-EXPORT_SYMBOL(vfs_readv);
-EXPORT_SYMBOL(vfs_write);
-EXPORT_SYMBOL(vfs_writev);
-EXPORT_SYMBOL(vfs_statfs);
-EXPORT_SYMBOL(vfs_fstat);
-EXPORT_SYMBOL(vfs_stat);
-EXPORT_SYMBOL(vfs_lstat);
-EXPORT_SYMBOL(vfs_getattr);
-EXPORT_SYMBOL(inode_add_bytes);
-EXPORT_SYMBOL(inode_sub_bytes);
-EXPORT_SYMBOL(inode_get_bytes);
-EXPORT_SYMBOL(inode_set_bytes);
-EXPORT_SYMBOL(generic_fillattr);
-EXPORT_SYMBOL(generic_file_llseek);
-EXPORT_SYMBOL(remote_llseek);
-EXPORT_SYMBOL(no_llseek);
-EXPORT_SYMBOL(poll_initwait);
-EXPORT_SYMBOL(poll_freewait);
EXPORT_SYMBOL(ROOT_DEV);
EXPORT_SYMBOL(read_cache_pages);
EXPORT_SYMBOL(mark_page_accessed);
-EXPORT_SYMBOL(vfs_readdir);
-EXPORT_SYMBOL(__break_lease);
-EXPORT_SYMBOL(lease_get_mtime);
-EXPORT_SYMBOL(lock_may_read);
-EXPORT_SYMBOL(lock_may_write);
-EXPORT_SYMBOL(fd_install);
-EXPORT_SYMBOL(put_unused_fd);
-EXPORT_SYMBOL(do_select);
/* for stackable file systems (lofs, wrapfs, cryptfs, etc.) */
-EXPORT_SYMBOL(default_llseek);
-EXPORT_SYMBOL(dentry_open);
EXPORT_SYMBOL(lock_page);
/* device registration */
EXPORT_SYMBOL(tty_std_termios);
/* block device driver support */
-EXPORT_SYMBOL(read_dev_sector);
-EXPORT_SYMBOL(iov_shorten);
EXPORT_SYMBOL_GPL(default_backing_dev_info);
/* tty routines */
EXPORT_SYMBOL(tty_wait_until_sent);
EXPORT_SYMBOL(tty_flip_buffer_push);
-/* filesystem registration */
-EXPORT_SYMBOL(register_filesystem);
-EXPORT_SYMBOL(unregister_filesystem);
-EXPORT_SYMBOL(__mntput);
-EXPORT_SYMBOL(may_umount);
-
/* interrupt handling */
EXPORT_SYMBOL(request_irq);
EXPORT_SYMBOL(free_irq);
EXPORT_SYMBOL(vsprintf);
EXPORT_SYMBOL(vsnprintf);
EXPORT_SYMBOL(vsscanf);
-EXPORT_SYMBOL(__bdevname);
-EXPORT_SYMBOL(bdevname);
EXPORT_SYMBOL(simple_strtoull);
EXPORT_SYMBOL(simple_strtoul);
EXPORT_SYMBOL(simple_strtol);
/* Added to make file system as module */
EXPORT_SYMBOL(sys_tz);
-EXPORT_SYMBOL(make_bad_inode);
-EXPORT_SYMBOL(is_bad_inode);
-EXPORT_SYMBOL(__inode_dir_notify);
-EXPORT_SYMBOL(generic_osync_inode);
#ifdef CONFIG_UID16
EXPORT_SYMBOL(overflowuid);
EXPORT_SYMBOL(fs_overflowuid);
EXPORT_SYMBOL(fs_overflowgid);
-/* all busmice */
-EXPORT_SYMBOL(fasync_helper);
-EXPORT_SYMBOL(kill_fasync);
-
/* library functions */
EXPORT_SYMBOL(strnicmp);
EXPORT_SYMBOL(strspn);
EXPORT_SYMBOL(__tasklet_hi_schedule);
/* init task, for moving kthread roots - ought to export a function ?? */
-
EXPORT_SYMBOL(init_task);
EXPORT_SYMBOL(tasklist_lock);
EXPORT_SYMBOL(__per_cpu_offset);
#endif
-EXPORT_SYMBOL(set_fs_pwd);
-EXPORT_SYMBOL(set_fs_root);
-
/* debug */
EXPORT_SYMBOL(dump_stack);
EXPORT_SYMBOL(ptrace_notify);
projects / history.git / commitdiff