linux-sys.c

* linux/kernel/sys.c

* //－－系统调用功能的实现函数

#include <errno.h>

#include <linux/sched.h>

#include <linux/tty.h>

#include <linux/kernel.h>

#include <linux/config.h>

#include <asm/segment.h>

#include <sys/times.h>

#include <sys/utsname.h>

#include <sys/param.h>

#include <sys/resource.h>

#include <string.h>

* The timezone where the local system is located. Used as a default by some

* programs who obtain this value by using gettimeofday.

struct timezone sys_tz = { 0, 0}; //－－本系统所在的时区

extern int session_of_pgrp(int pgrp);

int sys_ftime() //－－以下返回值为-NEOSYS的函数在本版本内核中未实现

{

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;

}

* This is done BSD-style, with no consideration of the saved gid, except

* that if you set the effective gid, it sets the saved gid too. This

* makes it possible for a setgid program to completely drop its privileges,

* which is often a useful assertion to make when you are doing a security

* audit over a program.

* The general idea is that a program which uses just setregid() will be

* 100% compatible with BSD. A program which uses just setgid() will be

* 100% compatible with POSIX w/ Saved ID's.

int sys_setregid(int rgid, int egid) //－－设置当前任务的gid和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;

}

* setgid() is implemeneted like SysV w/ SAVED_IDS

int sys_setgid(int 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) //－－返回1970年开始的时间值/秒，存储在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. (BSD-style)

* When you set the effective uid, it sets the saved uid too. This

* makes it possible for a setuid program to completely drop its privileges,

* which is often a useful assertion to make when you are doing a security

* audit over a program.

* The general idea is that a program which uses just setreuid() will be

* 100% compatible with BSD. A program which uses just setuid() will be

* 100% compatible with POSIX w/ Saved ID's.

int sys_setreuid(int ruid, int euid) //－－设置任务的ruid和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;

}

* setuid() is implemeneted like SysV w/ SAVED_IDS

* Note that SAVED_ID's is deficient in that a setuid root program

* like sendmail, for example, cannot set its uid to be a normal

* user and then switch back, because if you're root, setuid() sets

* the saved uid too. If you don't like this, blame the bright people

* in the POSIX commmittee and/or USG. Note that the BSD-style setreuid()

* will allow a root program to temporarily drop privileges and be able to

* regain them by swapping the real and effective uid.

int sys_setuid(int 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;

jiffies_offset = 0;

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) //－－设置数据段末尾为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.

* OK, I think I have the protection semantics right.... this is really

* only important on a multi-user system anyway, to make sure one user

* can't send a signal to a process owned by another. -TYT, 12/12/91

int sys_setpgid(int pid, int pgid) //－－设置指定进程pid的进程组号为pgid

{

int i;

if (!pid)

pid = current->pid;

if (!pgid)

pgid = current->pid;

if (pgid < 0)

return -EINVAL; //－－扫描数组，查找指定进程号pid的任务

for (i=0 ; i<NR_TASKS ; i++)

if (task[i] && (task[i]->pid == pid) &&

((task[i]->p_pptr == current) ||

(task[i] == current))) {

if (task[i]->leader)

return -EPERM;

if ((task[i]->session != current->session) ||

((pgid != pid) &&

(session_of_pgrp(pgid) != current->session)))

return -EPERM;

task[i]->pgrp = pgid;

return 0;

}

return -ESRCH;

}

int sys_getpgrp(void) //－－返回当前进程的进程组号

{

return current->pgrp;

}

int sys_setsid(void) //－－创建一个会话，即设置leader=1(会话号=组号=进程号)

{

if (current->leader && !suser())

return -EPERM;

current->leader = 1;

current->session = current->pgrp = current->pid;

current->tty = -1;

return current->pgrp;

}

* Supplementary group ID's

int sys_getgroups(int gidsetsize, gid_t *grouplist) //－－取当前任务其它辅助用户组号

{ //－－用户组号个数用户空间缓存

int i;

if (gidsetsize)

verify_area(grouplist, sizeof(gid_t) * gidsetsize);

for (i = 0; (i < NGROUPS) && (current->groups[i] != NOGROUP);

i++, grouplist++) {

if (gidsetsize) {

if (i >= gidsetsize)

return -EINVAL;

put_fs_word(current->groups[i], (short *) grouplist);

}

return(i);

}

int sys_setgroups(int gidsetsize, gid_t *grouplist) //－－设置当前进程同时所属的其它辅助用户组号

{

int i;

if (!suser())

return -EPERM;

if (gidsetsize > NGROUPS)

return -EINVAL;

for (i = 0; i < gidsetsize; i++, grouplist++) {

current->groups[i] = get_fs_word((unsigned short *) grouplist);

}

if (i < NGROUPS)

current->groups[i] = NOGROUP;

return 0;

}

int in_group_p(gid_t grp) //－－检查当前进程是否在指定的用户组grp中

{

int i;

if (grp == current->egid)

return 1;

for (i = 0; i < NGROUPS; i++) {

if (current->groups[i] == NOGROUP)

break;

if (current->groups[i] == grp)

return 1;

}

return 0;

}

static struct utsname thisname = { //－－当前操作系统的名称，网络节点名称(主机名)，发行级别，版本号，硬件类型名称

UTS_SYSNAME, UTS_NODENAME, UTS_RELEASE, UTS_VERSION, UTS_MACHINE

};

int sys_uname(struct utsname * name) //－－获取系统名称等信息

{

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;

}

* Only sethostname; gethostname can be implemented by calling uname()

int sys_sethostname(char *name, int len) //－－设置系统主机名(网络节点名)

{

int i;

if (!suser())

return -EPERM;

if (len > MAXHOSTNAMELEN)

return -EINVAL;

for (i=0; i < len; i++) {

if ((thisname.nodename[i] = get_fs_byte(name+i)) == 0)

break;

}

if (thisname.nodename[i]) {

thisname.nodename[i>MAXHOSTNAMELEN ? MAXHOSTNAMELEN : i] = 0;

}

return 0;

}

int sys_getrlimit(int resource, struct rlimit *rlim) //－－取当前进程指定资源的界限值

{

if (resource >= RLIM_NLIMITS)

return -EINVAL;

verify_area(rlim,sizeof *rlim);

put_fs_long(current->rlim[resource].rlim_cur,

(unsigned long *) rlim);

put_fs_long(current->rlim[resource].rlim_max,

((unsigned long *) rlim)+1);

return 0;

}

int sys_setrlimit(int resource, struct rlimit *rlim) //－－设置当前进程指定资源的界限值

{

struct rlimit new, *old;

if (resource >= RLIM_NLIMITS)

return -EINVAL;

old = current->rlim + resource;

new.rlim_cur = get_fs_long((unsigned long *) rlim);

new.rlim_max = get_fs_long(((unsigned long *) rlim)+1);

if (((new.rlim_cur > old->rlim_max) ||

(new.rlim_max > old->rlim_max)) &&

!suser())

return -EPERM;

*old = new;

return 0;

}

* It would make sense to put struct rusuage in the task_struct,

* except that would make the task_struct be *really big*. After

* task_struct gets moved into malloc'ed memory, it would

* make sense to do this. It will make moving the rest of the information

* a lot simpler! (Which we're not doing right now because we're not

* measuring them yet).

int sys_getrusage(int who, struct rusage *ru) //－－获取指定进程的资源利用信息

{ //－－指定进程

struct rusage r;

unsigned long *lp, *lpend, *dest;

if (who != RUSAGE_SELF && who != RUSAGE_CHILDREN)

return -EINVAL;

verify_area(ru, sizeof *ru);

memset((char *) &r, 0, sizeof(r));

if (who == RUSAGE_SELF) { //－－复制当前进程资源利用信息

r.ru_utime.tv_sec = CT_TO_SECS(current->utime);

r.ru_utime.tv_usec = CT_TO_USECS(current->utime);

r.ru_stime.tv_sec = CT_TO_SECS(current->stime);

r.ru_stime.tv_usec = CT_TO_USECS(current->stime);

} else { //－－复制当前进程的已终止和等待着的子进程资源利用信息

r.ru_utime.tv_sec = CT_TO_SECS(current->cutime);

r.ru_utime.tv_usec = CT_TO_USECS(current->cutime);

r.ru_stime.tv_sec = CT_TO_SECS(current->cstime);

r.ru_stime.tv_usec = CT_TO_USECS(current->cstime);

}

lp = (unsigned long *) &r;

lpend = (unsigned long *) (&r+1);

dest = (unsigned long *) ru;

for (; lp < lpend; lp++, dest++)

put_fs_long(*lp, dest);

return(0);

}

int sys_gettimeofday(struct timeval *tv, struct timezone *tz)

{ //－－取当前系统时间

if (tv) {

verify_area(tv, sizeof *tv);

put_fs_long(startup_time + CT_TO_SECS(jiffies+jiffies_offset),

(unsigned long *) tv);

put_fs_long(CT_TO_USECS(jiffies+jiffies_offset),

((unsigned long *) tv)+1);

}

if (tz) {

verify_area(tz, sizeof *tz);

put_fs_long(sys_tz.tz_minuteswest, (unsigned long *) tz);

put_fs_long(sys_tz.tz_dsttime, ((unsigned long *) tz)+1);

}

return 0;

}

* The first time we set the timezone, we will warp the clock so that

* it is ticking GMT time instead of local time. Presumably,

* if someone is setting the timezone then we are running in an

* environment where the programs understand about timezones.

* This should be done at boot time in the /etc/rc script, as

* soon as possible, so that the clock can be set right. Otherwise,

* various programs will get confused when the clock gets warped.

int sys_settimeofday(struct timeval *tv, struct timezone *tz)

{ //－－格林尼治时间和夏令时间调整类型

static int firsttime = 1;

void adjust_clock();

if (!suser())

return -EPERM;

if (tz) {

sys_tz.tz_minuteswest = get_fs_long((unsigned long *) tz);

sys_tz.tz_dsttime = get_fs_long(((unsigned long *) tz)+1);

if (firsttime) {

firsttime = 0;

if (!tv)

adjust_clock();

}

if (tv) {

int sec, usec;

sec = get_fs_long((unsigned long *)tv);

usec = get_fs_long(((unsigned long *)tv)+1);

startup_time = sec - jiffies/HZ;

jiffies_offset = usec * HZ / 1000000 - jiffies%HZ;

}

return 0;

}

* Adjust the time obtained from the CMOS to be GMT time instead of

* local time.

* This is ugly, but preferable to the alternatives. Otherwise we

* would either need to write a program to do it in /etc/rc (and risk

* confusion if the program gets run more than once; it would also be

* hard to make the program warp the clock precisely n hours) or

* compile in the timezone information into the kernel. Bad, bad....

* XXX Currently does not adjust for daylight savings time. May not

* need to do anything, depending on how smart (dumb?) the BIOS

* is. Blast it all.... the best thing to do not depend on the CMOS

* clock at all, but get the time via NTP or timed if you're on a

* network.... - TYT, 1/1/92

void adjust_clock() //－－把系统启动时间调整为以GMT为标准的时间

{

startup_time += sys_tz.tz_minuteswest*60;

}

int sys_umask(int mask) //－－设置当前进程创建文件属性屏蔽码为mask&0777

{

int old = current->umask;

current->umask = mask & 0777;

return (old);

}

|xGv00|fcc8d4de8197f69fde70263fb4d52380

linux-sys.c相关推荐

linux sys伪用户作用,【原创】Linux版对sys用户进行审计的示例
更多精彩内容尽在我们在操作数据库的时候,知道SYS用户的权限是最大的干什么事很方便,同时带来的问题就是非常危险,没有人可以束缚住.因此我们有时需要对SYS用户进行审计 SYS@LEO1>sho ...
linux sys存放内容,了解linux系统目录，sys,tmp,usr,var！
原标题:了解linux系统目录,sys,tmp,usr,var! linux小白到大神的成长之路:了解linux系统目录,sys,tmp,usr,var! 本经验由宗龙龙原创,全文共600多字,阅读需 ...
linux /sys目录下的各个子目录说明
ramdisk 文件系统基于磁盘模拟技术,实际文件系统是ex2 ex3等 sysfs是一种基于ram文件系统,和proc一样. Sysfs文件系统是一个类似于proc文件系统的特殊文件系统,用于将系统 ...
Linux sys文件系统
简述 sys文件系统提供了一个从用户空间通往内核空间的入口,Linux系统中有个sysfs伪文件系统挂载到/sys目录,通过访问这个目录下面的文件,可以获得各种的系统内核信息,例如设备.内核模块.文件 ...
linux /sys
sysfs 与 /sys sysfs 文件系统总是被挂载在 /sys 挂载点上.虽然在较早期的2.6内核系统上并没有规定 sysfs 的标准挂载位置,可以把 sysfs 挂载在任何位置,但较近的2.6 ...
linux sys伪用户作用,linux用户管理详解
Linux用户管理配置文件用户信息文件:/etc/password 密码文件:/etc/shadow 用户组文件:/etc/group 用户组密码文件:/etc/gshadow 用户配置文件:/e ...
linux c 各头文件作用总结
#include <linux/***.h> 是在linux-2.6.29/include/linux下面寻找源文件. #include <asm/***.h> 是在linux ...
linux下各个头文件及作用总结
#include <linux/***.h> 是在linux-2.6.29/include/linux下面寻找源文件. #include <asm/***.h> 是在linux ...
Linux and the Device Tree
来之\kernel\Documentation\devicetree\usage-model.txt Linux and the Device Tree ----------------------- ...
Linux系统调用在glibc中的实现
为什么80%的码农都做不了架构师?>>> How system calls work in Linux 转自:http://12000.org/my_notes/system_ ...

linux-sys.c

linux-sys.c相关推荐

最新文章

热门文章