public inbox for linux-kernel@vger.kernel.org
 help / color / mirror / Atom feed
* [PATCHES] today's batch of "nuking kernel/ksyms.c"
@ 2003-10-02  3:03 Arnaldo Carvalho de Melo
  2003-10-02  4:02 ` Larry McVoy
  0 siblings, 1 reply; 3+ messages in thread
From: Arnaldo Carvalho de Melo @ 2003-10-02  3:03 UTC (permalink / raw)
  To: Linus Torvalds; +Cc: Linux Kernel Mailing List

Hi Linus,

	Please pull from:

bk://kernel.bkbits.net/acme/ksyms-2.6

Thanks,

- Arnaldo

===================================================================

ChangeSet@1.1396, 2003-10-02 02:39:04-03:00, acme@parisc.kerneljanitors.org
  o kernel/ksyms.c: move relevant EXPORT_SYMBOLs to fs/fcntl.c

ChangeSet@1.1395, 2003-10-02 02:32:40-03:00, acme@parisc.kerneljanitors.org
  o kernel/ksyms.c: move relevant EXPORT_SYMBOLs to fs/attr.c

ChangeSet@1.1394, 2003-10-02 02:28:31-03:00, acme@parisc.kerneljanitors.org
  o kernel/ksyms.c: move relevant EXPORT_SYMBOLs to fs/filesystems.c

ChangeSet@1.1393, 2003-10-02 02:14:22-03:00, acme@parisc.kerneljanitors.org
  o kernel/ksyms.c: move relevant EXPORT_SYMBOLs to fs/fs-writeback.c

ChangeSet@1.1392, 2003-10-02 02:10:28-03:00, acme@parisc.kerneljanitors.org
  o kernel/ksyms.c: move relevant EXPORT_SYMBOLs to fs/partitions/check.c

ChangeSet@1.1391, 2003-10-02 02:02:17-03:00, acme@parisc.kerneljanitors.org
  o kernel/ksyms.c: move relevant EXPORT_SYMBOLs to fs/select.c

ChangeSet@1.1390, 2003-10-02 01:54:54-03:00, acme@parisc.kerneljanitors.org
  o kernel/ksyms.c: move relevant EXPORT_SYMBOLs to fs/locks.c

ChangeSet@1.1389, 2003-10-02 01:46:05-03:00, acme@parisc.kerneljanitors.org
  o kernel/ksyms.c: move relevant EXPORT_SYMBOLs to fs/namespace.c

ChangeSet@1.1388, 2003-10-02 01:31:38-03:00, acme@parisc.kerneljanitors.org
  o kernel/ksyms.c: move relevant EXPORT_SYMBOLs to fs/file_table.c

ChangeSet@1.1387, 2003-10-02 01:26:03-03:00, acme@parisc.kerneljanitors.org
  o kernel/ksyms.c: move relevant EXPORT_SYMBOLs to fs/open.c

ChangeSet@1.1386, 2003-10-02 01:17:47-03:00, acme@parisc.kerneljanitors.org
  o kernel/ksyms.c: move relevant EXPORT_SYMBOLs to fs/stat.c

ChangeSet@1.1385, 2003-10-02 01:04:15-03:00, acme@parisc.kerneljanitors.org
  o kernel/ksyms.c: move relevant EXPORT_SYMBOLs to fs/read_write.c


 fs/attr.c             |   11 +++++-
 fs/fcntl.c            |   41 ++++++++++++----------
 fs/file_table.c       |   29 +++++++++++-----
 fs/filesystems.c      |   28 ++++++++-------
 fs/fs-writeback.c     |   24 +++++++------
 fs/locks.c            |   90 +++++++++++++++++++++++++++++++-------------------
 fs/namespace.c        |   46 ++++++++++++++-----------
 fs/open.c             |   74 ++++++++++++++++++++++++++---------------
 fs/partitions/check.c |   52 +++++++++++++++++++---------
 fs/read_write.c       |   65 ++++++++++++++++++++++++++----------
 fs/select.c           |   28 ++++++++++-----
 fs/stat.c             |   57 +++++++++++++++++++++++++------
 kernel/ksyms.c        |   66 ------------------------------------
 13 files changed, 358 insertions(+), 253 deletions(-)


diff -Nru a/fs/attr.c b/fs/attr.c
--- a/fs/attr.c	Thu Oct  2 02:44:46 2003
+++ b/fs/attr.c	Thu Oct  2 02:44:46 2003
@@ -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,7 +60,9 @@
 	return retval;
 }
 
-int inode_setattr(struct inode * inode, struct iattr * attr)
+EXPORT_SYMBOL(inode_change_ok);
+
+int inode_setattr(struct inode *inode, struct iattr *attr)
 {
 	unsigned int ia_valid = attr->ia_valid;
 	int error = 0;
@@ -100,6 +103,8 @@
 	return error;
 }
 
+EXPORT_SYMBOL(inode_setattr);
+
 int setattr_mask(unsigned int ia_valid)
 {
 	unsigned long dn_mask = 0;
@@ -122,7 +127,7 @@
 	return dn_mask;
 }
 
-int notify_change(struct dentry * dentry, struct iattr * attr)
+int notify_change(struct dentry *dentry, struct iattr *attr)
 {
 	struct inode *inode = dentry->d_inode;
 	mode_t mode = inode->i_mode;
@@ -184,3 +189,5 @@
 	}
 	return error;
 }
+
+EXPORT_SYMBOL(notify_change);
diff -Nru a/fs/fcntl.c b/fs/fcntl.c
--- a/fs/fcntl.c	Thu Oct  2 02:44:46 2003
+++ b/fs/fcntl.c	Thu Oct  2 02:44:46 2003
@@ -77,9 +77,8 @@
  * expanding the fd arrays if necessary.  Must be called with the
  * file_lock held for write.
  */
-
 static int locate_fd(struct files_struct *files, 
-			    struct file *file, unsigned int orig_start)
+		     struct file *file, unsigned int orig_start)
 {
 	unsigned int newfd;
 	unsigned int start;
@@ -130,7 +129,7 @@
 
 static int dupfd(struct file *file, unsigned int start)
 {
-	struct files_struct * files = current->files;
+	struct files_struct *files = current->files;
 	int fd;
 
 	spin_lock(&files->file_lock);
@@ -151,7 +150,7 @@
 asmlinkage long sys_dup2(unsigned int oldfd, unsigned int newfd)
 {
 	int err = -EBADF;
-	struct file * file, *tofree;
+	struct file *file, *tofree;
 	struct files_struct * files = current->files;
 
 	spin_lock(&files->file_lock);
@@ -214,7 +213,7 @@
 
 #define SETFL_MASK (O_APPEND | O_NONBLOCK | O_NDELAY | FASYNC | O_DIRECT)
 
-static int setfl(int fd, struct file * filp, unsigned long arg)
+static int setfl(int fd, struct file *filp, unsigned long arg)
 {
 	struct inode * inode = filp->f_dentry->d_inode;
 	int error = 0;
@@ -263,9 +262,8 @@
 
 int f_setown(struct file *filp, unsigned long arg, int force)
 {
-	int err;
-	
-	err = security_file_set_fowner(filp);
+	int err = security_file_set_fowner(filp);
+
 	if (err)
 		return err;
 
@@ -273,13 +271,17 @@
 	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)
+		     unsigned long arg, struct file *filp)
 {
 	long err = -EINVAL;
 
@@ -349,7 +351,8 @@
 	return err;
 }
 
-asmlinkage long sys_fcntl(unsigned int fd, unsigned int cmd, unsigned long arg)
+asmlinkage long sys_fcntl(unsigned int fd, unsigned int cmd,
+			  unsigned long arg)
 {	
 	struct file * filp;
 	long err = -EBADF;
@@ -372,7 +375,8 @@
 }
 
 #if BITS_PER_LONG == 32
-asmlinkage long sys_fcntl64(unsigned int fd, unsigned int cmd, unsigned long arg)
+asmlinkage long sys_fcntl64(unsigned int fd, unsigned int cmd,
+			    unsigned long arg)
 {	
 	struct file * filp;
 	long err;
@@ -541,7 +545,8 @@
  * to set up the fasync queue. It returns negative on error, 0 if it did
  * no changes and positive if it added/deleted the entry.
  */
-int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp)
+int fasync_helper(int fd, struct file *filp, int on,
+		  struct fasync_struct **fapp)
 {
 	struct fasync_struct *fa, **fp;
 	struct fasync_struct *new = NULL;
@@ -580,6 +585,8 @@
 	return result;
 }
 
+EXPORT_SYMBOL(fasync_helper);
+
 void __kill_fasync(struct fasync_struct *fa, int sig, int band)
 {
 	while (fa) {
@@ -599,6 +606,8 @@
 	}
 }
 
+EXPORT_SYMBOL(__kill_fasync);
+
 void kill_fasync(struct fasync_struct **fp, int sig, int band)
 {
 	read_lock(&fasync_lock);
@@ -606,6 +615,8 @@
 	read_unlock(&fasync_lock);
 }
 
+EXPORT_SYMBOL(kill_fasync);
+
 static int __init fasync_init(void)
 {
 	fasync_cache = kmem_cache_create("fasync_cache",
@@ -616,9 +627,3 @@
 }
 
 module_init(fasync_init)
-
-EXPORT_SYMBOL(f_setown);
-EXPORT_SYMBOL(f_delown);
-#ifdef CONFIG_NET
-EXPORT_SYMBOL(__kill_fasync);
-#endif
diff -Nru a/fs/file_table.c b/fs/file_table.c
--- a/fs/file_table.c	Thu Oct  2 02:44:46 2003
+++ b/fs/file_table.c	Thu Oct  2 02:44:46 2003
@@ -22,16 +22,20 @@
 	.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
  * context and must be fully threaded - use a local spinlock
  * to protect files_stat.nr_files
  */
-void filp_ctor(void * objp, struct kmem_cache_s *cachep, unsigned long cflags)
+void filp_ctor(void *objp, struct kmem_cache_s *cachep, unsigned long cflags)
 {
 	if ((cflags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
 	    SLAB_CTOR_CONSTRUCTOR) {
@@ -42,7 +46,7 @@
 	}
 }
 
-void filp_dtor(void * objp, struct kmem_cache_s *cachep, unsigned long dflags)
+void filp_dtor(void *objp, struct kmem_cache_s *cachep, unsigned long dflags)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&filp_count_lock, flags);
@@ -61,8 +65,8 @@
  */
 struct file *get_empty_filp(void)
 {
-static int old_max;
-	struct file * f;
+	static int old_max;
+	struct file *f;
 
 	/*
 	 * Privileged users can go above max_files
@@ -100,6 +104,8 @@
 	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,25 +134,31 @@
 	return error;
 }
 
+EXPORT_SYMBOL(open_private_file);
+
 /*
  * Release a private file by calling the release function (if any) and
  * freeing the security structure.
  */
 void close_private_file(struct file *file)
 {
-	struct inode * inode = file->f_dentry->d_inode;
+	struct inode *inode = file->f_dentry->d_inode;
 
 	if (file->f_op && file->f_op->release)
 		file->f_op->release(inode, 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 @@
 	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 @@
 	}
 }
 
+EXPORT_SYMBOL(put_filp);
+
 void file_move(struct file *file, struct list_head *list)
 {
 	if (!list)
@@ -284,6 +300,3 @@
 	if (files_stat.max_files < NR_FILE)
 		files_stat.max_files = NR_FILE;
 } 
-
-/* Needed by unix.o */
-EXPORT_SYMBOL(files_stat);
diff -Nru a/fs/filesystems.c b/fs/filesystems.c
--- a/fs/filesystems.c	Thu Oct  2 02:44:46 2003
+++ b/fs/filesystems.c	Thu Oct  2 02:44:46 2003
@@ -61,8 +61,7 @@
  *	structures and must not be freed until the file system has been
  *	unregistered.
  */
- 
-int register_filesystem(struct file_system_type * fs)
+int register_filesystem(struct file_system_type *fs)
 {
 	int res = 0;
 	struct file_system_type ** p;
@@ -82,6 +81,8 @@
 	return res;
 }
 
+EXPORT_SYMBOL(register_filesystem);
+
 /**
  *	unregister_filesystem - unregister a file system
  *	@fs: filesystem to unregister
@@ -93,10 +94,9 @@
  *	Once this function has returned the &struct file_system_type structure
  *	may be freed or reused.
  */
- 
-int unregister_filesystem(struct file_system_type * fs)
+int unregister_filesystem(struct file_system_type *fs)
 {
-	struct file_system_type ** tmp;
+	struct file_system_type **tmp;
 
 	write_lock(&file_systems_lock);
 	tmp = &file_systems;
@@ -113,10 +113,12 @@
 	return -EINVAL;
 }
 
-static int fs_index(const char __user * __name)
+EXPORT_SYMBOL(unregister_filesystem);
+
+static int fs_index(const char __user *__name)
 {
-	struct file_system_type * tmp;
-	char * name;
+	struct file_system_type *tmp;
+	char *name;
 	int err, index;
 
 	name = getname(__name);
@@ -137,9 +139,9 @@
 	return err;
 }
 
-static int fs_name(unsigned int index, char __user * buf)
+static int fs_name(unsigned int index, char __user *buf)
 {
-	struct file_system_type * tmp;
+	struct file_system_type *tmp;
 	int len, res;
 
 	read_lock(&file_systems_lock);
@@ -159,7 +161,7 @@
 
 static int fs_maxindex(void)
 {
-	struct file_system_type * tmp;
+	struct file_system_type *tmp;
 	int index;
 
 	read_lock(&file_systems_lock);
@@ -192,7 +194,7 @@
 	return retval;
 }
 
-int get_filesystem_list(char * buf)
+int get_filesystem_list(char *buf)
 {
 	int len = 0;
 	struct file_system_type * tmp;
@@ -227,3 +229,5 @@
 	}
 	return fs;
 }
+
+EXPORT_SYMBOL(get_fs_type);
diff -Nru a/fs/fs-writeback.c b/fs/fs-writeback.c
--- a/fs/fs-writeback.c	Thu Oct  2 02:44:46 2003
+++ b/fs/fs-writeback.c	Thu Oct  2 02:44:46 2003
@@ -107,6 +107,8 @@
 	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))
@@ -129,8 +131,8 @@
  *
  * Called under inode_lock.
  */
-static void
-__sync_single_inode(struct inode *inode, struct writeback_control *wbc)
+static void __sync_single_inode(struct inode *inode,
+				struct writeback_control *wbc)
 {
 	unsigned dirty;
 	struct address_space *mapping = inode->i_mapping;
@@ -194,9 +196,8 @@
 /*
  * Write out an inode's dirty pages.  Called under inode_lock.
  */
-static void
-__writeback_single_inode(struct inode *inode,
-			struct writeback_control *wbc)
+static void __writeback_single_inode(struct inode *inode,
+				     struct writeback_control *wbc)
 {
 	if ((wbc->sync_mode != WB_SYNC_ALL) && (inode->i_state & I_LOCK)) {
 		list_move(&inode->i_list, &inode->i_sb->s_dirty);
@@ -246,8 +247,8 @@
  * on the writer throttling path, and we get decent balancing between many
  * throttled threads: we don't want them all piling up on __wait_on_inode.
  */
-static void
-sync_sb_inodes(struct super_block *sb, struct writeback_control *wbc)
+static void sync_sb_inodes(struct super_block *sb,
+			   struct writeback_control *wbc)
 {
 	const unsigned long start = jiffies;	/* livelock avoidance */
 
@@ -341,8 +342,7 @@
  * sync_sb_inodes will seekout the blockdev which matches `bdi'.  Maybe not
  * super-efficient but we're about to do a ton of I/O...
  */
-void
-writeback_inodes(struct writeback_control *wbc)
+void writeback_inodes(struct writeback_control *wbc)
 {
 	struct super_block *sb;
 
@@ -479,7 +479,6 @@
  *	This function commits an inode to disk immediately if it is
  *	dirty. This is primarily needed by knfsd.
  */
- 
 void write_inode_now(struct inode *inode, int sync)
 {
 	struct writeback_control wbc = {
@@ -494,6 +493,8 @@
 		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
@@ -509,7 +510,6 @@
  *    OSYNC_METADATA: the buffers at i_mapping->private_list
  *    OSYNC_INODE:    the inode itself
  */
-
 int generic_osync_inode(struct inode *inode, int what)
 {
 	int err = 0;
@@ -544,6 +544,8 @@
 
 	return err;
 }
+
+EXPORT_SYMBOL(generic_osync_inode);
 
 /**
  * writeback_acquire: attempt to get exclusive writeback access to a device
diff -Nru a/fs/locks.c b/fs/locks.c
--- a/fs/locks.c	Thu Oct  2 02:44:46 2003
+++ b/fs/locks.c	Thu Oct  2 02:44:46 2003
@@ -138,6 +138,9 @@
 	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 @@
 	fl->fl_remove = NULL;
 }
 
+EXPORT_SYMBOL(locks_init_lock);
+
 /*
  * Initialises the fields of the file lock which are invariant for
  * free file_locks.
@@ -218,7 +223,10 @@
 	new->fl_u = fl->fl_u;
 }
 
-static inline int flock_translate_cmd(int cmd) {
+EXPORT_SYMBOL(locks_copy_lock);
+
+static inline int flock_translate_cmd(int cmd)
+{
 	if (cmd & LOCK_MAND)
 		return cmd & (LOCK_MAND | LOCK_RW);
 	switch (cmd) {
@@ -234,7 +242,7 @@
 
 /* Fill in a file_lock structure with an appropriate FLOCK lock. */
 static int flock_make_lock(struct file *filp, struct file_lock **lock,
-		unsigned int cmd)
+			   unsigned int cmd)
 {
 	struct file_lock *fl;
 	int type = flock_translate_cmd(cmd);
@@ -410,8 +418,8 @@
  * Check whether two locks have the same owner.  The apparently superfluous
  * check for fl_pid enables us to distinguish between locks set by lockd.
  */
-static inline int
-posix_same_owner(struct file_lock *fl1, struct file_lock *fl2)
+static inline int posix_same_owner(struct file_lock *fl1,
+				   struct file_lock *fl2)
 {
 	return (fl1->fl_owner == fl2->fl_owner) &&
 		(fl1->fl_pid == fl2->fl_pid);
@@ -427,8 +435,6 @@
 	waiter->fl_next = NULL;
 }
 
-/*
- */
 static void locks_delete_block(struct file_lock *waiter)
 {
 	lock_kernel();
@@ -503,7 +509,8 @@
 
 	fasync_helper(0, fl->fl_file, 0, &fl->fl_fasync);
 	if (fl->fl_fasync != NULL) {
-		printk(KERN_ERR "locks_delete_lock: fasync == %p\n", fl->fl_fasync);
+		printk(KERN_ERR "locks_delete_lock: fasync == %p\n",
+		       fl->fl_fasync);
 		fl->fl_fasync = NULL;
 	}
 
@@ -517,7 +524,8 @@
 /* Determine if lock sys_fl blocks lock caller_fl. Common functionality
  * checks for shared/exclusive status of overlapping locks.
  */
-static int locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
+static int locks_conflict(struct file_lock *caller_fl,
+			  struct file_lock *sys_fl)
 {
 	if (sys_fl->fl_type == F_WRLCK)
 		return 1;
@@ -529,7 +537,8 @@
 /* Determine if lock sys_fl blocks lock caller_fl. POSIX specific
  * checking before calling the locks_conflict().
  */
-static int posix_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
+static int posix_locks_conflict(struct file_lock *caller_fl,
+				struct file_lock *sys_fl)
 {
 	/* POSIX locks owned by the same process do not conflict with
 	 * each other.
@@ -547,7 +556,8 @@
 /* Determine if lock sys_fl blocks lock caller_fl. FLOCK specific
  * checking before calling the locks_conflict().
  */
-static int flock_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
+static int flock_locks_conflict(struct file_lock *caller_fl,
+				struct file_lock *sys_fl)
 {
 	/* FLOCK locks referring to the same filp do not conflict with
 	 * each other.
@@ -560,7 +570,8 @@
 	return (locks_conflict(caller_fl, sys_fl));
 }
 
-static int interruptible_sleep_on_locked(wait_queue_head_t *fl_wait, int timeout)
+static int interruptible_sleep_on_locked(wait_queue_head_t *fl_wait,
+					 int timeout)
 {
 	int result = 0;
 	DECLARE_WAITQUEUE(wait, current);
@@ -578,7 +589,8 @@
 	return result;
 }
 
-static int locks_block_on_timeout(struct file_lock *blocker, struct file_lock *waiter, int time)
+static int locks_block_on_timeout(struct file_lock *blocker,
+				  struct file_lock *waiter, int time)
 {
 	int result;
 	locks_insert_block(blocker, waiter);
@@ -587,8 +599,7 @@
 	return result;
 }
 
-struct file_lock *
-posix_test_lock(struct file *filp, struct file_lock *fl)
+struct file_lock *posix_test_lock(struct file *filp, struct file_lock *fl)
 {
 	struct file_lock *cfl;
 
@@ -604,6 +615,8 @@
 	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
@@ -619,7 +632,7 @@
  * worry about than proper deadlock detection anyway... --okir
  */
 int posix_locks_deadlock(struct file_lock *caller_fl,
-				struct file_lock *block_fl)
+			 struct file_lock *block_fl)
 {
 	struct list_head *tmp;
 	fl_owner_t caller_owner, blocked_owner;
@@ -646,6 +659,8 @@
 	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 +722,8 @@
 	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 +995,8 @@
 	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 +1135,8 @@
 	return error;
 }
 
+EXPORT_SYMBOL(__break_lease);
+
 /**
  *	lease_get_mtime
  *	@inode: the inode
@@ -1133,6 +1154,8 @@
 		*time = inode->i_mtime;
 }
 
+EXPORT_SYMBOL(lease_get_mtime);
+
 /**
  *	fcntl_getlease - Enquire what lease is currently active
  *	@filp: the file
@@ -1548,7 +1571,8 @@
 /* Apply the lock described by l to an open file descriptor.
  * This implements both the F_SETLK and F_SETLKW commands of fcntl().
  */
-int fcntl_setlk64(struct file *filp, unsigned int cmd, struct flock64 __user *l)
+int fcntl_setlk64(struct file *filp, unsigned int cmd,
+		  struct flock64 __user *l)
 {
 	struct file_lock *file_lock = locks_alloc_lock();
 	struct flock64 flock;
@@ -1718,20 +1742,20 @@
  *
  * lockd needs to block waiting for locks.
  */
-void
-posix_block_lock(struct file_lock *blocker, struct file_lock *waiter)
+void 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
  *	@waiter: the lock which was waiting
  *
  *	lockd needs to block waiting for locks.
  */
-void
-posix_unblock_lock(struct file *filp, struct file_lock *waiter)
+void posix_unblock_lock(struct file *filp, struct file_lock *waiter)
 {
 	/* 
 	 * A remote machine may cancel the lock request after it's been
@@ -1748,7 +1772,10 @@
 	}
 }
 
-static void lock_get_status(char* out, struct file_lock *fl, int id, char *pfx)
+EXPORT_SYMBOL(posix_unblock_lock);
+
+static void lock_get_status(char* out, struct file_lock *fl,
+			    int id, char *pfx)
 {
 	struct inode *inode = NULL;
 
@@ -1844,7 +1871,6 @@
  *	@offset: how far we are through the buffer
  *	@length: how much to read
  */
-
 int get_locks_status(char *buffer, char **start, off_t offset, int length)
 {
 	struct list_head *tmp;
@@ -1902,7 +1928,8 @@
 		if (IS_POSIX(fl)) {
 			if (fl->fl_type == F_RDLCK)
 				continue;
-			if ((fl->fl_end < start) || (fl->fl_start > (start + len)))
+			if ((fl->fl_end < start) ||
+			    (fl->fl_start > (start + len)))
 				continue;
 		} else if (IS_FLOCK(fl)) {
 			if (!(fl->fl_type & LOCK_MAND))
@@ -1918,6 +1945,8 @@
 	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
@@ -1938,7 +1967,8 @@
 	lock_kernel();
 	for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
 		if (IS_POSIX(fl)) {
-			if ((fl->fl_end < start) || (fl->fl_start > (start + len)))
+			if ((fl->fl_end < start) ||
+			    (fl->fl_start > (start + len)))
 				continue;
 		} else if (IS_FLOCK(fl)) {
 			if (!(fl->fl_type & LOCK_MAND))
@@ -1954,6 +1984,8 @@
 	return result;
 }
 
+EXPORT_SYMBOL(lock_may_write);
+
 static int __init filelock_init(void)
 {
 	filelock_cache = kmem_cache_create("file_lock_cache",
@@ -1964,13 +1996,3 @@
 }
 
 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);
diff -Nru a/fs/namespace.c b/fs/namespace.c
--- a/fs/namespace.c	Thu Oct  2 02:44:46 2003
+++ b/fs/namespace.c	Thu Oct  2 02:44:46 2003
@@ -94,6 +94,8 @@
 	return found;
 }
 
+EXPORT_SYMBOL(lookup_mnt);
+
 static int check_mnt(struct vfsmount *mnt)
 {
 	spin_lock(&vfsmount_lock);
@@ -139,8 +141,7 @@
 	return list_entry(next, struct vfsmount, mnt_child);
 }
 
-static struct vfsmount *
-clone_mnt(struct vfsmount *old, struct dentry *root)
+static struct vfsmount *clone_mnt(struct vfsmount *old, struct dentry *root)
 {
 	struct super_block *sb = old->mnt_sb;
 	struct vfsmount *mnt = alloc_vfsmnt(old->mnt_devname);
@@ -164,6 +165,8 @@
 	deactivate_super(sb);
 }
 
+EXPORT_SYMBOL(__mntput);
+
 /* iterator */
 static void *m_start(struct seq_file *m, loff_t *pos)
 {
@@ -259,6 +262,8 @@
 	return 0;
 }
 
+EXPORT_SYMBOL(may_umount);
+
 void umount_tree(struct vfsmount *mnt)
 {
 	struct vfsmount *p;
@@ -366,8 +371,7 @@
  * We now support a flag for forced unmount like the other 'big iron'
  * unixes. Our API is identical to OSF/1 to avoid making a mess of AMD
  */
-
-asmlinkage long sys_umount(char __user * name, int flags)
+asmlinkage long sys_umount(char __user *name, int flags)
 {
 	struct nameidata nd;
 	int retval;
@@ -395,10 +399,9 @@
 /*
  *	The 2.0 compatible umount. No flags. 
  */
- 
-asmlinkage long sys_oldumount(char __user * name)
+asmlinkage long sys_oldumount(char __user *name)
 {
-	return sys_umount(name,0);
+	return sys_umount(name, 0);
 }
 
 static int mount_is_safe(struct nameidata *nd)
@@ -419,8 +422,7 @@
 #endif
 }
 
-static int
-lives_below_in_same_fs(struct dentry *d, struct dentry *dentry)
+static int lives_below_in_same_fs(struct dentry *d, struct dentry *dentry)
 {
 	while (1) {
 		if (d == dentry)
@@ -559,11 +561,11 @@
  * If you've mounted a non-root directory somewhere and want to do remount
  * on it - tough luck.
  */
-
-static int do_remount(struct nameidata *nd,int flags,int mnt_flags,void *data)
+static int do_remount(struct nameidata *nd, int flags,
+		      int mnt_flags, void *data)
 {
 	int err;
-	struct super_block * sb = nd->mnt->mnt_sb;
+	struct super_block *sb = nd->mnt->mnt_sb;
 
 	if (!capable(CAP_SYS_ADMIN))
 		return -EPERM;
@@ -684,7 +686,7 @@
 	return err;
 }
 
-static int copy_mount_options (const void __user *data, unsigned long *where)
+static int copy_mount_options(const void __user *data, unsigned long *where)
 {
 	int i;
 	unsigned long page;
@@ -731,8 +733,8 @@
  * Therefore, if this magic number is present, it carries no information
  * and must be discarded.
  */
-long do_mount(char * dev_name, char * dir_name, char *type_page,
-		  unsigned long flags, void *data_page)
+long do_mount(char *dev_name, char *dir_name, char *type_page,
+	      unsigned long flags, void *data_page)
 {
 	struct nameidata nd;
 	int retval = 0;
@@ -862,9 +864,9 @@
 	return -ENOMEM;
 }
 
-asmlinkage long sys_mount(char __user * dev_name, char __user * dir_name,
-			  char __user * type, unsigned long flags,
-			  void __user * data)
+asmlinkage long sys_mount(char __user *dev_name, char __user *dir_name,
+			  char __user *type, unsigned long flags,
+			  void __user *data)
 {
 	int retval;
 	unsigned long data_page;
@@ -925,6 +927,8 @@
 	}
 }
 
+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 +952,8 @@
 	}
 }
 
+EXPORT_SYMBOL(set_fs_pwd);
+
 static void chroot_fs_refs(struct nameidata *old_nd, struct nameidata *new_nd)
 {
 	struct task_struct *g, *p;
@@ -983,8 +989,8 @@
  *    though, so you may need to say mount --bind /nfs/my_root /nfs/my_root
  *    first.
  */
-
-asmlinkage long sys_pivot_root(const char __user *new_root, const char __user *put_old)
+asmlinkage long sys_pivot_root(const char __user *new_root,
+			       const char __user *put_old)
 {
 	struct vfsmount *tmp;
 	struct nameidata new_nd, old_nd, parent_nd, root_parent, user_nd;
diff -Nru a/fs/open.c b/fs/open.c
--- a/fs/open.c	Thu Oct  2 02:44:46 2003
+++ b/fs/open.c	Thu Oct  2 02:44:46 2003
@@ -42,6 +42,8 @@
 	return retval;
 }
 
+EXPORT_SYMBOL(vfs_statfs);
+
 static int vfs_statfs_native(struct super_block *sb, struct statfs *buf)
 {
 	struct kstatfs st;
@@ -103,7 +105,8 @@
 	return 0;
 }
 
-asmlinkage long sys_statfs(const char __user * path, struct statfs __user * buf)
+asmlinkage long sys_statfs(const char __user *path,
+			   struct statfs __user *buf)
 {
 	struct nameidata nd;
 	int error;
@@ -120,7 +123,8 @@
 }
 
 
-asmlinkage long sys_statfs64(const char __user *path, size_t sz, struct statfs64 __user *buf)
+asmlinkage long sys_statfs64(const char __user *path, size_t sz,
+			     struct statfs64 __user *buf)
 {
 	struct nameidata nd;
 	long error;
@@ -139,7 +143,7 @@
 }
 
 
-asmlinkage long sys_fstatfs(unsigned int fd, struct statfs __user * buf)
+asmlinkage long sys_fstatfs(unsigned int fd, struct statfs __user *buf)
 {
 	struct file * file;
 	struct statfs tmp;
@@ -157,7 +161,8 @@
 	return error;
 }
 
-asmlinkage long sys_fstatfs64(unsigned int fd, size_t sz, struct statfs64 __user *buf)
+asmlinkage long sys_fstatfs64(unsigned int fd, size_t sz,
+			      struct statfs64 __user *buf)
 {
 	struct file * file;
 	struct statfs64 tmp;
@@ -195,7 +200,7 @@
 	return err;
 }
 
-static inline long do_sys_truncate(const char __user * path, loff_t length)
+static inline long do_sys_truncate(const char __user *path, loff_t length)
 {
 	struct nameidata nd;
 	struct inode * inode;
@@ -255,7 +260,7 @@
 	return error;
 }
 
-asmlinkage long sys_truncate(const char __user * path, unsigned long length)
+asmlinkage long sys_truncate(const char __user *path, unsigned long length)
 {
 	/* on 32-bit boxen it will cut the range 2^31--2^32-1 off */
 	return do_sys_truncate(path, (long)length);
@@ -311,7 +316,7 @@
 
 /* LFS versions of truncate are only needed on 32 bit machines */
 #if BITS_PER_LONG == 32
-asmlinkage long sys_truncate64(const char __user * path, loff_t length)
+asmlinkage long sys_truncate64(const char __user *path, loff_t length)
 {
 	return do_sys_truncate(path, length);
 }
@@ -335,7 +340,7 @@
  * must be owner or have write permission.
  * Else, update from *times, must be owner or super user.
  */
-asmlinkage long sys_utime(char __user * filename, struct utimbuf __user * times)
+asmlinkage long sys_utime(char __user *filename, struct utimbuf __user *times)
 {
 	int error;
 	struct nameidata nd;
@@ -361,7 +366,8 @@
 		error = get_user(newattrs.ia_atime.tv_sec, &times->actime);
 		newattrs.ia_atime.tv_nsec = 0;
 		if (!error) 
-			error = get_user(newattrs.ia_mtime.tv_sec, &times->modtime);
+			error = get_user(newattrs.ia_mtime.tv_sec,
+					 &times->modtime);
 		newattrs.ia_mtime.tv_nsec = 0;
 		if (error)
 			goto dput_and_out;
@@ -391,7 +397,7 @@
  * must be owner or have write permission.
  * Else, update from *times, must be owner or super user.
  */
-long do_utimes(char __user * filename, struct timeval * times)
+long do_utimes(char __user *filename, struct timeval *times)
 {
 	int error;
 	struct nameidata nd;
@@ -438,7 +444,8 @@
 	return error;
 }
 
-asmlinkage long sys_utimes(char __user * filename, struct timeval __user * utimes)
+asmlinkage long sys_utimes(char __user *filename,
+			   struct timeval __user *utimes)
 {
 	struct timeval times[2];
 
@@ -453,7 +460,7 @@
  * We do this by temporarily clearing all FS-related capabilities and
  * switching the fsuid/fsgid around to the real ones.
  */
-asmlinkage long sys_access(const char __user * filename, int mode)
+asmlinkage long sys_access(const char __user *filename, int mode)
 {
 	struct nameidata nd;
 	int old_fsuid, old_fsgid;
@@ -500,7 +507,7 @@
 	return res;
 }
 
-asmlinkage long sys_chdir(const char __user * filename)
+asmlinkage long sys_chdir(const char __user *filename)
 {
 	struct nameidata nd;
 	int error;
@@ -551,12 +558,12 @@
 	return error;
 }
 
-asmlinkage long sys_chroot(const char __user * filename)
+asmlinkage long sys_chroot(const char __user *filename)
 {
 	struct nameidata nd;
-	int error;
-
-	error = __user_walk(filename, LOOKUP_FOLLOW | LOOKUP_DIRECTORY | LOOKUP_NOALT, &nd);
+	int error = __user_walk(filename,
+				LOOKUP_FOLLOW | LOOKUP_DIRECTORY |
+					LOOKUP_NOALT, &nd);
 	if (error)
 		goto out;
 
@@ -612,7 +619,7 @@
 	return err;
 }
 
-asmlinkage long sys_chmod(const char __user * filename, mode_t mode)
+asmlinkage long sys_chmod(const char __user *filename, mode_t mode)
 {
 	struct nameidata nd;
 	struct inode * inode;
@@ -646,7 +653,7 @@
 	return error;
 }
 
-static int chown_common(struct dentry * dentry, uid_t user, gid_t group)
+static int chown_common(struct dentry *dentry, uid_t user, gid_t group)
 {
 	struct inode * inode;
 	int error;
@@ -681,7 +688,7 @@
 	return error;
 }
 
-asmlinkage long sys_chown(const char __user * filename, uid_t user, gid_t group)
+asmlinkage long sys_chown(const char __user *filename, uid_t user, gid_t group)
 {
 	struct nameidata nd;
 	int error;
@@ -694,7 +701,7 @@
 	return error;
 }
 
-asmlinkage long sys_lchown(const char __user * filename, uid_t user, gid_t group)
+asmlinkage long sys_lchown(const char __user *filename, uid_t user, gid_t group)
 {
 	struct nameidata nd;
 	int error;
@@ -735,7 +742,7 @@
  * for the internal routines (ie open_namei()/follow_link() etc). 00 is
  * used by symlinks.
  */
-struct file *filp_open(const char * filename, int flags, int mode)
+struct file *filp_open(const char *filename, int flags, int mode)
 {
 	int namei_flags, error;
 	struct nameidata nd;
@@ -753,6 +760,8 @@
 	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 +821,8 @@
 	return ERR_PTR(error);
 }
 
+EXPORT_SYMBOL(dentry_open);
+
 /*
  * Find an empty file descriptor entry, and mark it busy.
  */
@@ -874,6 +885,8 @@
 	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 +902,8 @@
 	spin_unlock(&files->file_lock);
 }
 
+EXPORT_SYMBOL(put_unused_fd);
+
 /*
  * Install a file pointer in the fd array.  
  *
@@ -901,8 +916,7 @@
  * It should never happen - if we allow dup2() do it, _really_ bad things
  * will follow.
  */
-
-void fd_install(unsigned int fd, struct file * file)
+void fd_install(unsigned int fd, struct file *file)
 {
 	struct files_struct *files = current->files;
 	spin_lock(&files->file_lock);
@@ -912,7 +926,9 @@
 	spin_unlock(&files->file_lock);
 }
 
-asmlinkage long sys_open(const char __user * filename, int flags, int mode)
+EXPORT_SYMBOL(fd_install);
+
+asmlinkage long sys_open(const char __user *filename, int flags, int mode)
 {
 	char * tmp;
 	int fd, error;
@@ -948,7 +964,7 @@
  * For backward compatibility?  Maybe this should be moved
  * into arch/i386 instead?
  */
-asmlinkage long sys_creat(const char __user * pathname, int mode)
+asmlinkage long sys_creat(const char __user *pathname, int mode)
 {
 	return sys_open(pathname, O_CREAT | O_WRONLY | O_TRUNC, mode);
 }
@@ -985,6 +1001,8 @@
 	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 +1030,8 @@
 	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.
@@ -1031,7 +1051,7 @@
  * the caller didn't specify O_LARGEFILE.  On 64bit systems we force
  * on this flag in sys_open.
  */
-int generic_file_open(struct inode * inode, struct file * filp)
+int generic_file_open(struct inode *inode, struct file *filp)
 {
 	if (!(filp->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
 		return -EFBIG;
diff -Nru a/fs/partitions/check.c b/fs/partitions/check.c
--- a/fs/partitions/check.c	Thu Oct  2 02:44:46 2003
+++ b/fs/partitions/check.c	Thu Oct  2 02:44:46 2003
@@ -135,6 +135,8 @@
 	return disk_name(bdev->bd_disk, part, buf);
 }
 
+EXPORT_SYMBOL(bdevname);
+
 /*
  * NOTE: this cannot be called from interrupt context.
  *
@@ -158,8 +160,10 @@
 	return buffer;
 }
 
-static struct parsed_partitions *
-check_partition(struct gendisk *hd, struct block_device *bdev)
+EXPORT_SYMBOL(__bdevname);
+
+static struct parsed_partitions *check_partition(struct gendisk *hd,
+						 struct block_device *bdev)
 {
 	struct parsed_partitions *state;
 	int i, res;
@@ -205,14 +209,16 @@
 	ssize_t (*show)(struct hd_struct *,char *);
 };
 
-static ssize_t 
-part_attr_show(struct kobject * kobj, struct attribute * attr, char * page)
+static ssize_t part_attr_show(struct kobject *kobj,
+			      struct attribute *attr, char *page)
 {
-	struct hd_struct * p = container_of(kobj,struct hd_struct,kobj);
-	struct part_attribute * part_attr = container_of(attr,struct part_attribute,attr);
+	struct hd_struct *p = container_of(kobj,struct hd_struct,kobj);
+	struct part_attribute *part_attr = container_of(attr,
+							struct part_attribute,
+							attr);
 	ssize_t ret = 0;
 	if (part_attr->show)
-		ret = part_attr->show(p,page);
+		ret = part_attr->show(p, page);
 	return ret;
 }
 
@@ -220,44 +226,51 @@
 	.show	=	part_attr_show,
 };
 
-static ssize_t part_dev_read(struct hd_struct * p, char *page)
+static ssize_t part_dev_read(struct hd_struct *p, char *page)
 {
 	struct gendisk *disk = container_of(p->kobj.parent,struct gendisk,kobj);
 	dev_t dev = MKDEV(disk->major, disk->first_minor + p->partno); 
 	return print_dev_t(page, dev);
 }
-static ssize_t part_start_read(struct hd_struct * p, char *page)
+
+static ssize_t part_start_read(struct hd_struct *p, char *page)
 {
 	return sprintf(page, "%llu\n",(unsigned long long)p->start_sect);
 }
-static ssize_t part_size_read(struct hd_struct * p, char *page)
+
+static ssize_t part_size_read(struct hd_struct *p, char *page)
 {
 	return sprintf(page, "%llu\n",(unsigned long long)p->nr_sects);
 }
-static ssize_t part_stat_read(struct hd_struct * p, char *page)
+
+static ssize_t part_stat_read(struct hd_struct *p, char *page)
 {
 	return sprintf(page, "%8u %8llu %8u %8llu\n",
 		       p->reads, (unsigned long long)p->read_sectors,
 		       p->writes, (unsigned long long)p->write_sectors);
 }
+
 static struct part_attribute part_attr_dev = {
 	.attr = {.name = "dev", .mode = S_IRUGO },
 	.show	= part_dev_read
 };
+
 static struct part_attribute part_attr_start = {
 	.attr = {.name = "start", .mode = S_IRUGO },
 	.show	= part_start_read
 };
+
 static struct part_attribute part_attr_size = {
 	.attr = {.name = "size", .mode = S_IRUGO },
 	.show	= part_size_read
 };
+
 static struct part_attribute part_attr_stat = {
 	.attr = {.name = "stat", .mode = S_IRUGO },
 	.show	= part_stat_read
 };
 
-static struct attribute * default_attrs[] = {
+static struct attribute *default_attrs[] = {
 	&part_attr_dev.attr,
 	&part_attr_start.attr,
 	&part_attr_size.attr,
@@ -269,7 +282,7 @@
 
 static void part_release(struct kobject *kobj)
 {
-	struct hd_struct * p = container_of(kobj,struct hd_struct,kobj);
+	struct hd_struct *p = container_of(kobj, struct hd_struct, kobj);
 	kfree(p);
 }
 
@@ -294,7 +307,8 @@
 	kobject_unregister(&p->kobj);
 }
 
-void add_partition(struct gendisk *disk, int part, sector_t start, sector_t len)
+void add_partition(struct gendisk *disk, int part,
+		   sector_t start, sector_t len)
 {
 	struct hd_struct *p;
 
@@ -413,13 +427,14 @@
 	return res;
 }
 
-unsigned char *read_dev_sector(struct block_device *bdev, sector_t n, Sector *p)
+unsigned char *read_dev_sector(struct block_device *bdev,
+			       sector_t n, Sector *p)
 {
 	struct address_space *mapping = bdev->bd_inode->i_mapping;
 	struct page *page;
 
 	page = read_cache_page(mapping, (pgoff_t)(n >> (PAGE_CACHE_SHIFT-9)),
-			(filler_t *)mapping->a_ops->readpage, NULL);
+			       (filler_t *)mapping->a_ops->readpage, NULL);
 	if (!IS_ERR(page)) {
 		wait_on_page_locked(page);
 		if (!PageUptodate(page))
@@ -427,13 +442,16 @@
 		if (PageError(page))
 			goto fail;
 		p->v = page;
-		return (unsigned char *)page_address(page) +  ((n & ((1 << (PAGE_CACHE_SHIFT - 9)) - 1)) << 9);
+		return (unsigned char *)page_address(page) +
+		       ((n & ((1 << (PAGE_CACHE_SHIFT - 9)) - 1)) << 9);
 fail:
 		page_cache_release(page);
 	}
 	p->v = NULL;
 	return NULL;
 }
+
+EXPORT_SYMBOL(read_dev_sector);
 
 void del_gendisk(struct gendisk *disk)
 {
diff -Nru a/fs/read_write.c b/fs/read_write.c
--- a/fs/read_write.c	Thu Oct  2 02:44:46 2003
+++ b/fs/read_write.c	Thu Oct  2 02:44:46 2003
@@ -23,6 +23,8 @@
 	.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 @@
 	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 @@
 	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 @@
 	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);
@@ -169,7 +179,8 @@
 }
 #endif
 
-ssize_t do_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos)
+ssize_t do_sync_read(struct file *filp, char __user *buf,
+		     size_t len, loff_t *ppos)
 {
 	struct kiocb kiocb;
 	ssize_t ret;
@@ -183,7 +194,10 @@
 	return ret;
 }
 
-ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
+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;
 	ssize_t ret;
@@ -209,7 +223,10 @@
 	return ret;
 }
 
-ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos)
+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;
 	ssize_t ret;
@@ -223,7 +240,10 @@
 	return ret;
 }
 
-ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
+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;
 	ssize_t ret;
@@ -249,6 +269,8 @@
 	return ret;
 }
 
+EXPORT_SYMBOL(vfs_write);
+
 asmlinkage ssize_t sys_read(unsigned int fd, char __user * buf, size_t count)
 {
 	struct file *file;
@@ -264,7 +286,8 @@
 	return ret;
 }
 
-asmlinkage ssize_t sys_write(unsigned int fd, const char __user * buf, size_t count)
+asmlinkage ssize_t sys_write(unsigned int fd, const char __user * buf,
+			     size_t count)
 {
 	struct file *file;
 	ssize_t ret = -EBADF;
@@ -280,7 +303,7 @@
 }
 
 asmlinkage ssize_t sys_pread64(unsigned int fd, char __user *buf,
-			     size_t count, loff_t pos)
+			       size_t count, loff_t pos)
 {
 	struct file *file;
 	ssize_t ret = -EBADF;
@@ -337,12 +360,16 @@
 	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)
 {
-	typedef ssize_t (*io_fn_t)(struct file *, char __user *, size_t, loff_t *);
-	typedef ssize_t (*iov_fn_t)(struct file *, const struct iovec *, unsigned long, loff_t *);
+	typedef ssize_t (*io_fn_t)(struct file *, char __user *,
+				   size_t, loff_t *);
+	typedef ssize_t (*iov_fn_t)(struct file *, const struct iovec *,
+				    unsigned long, loff_t *);
 
 	size_t tot_len;
 	struct iovec iovstack[UIO_FASTIOV];
@@ -468,6 +495,8 @@
 	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,9 +508,11 @@
 	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)
+asmlinkage ssize_t sys_readv(unsigned long fd,
+			     const struct iovec __user *vec,
+			     unsigned long vlen)
 {
 	struct file *file;
 	ssize_t ret = -EBADF;
@@ -496,8 +527,9 @@
 	return ret;
 }
 
-asmlinkage ssize_t
-sys_writev(unsigned long fd, const struct iovec __user *vec, unsigned long vlen)
+asmlinkage ssize_t sys_writev(unsigned long fd,
+			      const struct iovec __user *vec,
+			      unsigned long vlen)
 {
 	struct file *file;
 	ssize_t ret = -EBADF;
@@ -595,7 +627,8 @@
 	return retval;
 }
 
-asmlinkage ssize_t sys_sendfile(int out_fd, int in_fd, off_t __user *offset, size_t count)
+asmlinkage ssize_t sys_sendfile(int out_fd, int in_fd,
+				off_t __user *offset, size_t count)
 {
 	loff_t pos;
 	off_t off;
@@ -614,7 +647,8 @@
 	return do_sendfile(out_fd, in_fd, NULL, count, MAX_NON_LFS);
 }
 
-asmlinkage ssize_t sys_sendfile64(int out_fd, int in_fd, loff_t __user *offset, size_t count)
+asmlinkage ssize_t sys_sendfile64(int out_fd, int in_fd,
+				  loff_t __user *offset, size_t count)
 {
 	loff_t pos;
 	ssize_t ret;
@@ -630,6 +664,3 @@
 
 	return do_sendfile(out_fd, in_fd, NULL, count, 0);
 }
-
-EXPORT_SYMBOL(do_sync_read);
-EXPORT_SYMBOL(do_sync_write);
diff -Nru a/fs/select.c b/fs/select.c
--- a/fs/select.c	Thu Oct  2 02:44:46 2003
+++ b/fs/select.c	Thu Oct  2 02:44:46 2003
@@ -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>
@@ -53,7 +54,8 @@
  * as all select/poll functions have to call it to add an entry to the
  * poll table.
  */
-void __pollwait(struct file *filp, wait_queue_head_t *wait_address, poll_table *p);
+void __pollwait(struct file *filp, wait_queue_head_t *wait_address,
+		poll_table *p);
 
 void poll_initwait(struct poll_wqueues *pwq)
 {
@@ -62,6 +64,8 @@
 	pwq->table = NULL;
 }
 
+EXPORT_SYMBOL(poll_initwait);
+
 void poll_freewait(struct poll_wqueues *pwq)
 {
 	struct poll_table_page * p = pwq->table;
@@ -81,7 +85,10 @@
 	}
 }
 
-void __pollwait(struct file *filp, wait_queue_head_t *wait_address, poll_table *_p)
+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);
 	struct poll_table_page *table = p->table;
@@ -89,7 +96,7 @@
 	if (!table || POLL_TABLE_FULL(table)) {
 		struct poll_table_page *new_table;
 
-		new_table = (struct poll_table_page *) __get_free_page(GFP_KERNEL);
+		new_table = (struct poll_table_page *)__get_free_page(GFP_KERNEL);
 		if (!new_table) {
 			p->error = -ENOMEM;
 			__set_current_state(TASK_RUNNING);
@@ -266,6 +273,8 @@
 	return retval;
 }
 
+EXPORT_SYMBOL(do_select);
+
 static void *select_bits_alloc(int size)
 {
 	return kmalloc(6 * size, GFP_KERNEL);
@@ -287,8 +296,8 @@
 #define MAX_SELECT_SECONDS \
 	((unsigned long) (MAX_SCHEDULE_TIMEOUT / HZ)-1)
 
-asmlinkage long
-sys_select(int n, fd_set __user *inp, fd_set __user *outp, fd_set __user *exp, struct timeval __user *tvp)
+asmlinkage long sys_select(int n, fd_set __user *inp, fd_set __user *outp,
+			   fd_set __user *exp, struct timeval __user *tvp)
 {
 	fd_set_bits fds;
 	char *bits;
@@ -388,8 +397,8 @@
 
 #define POLLFD_PER_PAGE  ((PAGE_SIZE-sizeof(struct poll_list)) / sizeof(struct pollfd))
 
-static void do_pollfd(unsigned int num, struct pollfd * fdpage,
-	poll_table ** pwait, int *count)
+static void do_pollfd(unsigned int num, struct pollfd *fdpage,
+		      poll_table **pwait, int *count)
 {
 	int i;
 
@@ -421,7 +430,7 @@
 }
 
 static int do_poll(unsigned int nfds,  struct poll_list *list,
-			struct poll_wqueues *wait, long timeout)
+		   struct poll_wqueues *wait, long timeout)
 {
 	int count = 0;
 	poll_table* pt = &wait->pt;
@@ -449,7 +458,8 @@
 	return count;
 }
 
-asmlinkage long sys_poll(struct pollfd __user * ufds, unsigned int nfds, long timeout)
+asmlinkage long sys_poll(struct pollfd __user *ufds, unsigned int nfds,
+			 long timeout)
 {
 	struct poll_wqueues table;
  	int fdcount, err;
diff -Nru a/fs/stat.c b/fs/stat.c
--- a/fs/stat.c	Thu Oct  2 02:44:46 2003
+++ b/fs/stat.c	Thu Oct  2 02:44:46 2003
@@ -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 @@
 	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 @@
 	return 0;
 }
 
+EXPORT_SYMBOL(vfs_getattr);
+
 int vfs_stat(char __user *name, struct kstat *stat)
 {
 	struct nameidata nd;
@@ -69,6 +74,8 @@
 	return error;
 }
 
+EXPORT_SYMBOL(vfs_stat);
+
 int vfs_lstat(char __user *name, struct kstat *stat)
 {
 	struct nameidata nd;
@@ -82,6 +89,8 @@
 	return error;
 }
 
+EXPORT_SYMBOL(vfs_lstat);
+
 int vfs_fstat(unsigned int fd, struct kstat *stat)
 {
 	struct file *f = fget(fd);
@@ -94,6 +103,8 @@
 	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__)
@@ -102,14 +113,16 @@
  * For backward compatibility?  Maybe this should be moved
  * into arch/i386 instead?
  */
-static int cp_old_stat(struct kstat *stat, struct __old_kernel_stat __user * statbuf)
+static int cp_old_stat(struct kstat *stat,
+		       struct __old_kernel_stat __user *statbuf)
 {
 	static int warncount = 5;
 	struct __old_kernel_stat tmp;
 	
 	if (warncount > 0) {
 		warncount--;
-		printk(KERN_WARNING "VFS: Warning: %s using old stat() call. Recompile your binary.\n",
+		printk(KERN_WARNING "VFS: Warning: %s using old stat() "
+				    "call. Recompile your binary.\n",
 			current->comm);
 	} else if (warncount < 0) {
 		/* it's laughable, but... */
@@ -135,7 +148,8 @@
 	return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
 }
 
-asmlinkage long sys_stat(char __user * filename, struct __old_kernel_stat __user * statbuf)
+asmlinkage long sys_stat(char __user *filename,
+			 struct __old_kernel_stat __user *statbuf)
 {
 	struct kstat stat;
 	int error = vfs_stat(filename, &stat);
@@ -145,7 +159,8 @@
 
 	return error;
 }
-asmlinkage long sys_lstat(char __user * filename, struct __old_kernel_stat __user * statbuf)
+asmlinkage long sys_lstat(char __user *filename,
+			  struct __old_kernel_stat __user *statbuf)
 {
 	struct kstat stat;
 	int error = vfs_lstat(filename, &stat);
@@ -155,7 +170,9 @@
 
 	return error;
 }
-asmlinkage long sys_fstat(unsigned int fd, struct __old_kernel_stat __user * statbuf)
+
+asmlinkage long sys_fstat(unsigned int fd,
+			  struct __old_kernel_stat __user *statbuf)
 {
 	struct kstat stat;
 	int error = vfs_fstat(fd, &stat);
@@ -214,7 +231,8 @@
 	return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
 }
 
-asmlinkage long sys_newstat(char __user * filename, struct stat __user * statbuf)
+asmlinkage long sys_newstat(char __user *filename,
+			    struct stat __user *statbuf)
 {
 	struct kstat stat;
 	int error = vfs_stat(filename, &stat);
@@ -224,7 +242,8 @@
 
 	return error;
 }
-asmlinkage long sys_newlstat(char __user * filename, struct stat __user * statbuf)
+asmlinkage long sys_newlstat(char __user *filename,
+			     struct stat __user *statbuf)
 {
 	struct kstat stat;
 	int error = vfs_lstat(filename, &stat);
@@ -234,7 +253,7 @@
 
 	return error;
 }
-asmlinkage long sys_newfstat(unsigned int fd, struct stat __user * statbuf)
+asmlinkage long sys_newfstat(unsigned int fd, struct stat __user *statbuf)
 {
 	struct kstat stat;
 	int error = vfs_fstat(fd, &stat);
@@ -245,7 +264,8 @@
 	return error;
 }
 
-asmlinkage long sys_readlink(const char __user * path, char __user * buf, int bufsiz)
+asmlinkage long sys_readlink(const char __user *path,
+			     char __user *buf, int bufsiz)
 {
 	struct nameidata nd;
 	int error;
@@ -309,7 +329,8 @@
 	return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
 }
 
-asmlinkage long sys_stat64(char __user * filename, struct stat64 __user * statbuf, long flags)
+asmlinkage long sys_stat64(char __user *filename,
+			   struct stat64 __user *statbuf, long flags)
 {
 	struct kstat stat;
 	int error = vfs_stat(filename, &stat);
@@ -319,7 +340,9 @@
 
 	return error;
 }
-asmlinkage long sys_lstat64(char __user * filename, struct stat64 __user * statbuf, long flags)
+
+asmlinkage long sys_lstat64(char __user *filename,
+			    struct stat64 __user *statbuf, long flags)
 {
 	struct kstat stat;
 	int error = vfs_lstat(filename, &stat);
@@ -329,7 +352,9 @@
 
 	return error;
 }
-asmlinkage long sys_fstat64(unsigned long fd, struct stat64 __user * statbuf, long flags)
+
+asmlinkage long sys_fstat64(unsigned long fd,
+			    struct stat64 __user *statbuf, long flags)
 {
 	struct kstat stat;
 	int error = vfs_fstat(fd, &stat);
@@ -355,6 +380,8 @@
 	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 +395,8 @@
 	spin_unlock(&inode->i_lock);
 }
 
+EXPORT_SYMBOL(inode_sub_bytes);
+
 loff_t inode_get_bytes(struct inode *inode)
 {
 	loff_t ret;
@@ -378,8 +407,12 @@
 	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);
diff -Nru a/kernel/ksyms.c b/kernel/ksyms.c
--- a/kernel/ksyms.c	Thu Oct  2 02:44:46 2003
+++ b/kernel/ksyms.c	Thu Oct  2 02:44:46 2003
@@ -137,65 +137,18 @@
 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 +159,12 @@
 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);
@@ -295,8 +240,6 @@
 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);
@@ -321,7 +264,6 @@
 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);
@@ -330,10 +272,6 @@
 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);
@@ -350,7 +288,6 @@
 EXPORT_SYMBOL(__tasklet_hi_schedule);
 
 /* init task, for moving kthread roots - ought to export a function ?? */
-
 EXPORT_SYMBOL(init_task);
 
 EXPORT_SYMBOL(tasklist_lock);
@@ -359,9 +296,6 @@
 #if defined(CONFIG_SMP) && defined(__GENERIC_PER_CPU)
 EXPORT_SYMBOL(__per_cpu_offset);
 #endif
-
-EXPORT_SYMBOL(set_fs_pwd);
-EXPORT_SYMBOL(set_fs_root);
 
 /* debug */
 EXPORT_SYMBOL(dump_stack);

===================================================================

^ permalink raw reply	[flat|nested] 3+ messages in thread
end of thread, other threads:[~2003-10-02  9:38 UTC | newest]

Thread overview: 3+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2003-10-02  3:03 [PATCHES] today's batch of "nuking kernel/ksyms.c" Arnaldo Carvalho de Melo
2003-10-02  4:02 ` Larry McVoy
2003-10-02  9:44   ` Arnaldo Carvalho de Melo

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox