taglinefilesource code
p247drivers/block/blk.hstruct task_struct * p;
p278drivers/block/blk.hif ((p = req->waiting) != NULL) {
p280drivers/block/blk.hp->state = TASK_RUNNING;
p281drivers/block/blk.hif (p->counter > current->counter)
p39drivers/block/genhd.cstruct partition *p;
p59drivers/block/genhd.cp = (struct partition *) (0x1BE + bh->b_data);
p64drivers/block/genhd.cif (p->sys_ind == EXTENDED_PARTITION ||
p65drivers/block/genhd.c!(hd->part[current_minor].nr_sects = p->nr_sects))
p67drivers/block/genhd.chd->part[current_minor].start_sect = this_sector + p->start_sect;
p72drivers/block/genhd.cp++;
p80drivers/block/genhd.cif (p->sys_ind != EXTENDED_PARTITION ||
p81drivers/block/genhd.c!(hd->part[current_minor].nr_sects = p->nr_sects))
p83drivers/block/genhd.chd->part[current_minor].start_sect = first_sector + p->start_sect;
p84drivers/block/genhd.cthis_sector = first_sector + p->start_sect;
p99drivers/block/genhd.cstruct partition *p;
p114drivers/block/genhd.cp = (struct partition *) (0x1BE + bh->b_data);
p115drivers/block/genhd.cfor (i=1 ; i<=4 ; minor++,i++,p++) {
p116drivers/block/genhd.cif (!(hd->part[minor].nr_sects = p->nr_sects))
p118drivers/block/genhd.chd->part[minor].start_sect = first_sector + p->start_sect;
p122drivers/block/genhd.cif (p->sys_ind == EXTENDED_PARTITION) {
p132drivers/block/genhd.cp = (struct partition *) (0x1BE + bh->b_data);
p134drivers/block/genhd.cp--;
p137drivers/block/genhd.cif (!(p->start_sect && p->nr_sects))
p139drivers/block/genhd.chd->part[current_minor].start_sect = p->start_sect;
p140drivers/block/genhd.chd->part[current_minor].nr_sects = p->nr_sects;
p199drivers/block/genhd.cstruct gendisk *p;
p202drivers/block/genhd.cfor (p = gendisk_head ; p ; p=p->next) {
p203drivers/block/genhd.csetup_dev(p);
p204drivers/block/genhd.cnr += p->nr_real;
p84drivers/block/mcd.cstatic void bin2bcd(unsigned char *p);
p913drivers/block/mcd.cbin2bcd(unsigned char *p)
p917drivers/block/mcd.cu = *p % 10;
p918drivers/block/mcd.ct = *p / 10;
p919drivers/block/mcd.c*p = u | (t << 4);
p489drivers/block/sbpcd.cstatic void bin2bcdx(u_char *p)  /* must work only up to 75 or 99 */
p491drivers/block/sbpcd.c*p=((*p/10)<<4)|(*p%10);
p1474drivers/block/sbpcd.cstatic int convert_UPC(u_char *p)
p1478drivers/block/sbpcd.cp++;
p1479drivers/block/sbpcd.cif (!new_drive) p[13]=0;
p1482drivers/block/sbpcd.cif (new_drive) DS[d].UPC_buf[i]=swap_nibbles(*p++);
p1485drivers/block/sbpcd.cDS[d].UPC_buf[i]=((*p++)<<4)&0xFF;
p1486drivers/block/sbpcd.cDS[d].UPC_buf[i] |= *p++;
p2693drivers/block/sbpcd.cu_char *p;
p2748drivers/block/sbpcd.cp = DS[d].sbp_buf + frame *  CD_FRAMESIZE;
p2752drivers/block/sbpcd.cREAD_DATA(CDi_data, p, CD_FRAMESIZE);
p2962drivers/block/sbpcd.cvoid sbpcd_setup(char *s, int *p)
p2964drivers/block/sbpcd.cDPRINTF((DBG_INI,"SBPCD: sbpcd_setup called with %04X,%s\n",p[1], s));
p2967drivers/block/sbpcd.cif (p[0]>0) sbpcd_ioaddr=p[1];
p702drivers/char/console.cstatic void respond_string(char * p, int currcons, struct tty_struct * tty)
p704drivers/char/console.cwhile (*p) {
p705drivers/char/console.cput_tty_queue(*p, &tty->read_q);
p706drivers/char/console.cp++;
p748drivers/char/console.cunsigned char *p;
p751drivers/char/console.cfor (p = (unsigned char *)origin+1; p < (unsigned char *)scr_end; p+=2)
p752drivers/char/console.c*p = (*p & 0x88) | (((*p >> 4) | (*p << 4)) & 0x77);
p754drivers/char/console.cfor (p = (unsigned char *)origin+1; p < (unsigned char *)scr_end; p+=2)
p755drivers/char/console.c*p ^= *p & 0x07 == 1 ? 0x70 : 0x77;
p843drivers/char/console.cunsigned short * p = (unsigned short *) pos;
p846drivers/char/console.ctmp = *p;
p847drivers/char/console.c*p = old;
p849drivers/char/console.cp++;
p863drivers/char/console.cunsigned short * p = (unsigned short *) pos;
p866drivers/char/console.c*p = *(p+1);
p867drivers/char/console.cp++;
p869drivers/char/console.c*p = video_erase_char;
p1635drivers/char/console.cunsigned char *p, *p1, *p2;
p1641drivers/char/console.cp = p1;
p1643drivers/char/console.cp2 = p;
p1645drivers/char/console.cfor (p = p1; p <= p2; p += 2)
p1646drivers/char/console.c*p = (*p & 0x88) | ((*p << 4) & 0x70) | ((*p >> 4) & 0x07);
p1653drivers/char/console.cstatic inline int atedge(const int p)
p1655drivers/char/console.creturn (!(p % video_size_row) || !((p + 2) % video_size_row));
p38drivers/char/mem.cunsigned long p = file->f_pos;
p43drivers/char/mem.cif (p >= high_memory)
p45drivers/char/mem.cif (count > high_memory - p)
p46drivers/char/mem.ccount = high_memory - p;
p48drivers/char/mem.cwhile (p < PAGE_SIZE && count > 0) {
p51drivers/char/mem.cp++;
p55drivers/char/mem.cmemcpy_tofs(buf,(void *) p,count);
p63drivers/char/mem.cunsigned long p = file->f_pos;
p68drivers/char/mem.cif (p >= high_memory)
p70drivers/char/mem.cif (count > high_memory - p)
p71drivers/char/mem.ccount = high_memory - p;
p73drivers/char/mem.cwhile (p < PAGE_SIZE && count > 0) {
p76drivers/char/mem.cp++;
p80drivers/char/mem.cmemcpy_fromfs((void *) p,buf,count);
p145drivers/char/tty_io.cunsigned char  *p = bufp;
p156drivers/char/tty_io.c*p++ =  tty->read_q.buf[tail++];
p242drivers/char/tty_io.cstruct task_struct *p;
p268drivers/char/tty_io.cfor_each_task(p) {
p269drivers/char/tty_io.cif (p->tty == tty->line)
p270drivers/char/tty_io.cp->tty = -1;
p310drivers/char/tty_io.cstruct task_struct *p;
p325drivers/char/tty_io.cfor_each_task(p)
p326drivers/char/tty_io.cif (p->session == current->session)
p327drivers/char/tty_io.cp->tty = -1;
p1356drivers/char/tty_io.cstruct task_struct **p;
p1415drivers/char/tty_io.cfor (p = &LAST_TASK ; p > &FIRST_TASK ; --p) {
p1416drivers/char/tty_io.cif ((*p) && (*p)->tty == tty->line)
p1417drivers/char/tty_io.c(*p)->tty = -1;
p1637drivers/char/tty_io.cstruct task_struct **p;
p1645drivers/char/tty_io.cfor (p = &LAST_TASK ; p > &FIRST_TASK ; --p) {
p1646drivers/char/tty_io.cif (!(*p))
p1648drivers/char/tty_io.cif (((*p)->tty == line) ||
p1649drivers/char/tty_io.c((session > 0) && ((*p)->session == session)))
p1650drivers/char/tty_io.csend_sig(SIGKILL, *p, 1);
p1653drivers/char/tty_io.cfilp = (*p)->files->fd[i];
p1656drivers/char/tty_io.csend_sig(SIGKILL, *p, 1);
p1685drivers/char/tty_io.cchar *p;
p1699drivers/char/tty_io.cp = bufp;
p1702drivers/char/tty_io.ctty->write_q.buf[head++] = *p++;
p1709drivers/char/tty_io.ctty->write_data_ptr = (unsigned char *) p;
p1730drivers/char/tty_io.cunsigned char * p;
p1747drivers/char/tty_io.cp = tty->write_data_ptr;
p1750drivers/char/tty_io.ctty->write_q.buf[head++] = *p++;
p1755drivers/char/tty_io.ctty->write_data_ptr = p;
p119drivers/char/tty_ioctl.cstruct task_struct **p;
p126drivers/char/tty_ioctl.cfor (p = &FIRST_TASK ; p <= &LAST_TASK ; p++, n++)
p127drivers/char/tty_ioctl.cif (*p)
p129drivers/char/tty_ioctl.cc = (char *)(*p);
p473drivers/char/tty_ioctl.cstruct task_struct *p;
p475drivers/char/tty_ioctl.cfor_each_task(p)
p476drivers/char/tty_ioctl.cif (p->tty == dev)
p477drivers/char/tty_ioctl.cp->tty = -1;
p314drivers/char/vt.cchar *p;
p323drivers/char/vt.cp = func_table[i];
p324drivers/char/vt.cif(!p) {
p330drivers/char/vt.cfor ( ; *p; p++)
p331drivers/char/vt.cput_fs_byte(*p, q++);
p342drivers/char/vt.cu_char *p;
p358drivers/char/vt.cfor (p = a->kb_string; get_fs_byte(p); p++)
p376drivers/char/vt.cfor (p = a->kb_string, q = func_table[i]; ; p++, q++)
p377drivers/char/vt.cif (!(*q = get_fs_byte(p)))
p660drivers/net/atp.cstatic void read_block(short ioaddr, int length, unsigned char *p, int data_mode)
p668drivers/net/atp.cdo  *p++ = read_byte_mode0(ioaddr);  while (--length > 0);
p670drivers/net/atp.cdo  *p++ = read_byte_mode2(ioaddr);  while (--length > 0);
p672drivers/net/atp.cdo      *p++ = read_byte_mode4(ioaddr);  while (--length > 0);
p674drivers/net/atp.cdo      *p++ = read_byte_mode6(ioaddr);  while (--length > 0);
p835drivers/net/depca.cchar *p = (char *) skb->data;
p868drivers/net/depca.cfor (p += len; skbL > 0; p += len) {
p892drivers/net/depca.cmemcpy((unsigned char *)(buf + PKT_HDR_LEN), (unsigned char *)p, len);
p447drivers/net/slip.cunsigned char *bp, *p;
p464drivers/net/slip.cp = icp;
p467drivers/net/slip.clen = slhc_compress(sl->slcomp, p, len, sl->cbuff, &p, 1);
p470drivers/net/slip.ccount=slip_esc6(p, (unsigned char *)sl->xbuff,len);
p472drivers/net/slip.ccount=slip_esc(p, (unsigned char *)sl->xbuff,len);
p615drivers/net/slip.cunsigned char *p;
p642drivers/net/slip.cp = (unsigned char *) kmalloc(l + 4, GFP_KERNEL);
p643drivers/net/slip.cif (p == NULL) {
p649drivers/net/slip.csl->dev->mem_start  = (unsigned long) p;
p652drivers/net/slip.cp = (unsigned char *) kmalloc(l + 4, GFP_KERNEL);
p653drivers/net/slip.cif (p == NULL) {
p657drivers/net/slip.csl->dev->rmem_start  = (unsigned long) p;
p669drivers/net/slip.cp = (unsigned char *) kmalloc(l + 4, GFP_KERNEL);
p670drivers/net/slip.cif (p == NULL) {
p675drivers/net/slip.csl->cbuff    = p;
p731drivers/net/slip.cunsigned char *p;
p751drivers/net/slip.cp = buff;
p1328drivers/scsi/NCR5380.cregister unsigned char p = *phase, tmp;
p1339drivers/scsi/NCR5380.cNCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
p1353drivers/scsi/NCR5380.cif ((tmp & PHASE_MASK) != p) {
p1362drivers/scsi/NCR5380.cif (!(p & SR_IO)) 
p1376drivers/scsi/NCR5380.cif (!(p & SR_IO)) {
p1377drivers/scsi/NCR5380.cif (!((p & SR_MSG) && c > 1)) {
p1407drivers/scsi/NCR5380.cif (!(p == PHASE_MSGOUT && c > 1))
p1425drivers/scsi/NCR5380.cif (!c || (*phase == p))
p1456drivers/scsi/NCR5380.cregister unsigned char p = *phase;
p1470drivers/scsi/NCR5380.cif ((tmp = (NCR5380_read(STATUS_REG) & PHASE_MASK)) != p) {
p1476drivers/scsi/NCR5380.cif (p & SR_IO) {
p1482drivers/scsi/NCR5380.cinstance->host_no, instance->dma_channel, (p & SR_IO) ? "reading" :
p1483drivers/scsi/NCR5380.c"writing", c, (p & SR_IO) ? "to" : "from", (unsigned) d);
p1485drivers/scsi/NCR5380.chostdata->dma_len = (p & SR_IO) ?
p1490drivers/scsi/NCR5380.cNCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
p1513drivers/scsi/NCR5380.cif (p & SR_IO)
p1562drivers/scsi/NCR5380.cif (p & SR_IO) {
p1596drivers/scsi/NCR5380.cif (*phase == p && (p & SR_IO) && residue == 0) {
p1626drivers/scsi/NCR5380.cif (p & SR_IO) {
p93drivers/scsi/aha1542.h#define any2scsi(up, p)        \
p94drivers/scsi/aha1542.h(up)[0] = (((unsigned long)(p)) >> 16)  ;  \
p95drivers/scsi/aha1542.h(up)[1] = (((unsigned long)(p)) >> 8);    \
p96drivers/scsi/aha1542.h(up)[2] = ((unsigned long)(p));
p100drivers/scsi/aha1542.h#define xany2scsi(up, p)  \
p101drivers/scsi/aha1542.h(up)[0] = ((long)(p)) >> 24;  \
p102drivers/scsi/aha1542.h(up)[1] = ((long)(p)) >> 16;  \
p103drivers/scsi/aha1542.h(up)[2] = ((long)(p)) >> 8;  \
p104drivers/scsi/aha1542.h(up)[3] = ((long)(p));
p89drivers/scsi/aha1740.h#define any2scsi(up, p)        \
p90drivers/scsi/aha1740.h(up)[0] = (((unsigned long)(p)) >> 16)  ;  \
p91drivers/scsi/aha1740.h(up)[1] = (((unsigned long)(p)) >> 8);    \
p92drivers/scsi/aha1740.h(up)[2] = ((unsigned long)(p));
p96drivers/scsi/aha1740.h#define xany2scsi(up, p)  \
p97drivers/scsi/aha1740.h(up)[0] = ((long)(p)) >> 24;  \
p98drivers/scsi/aha1740.h(up)[1] = ((long)(p)) >> 16;  \
p99drivers/scsi/aha1740.h(up)[2] = ((long)(p)) >> 8;  \
p100drivers/scsi/aha1740.h(up)[3] = ((long)(p));
p456drivers/scsi/scsi.hstruct task_struct * p;
p488drivers/scsi/scsi.hif ((p = req->waiting) != NULL) {
p490drivers/scsi/scsi.hp->state = TASK_RUNNING;
p491drivers/scsi/scsi.hif (p->counter > current->counter)
p157drivers/scsi/scsi_debug.cstruct partition * p;
p274drivers/scsi/scsi_debug.cp = (struct partition* ) (buff + 0x1be);
p277drivers/scsi/scsi_debug.cp->start_sect = starts[npart];
p278drivers/scsi/scsi_debug.cp->nr_sects = starts[npart+1] - starts [npart];
p279drivers/scsi/scsi_debug.cp->sys_ind = 0x81;  /* Linux partition */
p280drivers/scsi/scsi_debug.cp++;
p76drivers/scsi/scsi_ioctl.cstruct task_struct * p;
p81drivers/scsi/scsi_ioctl.cif ((p = req->waiting) != NULL) {
p83drivers/scsi/scsi_ioctl.cp->state = TASK_RUNNING;
p84drivers/scsi/scsi_ioctl.cif (p->counter > current->counter)
p770drivers/scsi/sd.cstruct task_struct * p;
p775drivers/scsi/sd.cif ((p = req->waiting) != NULL) {
p777drivers/scsi/sd.cp->state = TASK_RUNNING;
p778drivers/scsi/sd.cif (p->counter > current->counter)
p635drivers/scsi/sr.cstruct task_struct * p;
p640drivers/scsi/sr.cif ((p = req->waiting) != NULL) {
p642drivers/scsi/sr.cp->state = TASK_RUNNING;
p643drivers/scsi/sr.cif (p->counter > current->counter)
p24drivers/scsi/sr_ioctl.cstruct task_struct * p;
p29drivers/scsi/sr_ioctl.cif ((p = req->waiting) != NULL) {
p31drivers/scsi/sr_ioctl.cp->state = TASK_RUNNING;
p32drivers/scsi/sr_ioctl.cif (p->counter > current->counter)
p827drivers/scsi/ultrastor.cunsigned char p = inb(port0 + i);
p828drivers/scsi/ultrastor.cout[28 + i * 3] = "0123456789abcdef"[p >> 4];
p829drivers/scsi/ultrastor.cout[29 + i * 3] = "0123456789abcdef"[p & 15];
p107drivers/scsi/wd7000.h#define any2scsi(up, p)      \
p108drivers/scsi/wd7000.h(up)[0] = (((long)(p)) >> 16);  \
p109drivers/scsi/wd7000.h(up)[1] = ((long)(p)) >> 8;    \
p110drivers/scsi/wd7000.h(up)[2] = ((long)(p));
p114drivers/scsi/wd7000.h#define xany2scsi(up, p)  \
p115drivers/scsi/wd7000.h(up)[0] = ((long)(p)) >> 24;  \
p116drivers/scsi/wd7000.h(up)[1] = ((long)(p)) >> 16;  \
p117drivers/scsi/wd7000.h(up)[2] = ((long)(p)) >> 8;  \
p118drivers/scsi/wd7000.h(up)[3] = ((long)(p));
p129drivers/sound/audio.cint             c, p, l;
p135drivers/sound/audio.cp = 0;
p171drivers/sound/audio.cCOPY_FROM_USER (&wr_dma_buf[dev][wr_buff_ptr[dev]], buf, p, l);
p175drivers/sound/audio.cwr_dma_buf[dev], wr_buff_ptr[dev], buf, p, l);
p190drivers/sound/audio.cp += l;
p209drivers/sound/audio.cint             c, p, l;
p215drivers/sound/audio.cp = 0;
p250drivers/sound/audio.cCOPY_TO_USER (buf, p, dmabuf, l);
p254drivers/sound/audio.cp += l;
p108drivers/sound/dmabuf.cunsigned        i, p, n;
p159drivers/sound/dmabuf.cp = 0;
p161drivers/sound/dmabuf.cwhile ((p + bsz) <= sound_buffsizes[dev])
p163drivers/sound/dmabuf.cdev_buf[dev][n] = snd_raw_buf[dev][i] + p;
p164drivers/sound/dmabuf.cdev_buf_phys[dev][n] = snd_raw_buf_phys[dev][i] + p;
p165drivers/sound/dmabuf.cp += bsz;
p391drivers/sound/dmabuf.cint             p = dev_counts[dev][dev_qhead[dev]] + c;
p393drivers/sound/dmabuf.cif (p >= dev_buffsize[dev])
p400drivers/sound/dmabuf.cdev_counts[dev][dev_qhead[dev]] = p;
p262drivers/sound/pas2_mixer.cstruct sb_mixer_params p;
p267drivers/sound/pas2_mixer.cIOCTL_FROM_USER ((char *) &p, (char *) user_p, 0, sizeof (p));
p269drivers/sound/pas2_mixer.cif (p.record_source != SRC_MIC
p270drivers/sound/pas2_mixer.c&& p.record_source != SRC_CD
p271drivers/sound/pas2_mixer.c&& p.record_source != SRC_LINE)
p283drivers/sound/pas2_mixer.cif (!p.dsp_stereo)
p289drivers/sound/pas2_mixer.cswitch (p.record_source)
p79drivers/sound/sequencer.cint             c = count, p = 0;
p107drivers/sound/sequencer.cCOPY_TO_USER (buf, p, &iqueue[iqhead * IEV_SZ], IEV_SZ);
p108drivers/sound/sequencer.cp += 4;
p171drivers/sound/sequencer.cint             p = 0, c, ev_size;
p189drivers/sound/sequencer.cCOPY_FROM_USER (event, buf, p, 4);
p203drivers/sound/sequencer.cerr = synth_devs[dev]->load_patch (dev, *(short *) &event[0], buf, p + 4, c, 0);
p222drivers/sound/sequencer.cCOPY_FROM_USER (&event[4], buf, p + 4, 4);
p265drivers/sound/sequencer.cp += ev_size;
p449fs/binfmt_coff.cbprm->p += change_ldt (0, bprm->page);
p450fs/binfmt_coff.cbprm->p -= MAX_ARG_PAGES*PAGE_SIZE;
p451fs/binfmt_coff.cbprm->p  = (unsigned long) create_tables ((char *) bprm->p,
p471fs/binfmt_coff.ccurrent->mm->start_stack = bprm->p;
p49fs/binfmt_elf.cunsigned long * create_elf_tables(char * p,int argc,int envc,struct elfhdr * exec, unsigned int load_addr, int ibcs)
p58fs/binfmt_elf.cmpnt->vm_start = PAGE_MASK & (unsigned long) p;
p68fs/binfmt_elf.csp = (unsigned long *) (0xfffffffc & (unsigned long) p);
p97fs/binfmt_elf.ccurrent->mm->arg_start = (unsigned long) p;
p99fs/binfmt_elf.cput_fs_long((unsigned long) p,argv++);
p100fs/binfmt_elf.cwhile (get_fs_byte(p++)) /* nothing */ ;
p103fs/binfmt_elf.ccurrent->mm->arg_end = current->mm->env_start = (unsigned long) p;
p105fs/binfmt_elf.cput_fs_long((unsigned long) p,envp++);
p106fs/binfmt_elf.cwhile (get_fs_byte(p++)) /* nothing */ ;
p109fs/binfmt_elf.ccurrent->mm->env_end = (unsigned long) p;
p403fs/binfmt_elf.cbprm->p = copy_strings(1,&passed_p,bprm->page,bprm->p,2);
p407fs/binfmt_elf.cif (!bprm->p) {
p428fs/binfmt_elf.cbprm->p += change_ldt(0, bprm->page);
p429fs/binfmt_elf.ccurrent->mm->start_stack = bprm->p;
p504fs/binfmt_elf.ccurrent->start_stack = p = elf_stack - 4;
p506fs/binfmt_elf.cbprm->p -= MAX_ARG_PAGES*PAGE_SIZE;
p507fs/binfmt_elf.cbprm->p = (unsigned long) 
p508fs/binfmt_elf.ccreate_elf_tables((char *)bprm->p,
p520fs/binfmt_elf.ccurrent->mm->start_stack = bprm->p;
p539fs/binfmt_elf.cregs->esp = bprm->p;      /* stack pointer */
p32fs/block_dev.cregister char * p;
p108fs/block_dev.cp = offset + bh->b_data;
p113fs/block_dev.cmemcpy_fromfs(p,buf,chars);
p114fs/block_dev.cp += chars;
p1114fs/buffer.cint * p;
p1121fs/buffer.cp = b;
p1123fs/buffer.cblock = *(p++);
p1130fs/buffer.cp = b;
p1140fs/buffer.cbh->b_blocknr = *(p++);
p1296fs/buffer.cstruct buffer_head * tmp, * p;
p1312fs/buffer.cp = tmp;
p1316fs/buffer.cif (p == *bhp)
p1318fs/buffer.c*bhp = p->b_prev_free;
p1319fs/buffer.cif (p == *bhp) /* Was this the last in the list? */
p1322fs/buffer.cremove_from_queues(p);
p1323fs/buffer.cput_unused_buffer_head(p);
p1511fs/buffer.cstruct buffer_head * tmp, * p;
p1534fs/buffer.cp = tmp;
p1536fs/buffer.cremove_from_queues(p);
p1537fs/buffer.cp->b_dev=dev;
p1538fs/buffer.cp->b_uptodate = 0;
p1539fs/buffer.cp->b_req = 0;
p1540fs/buffer.cp->b_blocknr=starting_block++;
p1541fs/buffer.cinsert_into_queues(p);
p268fs/exec.cunsigned long * create_tables(char * p,int argc,int envc,int ibcs)
p277fs/exec.cmpnt->vm_start = PAGE_MASK & (unsigned long) p;
p287fs/exec.csp = (unsigned long *) (0xfffffffc & (unsigned long) p);
p297fs/exec.ccurrent->mm->arg_start = (unsigned long) p;
p299fs/exec.cput_fs_long((unsigned long) p,argv++);
p300fs/exec.cwhile (get_fs_byte(p++)) /* nothing */ ;
p303fs/exec.ccurrent->mm->arg_end = current->mm->env_start = (unsigned long) p;
p305fs/exec.cput_fs_long((unsigned long) p,envp++);
p306fs/exec.cwhile (get_fs_byte(p++)) /* nothing */ ;
p309fs/exec.ccurrent->mm->env_end = (unsigned long) p;
p346fs/exec.cunsigned long p, int from_kmem)
p352fs/exec.cif (!p)
p369fs/exec.cif (p < len) {  /* this shouldn't happen - 128kB */
p374fs/exec.c--p; --tmp; --len;
p376fs/exec.coffset = p % PAGE_SIZE;
p379fs/exec.cif (!(pag = (char *) page[p/PAGE_SIZE]) &&
p380fs/exec.c!(pag = (char *) page[p/PAGE_SIZE] =
p392fs/exec.creturn p;
p550fs/exec.cbprm.p = PAGE_SIZE*MAX_ARG_PAGES-4;
p644fs/exec.cbprm.p = copy_strings(bprm.envc, envp, bprm.page, bprm.p, 0);
p645fs/exec.cbprm.p = copy_strings(--bprm.argc, argv+1, bprm.page, bprm.p, 0);
p655fs/exec.cbprm.p = copy_strings(1, &bprm.filename, bprm.page, bprm.p, 2);
p658fs/exec.cbprm.p = copy_strings(1, &i_arg, bprm.page, bprm.p, 2);
p661fs/exec.cbprm.p = copy_strings(1, &i_name, bprm.page, bprm.p, 2);
p663fs/exec.cif (!bprm.p) {
p678fs/exec.cbprm.p = copy_strings(bprm.envc,envp,bprm.page,bprm.p,0);
p679fs/exec.cbprm.p = copy_strings(bprm.argc,argv,bprm.page,bprm.p,0);
p680fs/exec.cif (!bprm.p) {
p778fs/exec.cunsigned long p = bprm->p;
p859fs/exec.cp += change_ldt(ex.a_text,bprm->page);
p860fs/exec.cp -= MAX_ARG_PAGES*PAGE_SIZE;
p861fs/exec.cp = (unsigned long) create_tables((char *)p,bprm->argc,bprm->envc,0);
p862fs/exec.ccurrent->mm->start_stack = p;
p864fs/exec.cregs->esp = p;      /* stack pointer */
p202fs/ext/file.cchar * p;
p241fs/ext/file.cp = (pos % BLOCK_SIZE) + bh->b_data;
p248fs/ext/file.cmemcpy_fromfs(p,buf,c);
p224fs/ext/inode.cunsigned long * p;
p227fs/ext/inode.cp = inode->u.ext_i.i_data + nr;
p229fs/ext/inode.ctmp = *p;
p232fs/ext/inode.cif (tmp == *p)
p243fs/ext/inode.cif (*p) {
p248fs/ext/inode.c*p = tmp;
p258fs/ext/inode.cunsigned long * p;
p271fs/ext/inode.cp = nr + (unsigned long *) bh->b_data;
p273fs/ext/inode.ctmp = *p;
p276fs/ext/inode.cif (tmp == *p) {
p293fs/ext/inode.cif (*p) {
p298fs/ext/inode.c*p = tmp;
p35fs/ext/truncate.cunsigned long * p;
p42fs/ext/truncate.cp = inode->u.ext_i.i_data+i;
p43fs/ext/truncate.cif (!(tmp = *p))
p50fs/ext/truncate.cif ((bh && bh->b_count != 1) || tmp != *p) {
p55fs/ext/truncate.c*p = 0;
p63fs/ext/truncate.cstatic int trunc_indirect(struct inode * inode, int offset, unsigned long * p)
p72fs/ext/truncate.ctmp = *p;
p76fs/ext/truncate.cif (tmp != *p) {
p81fs/ext/truncate.c*p = 0;
p117fs/ext/truncate.ctmp = *p;
p118fs/ext/truncate.c*p = 0;
p126fs/ext/truncate.cstatic int trunc_dindirect(struct inode * inode, int offset, unsigned long * p)
p134fs/ext/truncate.ctmp = *p;
p138fs/ext/truncate.cif (tmp != *p) {
p143fs/ext/truncate.c*p = 0;
p167fs/ext/truncate.ctmp = *p;
p168fs/ext/truncate.c*p = 0;
p180fs/ext/truncate.cunsigned long * tind, * p;
p184fs/ext/truncate.cp = inode->u.ext_i.i_data+11;
p185fs/ext/truncate.cif (!(tmp = *p))
p188fs/ext/truncate.cif (tmp != *p) {
p193fs/ext/truncate.c*p = 0;
p214fs/ext/truncate.ctmp = *p;
p215fs/ext/truncate.c*p = 0;
p74fs/ext2/balloc.cunsigned long * p = ((unsigned long *) addr) + (offset >> 5);
p87fs/ext2/balloc.c: "r" (~(*p >> bit)));
p91fs/ext2/balloc.cp++;
p96fs/ext2/balloc.cres = find_first_zero_bit (p, size - 32 * (p - addr));
p339fs/ext2/balloc.cchar * p, * r;
p423fs/ext2/balloc.cp = ((char *) bh->b_data) + (j >> 3);
p424fs/ext2/balloc.cr = find_first_zero_byte (p, 
p88fs/ext2/dcache.cstruct dir_cache_entry * p;
p90fs/ext2/dcache.cfor (p = queue_head[queue]; p != NULL && (p->dev != dev ||
p91fs/ext2/dcache.cp->dir != dir || p->len != len ||
p92fs/ext2/dcache.cstrncmp (name, p->name, p->len) != 0);
p93fs/ext2/dcache.cp = p->queue_next)
p95fs/ext2/dcache.creturn p;
p104fs/ext2/dcache.cstruct dir_cache_entry * p;
p107fs/ext2/dcache.cfor (p = first; p != NULL; p = p->next)
p109fs/ext2/dcache.cp->dev, p->dir, p->name);
p116fs/ext2/dcache.cstatic void add_to_cache (struct dir_cache_entry * p)
p118fs/ext2/dcache.cp->prev = NULL;
p119fs/ext2/dcache.cp->next = first;
p121fs/ext2/dcache.cfirst->prev = p;
p123fs/ext2/dcache.clast = p;
p124fs/ext2/dcache.cfirst = p;
p130fs/ext2/dcache.cstatic void add_to_queue (int queue, struct dir_cache_entry * p)
p132fs/ext2/dcache.cp->queue_prev = NULL;
p133fs/ext2/dcache.cp->queue_next = queue_head[queue];
p135fs/ext2/dcache.cqueue_head[queue]->queue_prev = p;
p137fs/ext2/dcache.cqueue_tail[queue] = p;
p138fs/ext2/dcache.cqueue_head[queue] = p;
p144fs/ext2/dcache.cstatic void remove_from_cache (struct dir_cache_entry * p)
p146fs/ext2/dcache.cif (p->prev)
p147fs/ext2/dcache.cp->prev->next = p->next;
p149fs/ext2/dcache.cfirst = p->next;
p150fs/ext2/dcache.cif (p->next)
p151fs/ext2/dcache.cp->next->prev = p->prev;
p153fs/ext2/dcache.clast = p->prev;
p154fs/ext2/dcache.cp->prev = NULL;
p155fs/ext2/dcache.cp->next = NULL;
p161fs/ext2/dcache.cstatic void remove_from_queue (int queue, struct dir_cache_entry * p)
p163fs/ext2/dcache.cif (p->queue_prev)
p164fs/ext2/dcache.cp->queue_prev->queue_next = p->queue_next;
p166fs/ext2/dcache.cqueue_head[queue] = p->queue_next;
p167fs/ext2/dcache.cif (p->queue_next)
p168fs/ext2/dcache.cp->queue_next->queue_prev = p->queue_prev;
p170fs/ext2/dcache.cqueue_tail[queue] = p->queue_prev;
p171fs/ext2/dcache.cp->queue_prev = NULL;
p172fs/ext2/dcache.cp->queue_next = NULL;
p181fs/ext2/dcache.cstruct dir_cache_entry * p;
p186fs/ext2/dcache.cfor (p = first; p != NULL; p = p2) {
p187fs/ext2/dcache.cp2 = p->next;
p188fs/ext2/dcache.cif (p->dev == dev) {
p189fs/ext2/dcache.cremove_from_cache (p);
p190fs/ext2/dcache.cremove_from_queue (hash (p->dev, p->dir), p);
p191fs/ext2/dcache.cp->next = first_free;
p192fs/ext2/dcache.cfirst_free = p;
p208fs/ext2/dcache.cstruct dir_cache_entry * p;
p220fs/ext2/dcache.cif ((p = find_name (queue, dev, dir, our_name, len))) {
p221fs/ext2/dcache.cif (p != first) {
p222fs/ext2/dcache.cremove_from_cache (p);
p223fs/ext2/dcache.cadd_to_cache (p);
p225fs/ext2/dcache.cif (p != queue_head[queue]) {
p226fs/ext2/dcache.cremove_from_queue (queue, p);
p227fs/ext2/dcache.cadd_to_queue (queue, p);
p232fs/ext2/dcache.cour_name, p->ino, hits, misses);
p235fs/ext2/dcache.creturn p->ino;
p256fs/ext2/dcache.cstruct dir_cache_entry * p;
p268fs/ext2/dcache.cif ((p = find_name (queue, dev, dir, name, len))) {
p269fs/ext2/dcache.cp->dir = dir;
p270fs/ext2/dcache.cp->ino = ino;
p271fs/ext2/dcache.cif (p != first) {
p272fs/ext2/dcache.cremove_from_cache (p);
p273fs/ext2/dcache.cadd_to_cache (p);
p275fs/ext2/dcache.cif (p != queue_head[queue]) {
p276fs/ext2/dcache.cremove_from_queue (queue, p);
p277fs/ext2/dcache.cadd_to_queue (queue, p);
p281fs/ext2/dcache.cp = first_free;
p282fs/ext2/dcache.cfirst_free = p->next;
p287fs/ext2/dcache.cp = last;
p288fs/ext2/dcache.clast = p->prev;
p291fs/ext2/dcache.cremove_from_queue (hash (p->dev, p->dir), p);
p294fs/ext2/dcache.cp->dev = dev;
p295fs/ext2/dcache.cp->dir = dir;
p296fs/ext2/dcache.cp->ino = ino;
p297fs/ext2/dcache.cstrncpy (p->name, name, len);
p298fs/ext2/dcache.cp->len = len;
p299fs/ext2/dcache.cp->name[len] = '\0';
p300fs/ext2/dcache.cadd_to_cache (p);
p301fs/ext2/dcache.cadd_to_queue (queue, p);
p316fs/ext2/dcache.cstruct dir_cache_entry * p;
p327fs/ext2/dcache.cif ((p = find_name (queue, dev, dir, name, len))) {
p328fs/ext2/dcache.cremove_from_cache (p);
p329fs/ext2/dcache.cremove_from_queue (queue, p);
p330fs/ext2/dcache.cp->next = first_free;
p331fs/ext2/dcache.cfirst_free = p;
p232fs/ext2/file.cchar * p;
p278fs/ext2/file.cp = (pos % sb->s_blocksize) + bh->b_data;
p285fs/ext2/file.cmemcpy_fromfs (p, buf, c);
p193fs/ext2/inode.cunsigned long * p;
p197fs/ext2/inode.cp = inode->u.ext2_i.i_data + nr;
p199fs/ext2/inode.ctmp = *p;
p202fs/ext2/inode.cif (tmp == *p)
p237fs/ext2/inode.cif (*p) {
p242fs/ext2/inode.c*p = tmp;
p260fs/ext2/inode.cunsigned long * p;
p274fs/ext2/inode.cp = (unsigned long *) bh->b_data + nr;
p276fs/ext2/inode.ctmp = *p;
p279fs/ext2/inode.cif (tmp == *p) {
p311fs/ext2/inode.cif (*p) {
p316fs/ext2/inode.c*p = tmp;
p335fs/ext2/inode.cunsigned long * p;
p348fs/ext2/inode.cp = (unsigned long *) bh->b_data + nr + i;
p351fs/ext2/inode.cif(*p == 0) goto out;
p354fs/ext2/inode.cif(i==0) firstblock = *p;
p355fs/ext2/inode.celse if(*p != firstblock + i) goto out;
p358fs/ext2/inode.cp = (unsigned long *) bh->b_data + nr;
p359fs/ext2/inode.cresult = generate_cluster(bh->b_dev, (int *) p, blocksize);
p56fs/ext2/truncate.cunsigned long * p;
p68fs/ext2/truncate.cp = inode->u.ext2_i.i_data + i;
p69fs/ext2/truncate.ctmp = *p;
p82fs/ext2/truncate.cif ((bh && bh->b_count != 1) || tmp != *p) {
p87fs/ext2/truncate.c*p = 0;
p113fs/ext2/truncate.cstatic int trunc_indirect (struct inode * inode, int offset, unsigned long * p)
p127fs/ext2/truncate.ctmp = *p;
p131fs/ext2/truncate.cif (tmp != *p) {
p136fs/ext2/truncate.c*p = 0;
p196fs/ext2/truncate.ctmp = *p;
p197fs/ext2/truncate.c*p = 0;
p211fs/ext2/truncate.cunsigned long * p)
p222fs/ext2/truncate.ctmp = *p;
p226fs/ext2/truncate.cif (tmp != *p) {
p231fs/ext2/truncate.c*p = 0;
p256fs/ext2/truncate.ctmp = *p;
p257fs/ext2/truncate.c*p = 0;
p274fs/ext2/truncate.cunsigned long * tind, * p;
p283fs/ext2/truncate.cp = inode->u.ext2_i.i_data + EXT2_TIND_BLOCK;
p284fs/ext2/truncate.cif (!(tmp = *p))
p287fs/ext2/truncate.cif (tmp != *p) {
p292fs/ext2/truncate.c*p = 0;
p315fs/ext2/truncate.ctmp = *p;
p316fs/ext2/truncate.c*p = 0;
p253fs/hpfs/hpfs_fs.cstatic unsigned choose_conv(unsigned char *p, unsigned len);
p531fs/hpfs/hpfs_fs.cunsigned char *p = addr;
p532fs/hpfs/hpfs_fs.creturn p[0] == 0 && memcmp(p, p + 1, len - 1) == 0;
p542fs/hpfs/hpfs_fs.cchar *p, *rhs;
p553fs/hpfs/hpfs_fs.cfor (p = strtok(opts, ","); p != 0; p = strtok(0, ",")) {
p554fs/hpfs/hpfs_fs.cif ((rhs = strchr(p, '=')) != 0)
p556fs/hpfs/hpfs_fs.cif (!strcmp(p, "uid")) {
p563fs/hpfs/hpfs_fs.celse if (!strcmp(p, "gid")) {
p570fs/hpfs/hpfs_fs.celse if (!strcmp(p, "umask")) {
p577fs/hpfs/hpfs_fs.celse if (!strcmp(p, "case")) {
p585fs/hpfs/hpfs_fs.celse if (!strcmp(p, "conv")) {
p944fs/hpfs/hpfs_fs.cstatic unsigned choose_conv(unsigned char *p, unsigned len)
p952fs/hpfs/hpfs_fs.cc = *p++;
p954fs/hpfs/hpfs_fs.cif (c == '\r' && len && *p == '\n')
p283fs/isofs/rock.c{ int p;
p284fs/isofs/rock.cfor(p=0;p<rr->u.ER.len_id;p++) printk("%c",rr->u.ER.data[p]);
p14fs/isofs/util.cisonum_711 (char * p)
p16fs/isofs/util.creturn (*p & 0xff);
p20fs/isofs/util.cisonum_712 (char * p)
p24fs/isofs/util.cval = *p;
p31fs/isofs/util.cisonum_721 (char * p)
p33fs/isofs/util.creturn ((p[0] & 0xff) | ((p[1] & 0xff) << 8));
p37fs/isofs/util.cisonum_722 (char * p)
p39fs/isofs/util.creturn (((p[0] & 0xff) << 8) | (p[1] & 0xff));
p43fs/isofs/util.cisonum_723 (char * p)
p46fs/isofs/util.cif (p[0] != p[3] || p[1] != p[2]) {
p51fs/isofs/util.creturn (isonum_721 (p));
p55fs/isofs/util.cisonum_731 (char * p)
p57fs/isofs/util.creturn ((p[0] & 0xff)
p58fs/isofs/util.c| ((p[1] & 0xff) << 8)
p59fs/isofs/util.c| ((p[2] & 0xff) << 16)
p60fs/isofs/util.c| ((p[3] & 0xff) << 24));
p64fs/isofs/util.cisonum_732 (char * p)
p66fs/isofs/util.creturn (((p[0] & 0xff) << 24)
p67fs/isofs/util.c| ((p[1] & 0xff) << 16)
p68fs/isofs/util.c| ((p[2] & 0xff) << 8)
p69fs/isofs/util.c| (p[3] & 0xff));
p73fs/isofs/util.cisonum_733 (char * p)
p79fs/isofs/util.cif (p[i] != p[7-i]) {
p85fs/isofs/util.creturn (isonum_731 (p));
p92fs/isofs/util.cint iso_date(char * p, int flag)
p97fs/isofs/util.cyear = p[0] - 70;
p98fs/isofs/util.cmonth = p[1];
p99fs/isofs/util.cday = p[2];
p100fs/isofs/util.chour = p[3];
p101fs/isofs/util.cminute = p[4];
p102fs/isofs/util.csecond = p[5];
p103fs/isofs/util.cif (flag == 0) tz = p[6]; /* High sierra has no time zone */
p194fs/minix/file.cchar * p;
p233fs/minix/file.cp = (pos % BLOCK_SIZE) + bh->b_data;
p240fs/minix/file.cmemcpy_fromfs(p,buf,c);
p277fs/minix/inode.cunsigned short *p;
p280fs/minix/inode.cp = inode->u.minix_i.i_data + nr;
p282fs/minix/inode.ctmp = *p;
p285fs/minix/inode.cif (tmp == *p)
p296fs/minix/inode.cif (*p) {
p301fs/minix/inode.c*p = tmp;
p311fs/minix/inode.cunsigned short *p;
p324fs/minix/inode.cp = nr + (unsigned short *) bh->b_data;
p326fs/minix/inode.ctmp = *p;
p329fs/minix/inode.cif (tmp == *p) {
p346fs/minix/inode.cif (*p) {
p351fs/minix/inode.c*p = tmp;
p28fs/minix/truncate.cunsigned short * p;
p36fs/minix/truncate.cp = i + inode->u.minix_i.i_data;
p37fs/minix/truncate.cif (!(tmp = *p))
p44fs/minix/truncate.cif ((bh && bh->b_count != 1) || tmp != *p) {
p49fs/minix/truncate.c*p = 0;
p57fs/minix/truncate.cstatic int trunc_indirect(struct inode * inode, int offset, unsigned short * p)
p66fs/minix/truncate.ctmp = *p;
p70fs/minix/truncate.cif (tmp != *p) {
p75fs/minix/truncate.c*p = 0;
p111fs/minix/truncate.ctmp = *p;
p112fs/minix/truncate.c*p = 0;
p123fs/minix/truncate.cunsigned short * dind, * p;
p127fs/minix/truncate.cp = 8 + inode->u.minix_i.i_data;
p128fs/minix/truncate.cif (!(tmp = *p))
p131fs/minix/truncate.cif (tmp != *p) {
p136fs/minix/truncate.c*p = 0;
p157fs/minix/truncate.ctmp = *p;
p158fs/minix/truncate.c*p = 0;
p280fs/namei.cstruct task_struct ** p;
p352fs/namei.cfor (p = &LAST_TASK ; p > &FIRST_TASK ; --p) {
p354fs/namei.cif (!*p)
p356fs/namei.cif (inode == (*p)->executable) {
p360fs/namei.cfor(mpnt = (*p)->mm->mmap; mpnt; mpnt = mpnt->vm_next) {
p44fs/nfs/proc.cstatic int *nfs_rpc_header(int *p, int procedure, int ruid);
p45fs/nfs/proc.cstatic int *nfs_rpc_verify(int *p);
p57fs/nfs/proc.cstatic inline void nfs_rpc_free(int *p)
p59fs/nfs/proc.cfree_page((long) p);
p67fs/nfs/proc.cstatic inline int *xdr_encode_fhandle(int *p, struct nfs_fh *fhandle)
p69fs/nfs/proc.c*((struct nfs_fh *) p) = *fhandle;
p70fs/nfs/proc.cp += (sizeof (*fhandle) + 3) >> 2;
p71fs/nfs/proc.creturn p;
p74fs/nfs/proc.cstatic inline int *xdr_decode_fhandle(int *p, struct nfs_fh *fhandle)
p76fs/nfs/proc.c*fhandle = *((struct nfs_fh *) p);
p77fs/nfs/proc.cp += (sizeof (*fhandle) + 3) >> 2;
p78fs/nfs/proc.creturn p;
p81fs/nfs/proc.cstatic inline int *xdr_encode_string(int *p, const char *string)
p87fs/nfs/proc.c*p++ = htonl(len);
p88fs/nfs/proc.cmemcpy((char *) p, string, len);
p89fs/nfs/proc.cmemset(((char *) p) + len, '\0', (quadlen << 2) - len);
p90fs/nfs/proc.cp += quadlen;
p91fs/nfs/proc.creturn p;
p94fs/nfs/proc.cstatic inline int *xdr_decode_string(int *p, char *string, int maxlen)
p98fs/nfs/proc.clen = ntohl(*p++);
p101fs/nfs/proc.cmemcpy(string, (char *) p, len);
p103fs/nfs/proc.cp += (len + 3) >> 2;
p104fs/nfs/proc.creturn p;
p107fs/nfs/proc.cstatic inline int *xdr_encode_data(int *p, char *data, int len)
p112fs/nfs/proc.c*p++ = htonl(len);
p113fs/nfs/proc.cmemcpy((char *) p, data, len);
p114fs/nfs/proc.cmemset(((char *) p) + len, '\0', (quadlen << 2) - len);
p115fs/nfs/proc.cp += quadlen;
p116fs/nfs/proc.creturn p;
p119fs/nfs/proc.cstatic inline int *xdr_decode_data(int *p, char *data, int *lenp, int maxlen)
p123fs/nfs/proc.clen = *lenp = ntohl(*p++);
p126fs/nfs/proc.cmemcpy(data, (char *) p, len);
p127fs/nfs/proc.cp += (len + 3) >> 2;
p128fs/nfs/proc.creturn p;
p131fs/nfs/proc.cstatic int *xdr_decode_fattr(int *p, struct nfs_fattr *fattr)
p133fs/nfs/proc.cfattr->type = (enum nfs_ftype) ntohl(*p++);
p134fs/nfs/proc.cfattr->mode = ntohl(*p++);
p135fs/nfs/proc.cfattr->nlink = ntohl(*p++);
p136fs/nfs/proc.cfattr->uid = ntohl(*p++);
p137fs/nfs/proc.cfattr->gid = ntohl(*p++);
p138fs/nfs/proc.cfattr->size = ntohl(*p++);
p139fs/nfs/proc.cfattr->blocksize = ntohl(*p++);
p140fs/nfs/proc.cfattr->rdev = ntohl(*p++);
p141fs/nfs/proc.cfattr->blocks = ntohl(*p++);
p142fs/nfs/proc.cfattr->fsid = ntohl(*p++);
p143fs/nfs/proc.cfattr->fileid = ntohl(*p++);
p144fs/nfs/proc.cfattr->atime.seconds = ntohl(*p++);
p145fs/nfs/proc.cfattr->atime.useconds = ntohl(*p++);
p146fs/nfs/proc.cfattr->mtime.seconds = ntohl(*p++);
p147fs/nfs/proc.cfattr->mtime.useconds = ntohl(*p++);
p148fs/nfs/proc.cfattr->ctime.seconds = ntohl(*p++);
p149fs/nfs/proc.cfattr->ctime.useconds = ntohl(*p++);
p150fs/nfs/proc.creturn p;
p153fs/nfs/proc.cstatic int *xdr_encode_sattr(int *p, struct nfs_sattr *sattr)
p155fs/nfs/proc.c*p++ = htonl(sattr->mode);
p156fs/nfs/proc.c*p++ = htonl(sattr->uid);
p157fs/nfs/proc.c*p++ = htonl(sattr->gid);
p158fs/nfs/proc.c*p++ = htonl(sattr->size);
p159fs/nfs/proc.c*p++ = htonl(sattr->atime.seconds);
p160fs/nfs/proc.c*p++ = htonl(sattr->atime.useconds);
p161fs/nfs/proc.c*p++ = htonl(sattr->mtime.seconds);
p162fs/nfs/proc.c*p++ = htonl(sattr->mtime.useconds);
p163fs/nfs/proc.creturn p;
p166fs/nfs/proc.cstatic int *xdr_decode_entry(int *p, struct nfs_entry *entry)
p168fs/nfs/proc.centry->fileid = ntohl(*p++);
p169fs/nfs/proc.cif (!(p = xdr_decode_string(p, entry->name, NFS_MAXNAMLEN)))
p171fs/nfs/proc.centry->cookie = ntohl(*p++);
p173fs/nfs/proc.creturn p;
p176fs/nfs/proc.cstatic int *xdr_decode_fsinfo(int *p, struct nfs_fsinfo *res)
p178fs/nfs/proc.cres->tsize = ntohl(*p++);
p179fs/nfs/proc.cres->bsize = ntohl(*p++);
p180fs/nfs/proc.cres->blocks = ntohl(*p++);
p181fs/nfs/proc.cres->bfree = ntohl(*p++);
p182fs/nfs/proc.cres->bavail = ntohl(*p++);
p183fs/nfs/proc.creturn p;
p193fs/nfs/proc.cint *p, *p0;
p201fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_GETATTR, ruid);
p202fs/nfs/proc.cp = xdr_encode_fhandle(p, fhandle);
p203fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p)) < 0) {
p207fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p209fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p210fs/nfs/proc.cp = xdr_decode_fattr(p, fattr);
p227fs/nfs/proc.cint *p, *p0;
p235fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_SETATTR, ruid);
p236fs/nfs/proc.cp = xdr_encode_fhandle(p, fhandle);
p237fs/nfs/proc.cp = xdr_encode_sattr(p, sattr);
p238fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p)) < 0) {
p242fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p244fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p245fs/nfs/proc.cp = xdr_decode_fattr(p, fattr);
p262fs/nfs/proc.cint *p, *p0;
p274fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_LOOKUP, ruid);
p275fs/nfs/proc.cp = xdr_encode_fhandle(p, dir);
p276fs/nfs/proc.cp = xdr_encode_string(p, name);
p277fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p)) < 0) {
p281fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p283fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p284fs/nfs/proc.cp = xdr_decode_fhandle(p, fhandle);
p285fs/nfs/proc.cp = xdr_decode_fattr(p, fattr);
p302fs/nfs/proc.cint *p, *p0;
p310fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_READLINK, ruid);
p311fs/nfs/proc.cp = xdr_encode_fhandle(p, fhandle);
p312fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p)) < 0) {
p316fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p318fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p319fs/nfs/proc.cif (!(p = xdr_decode_string(p, res, NFS_MAXPATHLEN))) {
p340fs/nfs/proc.cint *p, *p0;
p349fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_READ, ruid);
p350fs/nfs/proc.cp = xdr_encode_fhandle(p, fhandle);
p351fs/nfs/proc.c*p++ = htonl(offset);
p352fs/nfs/proc.c*p++ = htonl(count);
p353fs/nfs/proc.c*p++ = htonl(count); /* traditional, could be any value */
p354fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p)) < 0) {
p358fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p360fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p361fs/nfs/proc.cp = xdr_decode_fattr(p, fattr);
p362fs/nfs/proc.cif (!(p = xdr_decode_data(p, data, &len, count))) {
p383fs/nfs/proc.cint *p, *p0;
p391fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_WRITE, ruid);
p392fs/nfs/proc.cp = xdr_encode_fhandle(p, fhandle);
p393fs/nfs/proc.c*p++ = htonl(offset); /* traditional, could be any value */
p394fs/nfs/proc.c*p++ = htonl(offset);
p395fs/nfs/proc.c*p++ = htonl(count); /* traditional, could be any value */
p396fs/nfs/proc.cp = xdr_encode_data(p, data, count);
p397fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p)) < 0) {
p401fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p403fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p404fs/nfs/proc.cp = xdr_decode_fattr(p, fattr);
p422fs/nfs/proc.cint *p, *p0;
p430fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_CREATE, ruid);
p431fs/nfs/proc.cp = xdr_encode_fhandle(p, dir);
p432fs/nfs/proc.cp = xdr_encode_string(p, name);
p433fs/nfs/proc.cp = xdr_encode_sattr(p, sattr);
p434fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p)) < 0) {
p438fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p440fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p441fs/nfs/proc.cp = xdr_decode_fhandle(p, fhandle);
p442fs/nfs/proc.cp = xdr_decode_fattr(p, fattr);
p458fs/nfs/proc.cint *p, *p0;
p466fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_REMOVE, ruid);
p467fs/nfs/proc.cp = xdr_encode_fhandle(p, dir);
p468fs/nfs/proc.cp = xdr_encode_string(p, name);
p469fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p)) < 0) {
p473fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p475fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p493fs/nfs/proc.cint *p, *p0;
p501fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_RENAME, ruid);
p502fs/nfs/proc.cp = xdr_encode_fhandle(p, old_dir);
p503fs/nfs/proc.cp = xdr_encode_string(p, old_name);
p504fs/nfs/proc.cp = xdr_encode_fhandle(p, new_dir);
p505fs/nfs/proc.cp = xdr_encode_string(p, new_name);
p506fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p)) < 0) {
p510fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p512fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p529fs/nfs/proc.cint *p, *p0;
p537fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_LINK, ruid);
p538fs/nfs/proc.cp = xdr_encode_fhandle(p, fhandle);
p539fs/nfs/proc.cp = xdr_encode_fhandle(p, dir);
p540fs/nfs/proc.cp = xdr_encode_string(p, name);
p541fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p)) < 0) {
p545fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p547fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p564fs/nfs/proc.cint *p, *p0;
p572fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_SYMLINK, ruid);
p573fs/nfs/proc.cp = xdr_encode_fhandle(p, dir);
p574fs/nfs/proc.cp = xdr_encode_string(p, name);
p575fs/nfs/proc.cp = xdr_encode_string(p, path);
p576fs/nfs/proc.cp = xdr_encode_sattr(p, sattr);
p577fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p)) < 0) {
p581fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p583fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p601fs/nfs/proc.cint *p, *p0;
p609fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_MKDIR, ruid);
p610fs/nfs/proc.cp = xdr_encode_fhandle(p, dir);
p611fs/nfs/proc.cp = xdr_encode_string(p, name);
p612fs/nfs/proc.cp = xdr_encode_sattr(p, sattr);
p613fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p)) < 0) {
p617fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p619fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p620fs/nfs/proc.cp = xdr_decode_fhandle(p, fhandle);
p621fs/nfs/proc.cp = xdr_decode_fattr(p, fattr);
p637fs/nfs/proc.cint *p, *p0;
p645fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_RMDIR, ruid);
p646fs/nfs/proc.cp = xdr_encode_fhandle(p, dir);
p647fs/nfs/proc.cp = xdr_encode_string(p, name);
p648fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p)) < 0) {
p652fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p654fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p671fs/nfs/proc.cint *p, *p0;
p683fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_READDIR, ruid);
p684fs/nfs/proc.cp = xdr_encode_fhandle(p, fhandle);
p685fs/nfs/proc.c*p++ = htonl(cookie);
p686fs/nfs/proc.c*p++ = htonl(size);
p687fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p)) < 0) {
p691fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p693fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p694fs/nfs/proc.cfor (i = 0; i < count && *p++; i++) {
p695fs/nfs/proc.cif (!(p = xdr_decode_entry(p, entry++)))
p698fs/nfs/proc.cif (!p) {
p703fs/nfs/proc.ceof = (i == count && !*p++ && *p++)
p704fs/nfs/proc.c|| (i < count && *p++);
p725fs/nfs/proc.cint *p, *p0;
p733fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_STATFS, ruid);
p734fs/nfs/proc.cp = xdr_encode_fhandle(p, fhandle);
p735fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p)) < 0) {
p739fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p741fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p742fs/nfs/proc.cp = xdr_decode_fsinfo(p, res);
p760fs/nfs/proc.cstatic int *nfs_rpc_header(int *p, int procedure, int ruid)
p771fs/nfs/proc.c*p++ = htonl(++xid);
p772fs/nfs/proc.c*p++ = htonl(RPC_CALL);
p773fs/nfs/proc.c*p++ = htonl(RPC_VERSION);
p774fs/nfs/proc.c*p++ = htonl(NFS_PROGRAM);
p775fs/nfs/proc.c*p++ = htonl(NFS_VERSION);
p776fs/nfs/proc.c*p++ = htonl(procedure);
p777fs/nfs/proc.c*p++ = htonl(RPC_AUTH_UNIX);
p778fs/nfs/proc.cp1 = p++;
p779fs/nfs/proc.c*p++ = htonl(CURRENT_TIME); /* traditional, could be anything */
p780fs/nfs/proc.cp = xdr_encode_string(p, (char *) sys);
p781fs/nfs/proc.c*p++ = htonl(ruid ? current->uid : current->euid);
p782fs/nfs/proc.c*p++ = htonl(current->egid);
p783fs/nfs/proc.cp2 = p++;
p785fs/nfs/proc.c*p++ = htonl(current->groups[i]);
p787fs/nfs/proc.c*p1 = htonl((p - (p1 + 1)) << 2);
p788fs/nfs/proc.c*p++ = htonl(RPC_AUTH_NULL);
p789fs/nfs/proc.c*p++ = htonl(0);
p790fs/nfs/proc.creturn p;
p793fs/nfs/proc.cstatic int *nfs_rpc_verify(int *p)
p797fs/nfs/proc.cp++;
p798fs/nfs/proc.cif ((n = ntohl(*p++)) != RPC_REPLY) {
p802fs/nfs/proc.cif ((n = ntohl(*p++)) != RPC_MSG_ACCEPTED) {
p806fs/nfs/proc.cswitch (n = ntohl(*p++)) {
p813fs/nfs/proc.cif ((n = ntohl(*p++)) > 400) {
p817fs/nfs/proc.cp += (n + 3) >> 2;
p818fs/nfs/proc.cif ((n = ntohl(*p++)) != RPC_SUCCESS) {
p822fs/nfs/proc.creturn p;
p41fs/proc/array.cunsigned long p = file->f_pos;
p53fs/proc/array.cif (p >= high_memory + PAGE_SIZE)
p55fs/proc/array.cif (count > high_memory + PAGE_SIZE - p)
p56fs/proc/array.ccount = high_memory + PAGE_SIZE - p;
p59fs/proc/array.cif (p < sizeof(struct user) && count > 0) {
p61fs/proc/array.cif (p + count1 > sizeof(struct user))
p62fs/proc/array.ccount1 = sizeof(struct user)-p;
p63fs/proc/array.cpnt = (char *) &dump + p;
p66fs/proc/array.cp += count1;
p71fs/proc/array.cwhile (p < 2*PAGE_SIZE && count > 0) {
p74fs/proc/array.cp++;
p78fs/proc/array.cmemcpy_tofs(buf,(void *) (p - PAGE_SIZE),count);
p171fs/proc/array.cstruct task_struct ** p;
p173fs/proc/array.cp = task;
p174fs/proc/array.cwhile (++p < task+NR_TASKS) {
p175fs/proc/array.cif (*p && (*p)->pid == pid)
p176fs/proc/array.creturn p;
p181fs/proc/array.cstatic unsigned long get_phys_addr(struct task_struct ** p, unsigned long ptr)
p185fs/proc/array.cif (!p || !*p || ptr >= TASK_SIZE)
p187fs/proc/array.cpage = *PAGE_DIR_OFFSET((*p)->tss.cr3,ptr);
p200fs/proc/array.cstatic int get_array(struct task_struct ** p, unsigned long start, unsigned long end, char * buffer)
p209fs/proc/array.caddr = get_phys_addr(p, start);
p235fs/proc/array.cstruct task_struct ** p = get_task(pid);
p237fs/proc/array.cif (!p || !*p)
p239fs/proc/array.creturn get_array(p, (*p)->mm->env_start, (*p)->mm->env_end, buffer);
p244fs/proc/array.cstruct task_struct ** p = get_task(pid);
p246fs/proc/array.cif (!p || !*p)
p248fs/proc/array.creturn get_array(p, (*p)->mm->arg_start, (*p)->mm->arg_end, buffer);
p251fs/proc/array.cstatic unsigned long get_wchan(struct task_struct *p)
p257fs/proc/array.cif (!p || p == current || p->state == TASK_RUNNING)
p259fs/proc/array.cstack_page = p->kernel_stack_page;
p262fs/proc/array.cebp = p->tss.ebp;
p280fs/proc/array.cstruct task_struct ** p = get_task(pid);
p286fs/proc/array.cif (!p || !*p)
p288fs/proc/array.cif ((*p)->state < 0 || (*p)->state > 5)
p291fs/proc/array.cstate = "RSDZTD"[(*p)->state];
p293fs/proc/array.cvsize = (*p)->kernel_stack_page;
p297fs/proc/array.cvsize = (*p)->mm->brk - (*p)->mm->start_code + PAGE_SIZE-1;
p301fs/proc/array.cwchan = get_wchan(*p);
p303fs/proc/array.cswitch((int) (*p)->sigaction[i].sa_handler) {
p309fs/proc/array.ctty_pgrp = (*p)->tty;
p318fs/proc/array.c(*p)->comm,
p320fs/proc/array.c(*p)->p_pptr->pid,
p321fs/proc/array.c(*p)->pgrp,
p322fs/proc/array.c(*p)->session,
p323fs/proc/array.c(*p)->tty,
p325fs/proc/array.c(*p)->flags,
p326fs/proc/array.c(*p)->mm->min_flt,
p327fs/proc/array.c(*p)->mm->cmin_flt,
p328fs/proc/array.c(*p)->mm->maj_flt,
p329fs/proc/array.c(*p)->mm->cmaj_flt,
p330fs/proc/array.c(*p)->utime,
p331fs/proc/array.c(*p)->stime,
p332fs/proc/array.c(*p)->cutime,
p333fs/proc/array.c(*p)->cstime,
p334fs/proc/array.c(*p)->counter,  /* this is the kernel priority ---
p336fs/proc/array.c(*p)->priority, /* this is the nice value ---
p338fs/proc/array.c(*p)->timeout,
p339fs/proc/array.c(*p)->it_real_value,
p340fs/proc/array.c(*p)->start_time,
p342fs/proc/array.c(*p)->mm->rss, /* you might want to shift this left 3 */
p343fs/proc/array.c(*p)->rlim[RLIMIT_RSS].rlim_cur,
p344fs/proc/array.c(*p)->mm->start_code,
p345fs/proc/array.c(*p)->mm->end_code,
p346fs/proc/array.c(*p)->mm->start_stack,
p349fs/proc/array.c(*p)->signal,
p350fs/proc/array.c(*p)->blocked,
p358fs/proc/array.cstruct task_struct ** p = get_task(pid);
p363fs/proc/array.cif (!p || !*p)
p365fs/proc/array.ctpag = (*p)->mm->end_code / PAGE_SIZE;
p366fs/proc/array.cif ((*p)->state != TASK_ZOMBIE) {
p367fs/proc/array.cpagedir = (unsigned long *) (*p)->tss.cr3;
p406fs/proc/array.cstruct task_struct **p = get_task(pid);
p409fs/proc/array.cif (!p || !*p)
p412fs/proc/array.cfor(map = (*p)->mm->mmap; map != NULL; map = map->vm_next) {
p57fs/proc/fd.cstruct task_struct * p;
p103fs/proc/fd.cif ((p = task[i]) && p->pid == pid)
p108fs/proc/fd.cif (fd >= NR_OPEN || !p->files->fd[fd] || !p->files->fd[fd]->f_inode)
p114fs/proc/fd.cfor (mpnt = p->mm->mmap; mpnt; mpnt = mpnt->vm_next)
p129fs/proc/fd.cstruct task_struct * p;
p159fs/proc/fd.cif ((p = task[i]) && p->pid == pid)
p166fs/proc/fd.cif (!p->files->fd[fd] || !p->files->fd[fd]->f_inode)
p171fs/proc/fd.cfor (mpnt = p->mm->mmap ; mpnt ; mpnt = mpnt->vm_next)
p77fs/proc/inode.cstruct task_struct * p;
p91fs/proc/inode.cp = task[0];
p93fs/proc/inode.cif ((p = task[i]) && (p->pid == pid))
p95fs/proc/inode.cif (!p || i >= NR_TASKS)
p135fs/proc/inode.cinode->i_uid = p->euid;
p136fs/proc/inode.cinode->i_gid = p->egid;
p172fs/proc/inode.cif (ino >= NR_OPEN || !p->files->fd[ino])
p183fs/proc/inode.cfor (mpnt = p->mm->mmap ; mpnt ; mpnt = mpnt->vm_next)
p45fs/proc/link.cstruct task_struct * p;
p62fs/proc/link.cif ((p = task[i]) && p->pid == pid)
p69fs/proc/link.cinode = p->fs->pwd;
p72fs/proc/link.cinode = p->fs->root;
p75fs/proc/link.cinode = p->executable;
p81fs/proc/link.cif (ino < NR_OPEN && p->files->fd[ino])
p82fs/proc/link.cinode = p->files->fd[ino]->f_inode;
p88fs/proc/link.cfor(mpnt = p->mm->mmap; mpnt && j >= 0;
p136fs/proc/root.cstruct task_struct * p;
p161fs/proc/root.cp = task[nr];
p162fs/proc/root.cif (!p || !(pid = p->pid))
p41fs/select.cstatic void free_wait(select_table * p)
p43fs/select.cstruct select_table_entry * entry = p->entry + p->nr;
p45fs/select.cwhile (p->nr > 0) {
p46fs/select.cp->nr--;
p249fs/sysv/file.cchar * p;
p294fs/sysv/file.cp = (pos & sb->sv_block_size_1) + bh_data;
p301fs/sysv/file.cmemcpy_fromfs(p,buf,c);
p476fs/sysv/inode.cunsigned long *p;
p480fs/sysv/inode.cp = inode->u.sysv_i.i_data + nr;
p482fs/sysv/inode.ctmp = *p;
p485fs/sysv/inode.cif (tmp == *p) {
p498fs/sysv/inode.cif (*p) {
p503fs/sysv/inode.c*p = tmp;
p515fs/sysv/inode.csysv_zone_t *p;
p529fs/sysv/inode.cp = nr + (sysv_zone_t *) *start;
p531fs/sysv/inode.cblock = tmp = *p;
p536fs/sysv/inode.cif (tmp == *p) {
p554fs/sysv/inode.cif (*p) {
p559fs/sysv/inode.c*p = (sb->sv_convert ? to_coh_ulong(block) : block);
p616fs/sysv/inode.cstatic inline unsigned long read3byte (char * p)
p618fs/sysv/inode.creturn (unsigned long)(*(unsigned short *)p)
p619fs/sysv/inode.c| (unsigned long)(*(unsigned char *)(p+2)) << 16;
p622fs/sysv/inode.cstatic inline void write3byte (char * p, unsigned long val)
p624fs/sysv/inode.c*(unsigned short *)p = (unsigned short) val;
p625fs/sysv/inode.c*(unsigned char *)(p+2) = val >> 16;
p628fs/sysv/inode.cstatic inline unsigned long coh_read3byte (char * p)
p630fs/sysv/inode.creturn (unsigned long)(*(unsigned char *)p) << 16
p631fs/sysv/inode.c| (unsigned long)(*(unsigned short *)(p+1));
p634fs/sysv/inode.cstatic inline void coh_write3byte (char * p, unsigned long val)
p636fs/sysv/inode.c*(unsigned char *)p = val >> 16;
p637fs/sysv/inode.c*(unsigned short *)(p+1) = (unsigned short) val;
p35fs/sysv/truncate.cunsigned long * p;
p39fs/sysv/truncate.cp = &inode->u.sysv_i.i_data[i];
p40fs/sysv/truncate.cblock = *p;
p43fs/sysv/truncate.c*p = 0;
p53fs/sysv/truncate.cstatic int coh_trunc_indirect (struct inode * inode, unsigned long blocks, unsigned long * p, int convert, unsigned char * dirt)
p64fs/sysv/truncate.cblock = tmp = *p;
p70fs/sysv/truncate.cif (tmp != *p) {
p75fs/sysv/truncate.c*p = 0;
p93fs/sysv/truncate.cif (tmp != *p) {
p97fs/sysv/truncate.c*p = 0;
p108fs/sysv/truncate.cstatic int coh_trunc_dindirect (struct inode * inode, unsigned long blocks, unsigned long * p, int convert, unsigned char * dirt)
p120fs/sysv/truncate.cblock = tmp = *p;
p126fs/sysv/truncate.cif (tmp != *p) {
p131fs/sysv/truncate.c*p = 0;
p150fs/sysv/truncate.cif (tmp != *p) {
p154fs/sysv/truncate.c*p = 0;
p165fs/sysv/truncate.cstatic int coh_trunc_tindirect (struct inode * inode, unsigned long blocks, unsigned long * p)
p177fs/sysv/truncate.cblock = *p;
p181fs/sysv/truncate.cif (block != *p) {
p186fs/sysv/truncate.c*p = 0;
p205fs/sysv/truncate.cif (block != *p) {
p209fs/sysv/truncate.c*p = 0;
p259fs/sysv/truncate.cunsigned long * p;
p267fs/sysv/truncate.cp = inode->u.sysv_i.i_data + i;
p268fs/sysv/truncate.cblock = *p;
p276fs/sysv/truncate.cif ((bh && bh->b_count != 1) || (block != *p)) {
p281fs/sysv/truncate.c*p = 0;
p291fs/sysv/truncate.cstatic int trunc_indirect(struct inode * inode, unsigned long offset, unsigned long * p, int convert, unsigned char * dirt)
p302fs/sysv/truncate.cindblock = indtmp = *p;
p309fs/sysv/truncate.cif (indtmp != *p) {
p314fs/sysv/truncate.c*p = 0;
p348fs/sysv/truncate.cif ((indbh->b_count != 1) || (indtmp != *p)) {
p352fs/sysv/truncate.c*p = 0;
p360fs/sysv/truncate.cstatic int trunc_dindirect(struct inode * inode, unsigned long offset, unsigned long * p, int convert, unsigned char * dirt)
p370fs/sysv/truncate.cindblock = indtmp = *p;
p377fs/sysv/truncate.cif (indtmp != *p) {
p382fs/sysv/truncate.c*p = 0;
p402fs/sysv/truncate.cif ((indbh->b_count != 1) || (indtmp != *p)) {
p406fs/sysv/truncate.c*p = 0;
p414fs/sysv/truncate.cstatic int trunc_tindirect(struct inode * inode, unsigned long offset, unsigned long * p, int convert, unsigned char * dirt)
p424fs/sysv/truncate.cindblock = indtmp = *p;
p431fs/sysv/truncate.cif (indtmp != *p) {
p436fs/sysv/truncate.c*p = 0;
p456fs/sysv/truncate.cif ((indbh->b_count != 1) || (indtmp != *p)) {
p460fs/sysv/truncate.c*p = 0;
p19include/linux/binfmts.hunsigned long p;
p44include/linux/binfmts.hextern unsigned long * create_tables(char * p,int argc,int envc,int ibcs);
p46include/linux/binfmts.hunsigned long p, int from_kmem);
p361include/linux/sched.hextern void sleep_on(struct wait_queue ** p);
p362include/linux/sched.hextern void interruptible_sleep_on(struct wait_queue ** p);
p363include/linux/sched.hextern void wake_up(struct wait_queue ** p);
p364include/linux/sched.hextern void wake_up_interruptible(struct wait_queue ** p);
p367include/linux/sched.hextern int send_sig(unsigned long sig,struct task_struct * p,int priv);
p452include/linux/sched.hextern inline void add_wait_queue(struct wait_queue ** p, struct wait_queue * wait)
p466include/linux/sched.hif (!*p) {
p468include/linux/sched.h*p = wait;
p470include/linux/sched.hwait->next = (*p)->next;
p471include/linux/sched.h(*p)->next = wait;
p476include/linux/sched.hextern inline void remove_wait_queue(struct wait_queue ** p, struct wait_queue * wait)
p486include/linux/sched.hif ((*p == wait) &&
p490include/linux/sched.h((*p = wait->next) == wait)) {
p491include/linux/sched.h*p = NULL;
p497include/linux/sched.hif (tmp == *p)
p508include/linux/sched.hprintk("list = %08x, queue = %08x\n",(unsigned long) p, (unsigned long) wait);
p515include/linux/sched.hextern inline void select_wait(struct wait_queue ** wait_address, select_table * p)
p519include/linux/sched.hif (!p || !wait_address)
p521include/linux/sched.hif (p->nr >= __MAX_SELECT_TABLE_ENTRIES)
p523include/linux/sched.hentry = p->entry + p->nr;
p528include/linux/sched.hp->nr++;
p573include/linux/sched.h#define REMOVE_LINKS(p) do { unsigned long flags; \
p575include/linux/sched.h(p)->next_task->prev_task = (p)->prev_task; \
p576include/linux/sched.h(p)->prev_task->next_task = (p)->next_task; \
p578include/linux/sched.hif ((p)->p_osptr) \
p579include/linux/sched.h(p)->p_osptr->p_ysptr = (p)->p_ysptr; \
p580include/linux/sched.hif ((p)->p_ysptr) \
p581include/linux/sched.h(p)->p_ysptr->p_osptr = (p)->p_osptr; \
p583include/linux/sched.h(p)->p_pptr->p_cptr = (p)->p_osptr; \
p586include/linux/sched.h#define SET_LINKS(p) do { unsigned long flags; \
p588include/linux/sched.h(p)->next_task = &init_task; \
p589include/linux/sched.h(p)->prev_task = init_task.prev_task; \
p590include/linux/sched.hinit_task.prev_task->next_task = (p); \
p591include/linux/sched.hinit_task.prev_task = (p); \
p593include/linux/sched.h(p)->p_ysptr = NULL; \
p594include/linux/sched.hif (((p)->p_osptr = (p)->p_pptr->p_cptr) != NULL) \
p595include/linux/sched.h(p)->p_osptr->p_ysptr = p; \
p596include/linux/sched.h(p)->p_pptr->p_cptr = p; \
p599include/linux/sched.h#define for_each_task(p) \
p600include/linux/sched.hfor (p = &init_task ; (p = p->next_task) != &init_task ; )
p108include/linux/ultrasound.h#define GUS_VOICEFREQ(chn, voice, p)    _GUS_CMD(chn, voice, _GUS_VOICEFREQ, \
p109include/linux/ultrasound.h(p) & 0xffff, ((p) >> 16) & 0xffff)
p118include/linux/ultrasound.h#define GUS_VOICE_POS(chn, voice, p)    _GUS_CMD(chn, voice, _GUS_VOICE_POS, \
p119include/linux/ultrasound.h(p) & 0xffff, ((p) >> 16) & 0xffff)
p44kernel/dma.cstatic __inline__ unsigned int mutex_atomic_swap(volatile unsigned int * p, unsigned int newval)
p57kernel/dma.c: /* inputs: newval, p */ "0" (semval), "m" (*p)
p25kernel/exit.cstatic int generate(unsigned long sig, struct task_struct * p)
p28kernel/exit.cstruct sigaction * sa = sig + p->sigaction - 1;
p31kernel/exit.cif (p->flags & PF_PTRACED) {
p32kernel/exit.cp->signal |= mask;
p42kernel/exit.cp->signal |= mask;
p46kernel/exit.cint send_sig(unsigned long sig,struct task_struct * p,int priv)
p48kernel/exit.cif (!p || sig > 32)
p50kernel/exit.cif (!priv && ((sig != SIGCONT) || (current->session != p->session)) &&
p51kernel/exit.c(current->euid != p->euid) && (current->uid != p->uid) && !suser())
p56kernel/exit.cif (p->state == TASK_STOPPED)
p57kernel/exit.cp->state = TASK_RUNNING;
p58kernel/exit.cp->exit_code = 0;
p59kernel/exit.cp->signal &= ~( (1<<(SIGSTOP-1)) | (1<<(SIGTSTP-1)) |
p64kernel/exit.cp->signal &= ~(1<<(SIGCONT-1));
p66kernel/exit.cgenerate(sig,p);
p78kernel/exit.cvoid release(struct task_struct * p)
p82kernel/exit.cif (!p)
p84kernel/exit.cif (p == current) {
p89kernel/exit.cif (task[i] == p) {
p91kernel/exit.cREMOVE_LINKS(p);
p92kernel/exit.cif (STACK_MAGIC != *(unsigned long *)p->kernel_stack_page)
p93kernel/exit.cprintk(KERN_ALERT "release: %s kernel stack corruption. Aiee\n", p->comm);
p94kernel/exit.cfree_page(p->kernel_stack_page);
p95kernel/exit.cfree_page((long) p);
p106kernel/exit.cint bad_task_ptr(struct task_struct *p)
p110kernel/exit.cif (!p)
p113kernel/exit.cif (task[i] == p)
p201kernel/exit.cstruct task_struct *p;
p205kernel/exit.cfor_each_task(p) {
p206kernel/exit.cif (p->session <= 0)
p208kernel/exit.cif (p->pgrp == pgrp)
p209kernel/exit.creturn p->session;
p210kernel/exit.cif (p->pid == pgrp)
p211kernel/exit.cfallback = p->session;
p222kernel/exit.cstruct task_struct *p;
p228kernel/exit.cfor_each_task(p) {
p229kernel/exit.cif (p->pgrp == pgrp) {
p230kernel/exit.cif ((err = send_sig(sig,p,priv)) != 0)
p246kernel/exit.cstruct task_struct *p;
p252kernel/exit.cfor_each_task(p) {
p253kernel/exit.cif (p->session == sess && p->leader) {
p254kernel/exit.cif ((err = send_sig(sig,p,priv)) != 0)
p265kernel/exit.cstruct task_struct *p;
p269kernel/exit.cfor_each_task(p) {
p270kernel/exit.cif (p && p->pid == pid)
p271kernel/exit.creturn send_sig(sig,p,priv);
p287kernel/exit.cstruct task_struct * p;
p288kernel/exit.cfor_each_task(p) {
p289kernel/exit.cif (p->pid > 1 && p != current) {
p291kernel/exit.cif ((err = send_sig(sig,p,0)) != -EPERM)
p313kernel/exit.cstruct task_struct *p;
p315kernel/exit.cfor_each_task(p) {
p316kernel/exit.cif ((p->pgrp != pgrp) || 
p317kernel/exit.c(p->state == TASK_ZOMBIE) ||
p318kernel/exit.c(p->p_pptr->pid == 1))
p320kernel/exit.cif ((p->p_pptr->pgrp != pgrp) &&
p321kernel/exit.c(p->p_pptr->session == p->session))
p329kernel/exit.cstruct task_struct * p;
p331kernel/exit.cfor_each_task(p) {
p332kernel/exit.cif (p->pgrp != pgrp)
p334kernel/exit.cif (p->state == TASK_STOPPED)
p342kernel/exit.cstruct task_struct * p;
p344kernel/exit.cfor_each_task(p) {
p345kernel/exit.cif (p->p_opptr == father)
p347kernel/exit.cp->p_opptr = task[1];
p349kernel/exit.cp->p_opptr = task[0];
p402kernel/exit.cstruct task_struct *p;
p444kernel/exit.cwhile ((p = current->p_cptr) != NULL) {
p445kernel/exit.ccurrent->p_cptr = p->p_osptr;
p446kernel/exit.cp->p_ysptr = NULL;
p447kernel/exit.cp->flags &= ~(PF_PTRACED|PF_TRACESYS);
p449kernel/exit.cp->p_pptr = task[1];
p451kernel/exit.cp->p_pptr = task[0];
p452kernel/exit.cp->p_osptr = p->p_pptr->p_cptr;
p453kernel/exit.cp->p_osptr->p_ysptr = p;
p454kernel/exit.cp->p_pptr->p_cptr = p;
p455kernel/exit.cif (p->state == TASK_ZOMBIE)
p456kernel/exit.cnotify_parent(p);
p463kernel/exit.cif ((p->pgrp != current->pgrp) &&
p464kernel/exit.c(p->session == current->session) &&
p465kernel/exit.cis_orphaned_pgrp(p->pgrp) &&
p466kernel/exit.chas_stopped_jobs(p->pgrp)) {
p467kernel/exit.ckill_pg(p->pgrp,SIGHUP,1);
p468kernel/exit.ckill_pg(p->pgrp,SIGCONT,1);
p507kernel/exit.cstruct task_struct *p;
p517kernel/exit.cfor (p = current->p_cptr ; p ; p = p->p_osptr) {
p519kernel/exit.cif (p->pid != pid)
p522kernel/exit.cif (p->pgrp != current->pgrp)
p525kernel/exit.cif (p->pgrp != -pid)
p529kernel/exit.cif ((p->exit_signal != SIGCHLD) ^ ((options & __WCLONE) != 0))
p532kernel/exit.cswitch (p->state) {
p534kernel/exit.cif (!p->exit_code)
p536kernel/exit.cif (!(options & WUNTRACED) && !(p->flags & PF_PTRACED))
p539kernel/exit.cput_fs_long((p->exit_code << 8) | 0x7f,
p541kernel/exit.cp->exit_code = 0;
p543kernel/exit.cgetrusage(p, RUSAGE_BOTH, ru);
p544kernel/exit.cretval = p->pid;
p547kernel/exit.ccurrent->cutime += p->utime + p->cutime;
p548kernel/exit.ccurrent->cstime += p->stime + p->cstime;
p549kernel/exit.ccurrent->mm->cmin_flt += p->mm->min_flt + p->mm->cmin_flt;
p550kernel/exit.ccurrent->mm->cmaj_flt += p->mm->maj_flt + p->mm->cmaj_flt;
p552kernel/exit.cgetrusage(p, RUSAGE_BOTH, ru);
p553kernel/exit.cflag = p->pid;
p555kernel/exit.cput_fs_long(p->exit_code, stat_addr);
p556kernel/exit.cif (p->p_opptr != p->p_pptr) {
p557kernel/exit.cREMOVE_LINKS(p);
p558kernel/exit.cp->p_pptr = p->p_opptr;
p559kernel/exit.cSET_LINKS(p);
p560kernel/exit.cnotify_parent(p);
p562kernel/exit.crelease(p);
p94kernel/fork.cstruct vm_area_struct * mpnt, **p, *tmp;
p98kernel/fork.cp = &tsk->mm->mmap;
p108kernel/fork.c*p = tmp;
p109kernel/fork.cp = &tmp->vm_next;
p119kernel/fork.cstatic void copy_files(unsigned long clone_flags, struct task_struct * p)
p126kernel/fork.cif ((f = p->files->fd[i]) != NULL)
p127kernel/fork.cp->files->fd[i] = copy_fd(f);
p130kernel/fork.cif ((f = p->files->fd[i]) != NULL)
p139kernel/fork.cstatic int copy_mm(unsigned long clone_flags, struct task_struct * p)
p142kernel/fork.cp->mm->swappable = 1;
p143kernel/fork.cp->mm->min_flt = p->mm->maj_flt = 0;
p144kernel/fork.cp->mm->cmin_flt = p->mm->cmaj_flt = 0;
p145kernel/fork.cif (copy_page_tables(p))
p147kernel/fork.cdup_mmap(p);
p149kernel/fork.cif (clone_page_tables(p))
p151kernel/fork.cdup_mmap(p);    /* wrong.. */
p156kernel/fork.cstatic void copy_fs(unsigned long clone_flags, struct task_struct * p)
p176kernel/fork.cstruct task_struct *p;
p180kernel/fork.cif(!(p = (struct task_struct*)__get_free_page(GFP_KERNEL)))
p185kernel/fork.ctask[nr] = p;
p186kernel/fork.c*p = *current;
p187kernel/fork.cp->did_exec = 0;
p188kernel/fork.cp->kernel_stack_page = 0;
p189kernel/fork.cp->state = TASK_UNINTERRUPTIBLE;
p190kernel/fork.cp->flags &= ~(PF_PTRACED|PF_TRACESYS);
p191kernel/fork.cp->pid = last_pid;
p192kernel/fork.cp->p_pptr = p->p_opptr = current;
p193kernel/fork.cp->p_cptr = NULL;
p194kernel/fork.cSET_LINKS(p);
p195kernel/fork.cp->signal = 0;
p196kernel/fork.cp->it_real_value = p->it_virt_value = p->it_prof_value = 0;
p197kernel/fork.cp->it_real_incr = p->it_virt_incr = p->it_prof_incr = 0;
p198kernel/fork.cp->leader = 0;    /* process leadership doesn't inherit */
p199kernel/fork.cp->utime = p->stime = 0;
p200kernel/fork.cp->cutime = p->cstime = 0;
p201kernel/fork.cp->start_time = jiffies;
p205kernel/fork.cif (!(p->kernel_stack_page = get_free_page(GFP_KERNEL)))
p207kernel/fork.c*(unsigned long *)p->kernel_stack_page = STACK_MAGIC;
p208kernel/fork.cp->tss.es = KERNEL_DS;
p209kernel/fork.cp->tss.cs = KERNEL_CS;
p210kernel/fork.cp->tss.ss = KERNEL_DS;
p211kernel/fork.cp->tss.ds = KERNEL_DS;
p212kernel/fork.cp->tss.fs = USER_DS;
p213kernel/fork.cp->tss.gs = KERNEL_DS;
p214kernel/fork.cp->tss.ss0 = KERNEL_DS;
p215kernel/fork.cp->tss.esp0 = p->kernel_stack_page + PAGE_SIZE;
p216kernel/fork.cp->tss.tr = _TSS(nr);
p217kernel/fork.cchildregs = ((struct pt_regs *) (p->kernel_stack_page + PAGE_SIZE)) - 1;
p218kernel/fork.cp->tss.esp = (unsigned long) childregs;
p219kernel/fork.cp->tss.eip = (unsigned long) ret_from_sys_call;
p222kernel/fork.cp->tss.back_link = 0;
p223kernel/fork.cp->tss.eflags = regs.eflags & 0xffffcfff;  /* iopl is always 0 for a new process */
p231kernel/fork.cp->exit_signal = clone_flags & CSIGNAL;
p232kernel/fork.cp->tss.ldt = _LDT(nr);
p233kernel/fork.cif (p->ldt) {
p234kernel/fork.cp->ldt = (struct desc_struct*) vmalloc(LDT_ENTRIES*LDT_ENTRY_SIZE);
p235kernel/fork.cif (p->ldt != NULL)
p236kernel/fork.cmemcpy(p->ldt, current->ldt, LDT_ENTRIES*LDT_ENTRY_SIZE);
p238kernel/fork.cp->tss.bitmap = offsetof(struct tss_struct,io_bitmap);
p240kernel/fork.cp->tss.io_bitmap[i] = ~0;
p242kernel/fork.c__asm__("clts ; fnsave %0 ; frstor %0":"=m" (p->tss.i387));
p243kernel/fork.cp->semun = NULL; p->shm = NULL;
p244kernel/fork.cif (copy_mm(clone_flags, p) || shm_fork(current, p))
p246kernel/fork.ccopy_files(clone_flags, p);
p247kernel/fork.ccopy_fs(clone_flags, p);
p248kernel/fork.cset_tss_desc(gdt+(nr<<1)+FIRST_TSS_ENTRY,&(p->tss));
p249kernel/fork.cif (p->ldt)
p250kernel/fork.cset_ldt_desc(gdt+(nr<<1)+FIRST_LDT_ENTRY,p->ldt, 512);
p254kernel/fork.cp->counter = current->counter >> 1;
p255kernel/fork.cp->state = TASK_RUNNING;  /* do this last, just in case */
p256kernel/fork.creturn p->pid;
p259kernel/fork.cREMOVE_LINKS(p);
p260kernel/fork.cfree_page(p->kernel_stack_page);
p262kernel/fork.cfree_page((long) p);
p21kernel/info.cstruct task_struct **p;
p34kernel/info.cfor (p = &LAST_TASK; p > &FIRST_TASK; p--)
p35kernel/info.cif (*p) val.procs++;
p238kernel/module.cchar *p;
p244kernel/module.cp = buf;
p246kernel/module.cif (p - buf > 4096 - 100)
p251kernel/module.c*p++ = *q++;
p259kernel/module.c*p++ = ' ';
p262kernel/module.c*p++ = *q++;
p272kernel/module.c*p++ = *q++;
p273kernel/module.c*p++ = '\n';
p275kernel/module.creturn p - buf;
p146kernel/printk.cchar *msg, *p, *buf_end;
p156kernel/printk.cfor (p = buf + 3; p < buf_end; p++) {
p157kernel/printk.cmsg = p;
p160kernel/printk.cp[0] != '<' ||
p161kernel/printk.cp[1] < '0' || 
p162kernel/printk.cp[1] > '7' ||
p163kernel/printk.cp[2] != '>'
p165kernel/printk.cp -= 3;
p166kernel/printk.cp[0] = '<';
p167kernel/printk.cp[1] = DEFAULT_MESSAGE_LOGLEVEL - 1 + '0';
p168kernel/printk.cp[2] = '>';
p171kernel/printk.cmsg_level = p[1] - '0';
p173kernel/printk.cfor (; p < buf_end; p++) {
p174kernel/printk.clog_buf[(log_start+log_size) & (LOG_BUF_LEN-1)] = *p;
p180kernel/printk.cif (*p == '\n')
p184kernel/printk.cchar tmp = p[1];
p185kernel/printk.cp[1] = '\0';
p187kernel/printk.cp[1] = tmp;
p189kernel/printk.cif (*p == '\n')
p206kernel/printk.cint  p = log_start;
p214kernel/printk.cbuf[j++] = log_buf[p];
p215kernel/printk.cp++; p &= LOG_BUF_LEN-1;
p165kernel/sched.cstruct task_struct * p;
p181kernel/sched.cp = &init_task;
p183kernel/sched.cif ((p = p->next_task) == &init_task)
p185kernel/sched.cif (ticks && p->it_real_value) {
p186kernel/sched.cif (p->it_real_value <= ticks) {
p187kernel/sched.csend_sig(SIGALRM, p, 1);
p188kernel/sched.cif (!p->it_real_incr) {
p189kernel/sched.cp->it_real_value = 0;
p193kernel/sched.cp->it_real_value += p->it_real_incr;
p194kernel/sched.c} while (p->it_real_value <= ticks);
p196kernel/sched.cp->it_real_value -= ticks;
p197kernel/sched.cif (p->it_real_value < itimer_next)
p198kernel/sched.citimer_next = p->it_real_value;
p201kernel/sched.cif (p->state != TASK_INTERRUPTIBLE)
p203kernel/sched.cif (p->signal & ~p->blocked) {
p204kernel/sched.cp->state = TASK_RUNNING;
p207kernel/sched.cif (p->timeout && p->timeout <= jiffies) {
p208kernel/sched.cp->timeout = 0;
p209kernel/sched.cp->state = TASK_RUNNING;
p226kernel/sched.cnext = p = &init_task;
p228kernel/sched.cif ((p = p->next_task) == &init_task)
p230kernel/sched.cif (p->state == TASK_RUNNING && p->counter > c)
p231kernel/sched.cc = p->counter, next = p;
p235kernel/sched.cfor_each_task(p)
p236kernel/sched.cp->counter = (p->counter >> 1) + p->priority;
p270kernel/sched.cstruct task_struct * p;
p275kernel/sched.cif ((p = tmp->task) != NULL) {
p276kernel/sched.cif ((p->state == TASK_UNINTERRUPTIBLE) ||
p277kernel/sched.c(p->state == TASK_INTERRUPTIBLE)) {
p278kernel/sched.cp->state = TASK_RUNNING;
p279kernel/sched.cif (p->counter > current->counter)
p297kernel/sched.cstruct task_struct * p;
p302kernel/sched.cif ((p = tmp->task) != NULL) {
p303kernel/sched.cif (p->state == TASK_INTERRUPTIBLE) {
p304kernel/sched.cp->state = TASK_RUNNING;
p305kernel/sched.cif (p->counter > current->counter)
p333kernel/sched.cstatic inline void __sleep_on(struct wait_queue **p, int state)
p338kernel/sched.cif (!p)
p343kernel/sched.cadd_wait_queue(p, &wait);
p347kernel/sched.cremove_wait_queue(p, &wait);
p351kernel/sched.cvoid interruptible_sleep_on(struct wait_queue **p)
p353kernel/sched.c__sleep_on(p,TASK_INTERRUPTIBLE);
p356kernel/sched.cvoid sleep_on(struct wait_queue **p)
p358kernel/sched.c__sleep_on(p,TASK_UNINTERRUPTIBLE);
p366kernel/sched.cstruct timer_list ** p;
p371kernel/sched.cp = &next_timer;
p374kernel/sched.cwhile (*p) {
p375kernel/sched.cif ((*p)->expires > timer->expires) {
p376kernel/sched.c(*p)->expires -= timer->expires;
p377kernel/sched.ctimer->next = *p;
p380kernel/sched.ctimer->expires -= (*p)->expires;
p381kernel/sched.cp = &(*p)->next;
p383kernel/sched.c*p = timer;
p391kernel/sched.cstruct timer_list **p;
p393kernel/sched.cp = &next_timer;
p396kernel/sched.cwhile (*p) {
p397kernel/sched.cif (*p == timer) {
p398kernel/sched.cif ((*p = timer->next) != NULL)
p399kernel/sched.c(*p)->expires += timer->expires;
p404kernel/sched.cexpires += (*p)->expires;
p405kernel/sched.cp = &(*p)->next;
p427kernel/sched.cstruct task_struct **p;
p430kernel/sched.cfor(p = &LAST_TASK; p > &FIRST_TASK; --p)
p431kernel/sched.cif (*p && ((*p)->state == TASK_RUNNING ||
p432kernel/sched.c(*p)->state == TASK_UNINTERRUPTIBLE ||
p433kernel/sched.c(*p)->state == TASK_SWAPPING))
p729kernel/sched.cstatic void show_task(int nr,struct task_struct * p)
p734kernel/sched.cprintk("%-8s %3d ", p->comm, (p == current) ? -nr : nr);
p735kernel/sched.cif (((unsigned) p->state) < sizeof(stat_nam)/sizeof(char *))
p736kernel/sched.cprintk(stat_nam[p->state]);
p739kernel/sched.cif (p == current)
p742kernel/sched.cprintk(" %08lX ", ((unsigned long *)p->tss.esp)[3]);
p744kernel/sched.cif (((unsigned long *)p->kernel_stack_page)[free])
p747kernel/sched.cprintk("%5lu %5d %6d ", free << 2, p->pid, p->p_pptr->pid);
p748kernel/sched.cif (p->p_cptr)
p749kernel/sched.cprintk("%5d ", p->p_cptr->pid);
p752kernel/sched.cif (p->p_ysptr)
p753kernel/sched.cprintk("%7d", p->p_ysptr->pid);
p756kernel/sched.cif (p->p_osptr)
p757kernel/sched.cprintk(" %5d\n", p->p_osptr->pid);
p776kernel/sched.cstruct desc_struct * p;
p784kernel/sched.cp = gdt+2+FIRST_TSS_ENTRY;
p787kernel/sched.cp->a=p->b=0;
p788kernel/sched.cp++;
p789kernel/sched.cp->a=p->b=0;
p790kernel/sched.cp++;
p117kernel/signal.cstruct sigaction *p;
p119kernel/signal.cp = signum - 1 + current->sigaction;
p120kernel/signal.cif (p->sa_handler == SIG_IGN) {
p126kernel/signal.cif (p->sa_handler == SIG_DFL) {
p155kernel/signal.cstruct sigaction new_sa, *p;
p159kernel/signal.cp = signum - 1 + current->sigaction;
p178kernel/signal.cmemcpy_tofs(oldaction, p, sizeof(struct sigaction));
p181kernel/signal.c*p = new_sa;
p55kernel/sys.cstatic int proc_sel(struct task_struct *p, int which, int who)
p59kernel/sys.cif (!who && p == current)
p61kernel/sys.creturn(p->pid == who);
p65kernel/sys.creturn(p->pgrp == who);
p69kernel/sys.creturn(p->uid == who);
p76kernel/sys.cstruct task_struct **p;
p86kernel/sys.cfor(p = &LAST_TASK; p > &FIRST_TASK; --p) {
p87kernel/sys.cif (!*p || !proc_sel(*p, which, who))
p89kernel/sys.cif ((*p)->uid != current->euid &&
p90kernel/sys.c(*p)->uid != current->uid && !suser()) {
p96kernel/sys.cif (priority > (*p)->priority && !suser())
p99kernel/sys.c(*p)->priority = priority;
p106kernel/sys.cstruct task_struct **p;
p112kernel/sys.cfor(p = &LAST_TASK; p > &FIRST_TASK; --p) {
p113kernel/sys.cif (!*p || !proc_sel(*p, which, who))
p115kernel/sys.cif ((*p)->priority > max_prio)
p116kernel/sys.cmax_prio = (*p)->priority;
p430kernel/sys.cstruct task_struct * p;
p438kernel/sys.cfor_each_task(p) {
p439kernel/sys.cif (p->pid == pid)
p445kernel/sys.cif (p->p_pptr == current || p->p_opptr == current) {
p446kernel/sys.cif (p->session != current->session)
p448kernel/sys.cif (p->did_exec)
p450kernel/sys.c} else if (p != current)
p452kernel/sys.cif (p->leader)
p465kernel/sys.cp->pgrp = pgid;
p471kernel/sys.cstruct task_struct * p;
p475kernel/sys.cfor_each_task(p) {
p476kernel/sys.cif (p->pid == pid)
p477kernel/sys.creturn p->pgrp;
p686kernel/sys.cint getrusage(struct task_struct *p, int who, struct rusage *ru)
p698kernel/sys.cr.ru_utime.tv_sec = CT_TO_SECS(p->utime);
p699kernel/sys.cr.ru_utime.tv_usec = CT_TO_USECS(p->utime);
p700kernel/sys.cr.ru_stime.tv_sec = CT_TO_SECS(p->stime);
p701kernel/sys.cr.ru_stime.tv_usec = CT_TO_USECS(p->stime);
p702kernel/sys.cr.ru_minflt = p->mm->min_flt;
p703kernel/sys.cr.ru_majflt = p->mm->maj_flt;
p706kernel/sys.cr.ru_utime.tv_sec = CT_TO_SECS(p->cutime);
p707kernel/sys.cr.ru_utime.tv_usec = CT_TO_USECS(p->cutime);
p708kernel/sys.cr.ru_stime.tv_sec = CT_TO_SECS(p->cstime);
p709kernel/sys.cr.ru_stime.tv_usec = CT_TO_USECS(p->cstime);
p710kernel/sys.cr.ru_minflt = p->mm->cmin_flt;
p711kernel/sys.cr.ru_majflt = p->mm->cmaj_flt;
p714kernel/sys.cr.ru_utime.tv_sec = CT_TO_SECS(p->utime + p->cutime);
p715kernel/sys.cr.ru_utime.tv_usec = CT_TO_USECS(p->utime + p->cutime);
p716kernel/sys.cr.ru_stime.tv_sec = CT_TO_SECS(p->stime + p->cstime);
p717kernel/sys.cr.ru_stime.tv_usec = CT_TO_USECS(p->stime + p->cstime);
p718kernel/sys.cr.ru_minflt = p->mm->min_flt + p->mm->cmin_flt;
p719kernel/sys.cr.ru_majflt = p->mm->maj_flt + p->mm->cmaj_flt;
p64mm/kmalloc.c#define BH(p) ((struct block_header *)(p))
p78mm/kmalloc.c#define PAGE_DESC(p) ((struct page_descriptor *)(((unsigned long)(p)) & PAGE_MASK))
p167mm/kmalloc.cstruct block_header *p;
p197mm/kmalloc.c(p    =  page->firstfree))
p199mm/kmalloc.cif (p->bh_flags == MF_FREE)
p201mm/kmalloc.cpage->firstfree = p->bh_next;
p212mm/kmalloc.cp->bh_flags =  MF_USED; /* As of now this block is officially in use */
p213mm/kmalloc.cp->bh_length = size;
p214mm/kmalloc.creturn p+1; /* Pointer arithmetic: increments past header */
p216mm/kmalloc.cprintk ("Problem: block on freelist at %08lx isn't free.\n",(long)p);
p242mm/kmalloc.cfor (i=NBLOCKS(order),p=BH (page+1);i > 1;i--,p=p->bh_next) 
p244mm/kmalloc.cp->bh_flags = MF_FREE;
p245mm/kmalloc.cp->bh_next = BH ( ((long)p)+sz);
p248mm/kmalloc.cp->bh_flags = MF_FREE;
p249mm/kmalloc.cp->bh_next = NULL;
p288mm/kmalloc.cregister struct block_header *p=((struct block_header *)ptr) -1;
p291mm/kmalloc.cpage = PAGE_DESC (p);
p296mm/kmalloc.c(p->bh_flags != MF_USED))
p299mm/kmalloc.cp, page->next, page->order);
p303mm/kmalloc.csize != p->bh_length)
p306mm/kmalloc.cp,size,p->bh_length);
p309mm/kmalloc.csize = p->bh_length;
p310mm/kmalloc.cp->bh_flags = MF_FREE; /* As of now this block is officially free */
p313mm/kmalloc.cp->bh_next = page->firstfree;
p314mm/kmalloc.cpage->firstfree = p;
p70mm/memory.c#define CODE_SPACE(addr,p) ((addr) < (p)->end_code)
p696mm/memory.cstruct task_struct * p, unsigned long error_code, unsigned long newpage)
p703mm/memory.cfrom_page = (unsigned long)PAGE_DIR_OFFSET(p->tss.cr3,address);
p758mm/memory.cstruct task_struct ** p;
p762mm/memory.cfor (p = &LAST_TASK ; p > &FIRST_TASK ; --p) {
p763mm/memory.cif (!*p)
p765mm/memory.cif (tsk == *p)
p767mm/memory.cif (inode != (*p)->executable) {
p773mm/memory.cfor (mpnt = (*p)->mm->mmap; mpnt; mpnt = mpnt->vm_next) {
p784mm/memory.cif (try_to_share(address,tsk,*p,error_code,newpage))
p796mm/memory.cunsigned long *p;
p798mm/memory.cp = PAGE_DIR_OFFSET(tsk->tss.cr3,address);
p799mm/memory.cif (PAGE_PRESENT & *p)
p800mm/memory.creturn *p;
p801mm/memory.cif (*p) {
p803mm/memory.c*p = 0;
p806mm/memory.cp = PAGE_DIR_OFFSET(tsk->tss.cr3,address);
p807mm/memory.cif (PAGE_PRESENT & *p) {
p809mm/memory.creturn *p;
p811mm/memory.cif (*p) {
p813mm/memory.c*p = 0;
p816mm/memory.c*p = page | PAGE_TABLE;
p817mm/memory.creturn *p;
p820mm/memory.c*p = BAD_PAGETABLE | PAGE_TABLE;
p60mm/swap.cstruct swap_info_struct * p;
p67mm/swap.cp = &swap_info[type];
p69mm/swap.cif (offset >= p->max) {
p73mm/swap.cif (!(p->flags & SWP_USED)) {
p77mm/swap.cwhile (set_bit(offset,p->swap_lockmap))
p83mm/swap.cif (p->swap_device) {
p84mm/swap.cll_rw_page(rw,p->swap_device,offset,buf);
p85mm/swap.c} else if (p->swap_file) {
p90mm/swap.cblock = offset << (12 - p->swap_file->i_sb->s_blocksize_bits);
p92mm/swap.cfor (i=0, j=0; j< PAGE_SIZE ; i++, j +=p->swap_file->i_sb->s_blocksize)
p93mm/swap.cif (!(zones[i] = bmap(p->swap_file,block++))) {
p97mm/swap.cll_rw_swap_file(rw,p->swap_file->i_dev, zones, i,buf);
p100mm/swap.cif (offset && !clear_bit(offset,p->swap_lockmap))
p107mm/swap.cstruct swap_info_struct * p;
p110mm/swap.cp = swap_info;
p111mm/swap.cfor (type = 0 ; type < nr_swapfiles ; type++,p++) {
p112mm/swap.cif ((p->flags & SWP_WRITEOK) != SWP_WRITEOK)
p114mm/swap.cfor (offset = p->lowest_bit; offset <= p->highest_bit ; offset++) {
p115mm/swap.cif (p->swap_map[offset])
p117mm/swap.cp->swap_map[offset] = 1;
p119mm/swap.cif (offset == p->highest_bit)
p120mm/swap.cp->highest_bit--;
p121mm/swap.cp->lowest_bit = offset;
p130mm/swap.cstruct swap_info_struct * p;
p143mm/swap.cp = type + swap_info;
p144mm/swap.cif (offset >= p->max) {
p148mm/swap.cif (!p->swap_map[offset]) {
p152mm/swap.cp->swap_map[offset]++;
p158mm/swap.cstruct swap_info_struct * p;
p170mm/swap.cp = & swap_info[type];
p172mm/swap.cif (offset >= p->max) {
p176mm/swap.cif (!(p->flags & SWP_USED)) {
p180mm/swap.cwhile (set_bit(offset,p->swap_lockmap))
p182mm/swap.cif (offset < p->lowest_bit)
p183mm/swap.cp->lowest_bit = offset;
p184mm/swap.cif (offset > p->highest_bit)
p185mm/swap.cp->highest_bit = offset;
p186mm/swap.cif (!p->swap_map[offset])
p189mm/swap.cif (!--p->swap_map[offset])
p191mm/swap.cif (!clear_bit(offset,p->swap_lockmap))
p301mm/swap.cstruct task_struct *p;
p319mm/swap.cp = task[swap_task];
p320mm/swap.cif(p && p->mm->swappable && p->mm->rss)
p329mm/swap.cif(! p->mm->swap_cnt) {
p330mm/swap.cp->mm->dec_flt = (p->mm->dec_flt * 3) / 4 + p->mm->maj_flt - p->mm->old_maj_flt;
p331mm/swap.cp->mm->old_maj_flt = p->mm->maj_flt;
p333mm/swap.cif(p->mm->dec_flt >= SWAP_RATIO / SWAP_MIN) {
p334mm/swap.cp->mm->dec_flt = SWAP_RATIO / SWAP_MIN;
p335mm/swap.cp->mm->swap_cnt = SWAP_MIN;
p336mm/swap.c} else if(p->mm->dec_flt <= SWAP_RATIO / SWAP_MAX)
p337mm/swap.cp->mm->swap_cnt = SWAP_MAX;
p339mm/swap.cp->mm->swap_cnt = SWAP_RATIO / p->mm->dec_flt;
p345mm/swap.cfor(table = p->mm->swap_table; table < 1024; table++) {
p346mm/swap.cpg_table = ((unsigned long *) p->tss.cr3)[table];
p354mm/swap.c((unsigned long *) p->tss.cr3)[table] = 0;
p362mm/swap.cfor(page = p->mm->swap_page; page < 1024; page++) {
p368mm/swap.cp->mm->rss--;
p370mm/swap.cp->mm->swap_table = table;
p371mm/swap.cp->mm->swap_page  = page + 1;
p372mm/swap.cif((--p->mm->swap_cnt) == 0)
p377mm/swap.cp->mm->rss--;
p382mm/swap.cp->mm->swap_page = 0;
p389mm/swap.cp->mm->swap_table = 0;
p411mm/swap.cstruct task_struct * p;
p421mm/swap.cp = task[swap_task];
p422mm/swap.cif (!p || !p->mm->swappable) {
p432mm/swap.cpg_table = ((unsigned long *) p->tss.cr3)[swap_table];
p440mm/swap.c((unsigned long *) p->tss.cr3)[swap_table] = 0;
p453mm/swap.ccase 1: p->mm->rss--; return 1;
p454mm/swap.cdefault: p->mm->rss--;
p654mm/swap.cstruct task_struct *p;
p663mm/swap.cp = task[nr];
p664mm/swap.cif (!p)
p667mm/swap.cppage = pgt + ((unsigned long *) p->tss.cr3);
p692mm/swap.c++p->mm->rss;
p706mm/swap.cstruct swap_info_struct * p;
p716mm/swap.cp = swap_info;
p717mm/swap.cfor (type = 0 ; type < nr_swapfiles ; type++,p++) {
p718mm/swap.cif ((p->flags & SWP_WRITEOK) != SWP_WRITEOK)
p720mm/swap.cif (p->swap_file) {
p721mm/swap.cif (p->swap_file == inode)
p726mm/swap.cif (p->swap_device == inode->i_rdev)
p733mm/swap.cp->flags = SWP_USED;
p736mm/swap.cp->flags = SWP_WRITEOK;
p739mm/swap.cnr_swap_pages -= p->pages;
p740mm/swap.ciput(p->swap_file);
p741mm/swap.cp->swap_file = NULL;
p742mm/swap.cp->swap_device = 0;
p743mm/swap.cvfree(p->swap_map);
p744mm/swap.cp->swap_map = NULL;
p745mm/swap.cfree_page((long) p->swap_lockmap);
p746mm/swap.cp->swap_lockmap = NULL;
p747mm/swap.cp->flags = 0;
p758mm/swap.cstruct swap_info_struct * p;
p766mm/swap.cp = swap_info;
p767mm/swap.cfor (type = 0 ; type < nr_swapfiles ; type++,p++)
p768mm/swap.cif (!(p->flags & SWP_USED))
p774mm/swap.cp->flags = SWP_USED;
p775mm/swap.cp->swap_file = NULL;
p776mm/swap.cp->swap_device = 0;
p777mm/swap.cp->swap_map = NULL;
p778mm/swap.cp->swap_lockmap = NULL;
p779mm/swap.cp->lowest_bit = 0;
p780mm/swap.cp->highest_bit = 0;
p781mm/swap.cp->max = 1;
p790mm/swap.cp->swap_device = swap_inode->i_rdev;
p793mm/swap.cif (!p->swap_device)
p799mm/swap.cif (p->swap_device == swap_info[i].swap_device)
p803mm/swap.cp->swap_file = swap_inode;
p806mm/swap.cp->swap_lockmap = (unsigned char *) get_free_page(GFP_USER);
p807mm/swap.cif (!p->swap_lockmap) {
p812mm/swap.cread_swap_page(SWP_ENTRY(type,0), (char *) p->swap_lockmap);
p813mm/swap.cif (memcmp("SWAP-SPACE",p->swap_lockmap+4086,10)) {
p818mm/swap.cmemset(p->swap_lockmap+PAGE_SIZE-10,0,10);
p820mm/swap.cp->lowest_bit = 0;
p821mm/swap.cp->highest_bit = 0;
p823mm/swap.cif (test_bit(i,p->swap_lockmap)) {
p824mm/swap.cif (!p->lowest_bit)
p825mm/swap.cp->lowest_bit = i;
p826mm/swap.cp->highest_bit = i;
p827mm/swap.cp->max = i+1;
p836mm/swap.cp->swap_map = (unsigned char *) vmalloc(p->max);
p837mm/swap.cif (!p->swap_map) {
p841mm/swap.cfor (i = 1 ; i < p->max ; i++) {
p842mm/swap.cif (test_bit(i,p->swap_lockmap))
p843mm/swap.cp->swap_map[i] = 0;
p845mm/swap.cp->swap_map[i] = 0x80;
p847mm/swap.cp->swap_map[0] = 0x80;
p848mm/swap.cmemset(p->swap_lockmap,0,PAGE_SIZE);
p849mm/swap.cp->flags = SWP_WRITEOK;
p850mm/swap.cp->pages = j;
p855mm/swap.cfree_page((long) p->swap_lockmap);
p856mm/swap.cvfree(p->swap_map);
p857mm/swap.ciput(p->swap_file);
p858mm/swap.cp->swap_device = 0;
p859mm/swap.cp->swap_file = NULL;
p860mm/swap.cp->swap_map = NULL;
p861mm/swap.cp->swap_lockmap = NULL;
p862mm/swap.cp->flags = 0;
p897mm/swap.cunsigned short * p;
p902mm/swap.cp = mem_map + MAP_NR(end_mem);
p903mm/swap.cstart_mem = (unsigned long) p;
p904mm/swap.cwhile (p > mem_map)
p905mm/swap.c*--p = MAP_PAGE_RESERVED;
p39mm/vmalloc.cstruct task_struct * p;
p41mm/vmalloc.cp = &init_task;
p43mm/vmalloc.c((unsigned long *) p->tss.cr3)[dindex] = value;
p44mm/vmalloc.cp = p->next_task;
p45mm/vmalloc.c} while (p != &init_task);
p130mm/vmalloc.cstruct vm_struct **p, *tmp;
p138mm/vmalloc.cfor (p = &vmlist ; (tmp = *p) ; p = &tmp->next) {
p140mm/vmalloc.c*p = tmp->next;
p152mm/vmalloc.cstruct vm_struct **p, *tmp, *area;
p163mm/vmalloc.cfor (p = &vmlist; (tmp = *p) ; p = &tmp->next) {
p169mm/vmalloc.carea->next = *p;
p170mm/vmalloc.c*p = area;
p180mm/vmalloc.cstruct vm_struct **p, *tmp;
p184mm/vmalloc.cfor (p = &vmlist; (tmp = *p) ; p = &tmp->next) {
p259net/inet/packet.cstruct packet_type *p;
p261net/inet/packet.cp = (struct packet_type *) kmalloc(sizeof(*p), GFP_KERNEL);
p262net/inet/packet.cif (p == NULL) 
p265net/inet/packet.cp->func = packet_rcv;
p266net/inet/packet.cp->type = sk->num;
p267net/inet/packet.cp->data = (void *)sk;
p268net/inet/packet.cdev_add_pack(p);
p274net/inet/packet.csk->pair = (struct sock *)p;
p89net/inet/protocol.cstruct inet_protocol *p;
p93net/inet/protocol.cfor (p = inet_protos[hash] ; p != NULL; p=p->next) {
p94net/inet/protocol.cDPRINTF((DBG_PROTO, "trying protocol %d\n", p->protocol));
p95net/inet/protocol.cif (p->protocol == prot) return((struct inet_protocol *) p);
p127net/inet/protocol.cstruct inet_protocol *p;
p137net/inet/protocol.cp = (struct inet_protocol *) inet_protos[hash];
p138net/inet/protocol.cwhile(p != NULL) {
p144net/inet/protocol.cif (p->next != NULL && p->next == prot) {
p149net/inet/protocol.cif (p->copy == 0 && lp != NULL) lp->copy = 0;
p150net/inet/protocol.cp->next = prot->next;
p154net/inet/protocol.cif (p->next != NULL && p->next->protocol == prot->protocol) {
p155net/inet/protocol.clp = p;
p158net/inet/protocol.cp = (struct inet_protocol *) p->next;
p310net/inet/raw.cstruct inet_protocol *p;
p312net/inet/raw.cp = (struct inet_protocol *) kmalloc(sizeof (*p), GFP_KERNEL);
p313net/inet/raw.cif (p == NULL) return(-ENOMEM);
p315net/inet/raw.cp->handler = raw_rcv;
p316net/inet/raw.cp->protocol = sk->protocol;
p317net/inet/raw.cp->data = (void *)sk;
p318net/inet/raw.cp->err_handler = raw_err;
p319net/inet/raw.cp->name="USER";
p320net/inet/raw.cp->frag_handler = NULL;  /* For now */
p321net/inet/raw.cinet_add_protocol(p);
p324net/inet/raw.csk->pair = (struct sock *)p;
p1780net/inet/sock.cstruct inet_protocol *p;
p1815net/inet/sock.cfor(p = inet_protocol_base; p != NULL;) 
p1819net/inet/sock.ctmp = (struct inet_protocol *) p->next;
p1820net/inet/sock.cinet_add_protocol(p);
p1821net/inet/sock.cprintk("%s%s",p->name,tmp?", ":"\n");
p1822net/inet/sock.cp = tmp;
p51net/inet/utils.cchar *p;
p53net/inet/utils.cp = (char *) &in;
p55net/inet/utils.c(p[0] & 255), (p[1] & 255), (p[2] & 255), (p[3] & 255));
p216zBoot/gzip.h#define SH(p) ((ush)(uch)((p)[0]) | ((ush)(uch)((p)[1]) << 8))
p217zBoot/gzip.h#define LG(p) ((ulg)(SH(p)) | ((ulg)(SH((p)+2)) << 16))
p122zBoot/inflate.cregister unsigned *p;         /* pointer into c[], b[], or v[] */
p137zBoot/inflate.cp = b;  i = n;
p139zBoot/inflate.cc[*p++]++;                  /* assume all entries <= BMAX */
p180zBoot/inflate.cp = c + 1;  xp = x + 2;
p182zBoot/inflate.c*xp++ = (j += *p++);
p188zBoot/inflate.cp = b;  i = 0;
p190zBoot/inflate.cif ((j = *p++) != 0)
p198zBoot/inflate.cp = v;                        /* grab values in bit order */
p272zBoot/inflate.cif (p >= v + n)
p274zBoot/inflate.celse if (*p < s)
p276zBoot/inflate.cr.e = (uch)(*p < 256 ? 16 : 15);    /* 256 is end-of-block code */
p277zBoot/inflate.cr.v.n = *p++;           /* simple code is just the value */
p281zBoot/inflate.cr.e = (uch)e[*p - s];   /* non-simple--look up in lists */
p282zBoot/inflate.cr.v.n = d[*p++ - s];
p321zBoot/inflate.cregister struct huft *p, *q;
p325zBoot/inflate.cp = t;
p326zBoot/inflate.cwhile (p != (struct huft *)NULL)
p328zBoot/inflate.cq = (--p)->v.t;
p329zBoot/inflate.cfree(p);
p330zBoot/inflate.cp = q;
p83zBoot/misc.cvoid *p;
p90zBoot/misc.cp = (void *)free_mem_ptr;
p96zBoot/misc.cif (p == NULL) error("malloc = NULL\n");
p97zBoot/misc.creturn p;
p260zBoot/misc.cstatic int p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
p264zBoot/misc.cfor (i = 0; i < sizeof(p)/sizeof(int); i++)
p265zBoot/misc.ce |= 1L << (31 - p[i]);