o kernel/ksyms.c: move remaining fs/*.c EXPORT_SYMBOLs

fs/attr.c

@@ -5,6 +5,7 @@
  *  changes by Thomas Schoebel-Theuer
  */
 
+#include <linux/module.h>
 #include <linux/time.h>
 #include <linux/mm.h>
 #include <linux/string.h>
@@ -59,6 +60,8 @@ int inode_change_ok(struct inode *inode, struct iattr *attr)
 	return retval;
 }
 
+EXPORT_SYMBOL(inode_change_ok);
+
 int inode_setattr(struct inode * inode, struct iattr * attr)
 {
 	unsigned int ia_valid = attr->ia_valid;
@@ -100,6 +103,8 @@ int inode_setattr(struct inode * inode, struct iattr * attr)
 	return error;
 }
 
+EXPORT_SYMBOL(inode_setattr);
+
 int setattr_mask(unsigned int ia_valid)
 {
 	unsigned long dn_mask = 0;
@@ -184,3 +189,5 @@ int notify_change(struct dentry * dentry, struct iattr * attr)
 	}
 	return error;
 }
+
+EXPORT_SYMBOL(notify_change);

fs/bad_inode.c

@@ -9,6 +9,7 @@
  */
 
 #include <linux/fs.h>
+#include <linux/module.h>
 #include <linux/stat.h>
 #include <linux/time.h>
 #include <linux/smp_lock.h>
@@ -106,6 +107,7 @@ void make_bad_inode(struct inode * inode)
 	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
@@ -124,3 +126,5 @@ int is_bad_inode(struct inode * inode)
 {
 	return (inode->i_op == &bad_inode_ops);	
 }
+
+EXPORT_SYMBOL(is_bad_inode);

fs/direct-io.c

@@ -20,6 +20,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/module.h>
 #include <linux/types.h>
 #include <linux/fs.h>
 #include <linux/mm.h>
@@ -1023,3 +1024,5 @@ blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
 out:
 	return retval;
 }
+
+EXPORT_SYMBOL(blockdev_direct_IO);

fs/dnotify.c

@@ -14,6 +14,7 @@
  * 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>
@@ -140,6 +141,8 @@ void __inode_dir_notify(struct inode *inode, unsigned long event)
 	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...

fs/fcntl.c

@@ -273,11 +273,15 @@ int f_setown(struct file *filp, unsigned long arg, int force)
 	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)
 {
@@ -580,6 +584,8 @@ int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fap
 	return result;
 }
 
+EXPORT_SYMBOL(fasync_helper);
+
 void __kill_fasync(struct fasync_struct *fa, int sig, int band)
 {
 	while (fa) {
@@ -599,6 +605,8 @@ void __kill_fasync(struct fasync_struct *fa, int sig, int band)
 	}
 }
 
+EXPORT_SYMBOL(__kill_fasync);
+
 void kill_fasync(struct fasync_struct **fp, int sig, int band)
 {
 	read_lock(&fasync_lock);
@@ -606,6 +614,8 @@ void kill_fasync(struct fasync_struct **fp, int sig, int band)
 	read_unlock(&fasync_lock);
 }
 
+EXPORT_SYMBOL(kill_fasync);
+
 static int __init fasync_init(void)
 {
 	fasync_cache = kmem_cache_create("fasync_cache",
@@ -616,9 +626,3 @@ static int __init fasync_init(void)
 }
 
 module_init(fasync_init)
-
-EXPORT_SYMBOL(f_setown);
-EXPORT_SYMBOL(f_delown);
-#ifdef CONFIG_NET
-EXPORT_SYMBOL(__kill_fasync);
-#endif

fs/file_table.c

@@ -22,9 +22,13 @@ struct files_stat_struct files_stat = {
 	.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
@@ -100,6 +104,8 @@ static int old_max;
 	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).  
@@ -128,6 +134,8 @@ int open_private_file(struct file *filp, struct dentry *dentry, int flags)
 	return error;
 }
 
+EXPORT_SYMBOL(open_private_file);
+
 /*
  * Release a private file by calling the release function (if any) and
  * freeing the security structure.
@@ -141,12 +149,16 @@ void close_private_file(struct file *file)
 	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.
  */
@@ -192,6 +204,8 @@ struct file *fget(unsigned int fd)
 	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 
@@ -229,6 +243,8 @@ void put_filp(struct file *file)
 	}
 }
 
+EXPORT_SYMBOL(put_filp);
+
 void file_move(struct file *file, struct list_head *list)
 {
 	if (!list)
@@ -284,6 +300,3 @@ void __init files_init(unsigned long mempages)
 	if (files_stat.max_files < NR_FILE)
 		files_stat.max_files = NR_FILE;
 } 
-
-/* Needed by unix.o */
-EXPORT_SYMBOL(files_stat);

fs/filesystems.c

@@ -82,6 +82,8 @@ int register_filesystem(struct file_system_type * fs)
 	return res;
 }
 
+EXPORT_SYMBOL(register_filesystem);
+
 /**
  *	unregister_filesystem - unregister a file system
  *	@fs: filesystem to unregister
@@ -113,6 +115,8 @@ int unregister_filesystem(struct file_system_type * fs)
 	return -EINVAL;
 }
 
+EXPORT_SYMBOL(unregister_filesystem);
+
 static int fs_index(const char __user * __name)
 {
 	struct file_system_type * tmp;
@@ -227,3 +231,5 @@ struct file_system_type *get_fs_type(const char *name)
 	}
 	return fs;
 }
+
+EXPORT_SYMBOL(get_fs_type);

fs/fs-writeback.c

@@ -107,6 +107,8 @@ void __mark_inode_dirty(struct inode *inode, int flags)
 	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))
@@ -494,6 +496,8 @@ void write_inode_now(struct inode *inode, int sync)
 		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
@@ -545,6 +549,8 @@ int generic_osync_inode(struct inode *inode, int what)
 	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

fs/locks.c

@@ -138,6 +138,9 @@ int lease_break_time = 45;
 	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;
@@ -185,6 +188,8 @@ void locks_init_lock(struct file_lock *fl)
 	fl->fl_remove = NULL;
 }
 
+EXPORT_SYMBOL(locks_init_lock);
+
 /*
  * Initialises the fields of the file lock which are invariant for
  * free file_locks.
@@ -218,6 +223,8 @@ void locks_copy_lock(struct file_lock *new, struct file_lock *fl)
 	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);
@@ -604,6 +611,8 @@ posix_test_lock(struct file *filp, struct file_lock *fl)
 	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
@@ -646,6 +655,8 @@ int posix_locks_deadlock(struct file_lock *caller_fl,
 	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.
@@ -707,6 +718,8 @@ static int flock_lock_file(struct file *filp, struct file_lock *new_fl)
 	return error;
 }
 
+EXPORT_SYMBOL(posix_lock_file);
+
 static int __posix_lock_file(struct inode *inode, struct file_lock *request)
 {
 	struct file_lock *fl;
@@ -978,6 +991,8 @@ int locks_mandatory_area(int read_write, struct inode *inode,
 	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)
 {
@@ -1116,6 +1131,8 @@ int __break_lease(struct inode *inode, unsigned int mode)
 	return error;
 }
 
+EXPORT_SYMBOL(__break_lease);
+
 /**
  *	lease_get_mtime
  *	@inode: the inode
@@ -1134,6 +1151,8 @@ void lease_get_mtime(struct inode *inode, struct timespec *time)
 		*time = inode->i_mtime;
 }
 
+EXPORT_SYMBOL(lease_get_mtime);
+
 /**
  *	fcntl_getlease - Enquire what lease is currently active
  *	@filp: the file
@@ -1725,6 +1744,8 @@ posix_block_lock(struct file_lock *blocker, struct file_lock *waiter)
 	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
@@ -1750,6 +1771,8 @@ posix_unblock_lock(struct file *filp, struct file_lock *waiter)
 	}
 }
 
+EXPORT_SYMBOL(posix_unblock_lock);
+
 static void lock_get_status(char* out, struct file_lock *fl, int id, char *pfx)
 {
 	struct inode *inode = NULL;
@@ -1920,6 +1943,8 @@ int lock_may_read(struct inode *inode, loff_t start, unsigned long len)
 	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
@@ -1956,6 +1981,8 @@ int lock_may_write(struct inode *inode, loff_t start, unsigned long len)
 	return result;
 }
 
+EXPORT_SYMBOL(lock_may_write);
+
 static int __init filelock_init(void)
 {
 	filelock_cache = kmem_cache_create("file_lock_cache",
@@ -1966,13 +1993,3 @@ static int __init filelock_init(void)
 }
 
 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);

fs/namespace.c

@@ -94,6 +94,8 @@ struct vfsmount *lookup_mnt(struct vfsmount *mnt, struct dentry *dentry)
 	return found;
 }
 
+EXPORT_SYMBOL(lookup_mnt);
+
 static int check_mnt(struct vfsmount *mnt)
 {
 	spin_lock(&vfsmount_lock);
@@ -164,6 +166,8 @@ void __mntput(struct vfsmount *mnt)
 	deactivate_super(sb);
 }
 
+EXPORT_SYMBOL(__mntput);
+
 /* iterator */
 static void *m_start(struct seq_file *m, loff_t *pos)
 {
@@ -259,6 +263,8 @@ int may_umount(struct vfsmount *mnt)
 	return 0;
 }
 
+EXPORT_SYMBOL(may_umount);
+
 void umount_tree(struct vfsmount *mnt)
 {
 	struct vfsmount *p;
@@ -925,6 +931,8 @@ void set_fs_root(struct fs_struct *fs, struct vfsmount *mnt,
 	}
 }
 
+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.
@@ -948,6 +956,8 @@ void set_fs_pwd(struct fs_struct *fs, struct vfsmount *mnt,
 	}
 }
 
+EXPORT_SYMBOL(set_fs_pwd);
+
 static void chroot_fs_refs(struct nameidata *old_nd, struct nameidata *new_nd)
 {
 	struct task_struct *g, *p;

fs/open.c

@@ -42,6 +42,8 @@ int vfs_statfs(struct super_block *sb, struct kstatfs *buf)
 	return retval;
 }
 
+EXPORT_SYMBOL(vfs_statfs);
+
 static int vfs_statfs_native(struct super_block *sb, struct statfs *buf)
 {
 	struct kstatfs st;
@@ -753,6 +755,8 @@ struct file *filp_open(const char * filename, int flags, int mode)
 	return ERR_PTR(error);
 }
 
+EXPORT_SYMBOL(filp_open);
+
 struct file *dentry_open(struct dentry *dentry, struct vfsmount *mnt, int flags)
 {
 	struct file * f;
@@ -812,6 +816,8 @@ struct file *dentry_open(struct dentry *dentry, struct vfsmount *mnt, int flags)
 	return ERR_PTR(error);
 }
 
+EXPORT_SYMBOL(dentry_open);
+
 /*
  * Find an empty file descriptor entry, and mark it busy.
  */
@@ -874,6 +880,8 @@ int get_unused_fd(void)
 	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);
@@ -889,6 +897,8 @@ void put_unused_fd(unsigned int fd)
 	spin_unlock(&files->file_lock);
 }
 
+EXPORT_SYMBOL(put_unused_fd);
+
 /*
  * Install a file pointer in the fd array.  
  *
@@ -912,6 +922,8 @@ void fd_install(unsigned int fd, struct file * file)
 	spin_unlock(&files->file_lock);
 }
 
+EXPORT_SYMBOL(fd_install);
+
 asmlinkage long sys_open(const char __user * filename, int flags, int mode)
 {
 	char * tmp;
@@ -985,6 +997,8 @@ int filp_close(struct file *filp, fl_owner_t id)
 	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
@@ -1012,6 +1026,8 @@ asmlinkage long sys_close(unsigned int fd)
 	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.

fs/partitions/check.c

@@ -135,6 +135,8 @@ const char *bdevname(struct block_device *bdev, char *buf)
 	return disk_name(bdev->bd_disk, part, buf);
 }
 
+EXPORT_SYMBOL(bdevname);
+
 /*
  * NOTE: this cannot be called from interrupt context.
  *
@@ -158,6 +160,8 @@ const char *__bdevname(dev_t dev, char *buffer)
 	return buffer;
 }
 
+EXPORT_SYMBOL(__bdevname);
+
 static struct parsed_partitions *
 check_partition(struct gendisk *hd, struct block_device *bdev)
 {
@@ -435,6 +439,8 @@ unsigned char *read_dev_sector(struct block_device *bdev, sector_t n, Sector *p)
 	return NULL;
 }
 
+EXPORT_SYMBOL(read_dev_sector);
+
 void del_gendisk(struct gendisk *disk)
 {
 	int p;

fs/read_write.c

@@ -23,6 +23,8 @@ struct file_operations generic_ro_fops = {
 	.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;
@@ -48,6 +50,8 @@ loff_t generic_file_llseek(struct file *file, loff_t offset, int origin)
 	return retval;
 }
 
+EXPORT_SYMBOL(generic_file_llseek);
+
 loff_t remote_llseek(struct file *file, loff_t offset, int origin)
 {
 	long long retval;
@@ -72,11 +76,15 @@ loff_t remote_llseek(struct file *file, loff_t offset, int origin)
 	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;
@@ -101,6 +109,8 @@ loff_t default_llseek(struct file *file, loff_t offset, int origin)
 	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);
@@ -183,6 +193,8 @@ ssize_t do_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *pp
 	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;
@@ -209,6 +221,8 @@ ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
 	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;
@@ -223,6 +237,8 @@ ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, lof
 	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;
@@ -249,6 +265,8 @@ ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_
 	return ret;
 }
 
+EXPORT_SYMBOL(vfs_write);
+
 asmlinkage ssize_t sys_read(unsigned int fd, char __user * buf, size_t count)
 {
 	struct file *file;
@@ -337,6 +355,8 @@ unsigned long iov_shorten(struct iovec *iov, unsigned long nr_segs, size_t to)
 	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)
@@ -468,6 +488,8 @@ ssize_t vfs_readv(struct file *file, const struct iovec __user *vec,
 	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)
 {
@@ -479,6 +501,7 @@ ssize_t vfs_writev(struct file *file, const struct iovec __user *vec,
 	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)
@@ -630,6 +653,3 @@ asmlinkage ssize_t sys_sendfile64(int out_fd, int in_fd, loff_t __user *offset,
 
 	return do_sendfile(out_fd, in_fd, NULL, count, 0);
 }
-
-EXPORT_SYMBOL(do_sync_read);
-EXPORT_SYMBOL(do_sync_write);

fs/readdir.c

@@ -4,6 +4,7 @@
  *  Copyright (C) 1995  Linus Torvalds
  */
 
+#include <linux/module.h>
 #include <linux/time.h>
 #include <linux/mm.h>
 #include <linux/errno.h>
@@ -37,6 +38,8 @@ int vfs_readdir(struct file *file, filldir_t filler, void *buf)
 	return res;
 }
 
+EXPORT_SYMBOL(vfs_readdir);
+
 /*
  * Traditional linux readdir() handling..
  *

fs/select.c

@@ -14,6 +14,7 @@
  *     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>
@@ -62,6 +63,8 @@ void poll_initwait(struct poll_wqueues *pwq)
 	pwq->table = NULL;
 }
 
+EXPORT_SYMBOL(poll_initwait);
+
 void poll_freewait(struct poll_wqueues *pwq)
 {
 	struct poll_table_page * p = pwq->table;
@@ -81,6 +84,8 @@ void poll_freewait(struct poll_wqueues *pwq)
 	}
 }
 
+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);
@@ -266,6 +271,8 @@ int do_select(int n, fd_set_bits *fds, long *timeout)
 	return retval;
 }
 
+EXPORT_SYMBOL(do_select);
+
 static void *select_bits_alloc(int size)
 {
 	return kmalloc(6 * size, GFP_KERNEL);

fs/stat.c

@@ -5,6 +5,7 @@
  */
 
 #include <linux/config.h>
+#include <linux/module.h>
 #include <linux/mm.h>
 #include <linux/errno.h>
 #include <linux/file.h>
@@ -33,6 +34,8 @@ void generic_fillattr(struct inode *inode, struct kstat *stat)
 	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;
@@ -56,6 +59,8 @@ int vfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 	return 0;
 }
 
+EXPORT_SYMBOL(vfs_getattr);
+
 int vfs_stat(char __user *name, struct kstat *stat)
 {
 	struct nameidata nd;
@@ -69,6 +74,8 @@ int vfs_stat(char __user *name, struct kstat *stat)
 	return error;
 }
 
+EXPORT_SYMBOL(vfs_stat);
+
 int vfs_lstat(char __user *name, struct kstat *stat)
 {
 	struct nameidata nd;
@@ -82,6 +89,8 @@ int vfs_lstat(char __user *name, struct kstat *stat)
 	return error;
 }
 
+EXPORT_SYMBOL(vfs_lstat);
+
 int vfs_fstat(unsigned int fd, struct kstat *stat)
 {
 	struct file *f = fget(fd);
@@ -94,6 +103,8 @@ int vfs_fstat(unsigned int fd, struct kstat *stat)
 	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__)
@@ -355,6 +366,8 @@ void inode_add_bytes(struct inode *inode, loff_t bytes)
 	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);
@@ -368,6 +381,8 @@ void inode_sub_bytes(struct inode *inode, loff_t bytes)
 	spin_unlock(&inode->i_lock);
 }
 
+EXPORT_SYMBOL(inode_sub_bytes);
+
 loff_t inode_get_bytes(struct inode *inode)
 {
 	loff_t ret;
@@ -378,8 +393,12 @@ loff_t inode_get_bytes(struct inode *inode)
 	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);

kernel/ksyms.c

@@ -40,8 +40,6 @@
 #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>
@@ -137,65 +135,16 @@ EXPORT_SYMBOL(page_address);
 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 */
@@ -206,20 +155,12 @@ EXPORT_SYMBOL(tty_unregister_driver);
 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);
@@ -291,8 +232,6 @@ EXPORT_SYMBOL(sscanf);
 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);
@@ -314,10 +253,6 @@ EXPORT_SYMBOL(si_meminfo);
 
 /* 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);
@@ -326,10 +261,6 @@ EXPORT_SYMBOL(overflowgid);
 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);
@@ -346,7 +277,6 @@ EXPORT_SYMBOL(__tasklet_schedule);
 EXPORT_SYMBOL(__tasklet_hi_schedule);
 
 /* init task, for moving kthread roots - ought to export a function ?? */
-
 EXPORT_SYMBOL(init_task);
 
 EXPORT_SYMBOL(tasklist_lock);
@@ -356,9 +286,6 @@ EXPORT_SYMBOL(next_thread);
 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);