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.
399 lines
7.0 KiB
399 lines
7.0 KiB
/*
|
|
* 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>
|
|
|
|
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);
|
|
}
|
|
|
|
//getdents
|
|
struct linux_dirent {
|
|
long d_ino;
|
|
off_t d_off;
|
|
unsigned short d_reclen;
|
|
char d_name[14];
|
|
};
|
|
/*int sys_getdents(unsigned int fd, struct linux_dirent * dirp, unsigned int count)
|
|
{
|
|
struct buffer_head * bh;
|
|
struct dir_entry * de;
|
|
struct dir_entry * tmp1;
|
|
struct dir_entry * tmp2;
|
|
unsigned long bmp = 0;
|
|
int i;
|
|
bh = bread(current->filp[fd]->f_inode->i_dev,current->filp[fd]->f_inode->i_zone[0]);
|
|
for(tmp1 = tmp2 = bh->b_data; (tmp1 - tmp2)*24 <= count-24 && tmp1->inode ; tmp1++)
|
|
{
|
|
de = tmp1;
|
|
printk("%d\n",de->inode);
|
|
put_fs_long( de->inode,(unsigned long *)& (dirp+bmp)->d_ino);
|
|
for(i = 0; i < 14; i++)
|
|
put_fs_byte(de->name[i] , (char *)& (dirp+bmp)->d_name[i]);
|
|
put_fs_word( 24,(unsigned short *)& dirp->d_reclen);
|
|
|
|
printk("%d\n",get_fs_word((unsigned short *)&(dirp+bmp)->d_ino));
|
|
put_fs_long( 24,(unsigned long *)& dirp->d_off);
|
|
bmp ++;
|
|
printk("%d\n",bmp);
|
|
}
|
|
|
|
return bmp*24;
|
|
|
|
}*/
|
|
int sys_getdents(unsigned int fd, struct linux_dirent *dir_rt, unsigned int count)
|
|
{
|
|
int i;
|
|
int size;
|
|
int width;
|
|
int count_n;
|
|
struct file *f;
|
|
struct m_inode *inode;
|
|
struct buffer_head *b_h;
|
|
struct dir_entry *d_e;
|
|
struct linux_dirent tmp;
|
|
|
|
f = current->filp[fd];
|
|
inode = f->f_inode;
|
|
width = sizeof(struct linux_dirent);
|
|
b_h = bread(inode->i_dev,inode->i_zone[0]);
|
|
d_e = (struct dir_entry*) b_h->b_data;
|
|
|
|
for(count_n = 0,size = 0; d_e[count_n].inode>0; count_n++){
|
|
if(size+width>count)
|
|
return 0;
|
|
tmp.d_reclen = width;
|
|
tmp.d_off = width;
|
|
tmp.d_ino = d_e[count_n].inode;
|
|
for(i = 0 ;i<NAME_LEN ;i++)
|
|
{
|
|
tmp.d_name[i] = d_e[count_n].name[i];
|
|
}
|
|
char * ptr;
|
|
ptr = &tmp;
|
|
for(i = 0 ;i<width ;i++)
|
|
{
|
|
put_fs_byte(*(ptr+i),(char*)dir_rt+size);
|
|
size++;
|
|
}
|
|
}
|
|
return size;
|
|
}
|
|
|
|
//getdents
|
|
|
|
//sys_sleep
|
|
void handler(int signo)
|
|
{}
|
|
unsigned int sys_sleep(unsigned int sec)
|
|
{
|
|
/*struct sigaction action,oldaction;
|
|
sigset_t newmask,oldmask,suspmask;
|
|
action.sa_handler = handler;
|
|
action.sa_flags = 0;
|
|
sigemptyset(&action.sa_mask);
|
|
sys_sigaction(SIGALRM,&action,&oldaction);
|
|
|
|
sigemptyset(&newmask);
|
|
sigaddset(&newmask,SIGALRM);
|
|
sigprocmask(SIG_BLOCK,&newmask,&oldmask);
|
|
|
|
alarm(sec);
|
|
suspmask = oldmask;
|
|
sigdelset(&suspmask,SIGALRM);
|
|
sigsuspend(&suspmask);
|
|
|
|
int ret = alarm(0);
|
|
sys_sigaction(SIGALRM,&oldaction,NULL);
|
|
sigprocmask(SIG_SETMASK,&oldmask,NULL);
|
|
return ret;*/
|
|
sys_signal(SIGALRM,SIG_IGN,NULL);
|
|
sys_alarm(sec);
|
|
sys_pause();
|
|
int ret = sys_alarm(0);
|
|
return ret;
|
|
} |