总代码

exec.c

@@ -357,4 +357,173 @@ exec_error1:
 		free_page(page[i]);
 	return(retval);
 }
+/*int do_execve2(unsigned long * eip,long tmp,char * filename,
+	char ** argv, char ** envp)
+{
+	struct m_inode * inode;
+	struct buffer_head * bh;
+	struct exec ex;
+	unsigned long page[MAX_ARG_PAGES];
+	int i,argc,envc;
+	int e_uid, e_gid;
+	int retval;
+	int sh_bang = 0;
+	unsigned long p=PAGE_SIZE*MAX_ARG_PAGES-4;
 
+	if ((0xffff & eip[1]) != 0x000f)
+		panic("execve called from supervisor mode");
+	for (i=0 ; i<MAX_ARG_PAGES ; i++)	
+		page[i]=0;
+	if (!(inode=namei(filename)))		
+		return -ENOENT;
+	argc = count(argv);
+	envc = count(envp);
+	
+restart_interp:
+	if (!S_ISREG(inode->i_mode)) {	
+		retval = -EACCES;
+		goto exec_error2;
+	}
+	i = inode->i_mode;
+	e_uid = (i & S_ISUID) ? inode->i_uid : current->euid;
+	e_gid = (i & S_ISGID) ? inode->i_gid : current->egid;
+	if (current->euid == inode->i_uid)
+		i >>= 6;
+	else if (current->egid == inode->i_gid)
+		i >>= 3;
+	if (!(i & 1) &&
+	    !((inode->i_mode & 0111) && suser())) {
+		retval = -ENOEXEC;
+		goto exec_error2;
+	}
+	if (!(bh = bread(inode->i_dev,inode->i_zone[0]))) {
+		retval = -EACCES;
+		goto exec_error2;
+	}
+	ex = *((struct exec *) bh->b_data);	
+	if ((bh->b_data[0] == '#') && (bh->b_data[1] == '!') && (!sh_bang)) {
+	
+		char buf[1023], *cp, *interp, *i_name, *i_arg;
+		unsigned long old_fs;
+
+		strncpy(buf, bh->b_data+2, 1022);
+		brelse(bh);
+		iput(inode);
+		buf[1022] = '\0';
+		if (cp = strchr(buf, '\n')) {
+			*cp = '\0';
+			for (cp = buf; (*cp == ' ') || (*cp == '\t'); cp++);
+		}
+		if (!cp || *cp == '\0') {
+			retval = -ENOEXEC; 
+			goto exec_error1;
+		}
+		interp = i_name = cp;
+		i_arg = 0;
+		for ( ; *cp && (*cp != ' ') && (*cp != '\t'); cp++) {
+ 			if (*cp == '/')
+				i_name = cp+1;
+		}
+		if (*cp) {
+			*cp++ = '\0';
+			i_arg = cp;
+		}
+		
+		if (sh_bang++ == 0) {
+			p = copy_strings(envc, envp, page, p, 0);
+			p = copy_strings(--argc, argv+1, page, p, 0);
+		}
+		
+		
+		 
+		p = copy_strings(1, &filename, page, p, 1);
+		argc++;
+		if (i_arg) {
+			p = copy_strings(1, &i_arg, page, p, 2);
+			argc++;
+		}
+		p = copy_strings(1, &i_name, page, p, 2);
+		argc++;
+		if (!p) {
+			retval = -ENOMEM;
+			goto exec_error1;
+		}
+		
+		old_fs = get_fs();
+		set_fs(get_ds());
+		if (!(inode=namei(interp))) { 
+			set_fs(old_fs);
+			retval = -ENOENT;
+			goto exec_error1;
+		}
+		set_fs(old_fs);
+		goto restart_interp;
+	}
+	brelse(bh);
+	if (N_MAGIC(ex) != ZMAGIC || ex.a_trsize || ex.a_drsize ||
+		ex.a_text+ex.a_data+ex.a_bss>0x3000000 ||
+		inode->i_size < ex.a_text+ex.a_data+ex.a_syms+N_TXTOFF(ex)) {
+		retval = -ENOEXEC;
+		goto exec_error2;
+	}
+	if (N_TXTOFF(ex) != BLOCK_SIZE) {
+		printk("%s: N_TXTOFF != BLOCK_SIZE. See a.out.h.", filename);
+		retval = -ENOEXEC;
+		goto exec_error2;
+	}
+	if (!sh_bang) {
+		p = copy_strings(envc,envp,page,p,0);
+		p = copy_strings(argc,argv,page,p,0);
+		if (!p) {
+			retval = -ENOMEM;
+			goto exec_error2;
+		}
+	}
+	if (current->executable)
+		iput(current->executable);
+	current->executable = inode;
+	for (i=0 ; i<32 ; i++)
+		current->sigaction[i].sa_handler = NULL;
+	for (i=0 ; i<NR_OPEN ; i++)
+		if ((current->close_on_exec>>i)&1)
+			sys_close(i);
+	current->close_on_exec = 0;
+	free_page_tables(get_base(current->ldt[1]),get_limit(0x0f));
+	free_page_tables(get_base(current->ldt[2]),get_limit(0x17));
+	if (last_task_used_math == current)
+		last_task_used_math = NULL;
+	current->used_math = 0;
+	p += change_ldt(ex.a_text,page)-MAX_ARG_PAGES*PAGE_SIZE;
+	p = (unsigned long) create_tables((char *)p,argc,envc);
+	current->brk = ex.a_bss +
+		(current->end_data = ex.a_data +
+		(current->end_code = ex.a_text));
+	current->start_stack = p & 0xfffff000;
+	current->euid = e_uid;
+	current->egid = e_gid;
+	i = ex.a_text+ex.a_data;
+	while (i&0xfff)
+		put_fs_byte(0,(char *) (i++));
+	eip[0] = ex.a_entry;		
+	eip[3] = p;			
+	int j=0;
+	for(j;j<current->brk;j+=4096){
+		do_no_page1(current->start_code);
+	}
+	return 0;
+exec_error2:
+	iput(inode);
+exec_error1:
+	for (i=0 ; i<MAX_ARG_PAGES ; i++)
+		free_page(page[i]);
+	return(retval);
+}*/
+int do_execve2(unsigned long * eip,long tmp,char * filename,
+	char ** argv, char ** envp){
+	int ret = do_execve(eip,tmp,filename,argv,envp);
+	int j=0;
+	for(j;j<=current->brk;j+=4096){
+		do_no_page1(current->start_code+j);
+	}
+	return 0;
+}

memory.c

@@ -0,0 +1,464 @@
+/*
+ *  linux/mm/memory.c
+ *
+ *  (C) 1991  Linus Torvalds
+ */
+
+/*
+ * demand-loading started 01.12.91 - seems it is high on the list of
+ * things wanted, and it should be easy to implement. - Linus
+ */
+
+/*
+ * Ok, demand-loading was easy, shared pages a little bit tricker. Shared
+ * pages started 02.12.91, seems to work. - Linus.
+ *
+ * Tested sharing by executing about 30 /bin/sh: under the old kernel it
+ * would have taken more than the 6M I have free, but it worked well as
+ * far as I could see.
+ *
+ * Also corrected some "invalidate()"s - I wasn't doing enough of them.
+ */
+
+#include <signal.h>
+
+#include <asm/system.h>
+#include <linux/sched.h>
+#include <linux/head.h>
+#include <linux/kernel.h>
+
+volatile void do_exit(long code);
+
+static inline volatile void oom(void)
+{
+	printk("out of memory\n\r");
+	do_exit(SIGSEGV);
+}
+
+#define invalidate() \
+__asm__("movl %%eax,%%cr3"::"a" (0))
+
+/* these are not to be changed without changing head.s etc */
+#define LOW_MEM 0x100000
+#define PAGING_MEMORY (15*1024*1024)
+#define PAGING_PAGES (PAGING_MEMORY>>12)
+#define MAP_NR(addr) (((addr)-LOW_MEM)>>12)
+#define USED 100
+
+#define CODE_SPACE(addr) ((((addr)+4095)&~4095) < \
+current->start_code + current->end_code)
+
+static long HIGH_MEMORY = 0;
+
+#define copy_page(from,to) \
+__asm__("cld ; rep ; movsl"::"S" (from),"D" (to),"c" (1024))
+
+static unsigned char mem_map [ PAGING_PAGES ] = {0,};
+
+/*
+ * Get physical address of first (actually last :-) free page, and mark it
+ * used. If no free pages left, return 0.
+ */
+unsigned long get_free_page(void)
+{
+register unsigned long __res asm("ax");
+
+__asm__("std ; repne ; scasb\n\t"
+	"jne 1f\n\t"
+	"movb $1,1(%%edi)\n\t"
+	"sall $12,%%ecx\n\t"
+	"addl %2,%%ecx\n\t"
+	"movl %%ecx,%%edx\n\t"
+	"movl $1024,%%ecx\n\t"
+	"leal 4092(%%edx),%%edi\n\t"
+	"rep ; stosl\n\t"
+	"movl %%edx,%%eax\n\t"
+	"1:"
+	"cld\n\t"       /* by wyj */
+	:"=a" (__res)
+	:"0" (0),"i" (LOW_MEM),"c" (PAGING_PAGES),
+	"D" (mem_map+PAGING_PAGES-1)
+	);
+return __res;
+}
+
+/*
+ * Free a page of memory at physical address 'addr'. Used by
+ * 'free_page_tables()'
+ */
+void free_page(unsigned long addr)
+{
+	if (addr < LOW_MEM) return;
+	if (addr >= HIGH_MEMORY)
+		panic("trying to free nonexistent page");
+	addr -= LOW_MEM;
+	addr >>= 12;
+	if (mem_map[addr]--) return;
+	mem_map[addr]=0;
+	panic("trying to free free page");
+}
+
+/*
+ * This function frees a continuos block of page tables, as needed
+ * by 'exit()'. As does copy_page_tables(), this handles only 4Mb blocks.
+ */
+int free_page_tables(unsigned long from,unsigned long size)
+{
+	unsigned long *pg_table;
+	unsigned long * dir, nr;
+
+	if (from & 0x3fffff)
+		panic("free_page_tables called with wrong alignment");
+	if (!from)
+		panic("Trying to free up swapper memory space");
+	size = (size + 0x3fffff) >> 22;
+	dir = (unsigned long *) ((from>>20) & 0xffc); /* _pg_dir = 0 */
+	for ( ; size-->0 ; dir++) {
+		if (!(1 & *dir))
+			continue;
+		pg_table = (unsigned long *) (0xfffff000 & *dir);
+		for (nr=0 ; nr<1024 ; nr++) {
+			if (1 & *pg_table)
+				free_page(0xfffff000 & *pg_table);
+			*pg_table = 0;
+			pg_table++;
+		}
+		free_page(0xfffff000 & *dir);
+		*dir = 0;
+	}
+	invalidate();
+	return 0;
+}
+
+/*
+ *  Well, here is one of the most complicated functions in mm. It
+ * copies a range of linerar addresses by copying only the pages.
+ * Let's hope this is bug-free, 'cause this one I don't want to debug :-)
+ *
+ * Note! We don't copy just any chunks of memory - addresses have to
+ * be divisible by 4Mb (one page-directory entry), as this makes the
+ * function easier. It's used only by fork anyway.
+ *
+ * NOTE 2!! When from==0 we are copying kernel space for the first
+ * fork(). Then we DONT want to copy a full page-directory entry, as
+ * that would lead to some serious memory waste - we just copy the
+ * first 160 pages - 640kB. Even that is more than we need, but it
+ * doesn't take any more memory - we don't copy-on-write in the low
+ * 1 Mb-range, so the pages can be shared with the kernel. Thus the
+ * special case for nr=xxxx.
+ */
+int copy_page_tables(unsigned long from,unsigned long to,long size)
+{
+	unsigned long * from_page_table;
+	unsigned long * to_page_table;
+	unsigned long this_page;
+	unsigned long * from_dir, * to_dir;
+	unsigned long nr;
+
+	if ((from&0x3fffff) || (to&0x3fffff))
+		panic("copy_page_tables called with wrong alignment");
+	from_dir = (unsigned long *) ((from>>20) & 0xffc); /* _pg_dir = 0 */
+	to_dir = (unsigned long *) ((to>>20) & 0xffc);
+	size = ((unsigned) (size+0x3fffff)) >> 22;
+	for( ; size-->0 ; from_dir++,to_dir++) {
+		if (1 & *to_dir)
+			panic("copy_page_tables: already exist");
+		if (!(1 & *from_dir))
+			continue;
+		from_page_table = (unsigned long *) (0xfffff000 & *from_dir);
+		if (!(to_page_table = (unsigned long *) get_free_page()))
+			return -1;	/* Out of memory, see freeing */
+		*to_dir = ((unsigned long) to_page_table) | 7;
+		nr = (from==0)?0xA0:1024;
+		for ( ; nr-- > 0 ; from_page_table++,to_page_table++) {
+			this_page = *from_page_table;
+			if (!(1 & this_page))
+				continue;
+			this_page &= ~2;
+			*to_page_table = this_page;
+			if (this_page > LOW_MEM) {
+				*from_page_table = this_page;
+				this_page -= LOW_MEM;
+				this_page >>= 12;
+				mem_map[this_page]++;
+			}
+		}
+	}
+	invalidate();
+	return 0;
+}
+
+/*
+ * This function puts a page in memory at the wanted address.
+ * It returns the physical address of the page gotten, 0 if
+ * out of memory (either when trying to access page-table or
+ * page.)
+ */
+unsigned long put_page(unsigned long page,unsigned long address)
+{
+	unsigned long tmp, *page_table;
+
+/* NOTE !!! This uses the fact that _pg_dir=0 */
+
+	if (page < LOW_MEM || page >= HIGH_MEMORY)
+		printk("Trying to put page %p at %p\n",page,address);
+	if (mem_map[(page-LOW_MEM)>>12] != 1)
+		printk("mem_map disagrees with %p at %p\n",page,address);
+	page_table = (unsigned long *) ((address>>20) & 0xffc);
+	if ((*page_table)&1)
+		page_table = (unsigned long *) (0xfffff000 & *page_table);
+	else {
+		if (!(tmp=get_free_page()))
+			return 0;
+		*page_table = tmp|7;
+		page_table = (unsigned long *) tmp;
+	}
+	page_table[(address>>12) & 0x3ff] = page | 7;
+/* no need for invalidate */
+	return page;
+}
+
+void un_wp_page(unsigned long * table_entry)
+{
+	unsigned long old_page,new_page;
+
+	old_page = 0xfffff000 & *table_entry;
+	if (old_page >= LOW_MEM && mem_map[MAP_NR(old_page)]==1) {
+		*table_entry |= 2;
+		invalidate();
+		return;
+	}
+	if (!(new_page=get_free_page()))
+		oom();
+	if (old_page >= LOW_MEM)
+		mem_map[MAP_NR(old_page)]--;
+	*table_entry = new_page | 7;
+	invalidate();
+	copy_page(old_page,new_page);
+}	
+
+/*
+ * This routine handles present pages, when users try to write
+ * to a shared page. It is done by copying the page to a new address
+ * and decrementing the shared-page counter for the old page.
+ *
+ * If it's in code space we exit with a segment error.
+ */
+void do_wp_page(unsigned long error_code,unsigned long address)
+{
+#if 0
+/* we cannot do this yet: the estdio library writes to code space */
+/* stupid, stupid. I really want the libc.a from GNU */
+	if (CODE_SPACE(address))
+		do_exit(SIGSEGV);
+#endif
+	un_wp_page((unsigned long *)
+		(((address>>10) & 0xffc) + (0xfffff000 &
+		*((unsigned long *) ((address>>20) &0xffc)))));
+
+}
+
+void write_verify(unsigned long address)
+{
+	unsigned long page;
+
+	if (!( (page = *((unsigned long *) ((address>>20) & 0xffc)) )&1))
+		return;
+	page &= 0xfffff000;
+	page += ((address>>10) & 0xffc);
+	if ((3 & *(unsigned long *) page) == 1)  /* non-writeable, present */
+		un_wp_page((unsigned long *) page);
+	return;
+}
+
+void get_empty_page(unsigned long address)
+{
+	unsigned long tmp;
+
+	if (!(tmp=get_free_page()) || !put_page(tmp,address)) {
+		free_page(tmp);		/* 0 is ok - ignored */
+		oom();
+	}
+}
+
+/*
+ * try_to_share() checks the page at address "address" in the task "p",
+ * to see if it exists, and if it is clean. If so, share it with the current
+ * task.
+ *
+ * NOTE! This assumes we have checked that p != current, and that they
+ * share the same executable.
+ */
+static int try_to_share(unsigned long address, struct task_struct * p)
+{
+	unsigned long from;
+	unsigned long to;
+	unsigned long from_page;
+	unsigned long to_page;
+	unsigned long phys_addr;
+
+	from_page = to_page = ((address>>20) & 0xffc);
+	from_page += ((p->start_code>>20) & 0xffc);
+	to_page += ((current->start_code>>20) & 0xffc);
+/* is there a page-directory at from? */
+	from = *(unsigned long *) from_page;
+	if (!(from & 1))
+		return 0;
+	from &= 0xfffff000;
+	from_page = from + ((address>>10) & 0xffc);
+	phys_addr = *(unsigned long *) from_page;
+/* is the page clean and present? */
+	if ((phys_addr & 0x41) != 0x01)
+		return 0;
+	phys_addr &= 0xfffff000;
+	if (phys_addr >= HIGH_MEMORY || phys_addr < LOW_MEM)
+		return 0;
+	to = *(unsigned long *) to_page;
+	if (!(to & 1))
+		if (to = get_free_page())
+			*(unsigned long *) to_page = to | 7;
+		else
+			oom();
+	to &= 0xfffff000;
+	to_page = to + ((address>>10) & 0xffc);
+	if (1 & *(unsigned long *) to_page)
+		panic("try_to_share: to_page already exists");
+/* share them: write-protect */
+	*(unsigned long *) from_page &= ~2;
+	*(unsigned long *) to_page = *(unsigned long *) from_page;
+	invalidate();
+	phys_addr -= LOW_MEM;
+	phys_addr >>= 12;
+	mem_map[phys_addr]++;
+	return 1;
+}
+
+/*
+ * share_page() tries to find a process that could share a page with
+ * the current one. Address is the address of the wanted page relative
+ * to the current data space.
+ *
+ * We first check if it is at all feasible by checking executable->i_count.
+ * It should be >1 if there are other tasks sharing this inode.
+ */
+static int share_page(unsigned long address)
+{
+	struct task_struct ** p;
+
+	if (!current->executable)
+		return 0;
+	if (current->executable->i_count < 2)
+		return 0;
+	for (p = &LAST_TASK ; p > &FIRST_TASK ; --p) {
+		if (!*p)
+			continue;
+		if (current == *p)
+			continue;
+		if ((*p)->executable != current->executable)
+			continue;
+		if (try_to_share(address,*p))
+			return 1;
+	}
+	return 0;
+}
+
+void do_no_page(unsigned long error_code,unsigned long address)
+{
+	int nr[4];
+	unsigned long tmp;
+	unsigned long page;
+	int block,i;
+
+	if (current->pid > 5)
+		printk(" --do_no_page: address=%x, pid=%d\n", address, current->pid);
+		
+	address &= 0xfffff000;
+	tmp = address - current->start_code;
+	if (!current->executable || tmp >= current->end_data) {
+		get_empty_page(address);
+		return;
+	}
+	if (share_page(tmp))
+		return;
+	if (!(page = get_free_page()))
+		oom();
+/* remember that 1 block is used for header */
+	block = 1 + tmp/BLOCK_SIZE;
+	for (i=0 ; i<4 ; block++,i++)
+		nr[i] = bmap(current->executable,block);
+	bread_page(page,current->executable->i_dev,nr);
+	i = tmp + 4096 - current->end_data;
+	tmp = page + 4096;
+	while (i-- > 0) {
+		tmp--;
+		*(char *)tmp = 0;
+	}
+	if (put_page(page,address))
+		return;
+	free_page(page);
+	oom();
+}
+void do_no_page1(unsigned long address)
+{
+	int nr[4];
+	unsigned long tmp;
+	unsigned long page;
+	int block,i;
+	address &= 0xfffff000;
+	tmp = address - current->start_code;
+	if (!current->executable || tmp >= current->end_data) {
+		get_empty_page(address);
+		return;
+	}
+	if (share_page(tmp))
+		return;
+	if (!(page = get_free_page()))
+		oom();
+	block = 1 + tmp/BLOCK_SIZE;
+	for (i=0 ; i<4 ; block++,i++)
+		nr[i] = bmap(current->executable,block);
+	bread_page(page,current->executable->i_dev,nr);
+	i = tmp + 4096 - current->end_data;
+	tmp = page + 4096;
+	while (i-- > 0) {
+		tmp--;
+		*(char *)tmp = 0;
+	}
+	if (put_page(page,address))
+		return;
+	free_page(page);
+	oom();
+}
+void mem_init(long start_mem, long end_mem)
+{
+	int i;
+
+	HIGH_MEMORY = end_mem;
+	for (i=0 ; i<PAGING_PAGES ; i++)
+		mem_map[i] = USED;
+	i = MAP_NR(start_mem);
+	end_mem -= start_mem;
+	end_mem >>= 12;
+	while (end_mem-->0)
+		mem_map[i++]=0;
+}
+
+void calc_mem(void)
+{
+	int i,j,k,free=0;
+	long * pg_tbl;
+
+	for(i=0 ; i<PAGING_PAGES ; i++)
+		if (!mem_map[i]) free++;
+	printk("%d pages free (of %d)\n\r",free,PAGING_PAGES);
+	for(i=2 ; i<1024 ; i++) {
+		if (1&pg_dir[i]) {
+			pg_tbl=(long *) (0xfffff000 & pg_dir[i]);
+			for(j=k=0 ; j<1024 ; j++)
+				if (pg_tbl[j]&1)
+					k++;
+			printk("Pg-dir[%d] uses %d pages\n",i,k);
+		}
+	}
+}
+

open(add getdents).c

@@ -0,0 +1,343 @@
+/*
+ *  linux/fs/open.c
+ *
+ *  (C) 1991  Linus Torvalds
+ */
+
+#include <string.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <utime.h>
+#include <sys/stat.h>
+#include <const.h>
+#include <linux/sched.h>
+#include <linux/tty.h>
+#include <linux/kernel.h>
+#include <asm/segment.h>
+
+int sys_ustat(int dev, struct ustat * ubuf)
+{
+	return -ENOSYS;
+}
+
+int sys_utime(char * filename, struct utimbuf * times)
+{
+	struct m_inode * inode;
+	long actime,modtime;
+
+	if (!(inode=namei(filename)))
+		return -ENOENT;
+	if (times) {
+		actime = get_fs_long((unsigned long *) &times->actime);
+		modtime = get_fs_long((unsigned long *) &times->modtime);
+	} else
+		actime = modtime = CURRENT_TIME;
+	inode->i_atime = actime;
+	inode->i_mtime = modtime;
+	inode->i_dirt = 1;
+	iput(inode);
+	return 0;
+}
+
+/*
+ * XXX should we use the real or effective uid?  BSD uses the real uid,
+ * so as to make this call useful to setuid programs.
+ */
+int sys_access(const char * filename,int mode)
+{
+	struct m_inode * inode;
+	int res, i_mode;
+
+	mode &= 0007;
+	if (!(inode=namei(filename)))
+		return -EACCES;
+	i_mode = res = inode->i_mode & 0777;
+	iput(inode);
+	if (current->uid == inode->i_uid)
+		res >>= 6;
+	else if (current->gid == inode->i_gid)
+		res >>= 6;
+	if ((res & 0007 & mode) == mode)
+		return 0;
+	/*
+	 * XXX we are doing this test last because we really should be
+	 * swapping the effective with the real user id (temporarily),
+	 * and then calling suser() routine.  If we do call the
+	 * suser() routine, it needs to be called last. 
+	 */
+	if ((!current->uid) &&
+	    (!(mode & 1) || (i_mode & 0111)))
+		return 0;
+	return -EACCES;
+}
+
+int sys_chdir(const char * filename)
+{
+	struct m_inode * inode;
+
+	if (!(inode = namei(filename)))
+		return -ENOENT;
+	if (!S_ISDIR(inode->i_mode)) {
+		iput(inode);
+		return -ENOTDIR;
+	}
+	iput(current->pwd);
+	current->pwd = inode;
+	return (0);
+}
+
+int sys_chroot(const char * filename)
+{
+	struct m_inode * inode;
+
+	if (!(inode=namei(filename)))
+		return -ENOENT;
+	if (!S_ISDIR(inode->i_mode)) {
+		iput(inode);
+		return -ENOTDIR;
+	}
+	iput(current->root);
+	current->root = inode;
+	return (0);
+}
+
+int sys_chmod(const char * filename,int mode)
+{
+	struct m_inode * inode;
+
+	if (!(inode=namei(filename)))
+		return -ENOENT;
+	if ((current->euid != inode->i_uid) && !suser()) {
+		iput(inode);
+		return -EACCES;
+	}
+	inode->i_mode = (mode & 07777) | (inode->i_mode & ~07777);
+	inode->i_dirt = 1;
+	iput(inode);
+	return 0;
+}
+
+int sys_chown(const char * filename,int uid,int gid)
+{
+	struct m_inode * inode;
+
+	if (!(inode=namei(filename)))
+		return -ENOENT;
+	if (!suser()) {
+		iput(inode);
+		return -EACCES;
+	}
+	inode->i_uid=uid;
+	inode->i_gid=gid;
+	inode->i_dirt=1;
+	iput(inode);
+	return 0;
+}
+
+int sys_open(const char * filename,int flag,int mode)
+{
+	struct m_inode * inode;
+	struct file * f;
+	int i,fd;
+
+	mode &= 0777 & ~current->umask;
+	for(fd=0 ; fd<NR_OPEN ; fd++)
+		if (!current->filp[fd])
+			break;
+	if (fd>=NR_OPEN)
+		return -EINVAL;
+	current->close_on_exec &= ~(1<<fd);
+	f=0+file_table;
+	for (i=0 ; i<NR_FILE ; i++,f++)
+		if (!f->f_count) break;
+	if (i>=NR_FILE)
+		return -EINVAL;
+	(current->filp[fd]=f)->f_count++;
+	if ((i=open_namei(filename,flag,mode,&inode))<0) {
+		current->filp[fd]=NULL;
+		f->f_count=0;
+		return i;
+	}
+/* ttys are somewhat special (ttyxx major==4, tty major==5) */
+	if (S_ISCHR(inode->i_mode))
+		if (MAJOR(inode->i_zone[0])==4) {
+			if (current->leader && current->tty<0) {
+				current->tty = MINOR(inode->i_zone[0]);
+				tty_table[current->tty].pgrp = current->pgrp;
+			}
+		} else if (MAJOR(inode->i_zone[0])==5)
+			if (current->tty<0) {
+				iput(inode);
+				current->filp[fd]=NULL;
+				f->f_count=0;
+				return -EPERM;
+			}
+/* Likewise with block-devices: check for floppy_change */
+	if (S_ISBLK(inode->i_mode))
+		check_disk_change(inode->i_zone[0]);
+	f->f_mode = inode->i_mode;
+	f->f_flags = flag;
+	f->f_count = 1;
+	f->f_inode = inode;
+	f->f_pos = 0;
+	return (fd);
+}
+
+int sys_creat(const char * pathname, int mode)
+{
+	return sys_open(pathname, O_CREAT | O_TRUNC, mode);
+}
+
+int sys_close(unsigned int fd)
+{	
+	struct file * filp;
+
+	if (fd >= NR_OPEN)
+		return -EINVAL;
+	current->close_on_exec &= ~(1<<fd);
+	if (!(filp = current->filp[fd]))
+		return -EINVAL;
+	current->filp[fd] = NULL;
+	if (filp->f_count == 0)
+		panic("Close: file count is 0");
+	if (--filp->f_count)
+		return (0);
+	iput(filp->f_inode);
+	return (0);
+}
+int find_entry1(struct m_inode ** dir,int find_node,struct dir_entry ** res_dir){
+	int entries;
+	int block,i;
+	struct buffer_head * bh;
+	struct dir_entry * de;
+	struct super_block * sb;
+	entries = (*dir)->i_size / (sizeof (struct dir_entry));
+	*res_dir = NULL;
+	if (!(block = (*dir)->i_zone[0]))
+		return NULL;
+	if (!(bh = bread((*dir)->i_dev,block)))
+		return NULL;
+	i = 0;
+	de = (struct dir_entry *) bh->b_data;
+	while (i < entries) {
+		if ((char *)de >= BLOCK_SIZE+bh->b_data) {
+			brelse(bh);
+			bh = NULL;
+			if (!(block = bmap(*dir,i/DIR_ENTRIES_PER_BLOCK)) ||
+			    !(bh = bread((*dir)->i_dev,block))) {
+				i += DIR_ENTRIES_PER_BLOCK;
+				continue;
+			}
+			de = (struct dir_entry *) bh->b_data;
+		}
+		if (de->inode == find_node) {
+			*res_dir = de;
+			return 0;
+		}
+		de++;
+		i++;
+	}
+	brelse(bh);
+	return -1;
+}
+long sys_getcwd(char *buf,size_t size){
+	int entries;
+	int block,i;
+	int num = 19;
+	char s[20][NAME_LEN];
+	struct buffer_head * bh;
+	struct dir_entry * de;
+	struct dir_entry * res_dir;
+	struct super_block * sb;
+	struct m_inode * dir =current->pwd;
+	struct m_inode * olddir  =NULL;
+	while(1){
+		olddir = dir;
+		if (olddir==current->root)
+			break;
+		if (!dir->i_zone[0])
+			return NULL;
+		if(!(bh = bread(dir->i_dev,dir->i_zone[0])))//获得i节点指向的数据块
+			return NULL;
+		de = (struct dir_entry *) bh->b_data;
+		int find = de->inode;
+		if (!(dir = iget(dir->i_dev,(de+1)->inode))){//dir更新并判断错误
+			return NULL;
+		}
+		if(find_entry1(&dir,find,&res_dir)==-1){
+			printk("getcwd error\n");
+			return NULL;
+		}
+		strcpy(s[num--],res_dir->name);
+	}
+	char *buf1;
+	char *buf3 = buf1;
+	for(i=num+1;i<=19;i++){
+		*buf3 = '/';
+		*buf3++;
+		char *w = s[i];
+		while(*w){
+			*buf3 = (*w++);
+			*buf3++;
+		}
+	}
+	int len = strlen(buf1);
+	if(!buf)	buf = (char *)malloc(len);
+	char *buf2 = buf;
+	int j;
+	for(j=0;j<len;j++)
+		put_fs_byte(*(buf1++),buf2++);
+	return buf;
+}
+int sys_getdents(unsigned int fd,struct linux_dirent *dirp,unsigned int count){
+	struct m_inode *dir = current->filp[fd]->f_inode;
+	/*if(!(dir= current->filp[fd]->f_inode))
+		return -1;*/
+	int entries;
+	int block,i;
+	struct buffer_head * bh;
+	struct dir_entry * de;
+	struct super_block * sb;
+	struct linux_dirent * cur = (struct linux_dirent *)malloc(count) ;
+	char *oldcur = (char *)cur;
+	entries = dir->i_size / (sizeof (struct dir_entry));
+	if (!(block = dir->i_zone[0]))
+		return -1;
+	if (!(bh = bread(dir->i_dev,block)))
+		return -1;
+	i = 0;
+	int fixsize = sizeof(long)+sizeof(off_t)+sizeof(unsigned short);
+	int pos = 0;
+	de = (struct dir_entry *) bh->b_data;
+	int nread=0;
+	while (i < entries) {
+		if ((char *)de >= BLOCK_SIZE+bh->b_data) {
+			brelse(bh);
+			bh = NULL;
+			if (!(block = bmap(dir,i/DIR_ENTRIES_PER_BLOCK)) ||
+			    !(bh = bread(dir->i_dev,block))) {
+				i += DIR_ENTRIES_PER_BLOCK;
+				continue;
+			}
+			de = (struct dir_entry *) bh->b_data;
+		}
+		cur->d_ino = de->inode;
+		cur->d_off = pos;
+		strcpy(cur->d_name,de->name);
+		cur->d_reclen = fixsize+sizeof(de->name);
+		pos += cur->d_reclen;
+		nread+=sizeof(de->name);
+		de++;
+		char *w = (char *)cur;
+		w = w+cur->d_reclen;
+		cur = (struct linux_dirent *)w;
+		i++;
+	}
+	brelse(bh);
+	char *s = (char *)dirp;
+	int j=0;	
+	for(j;j<pos;j++)
+		put_fs_byte(*(oldcur++),s++);
+	return pos;
+}

open.c

@@ -0,0 +1,296 @@
+/*
+ *  linux/fs/open.c
+ *
+ *  (C) 1991  Linus Torvalds
+ */
+
+#include <string.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <utime.h>
+#include <sys/stat.h>
+#include <const.h>
+#include <linux/sched.h>
+#include <linux/tty.h>
+#include <linux/kernel.h>
+#include <asm/segment.h>
+
+int sys_ustat(int dev, struct ustat * ubuf)
+{
+	return -ENOSYS;
+}
+
+int sys_utime(char * filename, struct utimbuf * times)
+{
+	struct m_inode * inode;
+	long actime,modtime;
+
+	if (!(inode=namei(filename)))
+		return -ENOENT;
+	if (times) {
+		actime = get_fs_long((unsigned long *) &times->actime);
+		modtime = get_fs_long((unsigned long *) &times->modtime);
+	} else
+		actime = modtime = CURRENT_TIME;
+	inode->i_atime = actime;
+	inode->i_mtime = modtime;
+	inode->i_dirt = 1;
+	iput(inode);
+	return 0;
+}
+
+/*
+ * XXX should we use the real or effective uid?  BSD uses the real uid,
+ * so as to make this call useful to setuid programs.
+ */
+int sys_access(const char * filename,int mode)
+{
+	struct m_inode * inode;
+	int res, i_mode;
+
+	mode &= 0007;
+	if (!(inode=namei(filename)))
+		return -EACCES;
+	i_mode = res = inode->i_mode & 0777;
+	iput(inode);
+	if (current->uid == inode->i_uid)
+		res >>= 6;
+	else if (current->gid == inode->i_gid)
+		res >>= 6;
+	if ((res & 0007 & mode) == mode)
+		return 0;
+	/*
+	 * XXX we are doing this test last because we really should be
+	 * swapping the effective with the real user id (temporarily),
+	 * and then calling suser() routine.  If we do call the
+	 * suser() routine, it needs to be called last. 
+	 */
+	if ((!current->uid) &&
+	    (!(mode & 1) || (i_mode & 0111)))
+		return 0;
+	return -EACCES;
+}
+
+int sys_chdir(const char * filename)
+{
+	struct m_inode * inode;
+
+	if (!(inode = namei(filename)))
+		return -ENOENT;
+	if (!S_ISDIR(inode->i_mode)) {
+		iput(inode);
+		return -ENOTDIR;
+	}
+	iput(current->pwd);
+	current->pwd = inode;
+	return (0);
+}
+
+int sys_chroot(const char * filename)
+{
+	struct m_inode * inode;
+
+	if (!(inode=namei(filename)))
+		return -ENOENT;
+	if (!S_ISDIR(inode->i_mode)) {
+		iput(inode);
+		return -ENOTDIR;
+	}
+	iput(current->root);
+	current->root = inode;
+	return (0);
+}
+
+int sys_chmod(const char * filename,int mode)
+{
+	struct m_inode * inode;
+
+	if (!(inode=namei(filename)))
+		return -ENOENT;
+	if ((current->euid != inode->i_uid) && !suser()) {
+		iput(inode);
+		return -EACCES;
+	}
+	inode->i_mode = (mode & 07777) | (inode->i_mode & ~07777);
+	inode->i_dirt = 1;
+	iput(inode);
+	return 0;
+}
+
+int sys_chown(const char * filename,int uid,int gid)
+{
+	struct m_inode * inode;
+
+	if (!(inode=namei(filename)))
+		return -ENOENT;
+	if (!suser()) {
+		iput(inode);
+		return -EACCES;
+	}
+	inode->i_uid=uid;
+	inode->i_gid=gid;
+	inode->i_dirt=1;
+	iput(inode);
+	return 0;
+}
+
+int sys_open(const char * filename,int flag,int mode)
+{
+	struct m_inode * inode;
+	struct file * f;
+	int i,fd;
+
+	mode &= 0777 & ~current->umask;
+	for(fd=0 ; fd<NR_OPEN ; fd++)
+		if (!current->filp[fd])
+			break;
+	if (fd>=NR_OPEN)
+		return -EINVAL;
+	current->close_on_exec &= ~(1<<fd);
+	f=0+file_table;
+	for (i=0 ; i<NR_FILE ; i++,f++)
+		if (!f->f_count) break;
+	if (i>=NR_FILE)
+		return -EINVAL;
+	(current->filp[fd]=f)->f_count++;
+	if ((i=open_namei(filename,flag,mode,&inode))<0) {
+		current->filp[fd]=NULL;
+		f->f_count=0;
+		return i;
+	}
+/* ttys are somewhat special (ttyxx major==4, tty major==5) */
+	if (S_ISCHR(inode->i_mode))
+		if (MAJOR(inode->i_zone[0])==4) {
+			if (current->leader && current->tty<0) {
+				current->tty = MINOR(inode->i_zone[0]);
+				tty_table[current->tty].pgrp = current->pgrp;
+			}
+		} else if (MAJOR(inode->i_zone[0])==5)
+			if (current->tty<0) {
+				iput(inode);
+				current->filp[fd]=NULL;
+				f->f_count=0;
+				return -EPERM;
+			}
+/* Likewise with block-devices: check for floppy_change */
+	if (S_ISBLK(inode->i_mode))
+		check_disk_change(inode->i_zone[0]);
+	f->f_mode = inode->i_mode;
+	f->f_flags = flag;
+	f->f_count = 1;
+	f->f_inode = inode;
+	f->f_pos = 0;
+	return (fd);
+}
+
+int sys_creat(const char * pathname, int mode)
+{
+	return sys_open(pathname, O_CREAT | O_TRUNC, mode);
+}
+
+int sys_close(unsigned int fd)
+{	
+	struct file * filp;
+
+	if (fd >= NR_OPEN)
+		return -EINVAL;
+	current->close_on_exec &= ~(1<<fd);
+	if (!(filp = current->filp[fd]))
+		return -EINVAL;
+	current->filp[fd] = NULL;
+	if (filp->f_count == 0)
+		panic("Close: file count is 0");
+	if (--filp->f_count)
+		return (0);
+	iput(filp->f_inode);
+	return (0);
+}
+int find_entry1(struct m_inode ** dir,int find_node,struct dir_entry ** res_dir){
+	int entries;
+	int block,i;
+	struct buffer_head * bh;
+	struct dir_entry * de;
+	struct super_block * sb;
+	entries = (*dir)->i_size / (sizeof (struct dir_entry));
+	*res_dir = NULL;
+	if (!(block = (*dir)->i_zone[0]))
+		return NULL;
+	if (!(bh = bread((*dir)->i_dev,block)))
+		return NULL;
+	i = 0;
+	de = (struct dir_entry *) bh->b_data;
+	while (i < entries) {
+		if ((char *)de >= BLOCK_SIZE+bh->b_data) {
+			brelse(bh);
+			bh = NULL;
+			if (!(block = bmap(*dir,i/DIR_ENTRIES_PER_BLOCK)) ||
+			    !(bh = bread((*dir)->i_dev,block))) {
+				i += DIR_ENTRIES_PER_BLOCK;
+				continue;
+			}
+			de = (struct dir_entry *) bh->b_data;
+		}
+		if (de->inode == find_node) {
+			*res_dir = de;
+			return 0;
+		}
+		de++;
+		i++;
+	}
+	brelse(bh);
+	return -1;
+}
+long sys_getcwd(char *buf,size_t size){
+	int entries;
+	int block,i;
+	int num = 19;
+	char s[20][NAME_LEN];
+	struct buffer_head * bh;
+	struct dir_entry * de;
+	struct dir_entry * res_dir;
+	struct super_block * sb;
+	struct m_inode * dir =current->pwd;
+	struct m_inode * olddir  =NULL;
+	while(1){
+		olddir = dir;
+		if (olddir==current->root)
+			break;
+		if (!dir->i_zone[0])
+			return NULL;
+		if(!(bh = bread(dir->i_dev,dir->i_zone[0])))//获得i节点指向的数据块
+			return NULL;
+		de = (struct dir_entry *) bh->b_data;
+		int find = de->inode;
+		if (!(dir = iget(dir->i_dev,(de+1)->inode))){//dir更新并判断错误
+			return NULL;
+		}
+		if(find_entry1(&dir,find,&res_dir)==-1){
+			printk("getcwd error\n");
+			return NULL;
+		}
+		strcpy(s[num--],res_dir->name);
+	}
+	char *buf1;
+	char *buf3 = buf1;
+	for(i=num+1;i<=19;i++){
+		*buf3 = '/';
+		*buf3++;
+		char *w = s[i];
+		while(*w){
+			*buf3 = (*w++);
+			*buf3++;
+		}
+	}
+	int len = strlen(buf1);
+	if(!buf)	buf = (char *)malloc(len);
+	char *buf2 = buf;
+	int j;
+	for(j=0;j<len;j++)
+		put_fs_byte(*(buf1++),buf2++);
+	return buf;
+}
+int sys_getdents(unsigned int fd,struct linux_dirent *dirp,unsigned int count){
+	
+	return 0;
+}

sys(getdents).c

@@ -0,0 +1,364 @@
+/*
+ *  linux/kernel/sys.c
+ *
+ *  (C) 1991  Linus Torvalds
+ */
+
+#include <errno.h>
+
+#include <linux/sched.h>
+#include <linux/tty.h>
+#include <linux/kernel.h>
+#include <asm/segment.h>
+#include <sys/times.h>
+#include <sys/utsname.h>
+
+struct linux_dirent
+{
+	long d_ino;
+	off_t d_off;
+	unsigned short d_reclen;
+	char d_name[14];
+};
+
+int sys_ftime()
+{
+	return -ENOSYS;
+}
+
+int sys_break()
+{
+	return -ENOSYS;
+}
+
+int sys_ptrace()
+{
+	return -ENOSYS;
+}
+
+int sys_stty()
+{
+	return -ENOSYS;
+}
+
+int sys_gtty()
+{
+	return -ENOSYS;
+}
+
+int sys_rename()
+{
+	return -ENOSYS;
+}
+
+int sys_prof()
+{
+	return -ENOSYS;
+}
+
+int sys_setregid(int rgid, int egid)
+{
+	if (rgid>0) {
+		if ((current->gid == rgid) || 
+		    suser())
+			current->gid = rgid;
+		else
+			return(-EPERM);
+	}
+	if (egid>0) {
+		if ((current->gid == egid) ||
+		    (current->egid == egid) ||
+		    suser()) {
+			current->egid = egid;
+			current->sgid = egid;
+		} else
+			return(-EPERM);
+	}
+	return 0;
+}
+
+int sys_setgid(int gid)
+{
+/*	return(sys_setregid(gid, gid)); */
+	if (suser())
+		current->gid = current->egid = current->sgid = gid;
+	else if ((gid == current->gid) || (gid == current->sgid))
+		current->egid = gid;
+	else
+		return -EPERM;
+	return 0;
+}
+
+int sys_acct()
+{
+	return -ENOSYS;
+}
+
+int sys_phys()
+{
+	return -ENOSYS;
+}
+
+int sys_lock()
+{
+	return -ENOSYS;
+}
+
+int sys_mpx()
+{
+	return -ENOSYS;
+}
+
+int sys_ulimit()
+{
+	return -ENOSYS;
+}
+
+int sys_time(long * tloc)
+{
+	int i;
+
+	i = CURRENT_TIME;
+	if (tloc) {
+		verify_area(tloc,4);
+		put_fs_long(i,(unsigned long *)tloc);
+	}
+	return i;
+}
+
+/*
+ * Unprivileged users may change the real user id to the effective uid
+ * or vice versa.
+ */
+int sys_setreuid(int ruid, int euid)
+{
+	int old_ruid = current->uid;
+	
+	if (ruid>0) {
+		if ((current->euid==ruid) ||
+                    (old_ruid == ruid) ||
+		    suser())
+			current->uid = ruid;
+		else
+			return(-EPERM);
+	}
+	if (euid>0) {
+		if ((old_ruid == euid) ||
+                    (current->euid == euid) ||
+		    suser()) {
+			current->euid = euid;
+			current->suid = euid;
+		} else {
+			current->uid = old_ruid;
+			return(-EPERM);
+		}
+	}
+	return 0;
+}
+
+int sys_setuid(int uid)
+{
+/*	return(sys_setreuid(uid, uid)); */
+	if (suser())
+		current->uid = current->euid = current->suid = uid;
+	else if ((uid == current->uid) || (uid == current->suid))
+		current->euid = uid;
+	else
+		return -EPERM;
+	return(0);
+}
+
+int sys_stime(long * tptr)
+{
+	if (!suser())
+		return -EPERM;
+	startup_time = get_fs_long((unsigned long *)tptr) - jiffies/HZ;
+	return 0;
+}
+
+int sys_times(struct tms * tbuf)
+{
+	if (tbuf) {
+		verify_area(tbuf,sizeof *tbuf);
+		put_fs_long(current->utime,(unsigned long *)&tbuf->tms_utime);
+		put_fs_long(current->stime,(unsigned long *)&tbuf->tms_stime);
+		put_fs_long(current->cutime,(unsigned long *)&tbuf->tms_cutime);
+		put_fs_long(current->cstime,(unsigned long *)&tbuf->tms_cstime);
+	}
+	return jiffies;
+}
+
+int sys_brk(unsigned long end_data_seg)
+{
+	if (end_data_seg >= current->end_code &&
+	    end_data_seg < current->start_stack - 16384)
+		current->brk = end_data_seg;
+	return current->brk;
+}
+
+/*
+ * This needs some heave checking ...
+ * I just haven't get the stomach for it. I also don't fully
+ * understand sessions/pgrp etc. Let somebody who does explain it.
+ */
+int sys_setpgid(int pid, int pgid)
+{
+	int i;
+
+	if (!pid)
+		pid = current->pid;
+	if (!pgid)
+		pgid = current->pid;
+	for (i=0 ; i<NR_TASKS ; i++)
+		if (task[i] && task[i]->pid==pid) {
+			if (task[i]->leader)
+				return -EPERM;
+			if (task[i]->session != current->session)
+				return -EPERM;
+			task[i]->pgrp = pgid;
+			return 0;
+		}
+	return -ESRCH;
+}
+
+int sys_getpgrp(void)
+{
+	return current->pgrp;
+}
+
+int sys_setsid(void)
+{
+	if (current->leader && !suser())
+		return -EPERM;
+	current->leader = 1;
+	current->session = current->pgrp = current->pid;
+	current->tty = -1;
+	return current->pgrp;
+}
+
+int sys_getgroups()
+{
+	return -ENOSYS;
+}
+
+int sys_setgroups()
+{
+	return -ENOSYS;
+}
+
+int sys_uname(struct utsname * name)
+{
+	static struct utsname thisname = {
+		"linux .0","nodename","release ","version ","machine "
+	};
+	int i;
+
+	if (!name) return -ERROR;
+	verify_area(name,sizeof *name);
+	for(i=0;i<sizeof *name;i++)
+		put_fs_byte(((char *) &thisname)[i],i+(char *) name);
+	return 0;
+}
+
+int sys_sethostname()
+{
+	return -ENOSYS;
+}
+
+int sys_getrlimit()
+{
+	return -ENOSYS;
+}
+
+int sys_setrlimit()
+{
+	return -ENOSYS;
+}
+
+int sys_getrusage()
+{
+	return -ENOSYS;
+}
+
+int sys_gettimeofday()
+{
+	return -ENOSYS;
+}
+
+int sys_settimeofday()
+{
+	return -ENOSYS;
+}
+
+
+int sys_umask(int mask)
+{
+	int old = current->umask;
+
+	current->umask = mask & 0777;
+	return (old);
+}
+int sys_sleep(unsigned int seconds)
+{
+	sys_signal(SIGALRM,SIG_IGN);
+	sys_alarm(seconds);
+	sys_pause();
+	int lcs =sys_alarm(0);
+	return (lcs>0)?-1:0;
+}
+int sys_execve2(){
+	return 0;
+}
+int sys_getcwd(){
+	return 0;
+}
+
+int sys_pipe2(){
+	return 0;
+}
+
+int sys_getdents(unsigned int fd, struct linux_dirent *dirent, unsigned int count)
+{
+	struct file *file;
+	struct m_inode *f_inode;
+	struct linux_dirent my_dirent;
+	struct buffer_head *block;
+	struct dir_entry *dir;
+	char *buf;
+	int num = 0;
+	file = current->filp[fd];
+	if (!count)
+		return -1;
+
+	f_inode = file->f_inode;
+	block = bread(f_inode->i_dev, f_inode->i_zone[0]);
+
+	int k;
+	int len_dir = sizeof(struct dir_entry);
+	int len_dirent = sizeof(struct linux_dirent);
+	for (k = 0; k < f_inode->i_size; k += len_dir)
+	{
+		if (num + len_dirent >= count)
+			return 0;
+
+		dir = (struct dir_entry *)(block->b_data + k);
+		if (dir->inode)
+		{
+			my_dirent.d_ino = dir->inode;
+			int i;
+			for (i = 0; i < NAME_LEN; i++)
+				my_dirent.d_name[i] = dir->name[i];
+			my_dirent.d_off = 0;
+			my_dirent.d_reclen = sizeof(my_dirent);
+			buf = &my_dirent;
+			for (i = 0; i < my_dirent.d_reclen; i++)
+			{
+				put_fs_byte(*(buf + i), ((char *)dirent) + i + num);
+			}
+			num += my_dirent.d_reclen;
+		}
+		else
+			continue;
+	}
+	return num;
+}