You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
463 lines
8.0 KiB
463 lines
8.0 KiB
/*
|
|
* linux/kernel/sys.c
|
|
*
|
|
* (C) 1991 Linus Torvalds
|
|
*/
|
|
#include <stdarg.h>
|
|
|
|
#include <linux/config.h>
|
|
#include <asm/system.h>
|
|
#include <asm/io.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <string.h>
|
|
#include <sys/stat.h>
|
|
#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>
|
|
#include <stdarg.h>
|
|
#include <new.h>
|
|
#include <mm.h>
|
|
//ADD FOR getcwd
|
|
|
|
long sys_getcwd(char *buf,size_t size)
|
|
{
|
|
int block=current->pwd->i_zone[0];
|
|
int idev=current->pwd->i_dev;
|
|
int flag=0;
|
|
struct buffer_head * bh;
|
|
struct dir_entry * de;
|
|
struct m_inode *dir=current->pwd,*rdir=current->root;
|
|
if(dir==rdir)
|
|
{
|
|
flag=1;
|
|
goto mytag;
|
|
}
|
|
unsigned short curinode,finode,tempfi;
|
|
char name[128],base[128];
|
|
int entries,i;
|
|
|
|
if (!(block = current->pwd->i_zone[0]))
|
|
return NULL;
|
|
if (!(bh = bread(current->pwd->i_dev,block)))
|
|
return NULL;
|
|
de = (struct dir_entry *) bh->b_data;
|
|
curinode=de->inode;
|
|
de++;
|
|
finode=de->inode;
|
|
while (rdir!=dir)
|
|
{
|
|
//update father
|
|
dir=iget(idev,finode);
|
|
if (!(block = dir->i_zone[0]))
|
|
return NULL;
|
|
if (!(bh = bread(dir->i_dev,block)))
|
|
return NULL;
|
|
i = 0;
|
|
entries = dir->i_size / (sizeof (struct dir_entry));
|
|
de = (struct dir_entry *) bh->b_data;
|
|
tempfi=(de+1)->inode;
|
|
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==curinode)
|
|
{
|
|
memset(base,'\0',sizeof(base));
|
|
strcat(base,"/");
|
|
strcat(base,de->name);
|
|
strcat(base,name);
|
|
strcpy(name,base);
|
|
break;
|
|
}
|
|
de++;
|
|
i++;
|
|
}
|
|
curinode=finode;
|
|
finode=tempfi;
|
|
}
|
|
mytag:
|
|
if(flag) strcpy(name,"/");
|
|
size_t len=strlen(name);
|
|
if(size<len && buf!=NULL)
|
|
{
|
|
errno=ERANGE;
|
|
return NULL;
|
|
}
|
|
if(!buf)
|
|
buf=(char*)malloc(len);
|
|
char *p1=buf;
|
|
char *p2=name;
|
|
while(len--)
|
|
put_fs_byte(*(p2++),p1++);
|
|
return buf;
|
|
}
|
|
//THE END
|
|
int sys_getdents(unsigned int fd,struct linux_dirent *dirp,unsigned int count)
|
|
{
|
|
struct m_inode *filenode =current->filp[fd]->f_inode;
|
|
int block,i,entries,sizdir=sizeof(struct dir_entry);
|
|
struct buffer_head * bh;
|
|
struct dir_entry * de;
|
|
struct linux_dirent *initmp,*temp;
|
|
if(!(temp=(struct linux_dirent *)malloc(count+64)))
|
|
return -1;
|
|
initmp=temp;
|
|
int size=sizeof(long)+sizeof(off_t)+sizeof(unsigned short);
|
|
|
|
if (!(block = filenode->i_zone[0]))
|
|
return -1;
|
|
if (!(bh = bread(filenode->i_dev,block)))
|
|
return -1;
|
|
de = (struct dir_entry *) bh->b_data;
|
|
entries=filenode->i_size/(sizeof(struct dir_entry));
|
|
i=0;
|
|
int nread=0,pos=0;
|
|
while(i<entries)
|
|
{
|
|
if ((char *)de >= BLOCK_SIZE+bh->b_data) {
|
|
brelse(bh);
|
|
bh = NULL;
|
|
if (!(block = bmap(filenode,i/DIR_ENTRIES_PER_BLOCK)) ||
|
|
!(bh = bread(filenode->i_dev,block))) {
|
|
i += DIR_ENTRIES_PER_BLOCK;
|
|
continue;
|
|
}
|
|
pos+=((char*) bh->b_data-(char*)(de));
|
|
de = (struct dir_entry *) bh->b_data;
|
|
}
|
|
temp->d_ino=de->inode;
|
|
temp->d_off=pos;
|
|
strcpy(temp->d_name,de->name);
|
|
temp->d_reclen=sizeof(de);
|
|
nread+=temp->d_reclen;
|
|
temp=(struct linux_dirent*)((char*)temp+temp->d_reclen);
|
|
de++;
|
|
pos+=sizdir;
|
|
i++;
|
|
}
|
|
if(count<nread)
|
|
{
|
|
errno=ERANGE;
|
|
return -1;
|
|
}//printk("%d",nread);
|
|
i=nread;
|
|
char *p1=dirp;
|
|
char *p2=initmp;
|
|
while(i--)
|
|
put_fs_byte(*(p2++),p1++);
|
|
free(initmp);
|
|
return nread;
|
|
}
|
|
int sys_pipe2()
|
|
{
|
|
return -1;
|
|
}
|
|
unsigned int sys_sleep(unsigned int seconds)
|
|
{
|
|
struct sigaction tmp;
|
|
tmp.sa_handler = (void (*)(int)) SIG_IGN;
|
|
tmp.sa_mask = 0;
|
|
tmp.sa_flags = SA_ONESHOT | SA_NOMASK;
|
|
tmp.sa_restorer = (void (*)(void)) NULL;
|
|
current->sigaction[SIGALRM-1] = tmp;
|
|
current->alarm=(seconds>0)?(jiffies+HZ*seconds):0;
|
|
current->state=TASK_INTERRUPTIBLE;
|
|
current->counter=(current->counter>>1)+current->priority;
|
|
schedule();
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
}
|
|
|
|
|