taglinefilesource code
current156drivers/FPU-emu/fpu_entry.cif (!current->used_math)
current167drivers/FPU-emu/fpu_entry.ccurrent->used_math = 1;
current220drivers/FPU-emu/fpu_entry.cif (current->flags & PF_PTRACED)
current308drivers/FPU-emu/fpu_entry.ccurrent->tss.trap_no = 16;
current309drivers/FPU-emu/fpu_entry.ccurrent->tss.error_code = 0;
current310drivers/FPU-emu/fpu_entry.csend_sig(SIGFPE, current, 1);
current683drivers/FPU-emu/fpu_entry.ccurrent->tss.trap_no = 16;
current684drivers/FPU-emu/fpu_entry.ccurrent->tss.error_code = 0;
current685drivers/FPU-emu/fpu_entry.csend_sig(signal,current,1);
current22drivers/FPU-emu/fpu_system.h#define LDT_DESCRIPTOR(s)       (current->ldt[(s) >> 3])
current35drivers/FPU-emu/fpu_system.h#define I387      (current->tss.i387)
current314drivers/block/cdu31a.ccurrent->state = TASK_INTERRUPTIBLE;
current315drivers/block/cdu31a.ccurrent->timeout = jiffies;
current484drivers/block/cdu31a.ccurrent->state = TASK_INTERRUPTIBLE;
current485drivers/block/cdu31a.ccurrent->timeout = jiffies + 200;
current885drivers/block/cdu31a.ccurrent->state = TASK_INTERRUPTIBLE;
current886drivers/block/cdu31a.ccurrent->timeout = jiffies + 10;
current916drivers/block/cdu31a.cif (current != has_cd_task) /* Allow recursive calls to this routine */
current921drivers/block/cdu31a.cif (current->signal & ~current->blocked)
current930drivers/block/cdu31a.chas_cd_task = current;
current974drivers/block/cdu31a.ccurrent->state = TASK_INTERRUPTIBLE;
current975drivers/block/cdu31a.ccurrent->timeout = jiffies + 10; /* Wait .1 seconds on retries */
current1153drivers/block/cdu31a.cif (current->signal & ~current->blocked)
current1159drivers/block/cdu31a.chas_cd_task = current;
current367drivers/block/floppy.c#define NO_SIGNAL (!(current->signal & ~current->blocked) || !interruptible)
current1563drivers/block/floppy.cif (current->pid)
current623drivers/block/sbpcd.ccurrent->state = TASK_INTERRUPTIBLE;
current624drivers/block/sbpcd.ccurrent->timeout = jiffies + jifs;
current755drivers/block/sbpcd.cif (current == task[0])
current783drivers/block/sbpcd.cif (current == task[0])
current813drivers/block/sbpcd.cif (current == task[0])
current875drivers/block/sbpcd.cif (current == task[0])
current2064drivers/char/console.cstruct wait_queue wait = { current, NULL };
current2073drivers/char/console.ccurrent->state = TASK_INTERRUPTIBLE;
current2085drivers/char/console.ccurrent->state = TASK_RUNNING;
current189drivers/char/lp.ccurrent->timeout = jiffies + LP_TIMEOUT_INTERRUPT;
current193drivers/char/lp.cif (current->signal & ~current->blocked) {
current243drivers/char/lp.ccurrent->state = TASK_INTERRUPTIBLE;
current244drivers/char/lp.ccurrent->timeout = jiffies + LP_TIMEOUT_POLLED;
current251drivers/char/lp.ccurrent->state = TASK_INTERRUPTIBLE;
current252drivers/char/lp.ccurrent->timeout = jiffies + LP_TIMEOUT_POLLED;
current260drivers/char/lp.ccurrent->state = TASK_INTERRUPTIBLE;
current261drivers/char/lp.ccurrent->timeout = jiffies + LP_TIMEOUT_POLLED;
current266drivers/char/lp.cif (current->signal & ~current->blocked) {
current277drivers/char/lp.ccurrent->state = TASK_INTERRUPTIBLE;
current278drivers/char/lp.ccurrent->timeout = jiffies + LP_TIME(minor);
current594drivers/char/n_tty.creturn ((current->blocked & (1<<(sig-1))) ||
current595drivers/char/n_tty.c(current->sigaction[sig-1].sa_handler == SIG_IGN));
current726drivers/char/n_tty.cstruct wait_queue wait = { current, NULL };
current746drivers/char/n_tty.ccurrent->tty == tty) {
current749drivers/char/n_tty.celse if (current->pgrp != tty->pgrp) {
current751drivers/char/n_tty.cis_orphaned_pgrp(current->pgrp))
current753drivers/char/n_tty.ckill_pg(current->pgrp, SIGTTIN, 1);
current760drivers/char/n_tty.ccurrent->timeout = (unsigned long) -1;
current765drivers/char/n_tty.ccurrent->timeout = (unsigned long) -1;
current773drivers/char/n_tty.ccurrent->timeout = time + jiffies;
current776drivers/char/n_tty.ccurrent->timeout = 0;
current794drivers/char/n_tty.ccurrent->state = TASK_INTERRUPTIBLE;
current807drivers/char/n_tty.cif (!current->timeout)
current813drivers/char/n_tty.cif (current->signal & ~current->blocked) {
current820drivers/char/n_tty.ccurrent->state = TASK_RUNNING;
current876drivers/char/n_tty.ccurrent->timeout = time + jiffies;
current883drivers/char/n_tty.ccurrent->state = TASK_RUNNING;
current884drivers/char/n_tty.ccurrent->timeout = 0;
current898drivers/char/n_tty.cstruct wait_queue wait = { current, NULL };
current912drivers/char/n_tty.ccurrent->state = TASK_INTERRUPTIBLE;
current913drivers/char/n_tty.cif (current->signal & ~current->blocked) {
current943drivers/char/n_tty.ccurrent->state = TASK_RUNNING;
current142drivers/char/psaux.ccurrent->state = TASK_INTERRUPTIBLE;
current143drivers/char/psaux.ccurrent->timeout = jiffies + 5;
current378drivers/char/psaux.cstruct wait_queue wait = { current, NULL };
current387drivers/char/psaux.ccurrent->state = TASK_INTERRUPTIBLE;
current388drivers/char/psaux.cif (queue_empty() && !(current->signal & ~current->blocked)) {
current392drivers/char/psaux.ccurrent->state = TASK_RUNNING;
current405drivers/char/psaux.cif (current->signal & ~current->blocked)
current491drivers/char/psaux.ccurrent->state = TASK_INTERRUPTIBLE;
current492drivers/char/psaux.ccurrent->timeout = jiffies + 5;
current514drivers/char/psaux.ccurrent->state = TASK_INTERRUPTIBLE;
current515drivers/char/psaux.ccurrent->timeout = jiffies + 5;
current207drivers/char/pty.cwhile (!tty->link->count && !(current->signal & ~current->blocked))
current1573drivers/char/serial.ccurrent->state = TASK_INTERRUPTIBLE;
current1574drivers/char/serial.ccurrent->timeout = jiffies + duration;
current1809drivers/char/serial.ccurrent->state = TASK_INTERRUPTIBLE;
current1810drivers/char/serial.ccurrent->timeout = jiffies + info->close_delay;
current1846drivers/char/serial.cstruct wait_queue wait = { current, NULL };
current1875drivers/char/serial.c(info->session != current->session))
current1879drivers/char/serial.c(info->pgrp != current->pgrp))
current1918drivers/char/serial.ccurrent->state = TASK_INTERRUPTIBLE;
current1936drivers/char/serial.cif (current->signal & ~current->blocked) {
current1946drivers/char/serial.ccurrent->state = TASK_RUNNING;
current2015drivers/char/serial.cinfo->session = current->session;
current2016drivers/char/serial.cinfo->pgrp = current->pgrp;
current753drivers/char/tpqic02.ccurrent->timeout = jiffies + 30;  /* nap 0.30 sec between checks, */
current754drivers/char/tpqic02.ccurrent->state = TASK_INTERRUPTIBLE;
current237drivers/char/tty_io.cif (current->tty != tty)
current243drivers/char/tty_io.cif (current->pgrp == tty->pgrp)
current247drivers/char/tty_io.cif (is_orphaned_pgrp(current->pgrp))
current249drivers/char/tty_io.c(void) kill_pg(current->pgrp,SIGTTOU,1);
current403drivers/char/tty_io.cstruct tty_struct *tty = current->tty;
current417drivers/char/tty_io.cif (p->session == current->session)
current437drivers/char/tty_io.creturn (current->signal & ~current->blocked) ? -1 : 0;
current650drivers/char/tty_io.c(current->tty == tty) &&
current651drivers/char/tty_io.c(tty->pgrp != current->pgrp))
current652drivers/char/tty_io.cif (is_ignored(SIGTTIN) || is_orphaned_pgrp(current->pgrp))
current655drivers/char/tty_io.c(void) kill_pg(current->pgrp, SIGTTIN, 1);
current686drivers/char/tty_io.c(current->tty == tty) && (tty->pgrp != current->pgrp)) {
current687drivers/char/tty_io.cif (is_orphaned_pgrp(current->pgrp))
current690drivers/char/tty_io.c(void) kill_pg(current->pgrp, SIGTTOU, 1);
current1069drivers/char/tty_io.cif (!current->tty)
current1071drivers/char/tty_io.cdevice = current->tty->device;
current1105drivers/char/tty_io.cif (current->signal & ~current->blocked)
current1115drivers/char/tty_io.ccurrent->leader &&
current1116drivers/char/tty_io.c!current->tty &&
current1118drivers/char/tty_io.ccurrent->tty = tty;
current1119drivers/char/tty_io.ctty->session = current->session;
current1120drivers/char/tty_io.ctty->pgrp = current->pgrp;
current1243drivers/char/tty_io.cif ((current->tty != tty) && !suser())
current1305drivers/char/tty_io.cif (current->tty != tty)
current1307drivers/char/tty_io.cif (current->leader)
current1309drivers/char/tty_io.ccurrent->tty = NULL;
current1312drivers/char/tty_io.cif (current->leader &&
current1313drivers/char/tty_io.c(current->session == tty->session))
current1319drivers/char/tty_io.cif (!current->leader || current->tty)
current1338drivers/char/tty_io.ccurrent->tty = tty;
current1339drivers/char/tty_io.ctty->session = current->session;
current1340drivers/char/tty_io.ctty->pgrp = current->pgrp;
current1347drivers/char/tty_io.cif (tty == real_tty && current->tty != real_tty)
current1359drivers/char/tty_io.cif (!current->tty ||
current1360drivers/char/tty_io.c(current->tty != real_tty) ||
current1361drivers/char/tty_io.c(real_tty->session != current->session))
current1366drivers/char/tty_io.cif (session_of_pgrp(pgrp) != current->session)
current43drivers/char/tty_ioctl.cstruct wait_queue wait = { current, NULL };
current49drivers/char/tty_ioctl.ccurrent->counter = 0;  /* make us low-priority */
current51drivers/char/tty_ioctl.ccurrent->timeout = timeout + jiffies;
current53drivers/char/tty_ioctl.ccurrent->timeout = (unsigned) -1;
current55drivers/char/tty_ioctl.ccurrent->state = TASK_INTERRUPTIBLE;
current56drivers/char/tty_ioctl.cif (current->signal & ~current->blocked)
current61drivers/char/tty_ioctl.c} while (current->timeout);
current62drivers/char/tty_ioctl.ccurrent->state = TASK_RUNNING;
current453drivers/char/vt.cvt_cons[console].vt_pid = current->pid;
current1283drivers/net/ppp.ccurrent->timeout = 0;
current1286drivers/net/ppp.cif (current->signal & ~current->blocked)
current1343drivers/net/ppp.ccurrent->timeout = 0;
current1346drivers/net/ppp.cif (current->signal & ~current->blocked)
current1484drivers/net/ppp.cppp->inp_sig_pid = current->pid;
current3086drivers/scsi/53c7,8xx.ccmd = (struct NCR53c7x0_cmd *) hostdata->current;
current1203drivers/scsi/53c7,8xx.hvolatile struct NCR53c7x0_cmd *current;  /* currently connected 
current745drivers/scsi/scsi.cif ((unsigned long) &SCpnt < current->kernel_stack_page)
current582drivers/scsi/scsi.hstruct wait_queue wait = { current, NULL};  \
current585drivers/scsi/scsi.hcurrent->state = TASK_UNINTERRUPTIBLE;    \
current591drivers/scsi/scsi.hcurrent->state = TASK_RUNNING;      \
current817drivers/scsi/sd.cif (current == task[0]){
current890drivers/scsi/sd.cif (current == task[0])
current95drivers/scsi/sg.cif (current->signal & ~current->blocked)
current106drivers/scsi/sg.cif (current->signal & ~current->blocked)
current138drivers/scsi/sg.cif (current->signal & ~current->blocked)
current173drivers/scsi/sg.cif (current->signal & ~current->blocked)
current239drivers/scsi/sg.cif (current->signal & ~current->blocked)
current722drivers/scsi/sr.cif (current == task[0])
current1015drivers/sound/gus_wave.cint             current, target, rate;
current1028drivers/sound/gus_wave.ccurrent = gus_read16 (0x09) >> 4;
current1045drivers/sound/gus_wave.cif ((target - current) / 64 == 0)  /* Close enough to target. */
current1053drivers/sound/gus_wave.cif (target > current)
current1057drivers/sound/gus_wave.cgus_ramp_range (current, target);
current1065drivers/sound/gus_wave.cgus_ramp_range (target, current);
current76drivers/sound/os.h#define PROCESS_ABORTING(q, f) (/*f.aborting | */(current->signal & ~current->blocked))
current81drivers/sound/os.hif (time_limit) tl = current->timeout = jiffies + (time_limit); \
current86drivers/sound/os.hif (current->signal & ~current->blocked) \
current113fs/buffer.cstruct wait_queue wait = { current, NULL };
current118fs/buffer.ccurrent->state = TASK_UNINTERRUPTIBLE;
current125fs/buffer.ccurrent->state = TASK_RUNNING;
current246fs/buffer.cif (fd>=NR_OPEN || !(file=current->files->fd[fd]) || !(inode=file->f_inode))
current1015fs/buffer.c++current->mm->min_flt;
current1073fs/buffer.c++current->mm->maj_flt;
current1132fs/buffer.c++current->mm->maj_flt;
current1831fs/buffer.cif (current->signal & (1 << (SIGKILL-1))) {
current1835fs/buffer.ccurrent->signal = 0;
current110fs/exec.cfpp = current->files->fd;
current165fs/exec.cchar corefile[6+sizeof(current->comm)];
current170fs/exec.cif (!current->dumpable)
current172fs/exec.ccurrent->dumpable = 0;
current175fs/exec.cif (current->rlim[RLIMIT_CORE].rlim_cur < PAGE_SIZE)
current181fs/exec.cmemcpy(corefile+5,current->comm,sizeof(current->comm));
current210fs/exec.cdump.u_tsize = ((unsigned long) current->mm->end_code) >> 12;
current211fs/exec.cdump.u_dsize = ((unsigned long) (current->mm->brk + (PAGE_SIZE-1))) >> 12;
current214fs/exec.cfor(i=0; i<8; i++) dump.u_debugreg[i] = current->debugreg[i];  
current220fs/exec.ccurrent->rlim[RLIMIT_CORE].rlim_cur)
current224fs/exec.ccurrent->rlim[RLIMIT_CORE].rlim_cur)
current226fs/exec.cstrncpy(dump.u_comm, current->comm, sizeof(current->comm));
current233fs/exec.cif ((dump.u_fpvalid = current->used_math) != 0) {
current234fs/exec.cif (last_task_used_math == current)
current237fs/exec.cmemcpy(&dump.i387,&current->tss.i387.hard,sizeof(dump.i387));
current265fs/exec.cDUMP_WRITE(current,sizeof(*current));
current290fs/exec.cfile = current->files->fd[fd];
current319fs/exec.cmpnt->vm_task = current;
current329fs/exec.cinsert_vm_struct(current, mpnt);
current341fs/exec.ccurrent->mm->arg_start = (unsigned long) p;
current347fs/exec.ccurrent->mm->arg_end = current->mm->env_start = (unsigned long) p;
current353fs/exec.ccurrent->mm->env_end = (unsigned long) p;
current447fs/exec.ccurrent->mm->start_code = code_base;
current452fs/exec.ccurrent->mm->rss++;
current453fs/exec.cput_dirty_page(current,page[i],data_base);
current515fs/exec.ccurrent->dumpable = 1;
current522fs/exec.ccurrent->comm[i++] = ch;
current524fs/exec.ccurrent->comm[i] = '\0';
current525fs/exec.cif (current->shm)
current529fs/exec.cmpnt = current->mm->mmap;
current530fs/exec.ccurrent->mm->mmap = NULL;
current542fs/exec.cif (current->ldt) {
current543fs/exec.cfree_page((unsigned long) current->ldt);
current544fs/exec.ccurrent->ldt = NULL;
current546fs/exec.cif (task[i] == current)  {
current554fs/exec.cfor (i=0 ; i<8 ; i++) current->debugreg[i] = 0;
current556fs/exec.cif (bprm->e_uid != current->euid || bprm->e_gid != current->egid || 
current558fs/exec.ccurrent->dumpable = 0;
current559fs/exec.ccurrent->signal = 0;
current561fs/exec.ccurrent->sigaction[i].sa_mask = 0;
current562fs/exec.ccurrent->sigaction[i].sa_flags = 0;
current563fs/exec.cif (current->sigaction[i].sa_handler != SIG_IGN)
current564fs/exec.ccurrent->sigaction[i].sa_handler = NULL;
current567fs/exec.cif (FD_ISSET(i,&current->files->close_on_exec))
current569fs/exec.cFD_ZERO(&current->files->close_on_exec);
current570fs/exec.cclear_page_tables(current);
current571fs/exec.cif (last_task_used_math == current)
current573fs/exec.ccurrent->used_math = 0;
current614fs/exec.cif (IS_NOSUID(bprm.inode) && (((i & S_ISUID) && bprm.inode->i_uid != current->
current620fs/exec.cif (current->flags & PF_PTRACED) {
current621fs/exec.cbprm.e_uid = current->euid;
current622fs/exec.cbprm.e_gid = current->egid;
current624fs/exec.cbprm.e_uid = (i & S_ISUID) ? bprm.inode->i_uid : current->euid;
current625fs/exec.cbprm.e_gid = (i & S_ISGID) ? bprm.inode->i_gid : current->egid;
current627fs/exec.cif (current->euid == bprm.inode->i_uid)
current733fs/exec.ccurrent->did_exec = 1;
current795fs/exec.ccurrent->personality = PER_LINUX;
current811fs/exec.ccurrent->mm->brk = ex.a_bss +
current812fs/exec.c(current->mm->start_brk =
current813fs/exec.c(current->mm->end_data = ex.a_data +
current814fs/exec.c(current->mm->end_code = ex.a_text +
current815fs/exec.c(current->mm->start_code = N_TXTADDR(ex)))));
current816fs/exec.ccurrent->mm->rss = 0;
current817fs/exec.ccurrent->mm->mmap = NULL;
current818fs/exec.ccurrent->suid = current->euid = current->fsuid = bprm->e_uid;
current819fs/exec.ccurrent->sgid = current->egid = current->fsgid = bprm->e_gid;
current833fs/exec.cfile = current->files->fd[fd];
current852fs/exec.csend_sig(SIGSEGV, current, 0);
current863fs/exec.csend_sig(SIGSEGV, current, 0);
current868fs/exec.cif (current->exec_domain && current->exec_domain->use_count)
current869fs/exec.c(*current->exec_domain->use_count)--;
current870fs/exec.cif (current->binfmt && current->binfmt->use_count)
current871fs/exec.c(*current->binfmt->use_count)--;
current872fs/exec.ccurrent->exec_domain = lookup_exec_domain(current->personality);
current873fs/exec.ccurrent->binfmt = &aout_format;
current874fs/exec.cif (current->exec_domain && current->exec_domain->use_count)
current875fs/exec.c(*current->exec_domain->use_count)++;
current876fs/exec.cif (current->binfmt && current->binfmt->use_count)
current877fs/exec.c(*current->binfmt->use_count)++;
current879fs/exec.cset_brk(current->mm->start_brk, current->mm->brk);
current885fs/exec.ccurrent->personality != PER_LINUX);
current886fs/exec.ccurrent->mm->start_stack = p;
current889fs/exec.cif (current->flags & PF_PTRACED)
current890fs/exec.csend_sig(SIGTRAP, current, 0);
current905fs/exec.cfile = current->files->fd[fd];
current292fs/ext/freelists.cinode->i_uid = current->fsuid;
current293fs/ext/freelists.cinode->i_gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
current364fs/ext/namei.cinode->i_uid = current->fsuid;
current451fs/ext/namei.cinode->i_mode = S_IFDIR | (mode & 0777 & ~current->fs->umask);
current548fs/ext/namei.ccurrent->fsuid != inode->i_uid &&
current549fs/ext/namei.ccurrent->fsuid != dir->i_uid)
current602fs/ext/namei.ccurrent->fsuid != inode->i_uid &&
current603fs/ext/namei.ccurrent->fsuid != dir->i_uid)
current780fs/ext/namei.ccurrent->counter = 0;
current794fs/ext/namei.ccurrent->fsuid != old_inode->i_uid &&
current795fs/ext/namei.ccurrent->fsuid != old_dir->i_uid && !fsuser())
current815fs/ext/namei.ccurrent->fsuid != new_inode->i_uid &&
current816fs/ext/namei.ccurrent->fsuid != new_dir->i_uid && !fsuser())
current55fs/ext/symlink.cdir = current->fs->root;
current67fs/ext/symlink.cif (current->link_count > 5) {
current78fs/ext/symlink.ccurrent->link_count++;
current80fs/ext/symlink.ccurrent->link_count--;
current237fs/ext/truncate.ccurrent->counter = 0;
current42fs/ext2/acl.celse if (current->fsuid == inode->i_uid)
current452fs/ext2/ialloc.cinode->i_uid = current->fsuid;
current460fs/ext2/ialloc.cinode->i_gid = current->fsgid;
current200fs/ext2/inode.c(current->rlim[RLIMIT_FSIZE].rlim_cur >>
current279fs/ext2/inode.c(current->rlim[RLIMIT_FSIZE].rlim_cur >> 
current43fs/ext2/ioctl.cif ((current->fsuid != inode->i_uid) && !fsuser())
current65fs/ext2/ioctl.cif ((current->fsuid != inode->i_uid) && !fsuser())
current425fs/ext2/namei.cinode->i_uid = current->fsuid;
current516fs/ext2/namei.cinode->i_mode = S_IFDIR | (mode & S_IRWXUGO & ~current->fs->umask);
current621fs/ext2/namei.ccurrent->counter = 0;
current626fs/ext2/namei.ccurrent->fsuid != inode->i_uid &&
current627fs/ext2/namei.ccurrent->fsuid != dir->i_uid)
current704fs/ext2/namei.ccurrent->counter = 0;
current709fs/ext2/namei.ccurrent->fsuid != inode->i_uid &&
current710fs/ext2/namei.ccurrent->fsuid != dir->i_uid)
current933fs/ext2/namei.ccurrent->counter = 0;
current948fs/ext2/namei.ccurrent->fsuid != old_inode->i_uid &&
current949fs/ext2/namei.ccurrent->fsuid != old_dir->i_uid && !fsuser())
current981fs/ext2/namei.ccurrent->fsuid != new_inode->i_uid &&
current982fs/ext2/namei.ccurrent->fsuid != new_dir->i_uid && !fsuser())
current60fs/ext2/symlink.cdir = current->fs->root;
current72fs/ext2/symlink.cif (current->link_count > 5) {
current86fs/ext2/symlink.ccurrent->link_count++;
current88fs/ext2/symlink.ccurrent->link_count--;
current344fs/ext2/truncate.ccurrent->counter = 0;
current22fs/fcntl.cif (fd >= NR_OPEN || !current->files->fd[fd])
current27fs/fcntl.cif (current->files->fd[arg])
current33fs/fcntl.cFD_CLR(arg, &current->files->close_on_exec);
current34fs/fcntl.c(current->files->fd[arg] = current->files->fd[fd])->f_count++;
current40fs/fcntl.cif (oldfd >= NR_OPEN || !current->files->fd[oldfd])
current70fs/fcntl.cif (fd >= NR_OPEN || !(filp = current->files->fd[fd]))
current76fs/fcntl.creturn FD_ISSET(fd, &current->files->close_on_exec);
current79fs/fcntl.cFD_SET(fd, &current->files->close_on_exec);
current81fs/fcntl.cFD_CLR(fd, &current->files->close_on_exec);
current31fs/fifo.cif (current->signal & ~current->blocked) {
current64fs/fifo.cif (current->signal & ~current->blocked) {
current544fs/hpfs/hpfs_fs.c*uid = current->uid;
current545fs/hpfs/hpfs_fs.c*gid = current->gid;
current546fs/hpfs/hpfs_fs.c*umask = current->fs->umask;
current417fs/inode.cinode->i_uid = current->fsuid;
current418fs/inode.cinode->i_gid = current->fsgid;
current491fs/inode.cstruct wait_queue wait = { current, NULL };
current495fs/inode.ccurrent->state = TASK_UNINTERRUPTIBLE;
current501fs/inode.ccurrent->state = TASK_RUNNING;
current62fs/ioctl.cif (fd >= NR_OPEN || !(filp = current->files->fd[fd]))
current66fs/ioctl.cFD_SET(fd, &current->files->close_on_exec);
current70fs/ioctl.cFD_CLR(fd, &current->files->close_on_exec);
current52fs/isofs/symlink.cdir = current->fs->root;
current65fs/isofs/symlink.cif ((current->link_count > 5) ||
current73fs/isofs/symlink.ccurrent->link_count++;
current75fs/isofs/symlink.ccurrent->link_count--;
current66fs/locks.cif (fd >= NR_OPEN || !(filp = current->files->fd[fd]))
current110fs/locks.cif (fd >= NR_OPEN || !(filp = current->files->fd[fd]))
current155fs/locks.cif (current->signal & ~current->blocked)
current161fs/locks.cif (current->signal & ~current->blocked)
current256fs/locks.cfl->fl_owner = current;
current478fs/locks.ctmp->fl_owner = current;  /* FIXME: needed? */
current216fs/minix/bitmap.cinode->i_uid = current->fsuid;
current217fs/minix/bitmap.cinode->i_gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
current268fs/minix/namei.cinode->i_uid = current->fsuid;
current352fs/minix/namei.cinode->i_mode = S_IFDIR | (mode & 0777 & ~current->fs->umask);
current447fs/minix/namei.ccurrent->fsuid != inode->i_uid &&
current448fs/minix/namei.ccurrent->fsuid != dir->i_uid)
current508fs/minix/namei.ccurrent->counter = 0;
current513fs/minix/namei.ccurrent->fsuid != inode->i_uid &&
current514fs/minix/namei.ccurrent->fsuid != dir->i_uid)
current689fs/minix/namei.ccurrent->counter = 0;
current703fs/minix/namei.ccurrent->fsuid != old_inode->i_uid &&
current704fs/minix/namei.ccurrent->fsuid != old_dir->i_uid && !fsuser())
current734fs/minix/namei.ccurrent->fsuid != new_inode->i_uid &&
current735fs/minix/namei.ccurrent->fsuid != new_dir->i_uid && !fsuser())
current49fs/minix/symlink.cdir = current->fs->root;
current61fs/minix/symlink.cif (current->link_count > 5) {
current72fs/minix/symlink.ccurrent->link_count++;
current74fs/minix/symlink.ccurrent->link_count--;
current179fs/minix/truncate.ccurrent->counter = 0;
current76fs/msdos/inode.c*uid = current->uid;
current77fs/msdos/inode.c*gid = current->gid;
current78fs/msdos/inode.c*umask = current->fs->umask;
current112fs/msdos/misc.cint count,nr,limit,last,current,sector;
current144fs/msdos/misc.cif ((current = MSDOS_I(inode)->i_start) != 0) {
current145fs/msdos/misc.ccache_lookup(inode,INT_MAX,&last,&current);
current146fs/msdos/misc.cwhile (current && current != -1)
current147fs/msdos/misc.cif (!(current = fat_access(inode->i_sb,
current148fs/msdos/misc.clast = current,-1))) {
current164fs/msdos/misc.cfor (current = 0; current < MSDOS_SB(inode->i_sb)->cluster_size;
current165fs/msdos/misc.ccurrent++) {
current167fs/msdos/misc.cMSDOS_SB(inode->i_sb)->cluster_size+current;
current171fs/msdos/misc.cif (current < MSDOS_SB(inode->i_sb)->cluster_size-1 &&
current180fs/msdos/misc.ccurrent++;
current459fs/msdos/misc.cint error,current,prev,nr;
current464fs/msdos/misc.cif ((current = raw_scan(dir->i_sb,MSDOS_I(dir)->i_start,MSDOS_DOTDOT,
current467fs/msdos/misc.creturn current;
current469fs/msdos/misc.cif (!current) nr = MSDOS_ROOT_INO;
current471fs/msdos/misc.cif ((prev = raw_scan(dir->i_sb,current,MSDOS_DOTDOT,&zero,NULL,
current476fs/msdos/misc.cif ((error = raw_scan(dir->i_sb,prev,NULL,&current,&nr,NULL,
current34fs/namei.cfor (vma = current->mm->mmap ; ; vma = vma->vm_next) {
current111fs/namei.celse if (current->fsuid == inode->i_uid)
current137fs/namei.cif (dir == current->fs->root) {
current197fs/namei.cbase = current->fs->pwd;
current202fs/namei.cbase = current->fs->root;
current313fs/namei.cmode &= S_IALLUGO & ~current->fs->umask;
current426fs/namei.cmode &= ~current->fs->umask;
current80fs/nfs/inode.cif (fd >= NR_OPEN || !(filp = current->files->fd[fd])) {
current264fs/nfs/proc.cif (!ruid && current->fsuid == 0 && current->uid != 0) {
current301fs/nfs/proc.cif (!ruid && current->fsuid == 0 && current->uid != 0) {
current343fs/nfs/proc.cif (!ruid && current->fsuid == 0 && current->uid != 0) {
current379fs/nfs/proc.cif (!ruid && current->fsuid == 0 && current->uid != 0) {
current424fs/nfs/proc.cif (!ruid && current->fsuid == 0 && current->uid != 0) {
current464fs/nfs/proc.cif (!ruid && current->fsuid == 0 && current->uid != 0) {
current504fs/nfs/proc.cif (!ruid && current->fsuid == 0 && current->uid != 0) {
current539fs/nfs/proc.cif (!ruid && current->fsuid == 0 && current->uid != 0) {
current578fs/nfs/proc.cif (!ruid && current->fsuid == 0 && current->uid != 0) {
current615fs/nfs/proc.cif (!ruid && current->fsuid == 0 && current->uid != 0) {
current653fs/nfs/proc.cif (!ruid && current->fsuid == 0 && current->uid != 0) {
current693fs/nfs/proc.cif (!ruid && current->fsuid == 0 && current->uid != 0) {
current728fs/nfs/proc.cif (!ruid && current->fsuid == 0 && current->uid != 0) {
current784fs/nfs/proc.cif (!ruid && current->fsuid == 0 && current->uid != 0) {
current820fs/nfs/proc.cif (!ruid && current->fsuid == 0 && current->uid != 0) {
current856fs/nfs/proc.c*p++ = htonl(ruid ? current->uid : current->fsuid);
current857fs/nfs/proc.c*p++ = htonl(current->egid);
current859fs/nfs/proc.cfor (i = 0; i < 16 && i < NGROUPS && current->groups[i] != NOGROUP; i++)
current860fs/nfs/proc.c*p++ = htonl(current->groups[i]);
current91fs/nfs/sock.cold_mask = current->blocked;
current92fs/nfs/sock.ccurrent->blocked |= ~(_S(SIGKILL)
current97fs/nfs/sock.c? ((current->sigaction[SIGINT - 1].sa_handler == SIG_DFL
current99fs/nfs/sock.c| (current->sigaction[SIGQUIT - 1].sa_handler == SIG_DFL
current113fs/nfs/sock.ccurrent->state = TASK_INTERRUPTIBLE;
current124fs/nfs/sock.ccurrent->timeout = jiffies + timeout;
current127fs/nfs/sock.ccurrent->state = TASK_RUNNING;
current128fs/nfs/sock.cif (current->signal & ~current->blocked) {
current129fs/nfs/sock.ccurrent->timeout = 0;
current133fs/nfs/sock.cif (!current->timeout) {
current153fs/nfs/sock.ccurrent->timeout = 0;
current157fs/nfs/sock.ccurrent->state = TASK_RUNNING;
current219fs/nfs/sock.ccurrent->blocked = old_mask;
current55fs/nfs/symlink.cdir = current->fs->root;
current67fs/nfs/symlink.cif (current->link_count > 5) {
current94fs/nfs/symlink.ccurrent->link_count++;
current96fs/nfs/symlink.ccurrent->link_count--;
current58fs/open.cif (fd >= NR_OPEN || !(file = current->files->fd[fd]))
current103fs/open.cif (fd >= NR_OPEN || !(file = current->files->fd[fd]))
current137fs/open.cif ((current->fsuid != inode->i_uid) && !fsuser()) {
current145fs/open.cif ((current->fsuid != inode->i_uid) &&
current172fs/open.cold_fsuid = current->fsuid;
current173fs/open.cold_fsgid = current->fsgid;
current174fs/open.ccurrent->fsuid = current->uid;
current175fs/open.ccurrent->fsgid = current->gid;
current182fs/open.ccurrent->fsuid = old_fsuid;
current183fs/open.ccurrent->fsgid = old_fsgid;
current203fs/open.ciput(current->fs->pwd);
current204fs/open.ccurrent->fs->pwd = inode;
current213fs/open.cif (fd >= NR_OPEN || !(file = current->files->fd[fd]))
current221fs/open.ciput(current->fs->pwd);
current222fs/open.ccurrent->fs->pwd = inode;
current243fs/open.ciput(current->fs->root);
current244fs/open.ccurrent->fs->root = inode;
current253fs/open.cif (fd >= NR_OPEN || !(file = current->files->fd[fd]))
current257fs/open.cif ((current->fsuid != inode->i_uid) && !fsuser())
current279fs/open.cif ((current->fsuid != inode->i_uid) && !fsuser()) {
current307fs/open.cif (fd >= NR_OPEN || !(file = current->files->fd[fd]))
current319fs/open.cif ((current->fsuid == inode->i_uid && user == inode->i_uid &&
current366fs/open.cif ((current->fsuid == inode->i_uid && user == inode->i_uid &&
current416fs/open.cif (!current->files->fd[fd])
current420fs/open.cFD_CLR(fd,&current->files->close_on_exec);
current424fs/open.ccurrent->files->fd[fd] = f;
current433fs/open.ccurrent->files->fd[fd]=NULL;
current449fs/open.ccurrent->files->fd[fd]=NULL;
current485fs/open.cfcntl_remove_locks(current, filp, fd);
current504fs/open.cFD_CLR(fd, &current->files->close_on_exec);
current505fs/open.cif (!(filp = current->files->fd[fd]))
current507fs/open.ccurrent->files->fd[fd] = NULL;
current520fs/open.cif (current->tty)
current521fs/open.ctty_vhangup(current->tty);
current42fs/pipe.cif (current->signal & ~current->blocked)
current77fs/pipe.csend_sig(SIGPIPE,current,0);
current88fs/pipe.csend_sig(SIGPIPE,current,0);
current91fs/pipe.cif (current->signal & ~current->blocked)
current210fs/pipe.cif (current->signal & ~current->blocked)
current397fs/pipe.cif (!current->files->fd[i]) {
current398fs/pipe.ccurrent->files->fd[ fd[j]=i ] = f[j];
current402fs/pipe.ccurrent->files->fd[fd[0]]=NULL;
current409fs/pipe.ccurrent->files->fd[fd[0]] = NULL;
current410fs/pipe.ccurrent->files->fd[fd[1]] = NULL;
current267fs/proc/array.cif (!p || p == current || p->state == TASK_RUNNING)
current47fs/proc/mem.cif (current->signal & ~current->blocked)
current95fs/proc/mem.cif (current->signal & ~current->blocked)
current106fs/proc/mem.cdo_wp_page(0,addr,current,0);
current122fs/proc/mem.cif (current->signal & ~current->blocked)
current186fs/proc/mem.cif (src_vma->vm_end - stmp > current->rlim[RLIMIT_STACK].rlim_cur)
current203fs/proc/mem.cdest_table = PAGE_DIR_OFFSET(current->tss.cr3, dtmp);
current207fs/proc/mem.cif (!*dest_table) { oom(current); *dest_table=BAD_PAGE; }
current102fs/proc/root.cino = (current->pid << 16) + 2;
current25fs/read_write.cif (fd >= NR_OPEN || !(file = current->files->fd[fd]) ||
current42fs/read_write.cif (fd >= NR_OPEN || !(file=current->files->fd[fd]) || !(file->f_inode))
current79fs/read_write.cif (fd >= NR_OPEN || !(file=current->files->fd[fd]) || !(file->f_inode))
current114fs/read_write.cif (fd>=NR_OPEN || !(file=current->files->fd[fd]) || !(inode=file->f_inode))
current135fs/read_write.cif (fd>=NR_OPEN || !(file=current->files->fd[fd]) || !(inode=file->f_inode))
current104fs/select.cif (!current->files->fd[i])
current106fs/select.cif (!current->files->fd[i]->f_inode)
current123fs/select.ccurrent->state = TASK_INTERRUPTIBLE;
current125fs/select.cif (FD_ISSET(i,in) && check(SEL_IN,wait,current->files->fd[i])) {
current130fs/select.cif (FD_ISSET(i,out) && check(SEL_OUT,wait,current->files->fd[i])) {
current135fs/select.cif (FD_ISSET(i,ex) && check(SEL_EX,wait,current->files->fd[i])) {
current142fs/select.cif (!count && current->timeout && !(current->signal & ~current->blocked)) {
current148fs/select.ccurrent->state = TASK_RUNNING;
current237fs/select.ccurrent->timeout = timeout;
current239fs/select.cif (current->timeout > jiffies)
current240fs/select.ctimeout = current->timeout - jiffies;
current243fs/select.ccurrent->timeout = 0;
current244fs/select.cif (tvp && !(current->personality & STICKY_TIMEOUTS)) {
current252fs/select.cif (!i && (current->signal & ~current->blocked))
current20fs/stat.ccurrent->comm);
current164fs/stat.cif (fd >= NR_OPEN || !(f=current->files->fd[fd]) || !(inode=f->f_inode))
current179fs/stat.cif (fd >= NR_OPEN || !(f=current->files->fd[fd]) || !(inode=f->f_inode))
current187fs/super.cstruct wait_queue wait = { current, NULL };
current191fs/super.ccurrent->state = TASK_UNINTERRUPTIBLE;
current197fs/super.ccurrent->state = TASK_RUNNING;
current516fs/super.cfor (vma = current->mm->mmap ; ; ) {
current675fs/super.ccurrent->fs->pwd = inode;
current676fs/super.ccurrent->fs->root = inode;
current138fs/sysv/ialloc.cinode->i_uid = current->fsuid;
current139fs/sysv/ialloc.cinode->i_gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
current35fs/sysv/inode.cstruct wait_queue wait = { current, NULL };
current39fs/sysv/inode.ccurrent->state = TASK_UNINTERRUPTIBLE;
current45fs/sysv/inode.ccurrent->state = TASK_RUNNING;
current268fs/sysv/namei.cinode->i_uid = current->fsuid;
current354fs/sysv/namei.cinode->i_mode = S_IFDIR | (mode & 0777 & ~current->fs->umask);
current451fs/sysv/namei.ccurrent->fsuid != inode->i_uid &&
current452fs/sysv/namei.ccurrent->fsuid != dir->i_uid)
current512fs/sysv/namei.ccurrent->counter = 0;
current517fs/sysv/namei.ccurrent->fsuid != inode->i_uid &&
current518fs/sysv/namei.ccurrent->fsuid != dir->i_uid)
current697fs/sysv/namei.ccurrent->counter = 0;
current711fs/sysv/namei.ccurrent->fsuid != old_inode->i_uid &&
current712fs/sysv/namei.ccurrent->fsuid != old_dir->i_uid && !fsuser())
current742fs/sysv/namei.ccurrent->fsuid != new_inode->i_uid &&
current743fs/sysv/namei.ccurrent->fsuid != new_dir->i_uid && !fsuser())
current56fs/sysv/symlink.cdir = current->fs->root;
current68fs/sysv/symlink.cif (current->link_count > 5) {
current79fs/sysv/symlink.ccurrent->link_count++;
current81fs/sysv/symlink.ccurrent->link_count--;
current494fs/sysv/truncate.ccurrent->counter = 0;
current502fs/sysv/truncate.ccurrent->counter = 0;
current35fs/umsdos/check.cint stack_level = (long)(&pg_dir)-current->kernel_stack_page;
current37fs/umsdos/check.cpg_dir = current->tss.cr3;
current33fs/umsdos/ioctl.cif (current->euid == 0
current35fs/umsdos/namei.c&& dir->u.umsdos_i.u.dir_info.pid != current->pid){
current89fs/umsdos/namei.cdir->u.umsdos_i.u.dir_info.pid = current->pid;
current108fs/umsdos/namei.cdir1->u.umsdos_i.u.dir_info.pid = current->pid;
current110fs/umsdos/namei.cdir2->u.umsdos_i.u.dir_info.pid = current->pid;
current219fs/umsdos/namei.cinfo.entry.uid = current->fsuid;
current221fs/umsdos/namei.c? dir->i_gid : current->fsgid;
current236fs/umsdos/namei.c,info.fake.fname,current->pid,info.f_pos));
current263fs/umsdos/namei.c,info.fake.fname,-ret,current->pid,info.f_pos);
current298fs/umsdos/namei.cif (STACK_MAGIC != *(unsigned long *)current->kernel_stack_page){\
current300fs/umsdos/namei.c, current->comm,STACK_MAGIC \
current301fs/umsdos/namei.c,*(unsigned long *)current->kernel_stack_page \
current662fs/umsdos/namei.cinfo.entry.uid = current->fsuid;
current664fs/umsdos/namei.c? dir->i_gid : current->fsgid;
current58fs/umsdos/symlink.cif (current->link_count < 5) {
current64fs/umsdos/symlink.cdir = current->fs[1].root;
current83fs/umsdos/symlink.ccurrent->link_count++;
current85fs/umsdos/symlink.ccurrent->link_count--;
current332fs/xiafs/bitmap.cinode->i_uid = current->fsuid;
current333fs/xiafs/bitmap.cinode->i_gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
current297fs/xiafs/namei.cinode->i_uid = current->fsuid;
current380fs/xiafs/namei.cinode->i_mode = S_IFDIR | (mode & S_IRWXUGO & ~current->fs->umask);
current500fs/xiafs/namei.ccurrent->fsuid != inode->i_uid &&
current501fs/xiafs/namei.ccurrent->fsuid != dir->i_uid)
current557fs/xiafs/namei.ccurrent->counter = 0;
current562fs/xiafs/namei.ccurrent->fsuid != inode->i_uid &&
current563fs/xiafs/namei.ccurrent->fsuid != dir->i_uid)
current733fs/xiafs/namei.ccurrent->fsuid != old_inode->i_uid &&
current734fs/xiafs/namei.ccurrent->fsuid != old_dir->i_uid && !fsuser())
current754fs/xiafs/namei.ccurrent->fsuid != new_inode->i_uid &&
current755fs/xiafs/namei.ccurrent->fsuid != new_dir->i_uid && !fsuser())
current792fs/xiafs/namei.ccurrent->counter=0;
current83fs/xiafs/symlink.cdir = current->fs->root;
current99fs/xiafs/symlink.cif (current->link_count > 5) {
current110fs/xiafs/symlink.ccurrent->link_count++;
current112fs/xiafs/symlink.ccurrent->link_count--;
current192fs/xiafs/truncate.ccurrent->counter = 0;
current387ibcs/binfmt_coff.cfp = current->files->fd[fd];
current444ibcs/binfmt_coff.ccurrent->mm->mmap        = NULL;
current445ibcs/binfmt_coff.ccurrent->mm->rss         = 0;
current458ibcs/binfmt_coff.ccurrent->mm->start_code  = text_vaddr & PAGE_MASK;
current459ibcs/binfmt_coff.ccurrent->mm->end_code    = text_vaddr + text_size;
current460ibcs/binfmt_coff.ccurrent->mm->end_data    = data_vaddr + data_size;
current461ibcs/binfmt_coff.ccurrent->mm->start_brk   =
current462ibcs/binfmt_coff.ccurrent->mm->brk         = bss_vaddr + bss_size;
current463ibcs/binfmt_coff.ccurrent->suid            =
current464ibcs/binfmt_coff.ccurrent->euid            = bprm->e_uid;
current465ibcs/binfmt_coff.ccurrent->sgid            =
current466ibcs/binfmt_coff.ccurrent->egid            = bprm->e_gid;
current467ibcs/binfmt_coff.ccurrent->executable      = bprm->inode; /* Store inode for file  */
current471ibcs/binfmt_coff.ccurrent->mm->start_stack = bprm->p;
current557ibcs/binfmt_coff.csend_sig (SIGSEGV, current, 0);  /* Generate the error trap  */
current559ibcs/binfmt_coff.cif (current->flags & PF_PTRACED)
current560ibcs/binfmt_coff.csend_sig (SIGTRAP, current, 0);
current759ibcs/binfmt_coff.cfile           = current->files->fd[fd];
current65ibcs/binfmt_elf.cmpnt->vm_task = current;
current75ibcs/binfmt_elf.cinsert_vm_struct(current, mpnt);
current106ibcs/binfmt_elf.ccurrent->mm->arg_start = (unsigned long) p;
current112ibcs/binfmt_elf.ccurrent->mm->arg_end = current->mm->env_start = (unsigned long) p;
current118ibcs/binfmt_elf.ccurrent->mm->env_end = (unsigned long) p;
current173ibcs/binfmt_elf.cfile = current->files->fd[elf_exec_fileno];
current222ibcs/binfmt_elf.ccurrent->mm->brk = interp_ex->a_bss +
current223ibcs/binfmt_elf.c(current->mm->end_data = interp_ex->a_data +
current224ibcs/binfmt_elf.c(current->mm->end_code = interp_ex->a_text));
current330ibcs/binfmt_elf.cfile = current->files->fd[elf_exec_fileno];
current428ibcs/binfmt_elf.ccurrent->mm->end_data = 0;
current429ibcs/binfmt_elf.ccurrent->mm->end_code = 0;
current430ibcs/binfmt_elf.ccurrent->mm->start_mmap = ELF_START_MMAP;
current431ibcs/binfmt_elf.ccurrent->mm->mmap = NULL;
current436ibcs/binfmt_elf.ccurrent->mm->rss = 0;
current438ibcs/binfmt_elf.ccurrent->mm->start_stack = bprm->p;
current471ibcs/binfmt_elf.csend_sig(SIGSEGV, current, 0);
current515ibcs/binfmt_elf.ccurrent->personality = PER_LINUX;
current516ibcs/binfmt_elf.ccurrent->lcall7 = no_lcall7;
current517ibcs/binfmt_elf.ccurrent->signal_map = current->signal_invmap = ident_map;
current519ibcs/binfmt_elf.ccurrent->executable = bprm->inode;
current522ibcs/binfmt_elf.ccurrent->start_stack = p = elf_stack - 4;
current533ibcs/binfmt_elf.ccurrent->mm->arg_start += strlen(passed_fileno) + 1;
current534ibcs/binfmt_elf.ccurrent->mm->start_brk = current->mm->brk = elf_brk;
current535ibcs/binfmt_elf.ccurrent->mm->end_code = end_code;
current536ibcs/binfmt_elf.ccurrent->mm->start_code = start_code;
current537ibcs/binfmt_elf.ccurrent->mm->end_data = end_data;
current538ibcs/binfmt_elf.ccurrent->mm->start_stack = bprm->p;
current539ibcs/binfmt_elf.ccurrent->suid = current->euid = bprm->e_uid;
current540ibcs/binfmt_elf.ccurrent->sgid = current->egid = bprm->e_gid;
current544ibcs/binfmt_elf.ccurrent->mm->brk = (elf_bss + 0xfff) & 0xfffff000;
current558ibcs/binfmt_elf.cif (current->flags & PF_PTRACED)
current559ibcs/binfmt_elf.csend_sig(SIGTRAP, current, 0);
current579ibcs/binfmt_elf.cfile = current->files->fd[fd];
current67include/linux/kernel.h#define suser() (current->euid == 0)
current68include/linux/kernel.h#define fsuser() (current->fsuid == 0)
current359include/linux/sched.hextern struct task_struct *current;
current531include/linux/sched.hentry->wait.task = current;
current620include/linux/sched.h:"m" (current->debugreg[register]) \
current548init/main.ccurrent->fs->root = pseudo_root;
current549init/main.ccurrent->fs->pwd  = pseudo_root;
current72ipc/msg.cif (current->signal & ~current->blocked)
current104ipc/msg.cmsq->msg_lspid = current->pid;
current189ipc/msg.cmsq->msg_lrpid = current->pid;
current202ipc/msg.cif (current->signal & ~current->blocked)
current251ipc/msg.cipcp->cuid = ipcp->uid = current->euid;
current252ipc/msg.cipcp->gid = ipcp->cgid = current->egid;
current399ipc/msg.cif (!suser() && current->euid != ipcp->cuid && 
current400ipc/msg.ccurrent->euid != ipcp->uid)
current87ipc/sem.cipcp->cuid = ipcp->uid = current->euid;
current88ipc/sem.cipcp->gid = ipcp->cgid = current->egid;
current250ipc/sem.cif (suser() || current->euid == ipcp->cuid || 
current251ipc/sem.ccurrent->euid == ipcp->uid) {
current308ipc/sem.cif (suser() || current->euid == ipcp->cuid || 
current309ipc/sem.ccurrent->euid == ipcp->uid) {
current382ipc/sem.cfor (un = current->semun; un; un = un->proc_next) 
current395ipc/sem.cun->proc_next = current->semun;
current396ipc/sem.ccurrent->semun = un;
current413ipc/sem.cif (current->signal & ~current->blocked) 
current423ipc/sem.cif (current->signal & ~current->blocked)
current435ipc/sem.ccurr->sempid = current->pid;
current440ipc/sem.cfor (un = current->semun; un; un = un->proc_next) 
current469ipc/sem.cfor (up = &current->semun; (u = *up); *up = u->proc_next, kfree(u)) {
current491ipc/sem.csem->sempid = current->pid;
current499ipc/sem.cif (current->signal & ~current->blocked)
current506ipc/sem.ccurrent->semun = NULL;
current107ipc/shm.cshp->shm_perm.cuid = shp->shm_perm.uid = current->euid;
current108ipc/shm.cshp->shm_perm.cgid = shp->shm_perm.gid = current->egid;
current111ipc/shm.cshp->shm_cpid = current->pid;
current301ipc/shm.cif (suser() || current->euid == shp->shm_perm.uid ||
current302ipc/shm.ccurrent->euid == shp->shm_perm.cuid) {
current312ipc/shm.cif (suser() || current->euid == shp->shm_perm.uid ||
current313ipc/shm.ccurrent->euid == shp->shm_perm.cuid) {
current348ipc/shm.c--current->mm->rss;
current404ipc/shm.cvma->vm_task = current;
current418ipc/shm.cinsert_vm_struct(current, vma);
current419ipc/shm.cmerge_segments(current->mm->mmap);
current454ipc/shm.cfor (shmd = current->shm; shmd; shmd = shmd->task_next) {
current467ipc/shm.cif ((addr > current->mm->start_stack - 16384 - PAGE_SIZE*shp->shm_npages))
current470ipc/shm.cfor (shmd = current->shm; shmd; shmd = shmd->task_next) {
current494ipc/shm.cshmd->task = current;
current510ipc/shm.cshmd->task_next = current->shm;
current511ipc/shm.ccurrent->shm = shmd;
current514ipc/shm.cshp->shm_lpid = current->pid;
current546ipc/shm.cshp->shm_lpid = current->pid;
current561ipc/shm.cfor (shmdp = &current->shm; (shmd = *shmdp); shmdp=&shmd->task_next) { 
current575ipc/shm.cwhile (current->shm) 
current576ipc/shm.cdetach(&current->shm);
current623ipc/shm.cshp->shm_lpid = current->pid;
current655ipc/shm.coom(current);
current674ipc/shm.c--current->mm->maj_flt;  /* was incremented in do_no_page */
current677ipc/shm.ccurrent->mm->min_flt++;
current55ipc/util.cif (current->euid == ipcp->cuid || current->euid == ipcp->uid)
current31kernel/exec_domain.csend_sig(SIGSEGV, current, 1);
current87kernel/exec_domain.creturn current->personality;
current93kernel/exec_domain.cold_personality = current->personality;
current94kernel/exec_domain.cif (current->exec_domain && current->exec_domain->use_count)
current95kernel/exec_domain.c(*current->exec_domain->use_count)--;
current96kernel/exec_domain.ccurrent->personality = personality;
current97kernel/exec_domain.ccurrent->exec_domain = it;
current98kernel/exec_domain.cif (current->exec_domain->use_count)
current99kernel/exec_domain.c(*current->exec_domain->use_count)++;
current50kernel/exit.cif (!priv && ((sig != SIGCONT) || (current->session != p->session)) &&
current51kernel/exit.c(current->euid != p->euid) && (current->uid != p->uid) && !suser())
current89kernel/exit.cif (p == current) {
current290kernel/exit.creturn(kill_pg(current->pgrp,sig,0));
current294kernel/exit.cif (p->pid > 1 && p != current) {
current362kernel/exit.cmpnt = current->mm->mmap;
current363kernel/exit.ccurrent->mm->mmap = NULL;
current378kernel/exit.ccurrent->tss.ldt = 0;
current379kernel/exit.cif (current->ldt) {
current380kernel/exit.cvoid * ldt = current->ldt;
current381kernel/exit.ccurrent->ldt = NULL;
current385kernel/exit.cfree_page_tables(current);
current393kernel/exit.cif (current->files->fd[i])
current399kernel/exit.ciput(current->fs->pwd);
current400kernel/exit.ccurrent->fs->pwd = NULL;
current401kernel/exit.ciput(current->fs->root);
current402kernel/exit.ccurrent->fs->root = NULL;
current414kernel/exit.cif (current->semun)
current416kernel/exit.cif (current->shm)
current421kernel/exit.cforget_original_parent(current);
current431kernel/exit.cif ((current->p_pptr->pgrp != current->pgrp) &&
current432kernel/exit.c(current->p_pptr->session == current->session) &&
current433kernel/exit.cis_orphaned_pgrp(current->pgrp) &&
current434kernel/exit.chas_stopped_jobs(current->pgrp)) {
current435kernel/exit.ckill_pg(current->pgrp,SIGHUP,1);
current436kernel/exit.ckill_pg(current->pgrp,SIGCONT,1);
current439kernel/exit.cnotify_parent(current);
current449kernel/exit.cwhile ((p = current->p_cptr) != NULL) {
current450kernel/exit.ccurrent->p_cptr = p->p_osptr;
current453kernel/exit.cif (task[1] && task[1] != current)
current468kernel/exit.cif ((p->pgrp != current->pgrp) &&
current469kernel/exit.c(p->session == current->session) &&
current476kernel/exit.cif (current->leader)
current478kernel/exit.cif (last_task_used_math == current)
current480kernel/exit.ccurrent->state = TASK_ZOMBIE;
current481kernel/exit.ccurrent->exit_code = code;
current482kernel/exit.ccurrent->mm->rss = 0;
current486kernel/exit.cif (current->exec_domain && current->exec_domain->use_count)
current487kernel/exit.c(*current->exec_domain->use_count)--;
current488kernel/exit.cif (current->binfmt && current->binfmt->use_count)
current489kernel/exit.c(*current->binfmt->use_count)--;
current515kernel/exit.cstruct wait_queue wait = { current, NULL };
current523kernel/exit.cadd_wait_queue(&current->wait_chldexit,&wait);
current526kernel/exit.cfor (p = current->p_cptr ; p ; p = p->p_osptr) {
current531kernel/exit.cif (p->pgrp != current->pgrp)
current556kernel/exit.ccurrent->cutime += p->utime + p->cutime;
current557kernel/exit.ccurrent->cstime += p->stime + p->cstime;
current558kernel/exit.ccurrent->mm->cmin_flt += p->mm->min_flt + p->mm->cmin_flt;
current559kernel/exit.ccurrent->mm->cmaj_flt += p->mm->maj_flt + p->mm->cmaj_flt;
current585kernel/exit.ccurrent->state=TASK_INTERRUPTIBLE;
current587kernel/exit.ccurrent->signal &= ~(1<<(SIGCHLD-1));
current589kernel/exit.cif (current->signal & ~current->blocked)
current595kernel/exit.cremove_wait_queue(&current->wait_chldexit,&wait);
current57kernel/fork.cif (task[i]->uid == current->uid)
current65kernel/fork.cif (current->uid)
current98kernel/fork.cfor (mpnt = current->mm->mmap ; mpnt ; mpnt = mpnt->vm_next) {
current150kernel/fork.creturn shm_fork(current, p);
current155kernel/fork.cif (current->fs->pwd)
current156kernel/fork.ccurrent->fs->pwd->i_count++;
current157kernel/fork.cif (current->fs->root)
current158kernel/fork.ccurrent->fs->root->i_count++;
current181kernel/fork.c*p = *current;
current193kernel/fork.cp->p_pptr = p->p_opptr = current;
current237kernel/fork.cmemcpy(p->ldt, current->ldt, LDT_ENTRIES*LDT_ENTRY_SIZE);
current242kernel/fork.cif (last_task_used_math == current)
current254kernel/fork.cp->counter = current->counter >> 1;
current33kernel/ioport.cint numl = sizeof(current->tss.io_bitmap) >> 2;
current38kernel/ioport.cprintk("%s ", ios(current->tss.io_bitmap[j++]));
current40kernel/ioport.cprintk("%s", ios(current->tss.io_bitmap[j++]));
current126kernel/ioport.cset_bitmap((unsigned long *)current->tss.io_bitmap, from, num, !turn_on);
current37kernel/itimer.cval = current->it_real_value;
current38kernel/itimer.cinterval = current->it_real_incr;
current41kernel/itimer.cval = current->it_virt_value;
current42kernel/itimer.cinterval = current->it_virt_incr;
current45kernel/itimer.cval = current->it_prof_value;
current46kernel/itimer.cinterval = current->it_prof_incr;
current89kernel/itimer.ccurrent->it_real_value = j;
current90kernel/itimer.ccurrent->it_real_incr = i;
current95kernel/itimer.ccurrent->it_virt_value = j;
current96kernel/itimer.ccurrent->it_virt_incr = i;
current101kernel/itimer.ccurrent->it_prof_value = j;
current102kernel/itimer.ccurrent->it_prof_incr = i;
current140kernel/ksyms.cX(current),
current18kernel/ldt.cvoid * address = current->ldt;
current64kernel/ldt.cif (!current->ldt) {
current66kernel/ldt.cif (task[i] == current) {
current67kernel/ldt.cif (!(current->ldt = (struct desc_struct*) vmalloc(LDT_ENTRIES*LDT_ENTRY_SIZE)))
current69kernel/ldt.cset_ldt_desc(gdt+(i<<1)+FIRST_LDT_ENTRY, current->ldt, LDT_ENTRIES);
current75kernel/ldt.clp = (unsigned long *) &current->ldt[ldt_info.entry_number];
current27kernel/panic.cif (current == task[0])
current78kernel/printk.cif (current->signal & ~current->blocked) {
current281kernel/ptrace.cif (current->flags & PF_PTRACED)
current284kernel/ptrace.ccurrent->flags |= PF_PTRACED;
current292kernel/ptrace.cif (child == current)
current295kernel/ptrace.c(current->uid != child->euid) ||
current296kernel/ptrace.c(current->uid != child->uid) ||
current297kernel/ptrace.c(current->gid != child->egid) ||
current298kernel/ptrace.c(current->gid != child->gid)) && !suser())
current304kernel/ptrace.cif (child->p_pptr != current) {
current306kernel/ptrace.cchild->p_pptr = current;
current318kernel/ptrace.cif (child->p_pptr != current)
current502kernel/ptrace.cif ((current->flags & (PF_PTRACED|PF_TRACESYS))
current505kernel/ptrace.ccurrent->exit_code = SIGTRAP;
current506kernel/ptrace.ccurrent->state = TASK_STOPPED;
current507kernel/ptrace.cnotify_parent(current);
current514kernel/ptrace.cif (current->exit_code)
current515kernel/ptrace.ccurrent->signal |= (1 << (current->exit_code - 1));
current516kernel/ptrace.ccurrent->exit_code = 0;
current99kernel/sched.cstruct task_struct *current = &init_task;
current123kernel/sched.cif (last_task_used_math == current)
current131kernel/sched.clast_task_used_math = current;
current132kernel/sched.cif (current->used_math) {
current133kernel/sched.c__asm__("frstor %0": :"m" (current->tss.i387));
current136kernel/sched.ccurrent->used_math=1;
current146kernel/sched.cprintk("killing %s.\n",current->comm);
current147kernel/sched.csend_sig(SIGFPE,current,1);
current226kernel/sched.cif (TASK_UNINTERRUPTIBLE >= (unsigned) current->state &&
current227kernel/sched.ccurrent->counter < current->priority*2) {
current228kernel/sched.c++current->counter;
current244kernel/sched.cif (current == next)
current249kernel/sched.cif(current->debugreg[7]){
current260kernel/sched.ccurrent->state = TASK_INTERRUPTIBLE;
current285kernel/sched.cif (p->counter > current->counter + 3)
current312kernel/sched.cif (p->counter > current->counter + 3)
current330kernel/sched.cstruct wait_queue wait = { current, NULL };
current332kernel/sched.ccurrent->state = TASK_UNINTERRUPTIBLE;
current335kernel/sched.ccurrent->state = TASK_UNINTERRUPTIBLE;
current337kernel/sched.ccurrent->state = TASK_RUNNING;
current344kernel/sched.cstruct wait_queue wait = { current, NULL };
current348kernel/sched.cif (current == task[0])
current350kernel/sched.ccurrent->state = state;
current654kernel/sched.ccurrent->utime++;
current655kernel/sched.cif (current != task[0]) {
current656kernel/sched.cif (current->priority < 15)
current662kernel/sched.cif (current->it_virt_value && !(--current->it_virt_value)) {
current663kernel/sched.ccurrent->it_virt_value = current->it_virt_incr;
current664kernel/sched.csend_sig(SIGVTALRM,current,1);
current667kernel/sched.ccurrent->stime++;
current668kernel/sched.cif(current != task[0])
current671kernel/sched.cif (prof_buffer && current != task[0]) {
current682kernel/sched.cif ((current->rlim[RLIMIT_CPU].rlim_max != RLIM_INFINITY) &&
current683kernel/sched.c(((current->stime + current->utime) / HZ) >= current->rlim[RLIMIT_CPU].rlim_max))
current684kernel/sched.csend_sig(SIGKILL, current, 1);
current685kernel/sched.cif ((current->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY) &&
current686kernel/sched.c(((current->stime + current->utime) % HZ) == 0)) {
current687kernel/sched.cpsecs = (current->stime + current->utime) / HZ;
current689kernel/sched.cif (psecs == current->rlim[RLIMIT_CPU].rlim_cur)
current690kernel/sched.csend_sig(SIGXCPU, current, 1);
current692kernel/sched.celse if ((psecs > current->rlim[RLIMIT_CPU].rlim_cur) &&
current693kernel/sched.c((psecs - current->rlim[RLIMIT_CPU].rlim_cur) % 5) == 0)
current694kernel/sched.csend_sig(SIGXCPU, current, 1);
current697kernel/sched.cif (current != task[0] && 0 > --current->counter) {
current698kernel/sched.ccurrent->counter = 0;
current702kernel/sched.cif (current->it_prof_value && !(--current->it_prof_value)) {
current703kernel/sched.ccurrent->it_prof_value = current->it_prof_incr;
current704kernel/sched.csend_sig(SIGPROF,current,1);
current739kernel/sched.creturn current->pid;
current744kernel/sched.creturn current->p_opptr->pid;
current749kernel/sched.creturn current->uid;
current754kernel/sched.creturn current->euid;
current759kernel/sched.creturn current->gid;
current764kernel/sched.creturn current->egid;
current773kernel/sched.cnewprio = current->priority - increment;
current778kernel/sched.ccurrent->priority = newprio;
current787kernel/sched.cprintk("%-8s %3d ", p->comm, (p == current) ? -nr : nr);
current792kernel/sched.cif (p == current)
current25kernel/signal.csigset_t new_set, old_set = current->blocked;
current35kernel/signal.ccurrent->blocked |= new_set;
current38kernel/signal.ccurrent->blocked &= ~new_set;
current41kernel/signal.ccurrent->blocked = new_set;
current58kernel/signal.creturn current->blocked;
current63kernel/signal.cint old=current->blocked;
current65kernel/signal.ccurrent->blocked = newmask & _BLOCKABLE;
current75kernel/signal.cput_fs_long(current->blocked & current->signal, (unsigned long *)set);
current87kernel/signal.cmask = current->blocked;
current88kernel/signal.ccurrent->blocked = set & _BLOCKABLE;
current91kernel/signal.ccurrent->state = TASK_INTERRUPTIBLE;
current117kernel/signal.cp = signum - 1 + current->sigaction;
current121kernel/signal.ccurrent->signal &= ~_S(signum);
current127kernel/signal.ccurrent->signal &= ~_S(signum);
current146kernel/signal.chandler = (long) current->sigaction[signum-1].sa_handler;
current147kernel/signal.ccurrent->sigaction[signum-1] = tmp;
current161kernel/signal.cp = signum - 1 + current->sigaction;
current208kernel/signal.ccurrent->blocked = context.oldmask & _BLOCKABLE;
current247kernel/signal.cif (current->exec_domain && current->exec_domain->signal_invmap)
current248kernel/signal.cput_fs_long(current->exec_domain->signal_invmap[signr], frame+1);
current263kernel/signal.cput_fs_long(current->tss.trap_no, frame+14);
current264kernel/signal.cput_fs_long(current->tss.error_code, frame+15);
current273kernel/signal.cput_fs_long(current->tss.cr2, frame+23);
current294kernel/signal.cunsigned long mask = ~current->blocked;
current301kernel/signal.cwhile ((signr = current->signal & mask)) {
current304kernel/signal.c:"=m" (current->signal),"=r" (signr)
current306kernel/signal.csa = current->sigaction + signr;
current308kernel/signal.cif ((current->flags & PF_PTRACED) && signr != SIGKILL) {
current309kernel/signal.ccurrent->exit_code = signr;
current310kernel/signal.ccurrent->state = TASK_STOPPED;
current311kernel/signal.cnotify_parent(current);
current313kernel/signal.cif (!(signr = current->exit_code))
current315kernel/signal.ccurrent->exit_code = 0;
current318kernel/signal.cif (_S(signr) & current->blocked) {
current319kernel/signal.ccurrent->signal |= _S(signr);
current322kernel/signal.csa = current->sigaction + signr - 1;
current333kernel/signal.cif (current->pid == 1)
current340kernel/signal.cif (current->flags & PF_PTRACED)
current342kernel/signal.ccurrent->state = TASK_STOPPED;
current343kernel/signal.ccurrent->exit_code = signr;
current344kernel/signal.cif (!(current->p_pptr->sigaction[SIGCHLD-1].sa_flags & 
current346kernel/signal.cnotify_parent(current);
current352kernel/signal.cif (current->binfmt && current->binfmt->core_dump) {
current353kernel/signal.cif (current->binfmt->core_dump(signr, regs))
current358kernel/signal.ccurrent->signal |= _S(signr & 0x7f);
current385kernel/signal.csa = current->sigaction;
current400kernel/signal.ccurrent->blocked |= sa->sa_mask;
current405kernel/signal.ccurrent->tss.trap_no = current->tss.error_code = 0;
current42kernel/sys.cif (current->pid != 0)
current50kernel/sys.ccurrent->counter = -100;
current62kernel/sys.cif (!who && p == current)
current67kernel/sys.cwho = current->pgrp;
current71kernel/sys.cwho = current->uid;
current92kernel/sys.cif ((*p)->uid != current->euid &&
current93kernel/sys.c(*p)->uid != current->uid && !suser()) {
current212kernel/sys.cint old_rgid = current->gid;
current216kernel/sys.c(current->egid==rgid) ||
current218kernel/sys.ccurrent->gid = rgid;
current224kernel/sys.c(current->egid == egid) ||
current225kernel/sys.c(current->sgid == egid) ||
current227kernel/sys.ccurrent->egid = egid;
current229kernel/sys.ccurrent->gid = old_rgid;
current235kernel/sys.ccurrent->sgid = current->egid;
current236kernel/sys.ccurrent->fsgid = current->egid;
current246kernel/sys.ccurrent->gid = current->egid = current->sgid = current->fsgid = gid;
current247kernel/sys.celse if ((gid == current->gid) || (gid == current->sgid))
current248kernel/sys.ccurrent->egid = current->fsgid = gid;
current301kernel/sys.cint old_ruid = current->uid;
current305kernel/sys.c(current->euid==ruid) ||
current307kernel/sys.ccurrent->uid = ruid;
current313kernel/sys.c(current->euid == euid) ||
current314kernel/sys.c(current->suid == euid) ||
current316kernel/sys.ccurrent->euid = euid;
current318kernel/sys.ccurrent->uid = old_ruid;
current324kernel/sys.ccurrent->suid = current->euid;
current325kernel/sys.ccurrent->fsuid = euid;
current343kernel/sys.ccurrent->uid = current->euid = current->suid = current->fsuid = uid;
current344kernel/sys.celse if ((uid == current->uid) || (uid == current->suid))
current345kernel/sys.ccurrent->fsuid = current->euid = uid;
current359kernel/sys.cint old_fsuid = current->fsuid;
current361kernel/sys.cif (uid == current->uid || uid == current->euid ||
current362kernel/sys.cuid == current->suid || uid == current->fsuid || suser())
current363kernel/sys.ccurrent->fsuid = uid;
current372kernel/sys.cint old_fsgid = current->fsgid;
current374kernel/sys.cif (gid == current->gid || gid == current->egid ||
current375kernel/sys.cgid == current->sgid || gid == current->fsgid || suser())
current376kernel/sys.ccurrent->fsgid = gid;
current386kernel/sys.cput_fs_long(current->utime,(unsigned long *)&tbuf->tms_utime);
current387kernel/sys.cput_fs_long(current->stime,(unsigned long *)&tbuf->tms_stime);
current388kernel/sys.cput_fs_long(current->cutime,(unsigned long *)&tbuf->tms_cutime);
current389kernel/sys.cput_fs_long(current->cstime,(unsigned long *)&tbuf->tms_cstime);
current400kernel/sys.cif (brk < current->mm->end_code)
current401kernel/sys.creturn current->mm->brk;
current403kernel/sys.coldbrk = PAGE_ALIGN(current->mm->brk);
current405kernel/sys.creturn current->mm->brk = brk;
current410kernel/sys.cif (brk <= current->mm->brk) {
current411kernel/sys.ccurrent->mm->brk = brk;
current418kernel/sys.crlim = current->rlim[RLIMIT_DATA].rlim_cur;
current421kernel/sys.cif (brk - current->mm->end_code > rlim ||
current422kernel/sys.cbrk >= current->mm->start_stack - 16384)
current423kernel/sys.creturn current->mm->brk;
current435kernel/sys.creturn current->mm->brk;
current437kernel/sys.cfreepages += current->mm->rss;
current440kernel/sys.creturn current->mm->brk;
current445kernel/sys.ccurrent->mm->brk = brk;
current469kernel/sys.cpid = current->pid;
current481kernel/sys.cif (p->p_pptr == current || p->p_opptr == current) {
current482kernel/sys.cif (p->session != current->session)
current486kernel/sys.c} else if (p != current)
current494kernel/sys.ctmp->session == current->session)
current510kernel/sys.creturn current->pgrp;
current520kernel/sys.creturn current->pgrp;
current525kernel/sys.cif (current->leader)
current527kernel/sys.ccurrent->leader = 1;
current528kernel/sys.ccurrent->session = current->pgrp = current->pid;
current529kernel/sys.ccurrent->tty = NULL;
current530kernel/sys.creturn current->pgrp;
current545kernel/sys.cfor (i = 0 ; (i < NGROUPS) && (current->groups[i] != NOGROUP) ; i++) {
current550kernel/sys.cput_fs_word(current->groups[i], (short *) grouplist);
current565kernel/sys.ccurrent->groups[i] = get_fs_word((unsigned short *) grouplist);
current568kernel/sys.ccurrent->groups[i] = NOGROUP;
current576kernel/sys.cif (grp == current->fsgid)
current580kernel/sys.cif (current->groups[i] == NOGROUP)
current582kernel/sys.cif (current->groups[i] == grp)
current690kernel/sys.cput_fs_long(current->rlim[resource].rlim_cur, 
current692kernel/sys.cput_fs_long(current->rlim[resource].rlim_max, 
current708kernel/sys.cold_rlim = current->rlim + resource;
current768kernel/sys.creturn getrusage(current, who, ru);
current773kernel/sys.cint old = current->fs->umask;
current775kernel/sys.ccurrent->fs->umask = mask & S_IRWXUGO;
current36kernel/traps.cif (signr == SIGTRAP && current->flags & PF_PTRACED) \
current37kernel/traps.ccurrent->blocked &= ~(1 << (SIGTRAP-1)); \
current104kernel/traps.cif (STACK_MAGIC != *(unsigned long *)current->kernel_stack_page)
current107kernel/traps.ccurrent->comm, current->pid, 0xffff & i, current->kernel_stack_page);
current117kernel/traps.cDO_ERROR( 0, SIGFPE,  "divide error", divide_error, current)
current118kernel/traps.cDO_ERROR( 3, SIGTRAP, "int3", int3, current)
current119kernel/traps.cDO_ERROR( 4, SIGSEGV, "overflow", overflow, current)
current120kernel/traps.cDO_ERROR( 5, SIGSEGV, "bounds", bounds, current)
current121kernel/traps.cDO_ERROR( 6, SIGILL,  "invalid operand", invalid_op, current)
current122kernel/traps.cDO_ERROR( 7, SIGSEGV, "device not available", device_not_available, current)
current123kernel/traps.cDO_ERROR( 8, SIGSEGV, "double fault", double_fault, current)
current125kernel/traps.cDO_ERROR(10, SIGSEGV, "invalid TSS", invalid_TSS, current)
current126kernel/traps.cDO_ERROR(11, SIGBUS,  "segment not present", segment_not_present, current)
current127kernel/traps.cDO_ERROR(12, SIGBUS,  "stack segment", stack_segment, current)
current128kernel/traps.cDO_ERROR(15, SIGSEGV, "reserved", reserved, current)
current129kernel/traps.cDO_ERROR(17, SIGSEGV, "alignment check", alignment_check, current)
current147kernel/traps.ccurrent->tss.error_code = error_code;
current148kernel/traps.ccurrent->tss.trap_no = 13;
current149kernel/traps.csend_sig(signr, current, 1);  
current164kernel/traps.cif (current->flags & PF_PTRACED)
current165kernel/traps.ccurrent->blocked &= ~(1 << (SIGTRAP-1));
current166kernel/traps.csend_sig(SIGTRAP, current, 1);
current167kernel/traps.ccurrent->tss.trap_no = 1;
current168kernel/traps.ccurrent->tss.error_code = error_code;
current42kernel/vm86.c#define VFLAGS  (*(unsigned short *)&(current->v86flags))
current43kernel/vm86.c#define VEFLAGS  (current->v86flags)
current55kernel/vm86.cif (!current->vm86_info) {
current59kernel/vm86.cset_flags(regs->eflags, VEFLAGS, VIF_MASK | current->v86mask);
current60kernel/vm86.cmemcpy_tofs(&current->vm86_info->regs,regs,sizeof(*regs));
current61kernel/vm86.cput_fs_long(current->screen_bitmap,&current->vm86_info->screen_bitmap);
current62kernel/vm86.ctmp = current->tss.esp0;
current63kernel/vm86.ccurrent->tss.esp0 = current->saved_kernel_stack;
current64kernel/vm86.ccurrent->saved_kernel_stack = 0;
current94kernel/vm86.cif (current->saved_kernel_stack)
current120kernel/vm86.ccurrent->v86mask = 0;
current123kernel/vm86.ccurrent->v86mask = NT_MASK | IOPL_MASK;
current126kernel/vm86.ccurrent->v86mask = AC_MASK | NT_MASK | IOPL_MASK;
current129kernel/vm86.ccurrent->v86mask = ID_MASK | AC_MASK | NT_MASK | IOPL_MASK;
current137kernel/vm86.ccurrent->saved_kernel_stack = current->tss.esp0;
current138kernel/vm86.ccurrent->tss.esp0 = (unsigned long) pt_regs;
current139kernel/vm86.ccurrent->vm86_info = v86;
current141kernel/vm86.ccurrent->screen_bitmap = info.screen_bitmap;
current143kernel/vm86.cmark_screen_rdonly(current);
current181kernel/vm86.cset_flags(VEFLAGS, eflags, current->v86mask);
current189kernel/vm86.cset_flags(VFLAGS, flags, current->v86mask);
current201kernel/vm86.creturn flags | (VEFLAGS & current->v86mask);
current290kernel/vm86.cis_revectored(i, &current->vm86_info->int_revectored))
current292kernel/vm86.cif (i==0x21 && is_revectored(AH(regs),&current->vm86_info->int21_revectored))
current310kernel/vm86.cif (current->flags & PF_PTRACED)
current311kernel/vm86.ccurrent->blocked &= ~(1 << (SIGTRAP-1));
current312kernel/vm86.csend_sig(SIGTRAP, current, 1);
current313kernel/vm86.ccurrent->tss.trap_no = 1;
current314kernel/vm86.ccurrent->tss.error_code = error_code;
current187mm/memory.cif (tsk == current)
current210mm/memory.cpg_dir = current->tss.cr3;
current229mm/memory.cold_pg_dir = current->tss.cr3;
current299mm/memory.cdir = PAGE_DIR_OFFSET(current->tss.cr3,from);
current324mm/memory.cif (current->mm->rss > 0)
current325mm/memory.c--current->mm->rss;
current357mm/memory.cdir = PAGE_DIR_OFFSET(current->tss.cr3,from);
current384mm/memory.cif (current->mm->rss > 0)
current385mm/memory.c--current->mm->rss;
current419mm/memory.cdir = PAGE_DIR_OFFSET(current->tss.cr3,from);
current446mm/memory.cif (current->mm->rss > 0)
current447mm/memory.c--current->mm->rss;
current468mm/memory.c++current->mm->rss;
current640mm/memory.cfor (vma = current->mm->mmap ; ; vma = vma->vm_next) {
current650mm/memory.cif (vma->vm_end - start > current->rlim[RLIMIT_STACK].rlim_cur)
current884mm/memory.coom(current);
current943mm/memory.coom(current);
current971mm/memory.coom(current);
current987mm/memory.cfor (vma = current->mm->mmap ; ; vma = vma->vm_next) {
current997mm/memory.cif (vma->vm_end - address > current->rlim[RLIMIT_STACK].rlim_cur)
current1009mm/memory.ccurrent->screen_bitmap |= 1 << bit;
current1032mm/memory.ccurrent->tss.cr2 = address;
current1033mm/memory.ccurrent->tss.error_code = error_code;
current1034mm/memory.ccurrent->tss.trap_no = 14;
current1035mm/memory.csend_sig(SIGSEGV, current, 1);
current1056mm/memory.ccurrent->tss.cr3, page);
current93mm/mmap.cfor (vmm = current->mm->mmap ; vmm ; vmm = vmm->vm_next) {
current129mm/mmap.cvma->vm_task = current;
current160mm/mmap.cif (!current->errno)
current161mm/mmap.ccurrent->errno = -error;
current164mm/mmap.cinsert_vm_struct(current, vma);
current165mm/mmap.cmerge_segments(current->mm->mmap);
current181mm/mmap.cif (fd >= NR_OPEN || !(file = current->files->fd[fd]))
current256mm/mmap.cinsert_vm_struct(current, mpnt);
current264mm/mmap.cinsert_vm_struct(current, mpnt);
current294mm/mmap.cnpp = &current->mm->mmap;
current27mm/mprotect.cdir = PAGE_DIR_OFFSET(current->tss.cr3, start);
current58mm/mprotect.cmerge_segments(current->mm->mmap);
current79mm/mprotect.cinsert_vm_struct(current, n);
current80mm/mprotect.cmerge_segments(current->mm->mmap);
current101mm/mprotect.cinsert_vm_struct(current, n);
current102mm/mprotect.cmerge_segments(current->mm->mmap);
current132mm/mprotect.cinsert_vm_struct(current, left);
current133mm/mprotect.cinsert_vm_struct(current, right);
current134mm/mprotect.cmerge_segments(current->mm->mmap);
current186mm/mprotect.cfor (vma = current->mm->mmap ; ; vma = vma->vm_next) {
current278mm/swap.coom(current);
current368net/inet/af_inet.cif (!suser() && current->pgrp != -arg &&
current369net/inet/af_inet.ccurrent->pid != arg) return(-EPERM);
current719net/inet/af_inet.ccurrent->timeout = jiffies + HZ*sk->lingertime;
current720net/inet/af_inet.cwhile(sk->state != TCP_CLOSE && current->timeout>0) 
current723net/inet/af_inet.cif (current->signal & ~current->blocked) 
current729net/inet/af_inet.ccurrent->timeout=0;
current734net/inet/af_inet.ccurrent->timeout=0;
current886net/inet/af_inet.cif (current->signal & ~current->blocked) 
current977net/inet/af_inet.cif (current->signal & ~current->blocked) 
current1080net/inet/af_inet.csend_sig(SIGPIPE, current, 1);
current1102net/inet/af_inet.csend_sig(SIGPIPE, current, 1);
current102net/inet/datagram.cif (current->signal & ~current->blocked)
current217net/inet/raw.cif (current->signal & ~current->blocked) {
current965net/inet/tcp.csend_sig(SIGPIPE, current, 0);
current985net/inet/tcp.cif (current->signal & ~current->blocked) 
current1123net/inet/tcp.cif (current->signal & ~current->blocked) 
current1403net/inet/tcp.cstruct wait_queue wait = { current, NULL };
current1443net/inet/tcp.cif (current->signal & ~current->blocked)
current1446net/inet/tcp.ccurrent->state = TASK_INTERRUPTIBLE;
current1452net/inet/tcp.ccurrent->state = TASK_RUNNING;
current1465net/inet/tcp.cstruct wait_queue wait = { current, NULL };
current1497net/inet/tcp.ccurrent->state = TASK_INTERRUPTIBLE;
current1555net/inet/tcp.cif (current->signal & ~current->blocked) 
current1599net/inet/tcp.ccurrent->state = TASK_RUNNING;
current3532net/inet/tcp.cif (current->signal & ~current->blocked) 
current161net/socket.cif (!current->files->fd[fd]) 
current169net/socket.cFD_CLR(fd, &current->files->close_on_exec);
current170net/socket.ccurrent->files->fd[fd] = file;
current225net/socket.cif (fd < 0 || fd >= NR_OPEN || !(file = current->files->fd[fd])) 
current273net/socket.cSOCK_INODE(sock)->i_uid = current->euid;
current274net/socket.cSOCK_INODE(sock)->i_gid = current->egid;
current294net/socket.cif (current->signal & ~current->blocked) 
current700net/socket.cif (fd < 0 || fd >= NR_OPEN || current->files->fd[fd] == NULL)
current727net/socket.cif (fd < 0 || fd >= NR_OPEN || current->files->fd[fd] == NULL)
current760net/socket.cif (fd < 0 || fd >= NR_OPEN || ((file = current->files->fd[fd]) == NULL))
current821net/socket.cif (fd < 0 || fd >= NR_OPEN || (file=current->files->fd[fd]) == NULL)
current872net/socket.cif (fd < 0 || fd >= NR_OPEN || current->files->fd[fd] == NULL)
current897net/socket.cif (fd < 0 || fd >= NR_OPEN || current->files->fd[fd] == NULL)
current921net/socket.cif (fd < 0 || fd >= NR_OPEN || ((file = current->files->fd[fd]) == NULL))
current948net/socket.cif (fd < 0 || fd >= NR_OPEN || ((file = current->files->fd[fd]) == NULL))
current981net/socket.cif (fd < 0 || fd >= NR_OPEN || ((file = current->files->fd[fd]) == NULL))
current1012net/socket.cif (fd < 0 || fd >= NR_OPEN || ((file = current->files->fd[fd]) == NULL))
current1046net/socket.cif (fd < 0 || fd >= NR_OPEN || ((file = current->files->fd[fd]) == NULL))
current1064net/socket.cif (fd < 0 || fd >= NR_OPEN || ((file = current->files->fd[fd]) == NULL))
current1084net/socket.cif (fd < 0 || fd >= NR_OPEN || ((file = current->files->fd[fd]) == NULL))
current550net/unix/sock.cif (current->signal & ~current->blocked) 
current626net/unix/sock.cif (current->signal & ~current->blocked) 
current645net/unix/sock.csend_sig(SIGKILL, current, 1);
current684net/unix/sock.csend_sig(SIGPIPE, current, 1);
current696net/unix/sock.cif (current->signal & ~current->blocked) 
current702net/unix/sock.csend_sig(SIGPIPE, current, 1);
current721net/unix/sock.csend_sig(SIGKILL, current, 1);
current732net/unix/sock.csend_sig(SIGPIPE, current, 1);