diff --git a/buffer2.c b/buffer2.c
deleted file mode 100644
index 028f11a..0000000
--- a/buffer2.c
+++ /dev/null
@@ -1,569 +0,0 @@
-#define __LIBRARY__
-/*
- *  linux/fs/buffer.c
- *
- *  (C) 1991  Linus Torvalds
- */
-
-/*
- *  'buffer.c' implements the buffer-cache functions. Race-conditions have
- * been avoided by NEVER letting a interrupt change a buffer (except for the
- * data, of course), but instead letting the caller do it. NOTE! As interrupts
- * can wake up a caller, some cli-sti sequences are needed to check for
- * sleep-on-calls. These should be extremely quick, though (I hope).
- */
-
-/*
- * NOTE! There is one discordant note here: checking floppies for
- * disk change. This is where it fits best, I think, as it should
- * invalidate changed floppy-disk-caches.
- */
-#include <unistd.h>
-#include <stdarg.h>
-#include <string.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <linux/config.h>
-#include <linux/sched.h>
-#include <linux/kernel.h>
-#include <asm/system.h>
-#include <asm/io.h>
-#include <asm/segment.h>
-
-#define BUF_MAX 4096
-#define DIRBUF  8192
-#define MAX_ARG_PAGES 32
-#define NAME_LEN 14
-
-extern void put_super(int dev);
-extern void invalidate_inodes(int dev);
-
-extern int end;
-struct buffer_head * start_buffer = (struct buffer_head *) &end;
-struct buffer_head * hash_table[NR_HASH];
-static struct buffer_head * free_list;
-static struct task_struct * buffer_wait = NULL;
-int NR_BUFFERS = 0;
-
-static inline void wait_on_buffer(struct buffer_head * bh)
-{
-	cli();
-	while (bh->b_lock)
-		sleep_on(&bh->b_wait);
-	sti();
-}
-
-int sys_sync(void)
-{
-	int i;
-	struct buffer_head * bh;
-
-	sync_inodes();		/* write out inodes into buffers */
-	bh = start_buffer;
-	for (i=0 ; i<NR_BUFFERS ; i++,bh++) {
-		wait_on_buffer(bh);
-		if (bh->b_dirt)
-			ll_rw_block(WRITE,bh);
-	}
-	return 0;
-}
-
-int sync_dev(int dev)
-{
-	int i;
-	struct buffer_head * bh;
-
-	bh = start_buffer;
-	for (i=0 ; i<NR_BUFFERS ; i++,bh++) {
-		if (bh->b_dev != dev)
-			continue;
-		wait_on_buffer(bh);
-		if (bh->b_dev == dev && bh->b_dirt)
-			ll_rw_block(WRITE,bh);
-	}
-	sync_inodes();
-	bh = start_buffer;
-	for (i=0 ; i<NR_BUFFERS ; i++,bh++) {
-		if (bh->b_dev != dev)
-			continue;
-		wait_on_buffer(bh);
-		if (bh->b_dev == dev && bh->b_dirt)
-			ll_rw_block(WRITE,bh);
-	}
-	return 0;
-}
-
-void inline invalidate_buffers(int dev)
-{
-	int i;
-	struct buffer_head * bh;
-
-	bh = start_buffer;
-	for (i=0 ; i<NR_BUFFERS ; i++,bh++) {
-		if (bh->b_dev != dev)
-			continue;
-		wait_on_buffer(bh);
-		if (bh->b_dev == dev)
-			bh->b_uptodate = bh->b_dirt = 0;
-	}
-}
-
-/*
- * This routine checks whether a floppy has been changed, and
- * invalidates all buffer-cache-entries in that case. This
- * is a relatively slow routine, so we have to try to minimize using
- * it. Thus it is called only upon a 'mount' or 'open'. This
- * is the best way of combining speed and utility, I think.
- * People changing diskettes in the middle of an operation deserve
- * to loose :-)
- *
- * NOTE! Although currently this is only for floppies, the idea is
- * that any additional removable block-device will use this routine,
- * and that mount/open needn't know that floppies/whatever are
- * special.
- */
-void check_disk_change(int dev)
-{
-	int i;
-
-	if (MAJOR(dev) != 2)
-		return;
-	if (!floppy_change(dev & 0x03))
-		return;
-	for (i=0 ; i<NR_SUPER ; i++)
-		if (super_block[i].s_dev == dev)
-			put_super(super_block[i].s_dev);
-	invalidate_inodes(dev);
-	invalidate_buffers(dev);
-}
-
-#define _hashfn(dev,block) (((unsigned)(dev^block))%NR_HASH)
-#define hash(dev,block) hash_table[_hashfn(dev,block)]
-
-static inline void remove_from_queues(struct buffer_head * bh)
-{
-/* remove from hash-queue */
-	if (bh->b_next)
-		bh->b_next->b_prev = bh->b_prev;
-	if (bh->b_prev)
-		bh->b_prev->b_next = bh->b_next;
-	if (hash(bh->b_dev,bh->b_blocknr) == bh)
-		hash(bh->b_dev,bh->b_blocknr) = bh->b_next;
-/* remove from free list */
-	if (!(bh->b_prev_free) || !(bh->b_next_free))
-		panic("Free block list corrupted");
-	bh->b_prev_free->b_next_free = bh->b_next_free;
-	bh->b_next_free->b_prev_free = bh->b_prev_free;
-	if (free_list == bh)
-		free_list = bh->b_next_free;
-}
-
-static inline void insert_into_queues(struct buffer_head * bh)
-{
-/* put at end of free list */
-	bh->b_next_free = free_list;
-	bh->b_prev_free = free_list->b_prev_free;
-	free_list->b_prev_free->b_next_free = bh;
-	free_list->b_prev_free = bh;
-/* put the buffer in new hash-queue if it has a device */
-	bh->b_prev = NULL;
-	bh->b_next = NULL;
-	if (!bh->b_dev)
-		return;
-	bh->b_next = hash(bh->b_dev,bh->b_blocknr);
-	hash(bh->b_dev,bh->b_blocknr) = bh;
-	bh->b_next->b_prev = bh;
-}
-
-static struct buffer_head * find_buffer(int dev, int block)
-{		
-	struct buffer_head * tmp;
-
-	for (tmp = hash(dev,block) ; tmp != NULL ; tmp = tmp->b_next)
-		if (tmp->b_dev==dev && tmp->b_blocknr==block)
-			return tmp;
-	return NULL;
-}
-
-/*
- * Why like this, I hear you say... The reason is race-conditions.
- * As we don't lock buffers (unless we are readint them, that is),
- * something might happen to it while we sleep (ie a read-error
- * will force it bad). This shouldn't really happen currently, but
- * the code is ready.
- */
-struct buffer_head * get_hash_table(int dev, int block)
-{
-	struct buffer_head * bh;
-
-	for (;;) {
-		if (!(bh=find_buffer(dev,block)))
-			return NULL;
-		bh->b_count++;
-		wait_on_buffer(bh);
-		if (bh->b_dev == dev && bh->b_blocknr == block)
-			return bh;
-		bh->b_count--;
-	}
-}
-
-/*
- * Ok, this is getblk, and it isn't very clear, again to hinder
- * race-conditions. Most of the code is seldom used, (ie repeating),
- * so it should be much more efficient than it looks.
- *
- * The algoritm is changed: hopefully better, and an elusive bug removed.
- */
-#define BADNESS(bh) (((bh)->b_dirt<<1)+(bh)->b_lock)
-struct buffer_head * getblk(int dev,int block)
-{
-	struct buffer_head * tmp, * bh;
-
-repeat:
-	if (bh = get_hash_table(dev,block))
-		return bh;
-	tmp = free_list;
-	do {
-		if (tmp->b_count)
-			continue;
-		if (!bh || BADNESS(tmp)<BADNESS(bh)) {
-			bh = tmp;
-			if (!BADNESS(tmp))
-				break;
-		}
-/* and repeat until we find something good */
-	} while ((tmp = tmp->b_next_free) != free_list);
-	if (!bh) {
-		sleep_on(&buffer_wait);
-		goto repeat;
-	}
-	wait_on_buffer(bh);
-	if (bh->b_count)
-		goto repeat;
-	while (bh->b_dirt) {
-		sync_dev(bh->b_dev);
-		wait_on_buffer(bh);
-		if (bh->b_count)
-			goto repeat;
-	}
-/* NOTE!! While we slept waiting for this block, somebody else might */
-/* already have added "this" block to the cache. check it */
-	if (find_buffer(dev,block))
-		goto repeat;
-/* OK, FINALLY we know that this buffer is the only one of it's kind, */
-/* and that it's unused (b_count=0), unlocked (b_lock=0), and clean */
-	bh->b_count=1;
-	bh->b_dirt=0;
-	bh->b_uptodate=0;
-	remove_from_queues(bh);
-	bh->b_dev=dev;
-	bh->b_blocknr=block;
-	insert_into_queues(bh);
-	return bh;
-}
-
-void brelse(struct buffer_head * buf)
-{
-	if (!buf)
-		return;
-	wait_on_buffer(buf);
-	if (!(buf->b_count--))
-		panic("Trying to free free buffer");
-	wake_up(&buffer_wait);
-}
-
-/*
- * bread() reads a specified block and returns the buffer that contains
- * it. It returns NULL if the block was unreadable.
- */
-struct buffer_head * bread(int dev,int block)
-{
-	struct buffer_head * bh;
-
-	if (!(bh=getblk(dev,block)))
-		panic("bread: getblk returned NULL\n");
-	if (bh->b_uptodate)
-		return bh;
-	ll_rw_block(READ,bh);
-	wait_on_buffer(bh);
-	if (bh->b_uptodate)
-		return bh;
-	brelse(bh);
-	return NULL;
-}
-
-#define COPYBLK(from,to) \
-__asm__("cld\n\t" \
-	"rep\n\t" \
-	"movsl\n\t" \
-	::"c" (BLOCK_SIZE/4),"S" (from),"D" (to) \
-	)
-
-/*
- * bread_page reads four buffers into memory at the desired address. It's
- * a function of its own, as there is some speed to be got by reading them
- * all at the same time, not waiting for one to be read, and then another
- * etc.
- */
-void bread_page(unsigned long address,int dev,int b[4])
-{
-	struct buffer_head * bh[4];
-	int i;
-
-	for (i=0 ; i<4 ; i++)
-		if (b[i]) {
-			if (bh[i] = getblk(dev,b[i]))
-				if (!bh[i]->b_uptodate)
-					ll_rw_block(READ,bh[i]);
-		} else
-			bh[i] = NULL;
-	for (i=0 ; i<4 ; i++,address += BLOCK_SIZE)
-		if (bh[i]) {
-			wait_on_buffer(bh[i]);
-			if (bh[i]->b_uptodate)
-				COPYBLK((unsigned long) bh[i]->b_data,address);
-			brelse(bh[i]);
-		}
-}
-
-/*
- * Ok, breada can be used as bread, but additionally to mark other
- * blocks for reading as well. End the argument list with a negative
- * number.
- */
-struct buffer_head * breada(int dev,int first, ...)
-{
-	va_list args;
-	struct buffer_head * bh, *tmp;
-
-	va_start(args,first);
-	if (!(bh=getblk(dev,first)))
-		panic("bread: getblk returned NULL\n");
-	if (!bh->b_uptodate)
-		ll_rw_block(READ,bh);
-	while ((first=va_arg(args,int))>=0) {
-		tmp=getblk(dev,first);
-		if (tmp) {
-			if (!tmp->b_uptodate)
-				ll_rw_block(READA,bh);
-			tmp->b_count--;
-		}
-	}
-	va_end(args);
-	wait_on_buffer(bh);
-	if (bh->b_uptodate)
-		return bh;
-	brelse(bh);
-	return (NULL);
-}
-
-void buffer_init(long buffer_end)
-{
-	struct buffer_head * h = start_buffer;
-	void * b;
-	int i;
-
-	if (buffer_end == 1<<20)
-		b = (void *) (640*1024);
-	else
-		b = (void *) buffer_end;
-	while ( (b -= BLOCK_SIZE) >= ((void *) (h+1)) ) {
-		h->b_dev = 0;
-		h->b_dirt = 0;
-		h->b_count = 0;
-		h->b_lock = 0;
-		h->b_uptodate = 0;
-		h->b_wait = NULL;
-		h->b_next = NULL;
-		h->b_prev = NULL;
-		h->b_data = (char *) b;
-		h->b_prev_free = h-1;
-		h->b_next_free = h+1;
-		h++;
-		NR_BUFFERS++;
-		if (b == (void *) 0x100000)
-			b = (void *) 0xA0000;
-	}
-	h--;
-	free_list = start_buffer;
-	free_list->b_prev_free = h;
-	h->b_next_free = free_list;
-	for (i=0;i<NR_HASH;i++)
-		hash_table[i]=NULL;
-}	
-
-//mygetdents
-/*���建�����ṹ*/
-struct linux_dirent
-{
-	long        d_ino;
-	off_t       d_off;
-	unsigned short  d_reclen;
-	char            d_name[NAME_LEN+1];
-};
-int sys_getdents(unsigned int fd, struct linux_dirent* dirp, unsigned int
-	count)
-{
-	struct file* file;
-	struct linux_dirent mydir;
-	struct dir_entry* dir;
-	struct m_inode* inode;
-	struct buffer_head* bh;
-	char* buf;
-	int i, j, dsize, ldsize;
-	int num = 0;
-	/*dirp��СΪ0*/
-	if (!count)
-		return -1;
-	file = current->filp[fd];//��fd����filp����õ������ļ�file
-	inode = file->f_inode;//ͨ��file�õ������ڵ�f_inode
-	bh = bread(inode->i_dev, inode->i_zone[0]);//����bread���豸��ȡ���ļ����ݶ�ӦӲ����������ݣ�
-	                                           //����buffer_head�ṹ��ָ��bh
-	dsize = sizeof(struct dir_entry);//��ȡdir_entry�ṹ��Ĵ�С
-	ldsize = sizeof(struct linux_dirent);//��ȡlinux_dirent�ṹ��Ĵ�С
-	for (j = 0; j < inode->i_size; j += dsize)
-	{
-		if (num + ldsize >= count)
-			return 0;
-
-		dir = (struct dir_entry*)(bh->b_data + j);
-		if (dir->inode)
-		{
-			mydir.d_ino = dir->inode;
-			for (i = 0; i < NAME_LEN; i++)
-				mydir.d_name[i] = dir->name[i];
-			mydir.d_off = 0;
-			mydir.d_reclen = sizeof(mydir);
-			buf = &mydir;
-			for (i = 0; i < mydir.d_reclen; i++)
-			{
-				put_fs_byte(*(buf + i), ((char*)dirp) + i + num);
-			}
-			num += mydir.d_reclen;
-		}
-		else
-			continue;
-	}
-	return num;
-}
-
-//mygetcwd
-typedef struct
-{
-	int	d_fd;			
-	int	d_off;			
-	int	d_size;		
-	char* d_buf;		
-}	DIR;			
-
-struct direct {
-	ino_t d_ino;
-	char d_name[NAME_LEN];
-};
-
-static struct linux_dirent res;
-_syscall3(int, read, int, fildes, char*, buf, off_t, count)         
-_syscall2(int, fstat, int, fildes, struct stat*, stat_buf)          
-_syscall2(int, stat, const char*, filename, struct stat*, stat_buf) 
-_syscall1(int, chdir, const char*, filename)                        
-struct linux_dirent* readdir(DIR* dir)             
-{                                           
-	struct direct* ptr;                       
-											  
-	if (!dir) {
-		errno = EBADF;
-		return NULL;
-	}
-	if (!dir->d_buf)
-		if (!(dir->d_buf = malloc(DIRBUF)))
-			return NULL;
-		else
-			dir->d_size = dir->d_off = 0;
-	while (1) {
-		if (dir->d_size <= dir->d_off) {
-			dir->d_off = 0;
-			dir->d_size = read(dir->d_fd, dir->d_buf, DIRBUF);
-		}
-		if (dir->d_size <= 0)
-			return NULL;
-		ptr = (struct direct*)(dir->d_off + dir->d_buf);
-		dir->d_off += sizeof(*ptr);
-		if (!ptr->d_ino)
-			continue;
-		res.d_ino = ptr->d_ino;
-		strncpy(res.d_name, ptr->d_name, NAME_LEN);
-		res.d_name[NAME_LEN] = 0;
-		res.d_reclen = strlen(res.d_name);
-		return &res;
-	}
-}
-int closedir(DIR* dir)       
-{
-	int fd;
-
-	if (!dir) {
-		errno = EBADF;
-		return -1;
-	}
-	fd = dir->d_fd;
-	free(dir->d_buf);
-	free(dir);
-	return close(fd);
-}
-DIR* opendir(const char* dirname)         
-{
-	int fd;
-	struct stat stat_buf;
-	DIR* ptr;
-
-	if ((fd = open(dirname, O_RDONLY)) < 0) 
-		return NULL;
-	if (fstat(fd, &stat_buf) < 0 ||          
-		!S_ISDIR(stat_buf.st_mode) ||
-		!(ptr = malloc(sizeof(*ptr)))) {
-		close(fd);
-		return NULL;
-	}
-	memset(ptr, 0, sizeof(*ptr));
-	ptr->d_fd = fd;
-	return ptr;
-}
-char* sys_getcwd(char* buf, size_t size) {
-	char path[BUF_MAX], cwd[BUF_MAX];
-	DIR* dirp;
-	struct linux_dirent* dp;
-	struct stat state0, state1, state2;
-	dev_t dev;
-	ino_t ino;
-
-	while (1) {
-		if (stat(".", &state0 == 0)) {            
-			dev = state0.st_dev;
-			ino = state0.st_ino;
-		}
-
-		dirp = opendir("..");                          
-		stat("..", &state2);                         
-		if (state2.st_dev == dev && state2.st_ino == ino)
-			break;                                            
-
-		while ((dp = readdir(dirp)) != NULL) {           
-			memcpy(path, dp->d_name, BUF_MAX);          
-			stat(path, &state1);                             
-
-			if (dev == state1.st_dev && ino == state1.st_ino) {
-				memset(cwd, 0, sizeof(cwd));                    
-				strcat(cwd, "/");
-				strcat(cwd, dp->d_name);
-				strcat(cwd, buf);                               
-				strncpy(buf, cwd, BUF_MAX);                     
-				break;
-			}
-		}
-		closedir(dirp);
-		chdir("..");											
-	}
-	return buf;
-}
\ No newline at end of file