taglinefilesource code
current168drivers/FPU-emu/fpu_entry.cif (!current->used_math)
current179drivers/FPU-emu/fpu_entry.ccurrent->used_math = 1;
current206drivers/FPU-emu/fpu_entry.cif (current->flags & PF_PTRACED)
current285drivers/FPU-emu/fpu_entry.ccurrent->tss.trap_no = 16;
current286drivers/FPU-emu/fpu_entry.ccurrent->tss.error_code = 0;
current287drivers/FPU-emu/fpu_entry.csend_sig(SIGFPE, current, 1);
current616drivers/FPU-emu/fpu_entry.ccurrent->tss.trap_no = 16;
current617drivers/FPU-emu/fpu_entry.ccurrent->tss.error_code = 0;
current618drivers/FPU-emu/fpu_entry.csend_sig(signal,current,1);
current21drivers/FPU-emu/fpu_system.h#define I387      (current->tss.i387)
current273drivers/block/blk.hif (p->counter > current->counter)
current202drivers/block/cdu31a.ccurrent->state = TASK_INTERRUPTIBLE;
current203drivers/block/cdu31a.ccurrent->timeout = jiffies;
current489drivers/block/cdu31a.cif (current != has_cd_task) /* Allow recursive calls to this routine */
current494drivers/block/cdu31a.cif (current->signal & ~current->blocked)
current504drivers/block/cdu31a.chas_cd_task = current;
current620drivers/block/cdu31a.ccurrent->state = TASK_INTERRUPTIBLE;
current621drivers/block/cdu31a.ccurrent->timeout = jiffies + 10; /* Wait .1 seconds on retries */
current647drivers/block/cdu31a.cif (current != has_cd_task) /* Allow recursive calls to this routine */
current652drivers/block/cdu31a.cif (current->signal & ~current->blocked)
current662drivers/block/cdu31a.chas_cd_task = current;
current700drivers/block/cdu31a.ccurrent->state = TASK_INTERRUPTIBLE;
current701drivers/block/cdu31a.ccurrent->timeout = jiffies + 10; /* Wait .1 seconds on retries */
current326drivers/block/ll_rw_blk.creq->waiting = current;
current329drivers/block/ll_rw_blk.ccurrent->state = TASK_SWAPPING;
current457drivers/block/ll_rw_blk.creq->waiting = current;
current460drivers/block/ll_rw_blk.ccurrent->state = TASK_UNINTERRUPTIBLE;
current170drivers/char/lp.ccurrent->timeout = jiffies + LP_TIMEOUT_INTERRUPT;
current173drivers/char/lp.cif (current->signal & ~current->blocked) {
current223drivers/char/lp.ccurrent->state = TASK_INTERRUPTIBLE;
current224drivers/char/lp.ccurrent->timeout = jiffies + LP_TIMEOUT_POLLED;
current231drivers/char/lp.ccurrent->state = TASK_INTERRUPTIBLE;
current232drivers/char/lp.ccurrent->timeout = jiffies + LP_TIMEOUT_POLLED;
current240drivers/char/lp.ccurrent->state = TASK_INTERRUPTIBLE;
current241drivers/char/lp.ccurrent->timeout = jiffies + LP_TIMEOUT_POLLED;
current246drivers/char/lp.cif (current->signal & ~current->blocked) {
current257drivers/char/lp.ccurrent->state = TASK_INTERRUPTIBLE;
current258drivers/char/lp.ccurrent->timeout = jiffies + LP_TIME(minor);
current100drivers/char/mem.cmpnt->vm_task = current;
current109drivers/char/mem.cinsert_vm_struct(current, mpnt);
current110drivers/char/mem.cmerge_segments(current->mmap, NULL, NULL);
current194drivers/char/mem.cmpnt->vm_task = current;
current202drivers/char/mem.cinsert_vm_struct(current, mpnt);
current203drivers/char/mem.cmerge_segments(current->mmap, ignoff_mergep, inode);
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)
current492drivers/char/psaux.ccurrent->state = TASK_INTERRUPTIBLE;
current493drivers/char/psaux.ccurrent->timeout = jiffies + 5;
current515drivers/char/psaux.ccurrent->state = TASK_INTERRUPTIBLE;
current516drivers/char/psaux.ccurrent->timeout = jiffies + 5;
current63drivers/char/pty.cif (current->signal & ~current->blocked)
current99drivers/char/pty.cwhile (!tty->link->count && !(current->signal & ~current->blocked))
current1307drivers/char/serial.ccurrent->state = TASK_INTERRUPTIBLE;
current1308drivers/char/serial.ccurrent->timeout = jiffies + duration;
current1524drivers/char/serial.ccurrent->state = TASK_INTERRUPTIBLE;
current1525drivers/char/serial.ccurrent->timeout = jiffies + info->close_delay;
current1566drivers/char/serial.cstruct wait_queue wait = { current, NULL };
current1588drivers/char/serial.c(info->session != current->session))
current1592drivers/char/serial.c(info->pgrp != current->pgrp))
current1631drivers/char/serial.ccurrent->state = TASK_INTERRUPTIBLE;
current1642drivers/char/serial.cif (current->signal & ~current->blocked) {
current1652drivers/char/serial.ccurrent->state = TASK_RUNNING;
current1718drivers/char/serial.cinfo->session = current->session;
current1719drivers/char/serial.cinfo->pgrp = current->pgrp;
current679drivers/char/tpqic02.ccurrent->timeout = jiffies + 30;  /* nap 0.30 sec between checks, */
current680drivers/char/tpqic02.ccurrent->state = TASK_INTERRUPTIBLE;
current305drivers/char/tty_io.cif (current->tty >= 0) {
current306drivers/char/tty_io.ctty = tty_table[current->tty];
current317drivers/char/tty_io.cif (p->session == current->session)
current337drivers/char/tty_io.creturn (current->signal & ~current->blocked) ? -1 : 0;
current742drivers/char/tty_io.creturn ((current->blocked & (1<<(sig-1))) ||
current743drivers/char/tty_io.c(current->sigaction[sig-1].sa_handler == SIG_IGN));
current752drivers/char/tty_io.cif (current->signal & ~current->blocked)
current760drivers/char/tty_io.cstruct wait_queue wait = { current, NULL };
current766drivers/char/tty_io.cminimum = time = current->timeout = 0;
current771drivers/char/tty_io.ccurrent->timeout = 0xffffffff;
current774drivers/char/tty_io.ccurrent->timeout = time + jiffies;
current776drivers/char/tty_io.ccurrent->timeout = 0;
current782drivers/char/tty_io.ctime = current->timeout = 0;
current787drivers/char/tty_io.cif (current->signal & ~current->blocked)
current828drivers/char/tty_io.ccurrent->timeout = time+jiffies;
current852drivers/char/tty_io.cif (b-buf >= minimum || !current->timeout)
current854drivers/char/tty_io.cif (current->signal & ~current->blocked) 
current861drivers/char/tty_io.ccurrent->state = TASK_INTERRUPTIBLE;
current864drivers/char/tty_io.ccurrent->state = TASK_RUNNING;
current870drivers/char/tty_io.ccurrent->timeout = 0;
current882drivers/char/tty_io.cif (current->signal & ~current->blocked)
current893drivers/char/tty_io.cstruct wait_queue wait = { current, NULL };
current897drivers/char/tty_io.ccurrent->state = TASK_INTERRUPTIBLE;
current900drivers/char/tty_io.cif (current->signal & ~current->blocked)
current906drivers/char/tty_io.ccurrent->state = TASK_RUNNING;
current927drivers/char/tty_io.cstruct wait_queue wait = { current, NULL };
current936drivers/char/tty_io.cif (current->signal & ~current->blocked)
current941drivers/char/tty_io.csend_sig(SIGPIPE,current,0);
current944drivers/char/tty_io.ccurrent->state = TASK_INTERRUPTIBLE;
current949drivers/char/tty_io.ccurrent->state = TASK_RUNNING;
current952drivers/char/tty_io.ccurrent->state = TASK_RUNNING;
current1015drivers/char/tty_io.cif (current->signal & ~current->blocked)
current1036drivers/char/tty_io.c(current->tty == dev) &&
current1037drivers/char/tty_io.c(tty->pgrp != current->pgrp))
current1038drivers/char/tty_io.cif (is_ignored(SIGTTIN) || is_orphaned_pgrp(current->pgrp))
current1041drivers/char/tty_io.c(void) kill_pg(current->pgrp, SIGTTIN, 1);
current1072drivers/char/tty_io.c(current->tty == dev) && (tty->pgrp != current->pgrp)) {
current1073drivers/char/tty_io.cif (is_orphaned_pgrp(current->pgrp))
current1076drivers/char/tty_io.c(void) kill_pg(current->pgrp, SIGTTOU, 1);
current1338drivers/char/tty_io.cminor = current->tty;
current1392drivers/char/tty_io.ccurrent->leader &&
current1393drivers/char/tty_io.ccurrent->tty<0 &&
current1395drivers/char/tty_io.ccurrent->tty = minor;
current1396drivers/char/tty_io.ctty->session = current->session;
current1397drivers/char/tty_io.ctty->pgrp = current->pgrp;
current87drivers/char/tty_ioctl.cstruct wait_queue wait = { current, NULL };
current93drivers/char/tty_ioctl.ccurrent->counter = 0;  /* make us low-priority */
current95drivers/char/tty_ioctl.ccurrent->state = TASK_INTERRUPTIBLE;
current96drivers/char/tty_ioctl.cif (current->signal & ~current->blocked)
current103drivers/char/tty_ioctl.ccurrent->state = TASK_RUNNING;
current176drivers/char/tty_ioctl.cif (current->tty != channel)
current178drivers/char/tty_ioctl.cif (tty->pgrp <= 0 || tty->pgrp == current->pgrp)
current180drivers/char/tty_ioctl.cif (is_orphaned_pgrp(current->pgrp))
current184drivers/char/tty_ioctl.c(void) kill_pg(current->pgrp,SIGTTOU,1);
current503drivers/char/tty_ioctl.cif (current->leader &&
current504drivers/char/tty_ioctl.c(current->session == tty->session))
current510drivers/char/tty_ioctl.cif (!current->leader || (current->tty >= 0))
current529drivers/char/tty_ioctl.ccurrent->tty = dev;
current530drivers/char/tty_ioctl.ctty->session = current->session;
current531drivers/char/tty_ioctl.ctty->pgrp = current->pgrp;
current539drivers/char/tty_ioctl.cif ((current->tty < 0) ||
current540drivers/char/tty_ioctl.c(current->tty != termios_dev) ||
current541drivers/char/tty_ioctl.c(termios_tty->session != current->session))
current546drivers/char/tty_ioctl.cif (session_of_pgrp(pgrp) != current->session)
current621drivers/char/tty_ioctl.cif (MINOR(file->f_rdev) != current->tty)
current623drivers/char/tty_ioctl.cif (current->leader)
current625drivers/char/tty_ioctl.ccurrent->tty = -1;
current377drivers/char/vt.cvt_cons[console].vt_pid = current->pid;
current702drivers/scsi/scsi.cif ((unsigned long) &SCpnt < current->kernel_stack_page)
current489drivers/scsi/scsi.hif (p->counter > current->counter)
current518drivers/scsi/scsi.hstruct wait_queue wait = { current, NULL};      \
current521drivers/scsi/scsi.hcurrent->state = TASK_UNINTERRUPTIBLE;    \
current527drivers/scsi/scsi.hcurrent->state = TASK_RUNNING;      \
current84drivers/scsi/scsi_ioctl.cif (p->counter > current->counter)
current100drivers/scsi/scsi_ioctl.cSCpnt->request.waiting = current;
current101drivers/scsi/scsi_ioctl.ccurrent->state = TASK_UNINTERRUPTIBLE;
current184drivers/scsi/scsi_ioctl.cSCpnt->request.waiting = current;
current185drivers/scsi/scsi_ioctl.ccurrent->state = TASK_UNINTERRUPTIBLE;
current659drivers/scsi/sd.cif (p->counter > current->counter)
current683drivers/scsi/sd.cif (current == task[0]){
current756drivers/scsi/sd.cif (current == task[0])
current760drivers/scsi/sd.cSCpnt->request.waiting = current;
current761drivers/scsi/sd.ccurrent->state = TASK_UNINTERRUPTIBLE;
current87drivers/scsi/sg.cif (current->signal & ~current->blocked)
current98drivers/scsi/sg.cif (current->signal & ~current->blocked)
current130drivers/scsi/sg.cif (current->signal & ~current->blocked)
current165drivers/scsi/sg.cif (current->signal & ~current->blocked)
current227drivers/scsi/sg.cif (current->signal & ~current->blocked)
current642drivers/scsi/sr.cif (p->counter > current->counter)
current669drivers/scsi/sr.cif (current == task[0])
current673drivers/scsi/sr.cSCpnt->request.waiting = current;
current674drivers/scsi/sr.ccurrent->state = TASK_UNINTERRUPTIBLE;
current32drivers/scsi/sr_ioctl.cif (p->counter > current->counter)
current53drivers/scsi/sr_ioctl.cSCpnt->request.waiting = current;
current54drivers/scsi/sr_ioctl.ccurrent->state = TASK_UNINTERRUPTIBLE;
current917drivers/sound/gus_wave.cint             current, target, rate;
current930drivers/sound/gus_wave.ccurrent = gus_read16 (0x09) >> 4;
current947drivers/sound/gus_wave.cif ((target - current) / 64 == 0)  /* Too close */
current955drivers/sound/gus_wave.cif (target > current)
current959drivers/sound/gus_wave.cgus_ramp_range (current, target);
current967drivers/sound/gus_wave.cgus_ramp_range (target, current);
current75drivers/sound/os.h#define PROCESS_ABORTING(q, f) (f.aborting | (current->signal & ~current->blocked))
current80drivers/sound/os.hif (time_limit) tl = current->timeout = jiffies + (time_limit); \
current85drivers/sound/os.hif (current->signal & ~current->blocked) \
current381fs/binfmt_coff.cfp = current->filp[fd];
current438fs/binfmt_coff.ccurrent->mmap        = NULL;
current439fs/binfmt_coff.ccurrent->rss         = 0;
current452fs/binfmt_coff.ccurrent->start_code  = text_vaddr & PAGE_MASK;
current453fs/binfmt_coff.ccurrent->end_code    = text_vaddr + text_size;
current454fs/binfmt_coff.ccurrent->end_data    = data_vaddr + data_size;
current455fs/binfmt_coff.ccurrent->start_brk   =
current456fs/binfmt_coff.ccurrent->brk         = bss_vaddr + bss_size;
current457fs/binfmt_coff.ccurrent->suid        =
current458fs/binfmt_coff.ccurrent->euid        = bprm->e_uid;
current459fs/binfmt_coff.ccurrent->sgid        =
current460fs/binfmt_coff.ccurrent->egid        = bprm->e_gid;
current461fs/binfmt_coff.ccurrent->executable  = bprm->inode; /* Store inode for file  */
current465fs/binfmt_coff.ccurrent->start_stack = bprm->p;
current549fs/binfmt_coff.csend_sig (SIGSEGV, current, 0);  /* Generate the error trap  */
current551fs/binfmt_coff.cif (current->flags & PF_PTRACED)
current552fs/binfmt_coff.csend_sig (SIGTRAP, current, 0);
current742fs/binfmt_coff.cfile           = current->filp[fd];
current114fs/binfmt_elf.cfile = current->filp[elf_exec_fileno];
current195fs/binfmt_elf.ccurrent->end_data = 0;
current196fs/binfmt_elf.ccurrent->end_code = 0;
current197fs/binfmt_elf.ccurrent->start_mmap = ELF_START_MMAP;
current198fs/binfmt_elf.ccurrent->mmap = NULL;
current203fs/binfmt_elf.ccurrent->rss = 0;
current205fs/binfmt_elf.ccurrent->start_stack = bprm->p;
current220fs/binfmt_elf.ccurrent->brk = ex.a_bss +
current221fs/binfmt_elf.c(current->end_data = ex.a_data +
current222fs/binfmt_elf.c(current->end_code = ex.a_text));
current260fs/binfmt_elf.csend_sig(SIGSEGV, current, 0);
current292fs/binfmt_elf.csend_sig(SIGSEGV, current, 0);
current303fs/binfmt_elf.ccurrent->elf_executable = 1;
current304fs/binfmt_elf.ccurrent->executable = bprm->inode;
current307fs/binfmt_elf.ccurrent->start_stack = p = elf_stack - 4;
current311fs/binfmt_elf.cif(elf_interpreter) current->arg_start += strlen(passed_fileno) + 1;
current312fs/binfmt_elf.ccurrent->start_brk = current->brk = elf_brk;
current313fs/binfmt_elf.ccurrent->end_code = end_code;
current314fs/binfmt_elf.ccurrent->start_code = start_code;
current315fs/binfmt_elf.ccurrent->end_data = end_data;
current316fs/binfmt_elf.ccurrent->start_stack = bprm->p;
current317fs/binfmt_elf.ccurrent->suid = current->euid = bprm->e_uid;
current318fs/binfmt_elf.ccurrent->sgid = current->egid = bprm->e_gid;
current322fs/binfmt_elf.ccurrent->brk = (elf_bss + 0xfff) & 0xfffff000;
current329fs/binfmt_elf.cif (current->flags & PF_PTRACED)
current330fs/binfmt_elf.csend_sig(SIGTRAP, current, 0);
current350fs/binfmt_elf.cfile = current->filp[fd];
current73fs/buffer.cstruct wait_queue wait = { current, NULL };
current78fs/buffer.ccurrent->state = TASK_UNINTERRUPTIBLE;
current85fs/buffer.ccurrent->state = TASK_RUNNING;
current182fs/buffer.cif (fd>=NR_OPEN || !(file=current->filp[fd]) || !(inode=file->f_inode))
current733fs/buffer.c++current->min_flt;
current787fs/buffer.c++current->maj_flt;
current846fs/buffer.c++current->maj_flt;
current67fs/exec.cfpp = current->filp;
current122fs/exec.cchar corefile[6+sizeof(current->comm)];
current127fs/exec.cif (!current->dumpable)
current129fs/exec.ccurrent->dumpable = 0;
current132fs/exec.cif (current->rlim[RLIMIT_CORE].rlim_cur < PAGE_SIZE)
current137fs/exec.cmemcpy(corefile+5,current->comm,sizeof(current->comm));
current163fs/exec.cdump.u_tsize = ((unsigned long) current->end_code) >> 12;
current164fs/exec.cdump.u_dsize = ((unsigned long) (current->brk + (PAGE_SIZE-1))) >> 12;
current167fs/exec.cfor(i=0; i<8; i++) dump.u_debugreg[i] = current->debugreg[i];  
current173fs/exec.ccurrent->rlim[RLIMIT_CORE].rlim_cur)
current177fs/exec.ccurrent->rlim[RLIMIT_CORE].rlim_cur)
current179fs/exec.cstrncpy(dump.u_comm, current->comm, sizeof(current->comm));
current186fs/exec.cif ((dump.u_fpvalid = current->used_math) != 0) {
current187fs/exec.cif (last_task_used_math == current)
current190fs/exec.cmemcpy(&dump.i387,&current->tss.i387.hard,sizeof(dump.i387));
current218fs/exec.cDUMP_WRITE(current,sizeof(*current));
current243fs/exec.cfile = current->filp[fd];
current272fs/exec.cmpnt->vm_task = current;
current280fs/exec.cinsert_vm_struct(current, mpnt);
current281fs/exec.ccurrent->stk_vma = mpnt;
current293fs/exec.ccurrent->arg_start = (unsigned long) p;
current299fs/exec.ccurrent->arg_end = current->env_start = (unsigned long) p;
current305fs/exec.ccurrent->env_end = (unsigned long) p;
current399fs/exec.ccurrent->start_code = code_base;
current404fs/exec.ccurrent->rss++;
current405fs/exec.cput_dirty_page(current,page[i],data_base);
current467fs/exec.ccurrent->dumpable = 1;
current474fs/exec.ccurrent->comm[i++] = ch;
current476fs/exec.ccurrent->comm[i] = '\0';
current477fs/exec.cif (current->shm)
current479fs/exec.cif (current->executable) {
current480fs/exec.ciput(current->executable);
current481fs/exec.ccurrent->executable = NULL;
current485fs/exec.cmpnt = current->mmap;
current486fs/exec.ccurrent->mmap = NULL;
current487fs/exec.ccurrent->stk_vma = NULL;
current497fs/exec.cif (current->ldt) {
current498fs/exec.cfree_page((unsigned long) current->ldt);
current499fs/exec.ccurrent->ldt = NULL;
current501fs/exec.cif (task[i] == current)  {
current509fs/exec.cfor (i=0 ; i<8 ; i++) current->debugreg[i] = 0;
current511fs/exec.cif (bprm->e_uid != current->euid || bprm->e_gid != current->egid || 
current513fs/exec.ccurrent->dumpable = 0;
current514fs/exec.ccurrent->signal = 0;
current516fs/exec.ccurrent->sigaction[i].sa_mask = 0;
current517fs/exec.ccurrent->sigaction[i].sa_flags = 0;
current518fs/exec.cif (current->sigaction[i].sa_handler != SIG_IGN)
current519fs/exec.ccurrent->sigaction[i].sa_handler = NULL;
current522fs/exec.cif (FD_ISSET(i,&current->close_on_exec))
current524fs/exec.cFD_ZERO(&current->close_on_exec);
current525fs/exec.cclear_page_tables(current);
current526fs/exec.cif (last_task_used_math == current)
current528fs/exec.ccurrent->used_math = 0;
current529fs/exec.ccurrent->elf_executable = 0;
current570fs/exec.cif (IS_NOSUID(bprm.inode) && (((i & S_ISUID) && bprm.inode->i_uid != current->
current577fs/exec.cif (current->flags & PF_PTRACED) {
current578fs/exec.cbprm.e_uid = current->euid;
current579fs/exec.cbprm.e_gid = current->egid;
current581fs/exec.cbprm.e_uid = (i & S_ISUID) ? bprm.inode->i_uid : current->euid;
current582fs/exec.cbprm.e_gid = (i & S_ISGID) ? bprm.inode->i_gid : current->egid;
current584fs/exec.cif (current->euid == bprm.inode->i_uid)
current786fs/exec.ccurrent->end_code = N_TXTADDR(ex) + ex.a_text;
current787fs/exec.ccurrent->end_data = ex.a_data + current->end_code;
current788fs/exec.ccurrent->start_brk = current->brk = current->end_data;
current789fs/exec.ccurrent->start_code += N_TXTADDR(ex);
current790fs/exec.ccurrent->rss = 0;
current791fs/exec.ccurrent->suid = current->euid = bprm->e_uid;
current792fs/exec.ccurrent->mmap = NULL;
current793fs/exec.ccurrent->executable = NULL;  /* for OMAGIC files */
current794fs/exec.ccurrent->sgid = current->egid = bprm->e_gid;
current802fs/exec.cprintk("%s: executable not page aligned\n", current->comm);
current808fs/exec.cfile = current->filp[fd];
current824fs/exec.csend_sig(SIGSEGV, current, 0);
current833fs/exec.csend_sig(SIGSEGV, current, 0);
current836fs/exec.ccurrent->executable = bprm->inode;
current840fs/exec.csys_brk(current->brk+ex.a_bss);
current845fs/exec.ccurrent->start_stack = p;
current848fs/exec.cif (current->flags & PF_PTRACED)
current849fs/exec.csend_sig(SIGTRAP, current, 0);
current864fs/exec.cfile = current->filp[fd];
current292fs/ext/freelists.cinode->i_uid = current->euid;
current293fs/ext/freelists.cinode->i_gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->egid;
current363fs/ext/namei.cinode->i_uid = current->euid;
current450fs/ext/namei.cinode->i_mode = S_IFDIR | (mode & 0777 & ~current->umask);
current546fs/ext/namei.cif ((dir->i_mode & S_ISVTX) && current->euid &&
current547fs/ext/namei.cinode->i_uid != current->euid)
current600fs/ext/namei.ccurrent->euid != inode->i_uid &&
current601fs/ext/namei.ccurrent->euid != dir->i_uid)
current778fs/ext/namei.ccurrent->counter = 0;
current792fs/ext/namei.ccurrent->euid != old_inode->i_uid &&
current793fs/ext/namei.ccurrent->euid != old_dir->i_uid && !suser())
current813fs/ext/namei.ccurrent->euid != new_inode->i_uid &&
current814fs/ext/namei.ccurrent->euid != new_dir->i_uid && !suser())
current55fs/ext/symlink.cdir = current->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;
current32fs/ext2/acl.celse if (current->euid == inode->i_uid)
current470fs/ext2/ialloc.cinode->i_uid = current->euid;
current471fs/ext2/ialloc.cinode->i_gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->egid;
current125fs/ext2/inode.c(current->rlim[RLIMIT_FSIZE].rlim_cur >>
current204fs/ext2/inode.c(current->rlim[RLIMIT_FSIZE].rlim_cur >> 
current26fs/ext2/ioctl.cif ((current->euid != inode->i_uid) && !suser())
current38fs/ext2/ioctl.cif ((current->euid != inode->i_uid) && !suser())
current379fs/ext2/namei.cinode->i_uid = current->euid;
current483fs/ext2/namei.cinode->i_mode = S_IFDIR | (mode & S_IRWXUGO & ~current->umask);
current590fs/ext2/namei.ccurrent->counter = 0;
current594fs/ext2/namei.cif ((dir->i_mode & S_ISVTX) && current->euid &&
current595fs/ext2/namei.cinode->i_uid != current->euid)
current672fs/ext2/namei.ccurrent->counter = 0;
current677fs/ext2/namei.ccurrent->euid != inode->i_uid &&
current678fs/ext2/namei.ccurrent->euid != dir->i_uid)
current902fs/ext2/namei.ccurrent->counter = 0;
current917fs/ext2/namei.ccurrent->euid != old_inode->i_uid &&
current918fs/ext2/namei.ccurrent->euid != old_dir->i_uid && !suser())
current948fs/ext2/namei.ccurrent->euid != new_inode->i_uid &&
current949fs/ext2/namei.ccurrent->euid != new_dir->i_uid && !suser())
current57fs/ext2/symlink.cdir = current->root;
current69fs/ext2/symlink.cif (current->link_count > 5) {
current83fs/ext2/symlink.ccurrent->link_count++;
current85fs/ext2/symlink.ccurrent->link_count--;
current309fs/ext2/truncate.ccurrent->counter = 0;
current22fs/fcntl.cif (fd >= NR_OPEN || !current->filp[fd])
current27fs/fcntl.cif (current->filp[arg])
current33fs/fcntl.cFD_CLR(arg, &current->close_on_exec);
current34fs/fcntl.c(current->filp[arg] = current->filp[fd])->f_count++;
current40fs/fcntl.cif (oldfd >= NR_OPEN || !current->filp[oldfd])
current70fs/fcntl.cif (fd >= NR_OPEN || !(filp = current->filp[fd]))
current76fs/fcntl.creturn FD_ISSET(fd, &current->close_on_exec);
current79fs/fcntl.cFD_SET(fd, &current->close_on_exec);
current81fs/fcntl.cFD_CLR(fd, &current->close_on_exec);
current31fs/fifo.cif (current->signal & ~current->blocked) {
current64fs/fifo.cif (current->signal & ~current->blocked) {
current543fs/hpfs/hpfs_fs.c*uid = current->uid;
current544fs/hpfs/hpfs_fs.c*gid = current->gid;
current545fs/hpfs/hpfs_fs.c*umask = current->umask;
current411fs/inode.cinode->i_uid = current->euid;
current412fs/inode.cinode->i_gid = current->egid;
current476fs/inode.cstruct wait_queue wait = { current, NULL };
current480fs/inode.ccurrent->state = TASK_UNINTERRUPTIBLE;
current486fs/inode.ccurrent->state = TASK_RUNNING;
current62fs/ioctl.cif (fd >= NR_OPEN || !(filp = current->filp[fd]))
current66fs/ioctl.cFD_SET(fd, &current->close_on_exec);
current70fs/ioctl.cFD_CLR(fd, &current->close_on_exec);
current52fs/isofs/symlink.cdir = current->root;
current65fs/isofs/symlink.cif ((current->link_count > 5) ||
current73fs/isofs/symlink.ccurrent->link_count++;
current75fs/isofs/symlink.ccurrent->link_count--;
current61fs/locks.cif (fd >= NR_OPEN || !(filp = current->filp[fd]))
current105fs/locks.cif (fd >= NR_OPEN || !(filp = current->filp[fd]))
current151fs/locks.cif (current->signal & ~current->blocked)
current154fs/locks.cif (current->signal & ~current->blocked)
current221fs/locks.cfl->fl_owner = current;
current429fs/locks.ctmp->fl_owner = current;  /* FIXME: needed? */
current216fs/minix/bitmap.cinode->i_uid = current->euid;
current217fs/minix/bitmap.cinode->i_gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->egid;
current268fs/minix/namei.cinode->i_uid = current->euid;
current352fs/minix/namei.cinode->i_mode = S_IFDIR | (mode & 0777 & ~current->umask);
current446fs/minix/namei.cif ((dir->i_mode & S_ISVTX) && current->euid &&
current447fs/minix/namei.cinode->i_uid != current->euid)
current507fs/minix/namei.ccurrent->counter = 0;
current512fs/minix/namei.ccurrent->euid != inode->i_uid &&
current513fs/minix/namei.ccurrent->euid != dir->i_uid)
current688fs/minix/namei.ccurrent->counter = 0;
current702fs/minix/namei.ccurrent->euid != old_inode->i_uid &&
current703fs/minix/namei.ccurrent->euid != old_dir->i_uid && !suser())
current733fs/minix/namei.ccurrent->euid != new_inode->i_uid &&
current734fs/minix/namei.ccurrent->euid != new_dir->i_uid && !suser())
current49fs/minix/symlink.cdir = current->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->umask;
current111fs/msdos/misc.cint count,nr,limit,last,current,sector;
current143fs/msdos/misc.cif ((current = MSDOS_I(inode)->i_start) != 0) {
current144fs/msdos/misc.ccache_lookup(inode,INT_MAX,&last,&current);
current145fs/msdos/misc.cwhile (current && current != -1)
current146fs/msdos/misc.cif (!(current = fat_access(inode->i_sb,
current147fs/msdos/misc.clast = current,-1))) {
current163fs/msdos/misc.cfor (current = 0; current < MSDOS_SB(inode->i_sb)->cluster_size;
current164fs/msdos/misc.ccurrent++) {
current166fs/msdos/misc.cMSDOS_SB(inode->i_sb)->cluster_size+current;
current170fs/msdos/misc.cif (current < MSDOS_SB(inode->i_sb)->cluster_size-1 &&
current179fs/msdos/misc.ccurrent++;
current458fs/msdos/misc.cint error,current,prev,nr;
current463fs/msdos/misc.cif ((current = raw_scan(dir->i_sb,MSDOS_I(dir)->i_start,MSDOS_DOTDOT,
current466fs/msdos/misc.creturn current;
current468fs/msdos/misc.cif (!current) nr = MSDOS_ROOT_INO;
current470fs/msdos/misc.cif ((prev = raw_scan(dir->i_sb,current,MSDOS_DOTDOT,&zero,NULL,
current475fs/msdos/misc.cif ((error = raw_scan(dir->i_sb,prev,NULL,&current,&nr,NULL,
current80fs/namei.celse if (current->euid == inode->i_uid)
current106fs/namei.cif (dir == current->root) {
current166fs/namei.cbase = current->pwd;
current171fs/namei.cbase = current->root;
current282fs/namei.cmode &= S_IALLUGO & ~current->umask;
current398fs/namei.cmode &= ~current->umask;
current80fs/nfs/inode.cif (fd >= NR_OPEN || !(filp = current->filp[fd])) {
current72fs/nfs/mmap.cmpnt->vm_task = current;
current81fs/nfs/mmap.cinsert_vm_struct(current, mpnt);
current82fs/nfs/mmap.cmerge_segments(current->mmap, NULL, NULL);
current110fs/nfs/mmap.coom(current);
current155fs/nfs/mmap.coom(current);
current625fs/nfs/proc.c*p++ = htonl(current->euid);
current626fs/nfs/proc.c*p++ = htonl(current->egid);
current628fs/nfs/proc.cfor (i = 0; i < 16 && i < NGROUPS && current->groups[i] != NOGROUP; i++)
current629fs/nfs/proc.c*p++ = htonl(current->groups[i]);
current70fs/nfs/sock.cold_mask = current->blocked;
current71fs/nfs/sock.ccurrent->blocked |= ~(_S(SIGKILL)
current76fs/nfs/sock.c? ((current->sigaction[SIGINT - 1].sa_handler == SIG_DFL
current78fs/nfs/sock.c| (current->sigaction[SIGQUIT - 1].sa_handler == SIG_DFL
current92fs/nfs/sock.ccurrent->state = TASK_INTERRUPTIBLE;
current97fs/nfs/sock.ccurrent->timeout = jiffies + timeout;
current100fs/nfs/sock.ccurrent->state = TASK_RUNNING;
current101fs/nfs/sock.cif (current->signal & ~current->blocked) {
current102fs/nfs/sock.ccurrent->timeout = 0;
current106fs/nfs/sock.cif (!current->timeout) {
current126fs/nfs/sock.ccurrent->timeout = 0;
current130fs/nfs/sock.ccurrent->state = TASK_RUNNING;
current162fs/nfs/sock.ccurrent->blocked = old_mask;
current51fs/nfs/symlink.cdir = current->root;
current63fs/nfs/symlink.cif (current->link_count > 5) {
current77fs/nfs/symlink.ccurrent->link_count++;
current79fs/nfs/symlink.ccurrent->link_count--;
current58fs/open.cif (fd >= NR_OPEN || !(file = current->filp[fd]))
current99fs/open.cif (fd >= NR_OPEN || !(file = current->filp[fd]))
current131fs/open.cif ((current->euid != inode->i_uid) && !suser()) {
current139fs/open.cif ((current->euid != inode->i_uid) &&
current170fs/open.cif (current->uid == inode->i_uid)
current186fs/open.cif ((!current->uid) &&
current208fs/open.ciput(current->pwd);
current209fs/open.ccurrent->pwd = inode;
current229fs/open.ciput(current->root);
current230fs/open.ccurrent->root = inode;
current239fs/open.cif (fd >= NR_OPEN || !(file = current->filp[fd]))
current243fs/open.cif ((current->euid != inode->i_uid) && !suser())
current263fs/open.cif ((current->euid != inode->i_uid) && !suser()) {
current286fs/open.cif (fd >= NR_OPEN || !(file = current->filp[fd]))
current296fs/open.cif ((current->euid == inode->i_uid && user == inode->i_uid &&
current324fs/open.cif ((current->euid == inode->i_uid && user == inode->i_uid &&
current360fs/open.cif (!current->filp[fd])
current364fs/open.cFD_CLR(fd,&current->close_on_exec);
current368fs/open.ccurrent->filp[fd] = f;
current377fs/open.ccurrent->filp[fd]=NULL;
current393fs/open.ccurrent->filp[fd]=NULL;
current429fs/open.cfcntl_remove_locks(current, filp, fd);
current448fs/open.cFD_CLR(fd, &current->close_on_exec);
current449fs/open.cif (!(filp = current->filp[fd]))
current451fs/open.ccurrent->filp[fd] = NULL;
current466fs/open.cif (current->tty < 0)
current468fs/open.ctty = TTY_TABLE(MINOR(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->filp[i]) {
current398fs/pipe.ccurrent->filp[ fd[j]=i ] = f[j];
current402fs/pipe.ccurrent->filp[fd[0]]=NULL;
current409fs/pipe.ccurrent->filp[fd[0]] = NULL;
current410fs/pipe.ccurrent->filp[fd[1]] = NULL;
current206fs/proc/array.cif (!p || p == current || p->state == TASK_RUNNING)
current45fs/proc/mem.cif (current->signal & ~current->blocked)
current93fs/proc/mem.cif (current->signal & ~current->blocked)
current104fs/proc/mem.cdo_wp_page(0,addr,current,0);
current120fs/proc/mem.cif (current->signal & ~current->blocked)
current96fs/proc/root.cino = (current->pid << 16) + 2;
current25fs/read_write.cif (fd >= NR_OPEN || !(file = current->filp[fd]) ||
current42fs/read_write.cif (fd >= NR_OPEN || !(file=current->filp[fd]) || !(file->f_inode))
current76fs/read_write.cif (fd>=NR_OPEN || !(file=current->filp[fd]) || !(inode=file->f_inode))
current96fs/read_write.cif (fd>=NR_OPEN || !(file=current->filp[fd]) || !(inode=file->f_inode))
current98fs/select.cif (!current->filp[i])
current100fs/select.cif (!current->filp[i]->f_inode)
current117fs/select.ccurrent->state = TASK_INTERRUPTIBLE;
current119fs/select.cif (FD_ISSET(i,in) && check(SEL_IN,wait,current->filp[i])) {
current124fs/select.cif (FD_ISSET(i,out) && check(SEL_OUT,wait,current->filp[i])) {
current129fs/select.cif (FD_ISSET(i,ex) && check(SEL_EX,wait,current->filp[i])) {
current136fs/select.cif (!count && current->timeout && !(current->signal & ~current->blocked)) {
current142fs/select.ccurrent->state = TASK_RUNNING;
current232fs/select.ccurrent->timeout = timeout;
current234fs/select.cif (current->timeout > jiffies)
current235fs/select.ctimeout = current->timeout - jiffies;
current238fs/select.ccurrent->timeout = 0;
current247fs/select.cif (!i && (current->signal & ~current->blocked))
current19fs/stat.ccurrent->comm);
current162fs/stat.cif (fd >= NR_OPEN || !(f=current->filp[fd]) || !(inode=f->f_inode))
current177fs/stat.cif (fd >= NR_OPEN || !(f=current->filp[fd]) || !(inode=f->f_inode))
current58fs/super.cstruct wait_queue wait = { current, NULL };
current62fs/super.ccurrent->state = TASK_UNINTERRUPTIBLE;
current68fs/super.ccurrent->state = TASK_RUNNING;
current461fs/super.cfor (vma = current->mmap ; ; ) {
current509fs/super.ccurrent->pwd = inode;
current510fs/super.ccurrent->root = inode;
current137fs/sysv/ialloc.cinode->i_uid = current->euid;
current138fs/sysv/ialloc.cinode->i_gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->egid;
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->euid;
current354fs/sysv/namei.cinode->i_mode = S_IFDIR | (mode & 0777 & ~current->umask);
current450fs/sysv/namei.cif ((dir->i_mode & S_ISVTX) && current->euid &&
current451fs/sysv/namei.cinode->i_uid != current->euid)
current511fs/sysv/namei.ccurrent->counter = 0;
current516fs/sysv/namei.ccurrent->euid != inode->i_uid &&
current517fs/sysv/namei.ccurrent->euid != dir->i_uid)
current696fs/sysv/namei.ccurrent->counter = 0;
current710fs/sysv/namei.ccurrent->euid != old_inode->i_uid &&
current711fs/sysv/namei.ccurrent->euid != old_dir->i_uid && !suser())
current741fs/sysv/namei.ccurrent->euid != new_inode->i_uid &&
current742fs/sysv/namei.ccurrent->euid != new_dir->i_uid && !suser())
current56fs/sysv/symlink.cdir = current->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;
current332fs/xiafs/bitmap.cinode->i_uid = current->euid;
current333fs/xiafs/bitmap.cinode->i_gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->egid;
current297fs/xiafs/namei.cinode->i_uid = current->euid;
current380fs/xiafs/namei.cinode->i_mode = S_IFDIR | (mode & S_IRWXUGO & ~current->umask);
current499fs/xiafs/namei.cif ((dir->i_mode & S_ISVTX) && current->euid &&
current500fs/xiafs/namei.cinode->i_uid != current->euid)
current556fs/xiafs/namei.ccurrent->counter = 0;
current561fs/xiafs/namei.ccurrent->euid != inode->i_uid &&
current562fs/xiafs/namei.ccurrent->euid != dir->i_uid)
current732fs/xiafs/namei.ccurrent->euid != old_inode->i_uid &&
current733fs/xiafs/namei.ccurrent->euid != old_dir->i_uid && !suser())
current753fs/xiafs/namei.ccurrent->euid != new_inode->i_uid &&
current754fs/xiafs/namei.ccurrent->euid != new_dir->i_uid && !suser())
current791fs/xiafs/namei.ccurrent->counter=0;
current83fs/xiafs/symlink.cdir = current->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;
current65include/linux/kernel.h#define suser() (current->euid == 0)
current288include/linux/sched.hextern struct task_struct *current;
current466include/linux/sched.hentry->wait.task = current;
current537include/linux/sched.h:"m" (current->debugreg[register]) \
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;
current400ipc/msg.cif (!suser() && current->euid != ipcp->cuid && 
current401ipc/msg.ccurrent->euid != ipcp->uid)
current86ipc/sem.cipcp->cuid = ipcp->uid = current->euid;
current87ipc/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;
current105ipc/shm.cshp->shm_perm.cuid = shp->shm_perm.uid = current->euid;
current106ipc/shm.cshp->shm_perm.cgid = shp->shm_perm.gid = current->egid;
current109ipc/shm.cshp->shm_cpid = current->pid;
current300ipc/shm.cif (suser() || current->euid == shp->shm_perm.uid ||
current301ipc/shm.ccurrent->euid == shp->shm_perm.cuid) {
current311ipc/shm.cif (suser() || current->euid == shp->shm_perm.uid ||
current312ipc/shm.ccurrent->euid == shp->shm_perm.cuid) {
current347ipc/shm.c--current->rss;
current403ipc/shm.cfor (shmd = current->shm; shmd; shmd = shmd->task_next) {
current416ipc/shm.cif ((addr > current->start_stack - 16384 - PAGE_SIZE*shp->shm_npages))
current419ipc/shm.cfor (shmd = current->shm; shmd; shmd = shmd->task_next) {
current443ipc/shm.cshmd->task = current;
current446ipc/shm.cif (addr < current->end_data) {
current447ipc/shm.ciput (current->executable);
current448ipc/shm.ccurrent->executable = NULL;
current459ipc/shm.cshmd->task_next = current->shm;
current460ipc/shm.ccurrent->shm = shmd;
current463ipc/shm.cshp->shm_lpid = current->pid;
current493ipc/shm.cshp->shm_lpid = current->pid;
current508ipc/shm.cfor (shmdp = &current->shm; (shmd = *shmdp); shmdp=&shmd->task_next) { 
current522ipc/shm.cwhile (current->shm) 
current523ipc/shm.cdetach(&current->shm);
current568ipc/shm.cshp->shm_lpid = current->pid;
current601ipc/shm.coom(current);
current621ipc/shm.c--current->maj_flt;  /* was incremented in do_no_page */
current624ipc/shm.ccurrent->min_flt++;
current54ipc/util.cperm = S_IRWXO; euid = current->euid;
current59ipc/util.cfor (i = 0; (egid = current->groups[i]) != NOGROUP; i++)
current50kernel/exit.cif (!priv && ((sig != SIGCONT) || (current->session != p->session)) &&
current51kernel/exit.c(current->euid != p->euid) && (current->uid != p->uid) && !suser())
current84kernel/exit.cif (p == current) {
current283kernel/exit.creturn(kill_pg(current->pgrp,sig,0));
current287kernel/exit.cif (p->pid > 1 && p != current) {
current357kernel/exit.cif (current->semun)
current359kernel/exit.cif (current->shm)
current361kernel/exit.cfree_page_tables(current);
current363kernel/exit.cif (current->filp[i])
current365kernel/exit.cforget_original_parent(current);
current366kernel/exit.ciput(current->pwd);
current367kernel/exit.ccurrent->pwd = NULL;
current368kernel/exit.ciput(current->root);
current369kernel/exit.ccurrent->root = NULL;
current370kernel/exit.ciput(current->executable);
current371kernel/exit.ccurrent->executable = NULL;
current376kernel/exit.cmpnt = current->mmap;
current377kernel/exit.ccurrent->mmap = NULL;
current387kernel/exit.cif (current->ldt) {
current388kernel/exit.cvfree(current->ldt);
current389kernel/exit.ccurrent->ldt = NULL;
current391kernel/exit.cif (task[i] == current) {
current398kernel/exit.ccurrent->state = TASK_ZOMBIE;
current399kernel/exit.ccurrent->exit_code = code;
current400kernel/exit.ccurrent->rss = 0;
current410kernel/exit.cif ((current->p_pptr->pgrp != current->pgrp) &&
current411kernel/exit.c(current->p_pptr->session == current->session) &&
current412kernel/exit.cis_orphaned_pgrp(current->pgrp) &&
current413kernel/exit.chas_stopped_jobs(current->pgrp)) {
current414kernel/exit.ckill_pg(current->pgrp,SIGHUP,1);
current415kernel/exit.ckill_pg(current->pgrp,SIGCONT,1);
current418kernel/exit.cnotify_parent(current);
current428kernel/exit.cwhile ((p = current->p_cptr) != NULL) {
current429kernel/exit.ccurrent->p_cptr = p->p_osptr;
current447kernel/exit.cif ((p->pgrp != current->pgrp) &&
current448kernel/exit.c(p->session == current->session) &&
current455kernel/exit.cif (current->leader)
current457kernel/exit.cif (last_task_used_math == current)
current487kernel/exit.cstruct wait_queue wait = { current, NULL };
current495kernel/exit.cadd_wait_queue(&current->wait_chldexit,&wait);
current498kernel/exit.cfor (p = current->p_cptr ; p ; p = p->p_osptr) {
current503kernel/exit.cif (p->pgrp != current->pgrp)
current528kernel/exit.ccurrent->cutime += p->utime + p->cutime;
current529kernel/exit.ccurrent->cstime += p->stime + p->cstime;
current530kernel/exit.ccurrent->cmin_flt += p->min_flt + p->cmin_flt;
current531kernel/exit.ccurrent->cmaj_flt += p->maj_flt + p->cmaj_flt;
current557kernel/exit.ccurrent->state=TASK_INTERRUPTIBLE;
current559kernel/exit.ccurrent->signal &= ~(1<<(SIGCHLD-1));
current561kernel/exit.cif (current->signal & ~current->blocked)
current567kernel/exit.cremove_wait_queue(&current->wait_chldexit,&wait);
current57kernel/fork.cif (task[i]->uid == current->uid)
current64kernel/fork.cif (current->uid)
current98kernel/fork.cfor (mpnt = current->mmap ; mpnt ; mpnt = mpnt->vm_next) {
current109kernel/fork.cif (current->stk_vma == mpnt)
current137kernel/fork.c*p = *current;
current143kernel/fork.cp->p_pptr = p->p_opptr = current;
current188kernel/fork.cmemcpy(p->ldt, current->ldt, LDT_ENTRIES*LDT_ENTRY_SIZE);
current193kernel/fork.cif (last_task_used_math == current)
current196kernel/fork.cif (copy_vm(p) || shm_fork(current, p))
current207kernel/fork.cif (current->pwd)
current208kernel/fork.ccurrent->pwd->i_count++;
current209kernel/fork.cif (current->root)
current210kernel/fork.ccurrent->root->i_count++;
current211kernel/fork.cif (current->executable)
current212kernel/fork.ccurrent->executable->i_count++;
current220kernel/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;
current84kernel/itimer.ccurrent->it_real_value = j;
current85kernel/itimer.ccurrent->it_real_incr = i;
current88kernel/itimer.ccurrent->it_virt_value = j;
current89kernel/itimer.ccurrent->it_virt_incr = i;
current92kernel/itimer.ccurrent->it_prof_value = j;
current93kernel/itimer.ccurrent->it_prof_incr = i;
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];
current29kernel/panic.cif (current == task[0])
current79kernel/printk.cif (current->signal & ~current->blocked) {
current247kernel/ptrace.cif (current->flags & PF_PTRACED)
current250kernel/ptrace.ccurrent->flags |= PF_PTRACED;
current258kernel/ptrace.cif (child == current)
current260kernel/ptrace.cif ((!child->dumpable || (current->uid != child->euid) ||
current261kernel/ptrace.c(current->gid != child->egid)) && !suser())
current267kernel/ptrace.cif (child->p_pptr != current) {
current269kernel/ptrace.cchild->p_pptr = current;
current281kernel/ptrace.cif (child->p_pptr != current)
current465kernel/ptrace.cif ((current->flags & (PF_PTRACED|PF_TRACESYS))
current468kernel/ptrace.ccurrent->exit_code = SIGTRAP;
current469kernel/ptrace.ccurrent->state = TASK_STOPPED;
current470kernel/ptrace.cnotify_parent(current);
current477kernel/ptrace.cif (current->exit_code)
current478kernel/ptrace.ccurrent->signal |= (1 << (current->exit_code - 1));
current479kernel/ptrace.ccurrent->exit_code = 0;
current86kernel/sched.cstruct task_struct *current = &init_task;
current154kernel/sched.cif (last_task_used_math == current)
current162kernel/sched.clast_task_used_math = current;
current163kernel/sched.cif (current->used_math) {
current164kernel/sched.c__asm__("frstor %0": :"m" (current->tss.i387));
current167kernel/sched.ccurrent->used_math=1;
current177kernel/sched.cprintk("killing %s.\n",current->comm);
current178kernel/sched.csend_sig(SIGFPE,current,1);
current254kernel/sched.cif (TASK_UNINTERRUPTIBLE >= (unsigned) current->state &&
current255kernel/sched.ccurrent->counter < current->priority*2) {
current256kernel/sched.c++current->counter;
current274kernel/sched.cif(current->debugreg[7]){
current285kernel/sched.ccurrent->state = TASK_INTERRUPTIBLE;
current310kernel/sched.cif (p->counter > current->counter)
current336kernel/sched.cif (p->counter > current->counter)
current354kernel/sched.cstruct wait_queue wait = { current, NULL };
current358kernel/sched.cif (current == task[0])
current360kernel/sched.ccurrent->state = state;
current634kernel/sched.ccurrent->utime++;
current636kernel/sched.cif (current->it_virt_value && !(--current->it_virt_value)) {
current637kernel/sched.ccurrent->it_virt_value = current->it_virt_incr;
current638kernel/sched.csend_sig(SIGVTALRM,current,1);
current641kernel/sched.ccurrent->stime++;
current643kernel/sched.cif (prof_buffer && current != task[0]) {
current651kernel/sched.cif (current == task[0] || (--current->counter)<=0) {
current652kernel/sched.ccurrent->counter=0;
current656kernel/sched.cif (current->it_prof_value && !(--current->it_prof_value)) {
current657kernel/sched.ccurrent->it_prof_value = current->it_prof_incr;
current658kernel/sched.csend_sig(SIGPROF,current,1);
current699kernel/sched.creturn current->pid;
current704kernel/sched.creturn current->p_opptr->pid;
current709kernel/sched.creturn current->uid;
current714kernel/sched.creturn current->euid;
current719kernel/sched.creturn current->gid;
current724kernel/sched.creturn current->egid;
current733kernel/sched.cnewprio = current->priority - increment;
current738kernel/sched.ccurrent->priority = newprio;
current746kernel/sched.cprintk("%-8s %3d ", p->comm, (p == current) ? -nr : nr);
current52kernel/signal.csigset_t new_set, old_set = current->blocked;
current62kernel/signal.ccurrent->blocked |= new_set;
current65kernel/signal.ccurrent->blocked &= ~new_set;
current68kernel/signal.ccurrent->blocked = new_set;
current85kernel/signal.creturn current->blocked;
current90kernel/signal.cint old=current->blocked;
current92kernel/signal.ccurrent->blocked = newmask & _BLOCKABLE;
current102kernel/signal.cput_fs_long(current->blocked & current->signal, (unsigned long *)set);
current114kernel/signal.cmask = current->blocked;
current115kernel/signal.ccurrent->blocked = set & _BLOCKABLE;
current118kernel/signal.ccurrent->state = TASK_INTERRUPTIBLE;
current144kernel/signal.cp = signum - 1 + current->sigaction;
current148kernel/signal.ccurrent->signal &= ~_S(signum);
current154kernel/signal.ccurrent->signal &= ~_S(signum);
current171kernel/signal.chandler = (long) current->sigaction[signum-1].sa_handler;
current172kernel/signal.ccurrent->sigaction[signum-1] = tmp;
current184kernel/signal.cp = signum - 1 + current->sigaction;
current221kernel/signal.ccurrent->blocked = context.oldmask & _BLOCKABLE;
current271kernel/signal.cput_fs_long(current->tss.trap_no, frame+14);
current272kernel/signal.cput_fs_long(current->tss.error_code, frame+15);
current281kernel/signal.cput_fs_long(current->tss.cr2, frame+23);
current302kernel/signal.cunsigned long mask = ~current->blocked;
current309kernel/signal.cwhile ((signr = current->signal & mask)) {
current312kernel/signal.c:"=m" (current->signal),"=r" (signr)
current314kernel/signal.csa = current->sigaction + signr;
current316kernel/signal.cif ((current->flags & PF_PTRACED) && signr != SIGKILL) {
current317kernel/signal.ccurrent->exit_code = signr;
current318kernel/signal.ccurrent->state = TASK_STOPPED;
current319kernel/signal.cnotify_parent(current);
current321kernel/signal.cif (!(signr = current->exit_code))
current323kernel/signal.ccurrent->exit_code = 0;
current326kernel/signal.cif (_S(signr) & current->blocked) {
current327kernel/signal.ccurrent->signal |= _S(signr);
current330kernel/signal.csa = current->sigaction + signr - 1;
current341kernel/signal.cif (current->pid == 1)
current348kernel/signal.cif (current->flags & PF_PTRACED)
current350kernel/signal.ccurrent->state = TASK_STOPPED;
current351kernel/signal.ccurrent->exit_code = signr;
current352kernel/signal.cif (!(current->p_pptr->sigaction[SIGCHLD-1].sa_flags & 
current354kernel/signal.cnotify_parent(current);
current364kernel/signal.ccurrent->signal |= _S(signr & 0x7f);
current391kernel/signal.csa = current->sigaction;
current406kernel/signal.ccurrent->blocked |= sa->sa_mask;
current411kernel/signal.ccurrent->tss.trap_no = current->tss.error_code = 0;
current38kernel/sys.cif (!who && p == current)
current43kernel/sys.cwho = current->pgrp;
current47kernel/sys.cwho = current->uid;
current68kernel/sys.cif ((*p)->uid != current->euid &&
current69kernel/sys.c(*p)->uid != current->uid && !suser()) {
current134kernel/sys.cif (!current->vm86_info) {
current138kernel/sys.cmemcpy_tofs(&(current->vm86_info->regs),regs,sizeof(*regs));
current139kernel/sys.cput_fs_long(current->screen_bitmap,&(current->vm86_info->screen_bitmap));
current140kernel/sys.cstack = current->tss.esp0;
current141kernel/sys.ccurrent->tss.esp0 = current->saved_kernel_stack;
current142kernel/sys.ccurrent->saved_kernel_stack = 0;
current171kernel/sys.cif (current->saved_kernel_stack)
current189kernel/sys.ccurrent->saved_kernel_stack = current->tss.esp0;
current190kernel/sys.ccurrent->tss.esp0 = (unsigned long) pt_regs;
current191kernel/sys.ccurrent->vm86_info = v86;
current192kernel/sys.ccurrent->screen_bitmap = info.screen_bitmap;
current194kernel/sys.cmark_screen_rdonly(current);
current257kernel/sys.cint old_rgid = current->gid;
current260kernel/sys.cif ((current->egid==rgid) ||
current263kernel/sys.ccurrent->gid = rgid;
current269kernel/sys.c(current->egid == egid) ||
current271kernel/sys.ccurrent->egid = egid;
current272kernel/sys.ccurrent->sgid = egid;
current274kernel/sys.ccurrent->gid = old_rgid;
current287kernel/sys.ccurrent->gid = current->egid = current->sgid = gid;
current288kernel/sys.celse if ((gid == current->gid) || (gid == current->sgid))
current289kernel/sys.ccurrent->egid = gid;
current340kernel/sys.cint old_ruid = current->uid;
current343kernel/sys.cif ((current->euid==ruid) ||
current346kernel/sys.ccurrent->uid = ruid;
current352kernel/sys.c(current->euid == euid) ||
current354kernel/sys.ccurrent->euid = euid;
current355kernel/sys.ccurrent->suid = euid;
current357kernel/sys.ccurrent->uid = old_ruid;
current378kernel/sys.ccurrent->uid = current->euid = current->suid = uid;
current379kernel/sys.celse if ((uid == current->uid) || (uid == current->suid))
current380kernel/sys.ccurrent->euid = uid;
current392kernel/sys.cput_fs_long(current->utime,(unsigned long *)&tbuf->tms_utime);
current393kernel/sys.cput_fs_long(current->stime,(unsigned long *)&tbuf->tms_stime);
current394kernel/sys.cput_fs_long(current->cutime,(unsigned long *)&tbuf->tms_cutime);
current395kernel/sys.cput_fs_long(current->cstime,(unsigned long *)&tbuf->tms_cstime);
current406kernel/sys.cif (brk < current->end_code)
current407kernel/sys.creturn current->brk;
current409kernel/sys.coldbrk = PAGE_ALIGN(current->brk);
current411kernel/sys.creturn current->brk = brk;
current416kernel/sys.cif (brk <= current->brk) {
current417kernel/sys.ccurrent->brk = brk;
current424kernel/sys.crlim = current->rlim[RLIMIT_DATA].rlim_cur;
current427kernel/sys.cif (brk - current->end_code > rlim || brk >= current->start_stack - 16384)
current428kernel/sys.creturn current->brk;
current440kernel/sys.creturn current->brk;
current442kernel/sys.cfreepages += current->rss;
current445kernel/sys.creturn current->brk;
current450kernel/sys.ccurrent->brk = brk;
current471kernel/sys.cpid = current->pid;
current473kernel/sys.cpgid = current->pid;
current478kernel/sys.c((task[i]->p_pptr == current) || 
current479kernel/sys.c(task[i]->p_opptr == current) || 
current480kernel/sys.c(task[i] == current))) {
current483kernel/sys.cif ((task[i]->session != current->session) ||
current485kernel/sys.c(session_of_pgrp(pgid) != current->session)))
current495kernel/sys.creturn current->pgrp;
current500kernel/sys.cif (current->leader && !suser())
current502kernel/sys.ccurrent->leader = 1;
current503kernel/sys.ccurrent->session = current->pgrp = current->pid;
current504kernel/sys.ccurrent->tty = -1;
current505kernel/sys.creturn current->pgrp;
current520kernel/sys.cfor (i = 0 ; (i < NGROUPS) && (current->groups[i] != NOGROUP) ; i++) {
current525kernel/sys.cput_fs_word(current->groups[i], (short *) grouplist);
current540kernel/sys.ccurrent->groups[i] = get_fs_word((unsigned short *) grouplist);
current543kernel/sys.ccurrent->groups[i] = NOGROUP;
current551kernel/sys.cif (grp == current->egid)
current555kernel/sys.cif (current->groups[i] == NOGROUP)
current557kernel/sys.cif (current->groups[i] == grp)
current665kernel/sys.cput_fs_long(current->rlim[resource].rlim_cur, 
current667kernel/sys.cput_fs_long(current->rlim[resource].rlim_max, 
current678kernel/sys.cold_rlim = current->rlim + resource;
current745kernel/sys.creturn getrusage(current, who, ru);
current750kernel/sys.cint old = current->umask;
current752kernel/sys.ccurrent->umask = mask & S_IRWXUGO;
current30kernel/traps.cif (signr == SIGTRAP && current->flags & PF_PTRACED) \
current31kernel/traps.ccurrent->blocked &= ~(1 << (SIGTRAP-1)); \
current90kernel/traps.cprintk("Pid: %d, process nr: %d\n", current->pid, 0xffff & i);
current97kernel/traps.cDO_ERROR( 0, SIGFPE,  "divide error", divide_error, current)
current98kernel/traps.cDO_ERROR( 3, SIGTRAP, "int3", int3, current)
current99kernel/traps.cDO_ERROR( 4, SIGSEGV, "overflow", overflow, current)
current100kernel/traps.cDO_ERROR( 5, SIGSEGV, "bounds", bounds, current)
current101kernel/traps.cDO_ERROR( 6, SIGILL,  "invalid operand", invalid_op, current)
current102kernel/traps.cDO_ERROR( 7, SIGSEGV, "device not available", device_not_available, current)
current103kernel/traps.cDO_ERROR( 8, SIGSEGV, "double fault", double_fault, current)
current105kernel/traps.cDO_ERROR(10, SIGSEGV, "invalid TSS", invalid_TSS, current)
current106kernel/traps.cDO_ERROR(11, SIGSEGV, "segment not present", segment_not_present, current)
current107kernel/traps.cDO_ERROR(12, SIGSEGV, "stack segment", stack_segment, current)
current108kernel/traps.cDO_ERROR(13, SIGSEGV, "general protection", general_protection, current)
current109kernel/traps.cDO_ERROR(15, SIGSEGV, "reserved", reserved, current)
current110kernel/traps.cDO_ERROR(17, SIGSEGV, "alignment check", alignment_check, current)
current120kernel/traps.cif (current->flags & PF_PTRACED)
current121kernel/traps.ccurrent->blocked &= ~(1 << (SIGTRAP-1));
current122kernel/traps.csend_sig(SIGTRAP, current, 1);
current123kernel/traps.ccurrent->tss.trap_no = 1;
current124kernel/traps.ccurrent->tss.error_code = error_code;
current163kernel/traps.ccurrent->tss.trap_no = 16;
current164kernel/traps.ccurrent->tss.error_code = 0;
current175mm/memory.cif (tsk == current)
current198mm/memory.cpg_dir = current->tss.cr3;
current217mm/memory.cold_pg_dir = current->tss.cr3;
current283mm/memory.cdir = PAGE_DIR_OFFSET(current->tss.cr3,from);
current309mm/memory.c--current->rss;
current341mm/memory.cdir = PAGE_DIR_OFFSET(current->tss.cr3,from);
current369mm/memory.c--current->rss;
current403mm/memory.cdir = PAGE_DIR_OFFSET(current->tss.cr3,from);
current431mm/memory.c--current->rss;
current452mm/memory.c++current->rss;
current634mm/memory.cif (user_esp && tsk == current) {
current635mm/memory.ccurrent->tss.cr2 = address;
current636mm/memory.ccurrent->tss.error_code = error_code;
current637mm/memory.ccurrent->tss.trap_no = 14;
current670mm/memory.cdo_wp_page(1,start,current,0);
current826mm/memory.coom(current);
current869mm/memory.cif (tsk != current)
current880mm/memory.ccurrent->tss.error_code = error_code;
current881mm/memory.ccurrent->tss.trap_no = 14;
current908mm/memory.ccurrent->screen_bitmap |= 1 << bit;
current913mm/memory.cdo_wp_page(error_code, address, current, user_esp);
current915mm/memory.cdo_no_page(error_code, address, current, user_esp);
current1177mm/memory.coom(current);
current1194mm/memory.coom(current);
current40mm/mmap.c(PAGE_ALIGN(addr) < current->start_code + current->end_code)
current89mm/mmap.cfor (vmm = current->mmap ; vmm ; vmm = vmm->vm_next) {
current132mm/mmap.cif (!current->errno)
current133mm/mmap.ccurrent->errno = -error;
current147mm/mmap.cif (fd >= NR_OPEN || !(file = current->filp[fd]))
current216mm/mmap.cinsert_vm_struct(current, mpnt);
current223mm/mmap.cinsert_vm_struct(current, mpnt);
current259mm/mmap.cnpp = &current->mmap;
current336mm/mmap.cmpnt->vm_task = current;
current345mm/mmap.cinsert_vm_struct(current, mpnt);
current346mm/mmap.cmerge_segments(current->mmap, NULL, NULL);
current455mm/mmap.cmpnt->vm_task = current;
current463mm/mmap.cinsert_vm_struct(current, mpnt);
current464mm/mmap.cmerge_segments(current->mmap, ignoff_mergep, NULL);
current211mm/swap.coom(current);
current97net/inet/datagram.cif (current->signal & ~current->blocked) 
current199net/inet/raw.cif (current->signal & ~current->blocked) {
current463net/inet/sock.cif (!suser() && current->pgrp != -arg &&
current464net/inet/sock.ccurrent->pid != arg) return(-EPERM);
current912net/inet/sock.ccurrent->timeout = jiffies + HZ*sk->lingertime;
current913net/inet/sock.cwhile(sk->state != TCP_CLOSE && current->timeout>0) {
current915net/inet/sock.cif (current->signal & ~current->blocked) {
current917net/inet/sock.ccurrent->timeout=0;
current921net/inet/sock.ccurrent->timeout=0;
current1072net/inet/sock.cif (current->signal & ~current->blocked) {
current1151net/inet/sock.cif (current->signal & ~current->blocked) {
current1277net/inet/sock.csend_sig(SIGPIPE, current, 1);
current1305net/inet/sock.csend_sig(SIGPIPE, current, 1);
current1333net/inet/sock.csend_sig(SIGPIPE, current, 1);
current755net/inet/tcp.csend_sig(SIGPIPE, current, 0);
current772net/inet/tcp.cif (current->signal & ~current->blocked) {
current866net/inet/tcp.cif (current->signal & ~current->blocked) {
current1171net/inet/tcp.cif (current->signal & ~current->blocked) {
current1339net/inet/tcp.cif (current->signal & ~current->blocked) {
current1389net/inet/tcp.csend_sig(SIGURG, current, 0);
current2743net/inet/tcp.cif (current->signal & ~current->blocked) {
current108net/socket.cif (!current->filp[fd]) break;
current113net/socket.cFD_CLR(fd, &current->close_on_exec);
current114net/socket.ccurrent->filp[fd] = file;
current162net/socket.cif (fd < 0 || fd >= NR_OPEN || !(file = current->filp[fd])) return(NULL);
current198net/socket.cSOCK_INODE(sock)->i_uid = current->euid;
current199net/socket.cSOCK_INODE(sock)->i_gid = current->egid;
current213net/socket.cif (current->signal & ~current->blocked) {
current542net/socket.cif (fd < 0 || fd >= NR_OPEN || current->filp[fd] == NULL)
current564net/socket.cif (fd < 0 || fd >= NR_OPEN || current->filp[fd] == NULL)
current590net/socket.cif (fd < 0 || fd >= NR_OPEN || ((file = current->filp[fd]) == NULL))
current645net/socket.cif (fd < 0 || fd >= NR_OPEN || (file=current->filp[fd]) == NULL)
current680net/socket.cif (fd < 0 || fd >= NR_OPEN || current->filp[fd] == NULL)
current693net/socket.cif (fd < 0 || fd >= NR_OPEN || current->filp[fd] == NULL)
current710net/socket.cif (fd < 0 || fd >= NR_OPEN || ((file = current->filp[fd]) == NULL))
current729net/socket.cif (fd < 0 || fd >= NR_OPEN || ((file = current->filp[fd]) == NULL))
current748net/socket.cif (fd < 0 || fd >= NR_OPEN || ((file = current->filp[fd]) == NULL))
current767net/socket.cif (fd < 0 || fd >= NR_OPEN || ((file = current->filp[fd]) == NULL))
current787net/socket.cif (fd < 0 || fd >= NR_OPEN || ((file = current->filp[fd]) == NULL))
current806net/socket.cif (fd < 0 || fd >= NR_OPEN || ((file = current->filp[fd]) == NULL))
current823net/socket.cif (fd < 0 || fd >= NR_OPEN || ((file = current->filp[fd]) == NULL))
current513net/unix/sock.cif (current->signal & ~current->blocked) {
current591net/unix/sock.cif (current->signal & ~current->blocked) {
current606net/unix/sock.csend_sig(SIGKILL, current, 1);
current643net/unix/sock.csend_sig(SIGPIPE, current, 1);
current654net/unix/sock.cif (current->signal & ~current->blocked) {
current660net/unix/sock.csend_sig(SIGPIPE, current, 1);
current674net/unix/sock.csend_sig(SIGKILL, current, 1);
current683net/unix/sock.csend_sig(SIGPIPE, current, 1);