Compare commits
1 Commits
| Author | SHA1 | Date |
|---|---|---|
 pbmpay3zt
|
8b3f5938ee | 2 years ago |
@ -1,464 +0,0 @@
|
||||
/*
|
||||
* 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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,343 +0,0 @@
|
||||
/*
|
||||
* 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 *) ×->actime);
|
||||
modtime = get_fs_long((unsigned long *) ×->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;
|
||||
}
|
||||
@ -1,296 +0,0 @@
|
||||
/*
|
||||
* 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 *) ×->actime);
|
||||
modtime = get_fs_long((unsigned long *) ×->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;
|
||||
}
|
||||
@ -1,364 +0,0 @@
|
||||
/*
|
||||
* 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;
|
||||
}
|
||||
Loading…
Reference in new issue