taglinefilesource code
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;
p265drivers/block/hd.cunsigned char *p, *end = &s[bytecount &= ~1];  /* bytecount must be even */
p268drivers/block/hd.cfor (p = end ; p != s;) {
p269drivers/block/hd.cunsigned short *pp = (unsigned short *) (p -= 2);
p280drivers/block/hd.c*p++ = *(s-1);
p284drivers/block/hd.cwhile (p != end)
p285drivers/block/hd.c*p++ = '\0';
p136drivers/block/mcd.cstatic void bin2bcd(unsigned char *p);
p1205drivers/block/mcd.cbin2bcd(unsigned char *p)
p1209drivers/block/mcd.cu = *p % 10;
p1210drivers/block/mcd.ct = *p / 10;
p1211drivers/block/mcd.c*p = u | (t << 4);
p669drivers/block/sbpcd.cstatic void bin2bcdx(u_char *p)  /* must work only up to 75 or 99 */
p671drivers/block/sbpcd.c*p=((*p/10)<<4)|(*p%10);
p1745drivers/block/sbpcd.cstatic int convert_UPC(u_char *p)
p1749drivers/block/sbpcd.cp++;
p1750drivers/block/sbpcd.cif (!new_drive) p[13]=0;
p1753drivers/block/sbpcd.cif (new_drive) DriveStruct[d].UPC_buf[i]=swap_nibbles(*p++);
p1756drivers/block/sbpcd.cDriveStruct[d].UPC_buf[i]=((*p++)<<4)&0xFF;
p1757drivers/block/sbpcd.cDriveStruct[d].UPC_buf[i] |= *p++;
p2800drivers/block/sbpcd.cu_char *p;
p2909drivers/block/sbpcd.cp = DriveStruct[d].aud_buf;
p2914drivers/block/sbpcd.cREAD_DATA(CDi_data, p, read_audio.nframes*CD_FRAMESIZE_RAW);
p3235drivers/block/sbpcd.cu_char *p;
p3284drivers/block/sbpcd.cp = DriveStruct[d].sbp_buf + frame *  CD_FRAMESIZE;
p3288drivers/block/sbpcd.cREAD_DATA(CDi_data, p, CD_FRAMESIZE);
p3514drivers/block/sbpcd.cvoid sbpcd_setup(char *s, int *p)
p3516drivers/block/sbpcd.cDPRINTF((DBG_INI,"SBPCD: sbpcd_setup called with %04X,%s\n",p[1], s));
p3520drivers/block/sbpcd.cif (p[0]>0) sbpcd_ioaddr=p[1];
p312drivers/char/console.clong p, q;
p324drivers/char/console.cp = (long) kmalloc(structsize, GFP_KERNEL);
p325drivers/char/console.cif (!p) {
p330drivers/char/console.cvc_cons[i].d = (struct vc_data *) p;
p331drivers/char/console.cp += sizeof(struct vc_data);
p332drivers/char/console.cvt_cons[i] = (struct vt_struct *) p;
p350drivers/char/console.cunsigned short *p;
p373drivers/char/console.cp = (unsigned short *) kmalloc(ss, GFP_USER);
p374drivers/char/console.cif (!p) {
p380drivers/char/console.cnewscreens[currcons] = p;
p1005drivers/char/console.cstatic void respond_string(char * p, struct tty_struct * tty)
p1007drivers/char/console.cwhile (*p) {
p1008drivers/char/console.ctty_insert_flip_char(tty, *p, 0);
p1009drivers/char/console.cp++;
p1045drivers/char/console.cunsigned char *p;
p1048drivers/char/console.cfor (p = (unsigned char *)origin+1; p < (unsigned char *)scr_end; p+=2)
p1049drivers/char/console.c*p = (*p & 0x88) | (((*p >> 4) | (*p << 4)) & 0x77);
p1051drivers/char/console.cfor (p = (unsigned char *)origin+1; p < (unsigned char *)scr_end; p+=2)
p1052drivers/char/console.c*p ^= *p & 0x07 == 1 ? 0x70 : 0x77;
p1150drivers/char/console.cunsigned short * p = (unsigned short *) pos;
p1153drivers/char/console.ctmp = *p;
p1154drivers/char/console.c*p = old;
p1156drivers/char/console.cp++;
p1170drivers/char/console.cunsigned short * p = (unsigned short *) pos;
p1173drivers/char/console.c*p = *(p+1);
p1174drivers/char/console.cp++;
p1176drivers/char/console.c*p = video_erase_char;
p2210drivers/char/console.cunsigned char *p, *p1, *p2;
p2216drivers/char/console.cp = p1;
p2218drivers/char/console.cp2 = p;
p2220drivers/char/console.cfor (p = p1; p <= p2; p += 2)
p2221drivers/char/console.c*p = (*p & 0x88) | ((*p << 4) & 0x70) | ((*p >> 4) & 0x07);
p2227drivers/char/console.cunsigned char *p;
p2240drivers/char/console.cp = (unsigned char *)origin - hwscroll_offset + where + 1;
p2241drivers/char/console.c*p ^= 0x77;
p2243drivers/char/console.cprev=p;
p2269drivers/char/console.cstatic inline int atedge(const int p)
p2271drivers/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);
p521drivers/char/n_tty.cunsigned char *p;
p543drivers/char/n_tty.cfor (i=count, p = cp, f = fp; i; i--, p++) {
p548drivers/char/n_tty.cn_tty_receive_char(tty, *p);
p555drivers/char/n_tty.cn_tty_receive_parity_error(tty, *p);
p216drivers/char/tty_io.cstruct tty_driver *p;
p221drivers/char/tty_io.cfor (p = tty_drivers; p; p = p->next) {
p222drivers/char/tty_io.cif (p->major != major)
p224drivers/char/tty_io.cif (minor < p->minor_start)
p226drivers/char/tty_io.cif (minor >= p->minor_start + p->num)
p228drivers/char/tty_io.creturn p;
p314drivers/char/tty_io.cstruct task_struct *p;
p365drivers/char/tty_io.cfor_each_task(p) {
p366drivers/char/tty_io.cif (p->tty == tty)
p367drivers/char/tty_io.cp->tty = NULL;
p409drivers/char/tty_io.cstruct task_struct *p;
p421drivers/char/tty_io.cfor_each_task(p)
p422drivers/char/tty_io.cif (p->session == current->session)
p423drivers/char/tty_io.cp->tty = NULL;
p890drivers/char/tty_io.cstruct task_struct **p;
p995drivers/char/tty_io.cfor (p = &LAST_TASK ; p > &FIRST_TASK ; --p) {
p996drivers/char/tty_io.cif (*p == 0)
p998drivers/char/tty_io.cif ((*p)->tty == tty)
p999drivers/char/tty_io.c(*p)->tty = NULL;
p1000drivers/char/tty_io.cif (o_tty && (*p)->tty == o_tty)
p1001drivers/char/tty_io.c(*p)->tty = NULL;
p1215drivers/char/tty_io.cstruct task_struct **p;
p1222drivers/char/tty_io.cfor (p = &FIRST_TASK ; p <= &LAST_TASK ; p++, n++)
p1223drivers/char/tty_io.cif (*p)
p1225drivers/char/tty_io.cc = (char *)(*p);
p1346drivers/char/tty_io.cstruct task_struct *p;
p1348drivers/char/tty_io.cfor_each_task(p)
p1349drivers/char/tty_io.cif (p->tty == tty)
p1350drivers/char/tty_io.cp->tty = NULL;
p1484drivers/char/tty_io.cstruct task_struct **p;
p1496drivers/char/tty_io.cfor (p = &LAST_TASK ; p > &FIRST_TASK ; --p) {
p1497drivers/char/tty_io.cif (!(*p))
p1499drivers/char/tty_io.cif (((*p)->tty == tty) ||
p1500drivers/char/tty_io.c((session > 0) && ((*p)->session == session)))
p1501drivers/char/tty_io.csend_sig(SIGKILL, *p, 1);
p1504drivers/char/tty_io.cfilp = (*p)->files->fd[i];
p1507drivers/char/tty_io.csend_sig(SIGKILL, *p, 1);
p1610drivers/char/tty_io.cstruct tty_driver *p;
p1617drivers/char/tty_io.cfor (p = tty_drivers; p; p = p->next) {
p1618drivers/char/tty_io.cif (p == driver)
p1620drivers/char/tty_io.celse if (p->major == driver->major)
p411drivers/char/vt.cchar *p;
p423drivers/char/vt.cp = func_table[i];
p424drivers/char/vt.cif(p)
p425drivers/char/vt.cfor ( ; *p && sz; p++, sz--)
p426drivers/char/vt.cput_fs_byte(*p, q++);
p428drivers/char/vt.creturn ((p && *p) ? -EOVERFLOW : 0);
p437drivers/char/vt.cu_char *p;
p457drivers/char/vt.cfor (p = a->kb_string; get_fs_byte(p) && sz; p++,sz--)
p499drivers/char/vt.cfor (p = a->kb_string, q = func_table[i]; ; p++, q++)
p500drivers/char/vt.cif (!(*q = get_fs_byte(p)))
p100drivers/net/3c505.c#define CHECK_NULL(p) if (!p) printk(null_msg, filename, __LINE__)
p659drivers/net/atp.cstatic void read_block(short ioaddr, int length, unsigned char *p, int data_mode)
p667drivers/net/atp.cdo  *p++ = read_byte_mode0(ioaddr);  while (--length > 0);
p669drivers/net/atp.cdo  *p++ = read_byte_mode2(ioaddr);  while (--length > 0);
p671drivers/net/atp.cdo      *p++ = read_byte_mode4(ioaddr);  while (--length > 0);
p673drivers/net/atp.cdo      *p++ = read_byte_mode6(ioaddr);  while (--length > 0);
p854drivers/net/depca.cchar *p = (char *) skb->data;
p888drivers/net/depca.cfor (p += len; skbL > 0; p += len) {
p913drivers/net/depca.cmemcpy((unsigned char *)(buf + PKT_HDR_LEN), (unsigned char *)p, len);
p833drivers/net/ewrk3.cunsigned char *p = skb->data;
p840drivers/net/ewrk3.coutb(*p++, EWRK3_DATA);
p1029drivers/net/ewrk3.cunsigned char *p = skb->data;
p1031drivers/net/ewrk3.c*p = inb(EWRK3_DATA);         /* dummy read */
p1033drivers/net/ewrk3.c*p++ = inb(EWRK3_DATA);
p1240drivers/net/ewrk3.cshort *p = (short *) multicast_table;
p1259drivers/net/ewrk3.c*p++ = 0xffff;
p79drivers/net/ni52.c#define make32(ptr16) (p->memtop + (short) (ptr16) )
p80drivers/net/ni52.c#define make24(ptr32) ((char *) (ptr32) - p->base)
p81drivers/net/ni52.c#define make16(ptr32) ((unsigned short) ((unsigned long) (ptr32) - (unsigned long) p->memtop ))
p281drivers/net/ni52.cstruct priv *p = (struct priv *) dev->priv;
p285drivers/net/ni52.cp->base = (unsigned long) where + size - 0x01000000;
p286drivers/net/ni52.cp->memtop = where + size;
p287drivers/net/ni52.cp->scp = (struct scp_struct *)(p->base + SCP_DEFAULT_ADDRESS);
p288drivers/net/ni52.cmemset((char *)p->scp,0, sizeof(struct scp_struct));
p289drivers/net/ni52.cp->scp->sysbus = SYSBUSVAL;        /* 1 = 8Bit-Bus */
p292drivers/net/ni52.ciscp_addrs[1]= (char *) p->scp - sizeof(struct iscp_struct);
p296drivers/net/ni52.cp->iscp = (struct iscp_struct *) iscp_addrs[i];
p297drivers/net/ni52.cmemset((char *)p->iscp,0, sizeof(struct iscp_struct));
p299drivers/net/ni52.cp->scp->iscp = make24(p->iscp);
p300drivers/net/ni52.cp->iscp->busy = 1;
p306drivers/net/ni52.cif(p->iscp->busy)
p318drivers/net/ni52.cstruct priv *p =  (struct priv *) dev->priv; 
p320drivers/net/ni52.cp->scp  = (struct scp_struct *)  (p->base + SCP_DEFAULT_ADDRESS);
p321drivers/net/ni52.cp->scb  = (struct scb_struct *)  (dev->mem_start);
p322drivers/net/ni52.cp->iscp = (struct iscp_struct *) ((char *)p->scp - sizeof(struct iscp_struct));
p324drivers/net/ni52.cmemset((char *) p->iscp,0,sizeof(struct iscp_struct));
p325drivers/net/ni52.cmemset((char *) p->scp ,0,sizeof(struct scp_struct));
p327drivers/net/ni52.cp->scp->iscp = make24(p->iscp);
p328drivers/net/ni52.cp->scp->sysbus = SYSBUSVAL;
p329drivers/net/ni52.cp->iscp->scb_offset = make16(p->scb);
p331drivers/net/ni52.cp->iscp->busy = 1;
p338drivers/net/ni52.cif(p->iscp->busy)
p342drivers/net/ni52.cmemset((char *)p->scb,0,sizeof(struct scb_struct));
p478drivers/net/ni52.cstruct priv *p = (struct priv *) dev->priv;
p483drivers/net/ni52.cptr = (void *) ((char *)p->scb + sizeof(struct scb_struct));
p495drivers/net/ni52.cp->scb->cbl_offset = make16(cfg_cmd);
p497drivers/net/ni52.cp->scb->cmd = CUC_START; /* cmd.-unit start */
p521drivers/net/ni52.cp->scb->cbl_offset = make16(ias_cmd);
p523drivers/net/ni52.cp->scb->cmd = CUC_START; /* cmd.-unit start */
p545drivers/net/ni52.cp->scb->cbl_offset = make16(tdr_cmd);
p547drivers/net/ni52.cp->scb->cmd = CUC_START; /* cmd.-unit start */
p562drivers/net/ni52.cp->scb->cmd = p->scb->status & STAT_MASK;
p582drivers/net/ni52.cp->scb->cmd = p->scb->status & STAT_MASK;
p591drivers/net/ni52.cp->nop_cmds[i] = (struct nop_cmd_struct *)ptr;
p592drivers/net/ni52.cp->nop_cmds[i]->cmd_cmd    = 0;
p593drivers/net/ni52.cp->nop_cmds[i]->cmd_status = 0;
p594drivers/net/ni52.cp->nop_cmds[i]->cmd_link   = make16((p->nop_cmds[i]));
p597drivers/net/ni52.cp->xmit_cmds[0] = (struct transmit_cmd_struct *)ptr; /* transmit cmd/buff 0 */
p602drivers/net/ni52.cp->nop_cmds[i] = (struct nop_cmd_struct *)ptr;
p603drivers/net/ni52.cp->nop_cmds[i]->cmd_cmd    = 0;
p604drivers/net/ni52.cp->nop_cmds[i]->cmd_status = 0;
p605drivers/net/ni52.cp->nop_cmds[i]->cmd_link   = make16((p->nop_cmds[i]));
p607drivers/net/ni52.cp->xmit_cmds[i] = (struct transmit_cmd_struct *)ptr; /* transmit cmd/buff 0 */
p619drivers/net/ni52.cp->xmit_cbuffs[i] = (char *)ptr; /* char-buffs */
p621drivers/net/ni52.cp->xmit_buffs[i] = (struct tbd_struct *)ptr; /* TBD */
p623drivers/net/ni52.cif((void *)ptr > (void *)p->iscp) 
p628drivers/net/ni52.cmemset((char *)(p->xmit_cmds[i]) ,0, sizeof(struct transmit_cmd_struct));
p629drivers/net/ni52.cmemset((char *)(p->xmit_buffs[i]),0, sizeof(struct tbd_struct));
p630drivers/net/ni52.cp->xmit_cmds[i]->cmd_status = STAT_COMPL;
p631drivers/net/ni52.cp->xmit_cmds[i]->tbd_offset = make16((p->xmit_buffs[i]));
p632drivers/net/ni52.cp->xmit_buffs[i]->next = 0xffff;
p633drivers/net/ni52.cp->xmit_buffs[i]->buffer = make24((p->xmit_cbuffs[i]));
p636drivers/net/ni52.cp->xmit_count = 0; 
p637drivers/net/ni52.cp->xmit_last  = 0;
p639drivers/net/ni52.cp->nop_point  = 0;
p646drivers/net/ni52.cp->scb->cbl_offset = make16(p->nop_cmds[0]);
p647drivers/net/ni52.cp->scb->cmd = CUC_START;
p649drivers/net/ni52.cwhile(p->scb->cmd);
p655drivers/net/ni52.cp->xmit_cmds[0]->cmd_link = 0xffff;
p656drivers/net/ni52.cp->xmit_cmds[0]->cmd_cmd  = CMD_XMIT | CMD_LAST | CMD_INT;
p672drivers/net/ni52.cstruct priv *p = (struct priv *) dev->priv;
p675drivers/net/ni52.cp->rfd_first = rfd;
p689drivers/net/ni52.cp->min_cbuff32 = ptr;
p698drivers/net/ni52.cp->max_cbuff32 = ptr;
p699drivers/net/ni52.cp->max_cbuff24 = make24(p->max_cbuff32);
p701drivers/net/ni52.cp->rfd_top  = p->rfd_first;
p702drivers/net/ni52.cp->rfd_last = p->rfd_first + NUM_RECV_FRAMES - 1;
p704drivers/net/ni52.cp->rbd_last = rbd + NUM_RECV_BUFFS - 1;
p706drivers/net/ni52.cp->scb->rfa_offset    = make16(p->rfd_first);
p707drivers/net/ni52.cp->rfd_first->rbd_offset  = make16(rbd);
p722drivers/net/ni52.cstruct priv *p;
p732drivers/net/ni52.cp = (struct priv *) dev->priv;
p742drivers/net/ni52.cwhile((stat=p->scb->status & STAT_MASK))
p744drivers/net/ni52.cp->scb->cmd = stat;
p748drivers/net/ni52.cprintk("ni52-%04x/%04x-",(int) stat,(int) p->scb->status); /* debug */
p761drivers/net/ni52.cprintk("%s: oops! CU has left active state. stat: %04x/%04x.\n",dev->name,(int) stat,(int) p->scb->status);
p765drivers/net/ni52.cprintk("%s: rnr: %04x/%04x.\n",dev->name,(int) stat,(int) p->scb->status);
p774drivers/net/ni52.cwhile(p->scb->cmd)
p785drivers/net/ni52.cif((l = p->scb->ovrn_errs - old_ovr))
p788drivers/net/ni52.cp->stats.rx_over_errors += l;
p812drivers/net/ni52.cstruct priv *p = (struct priv *) dev->priv;
p814drivers/net/ni52.cfor(;(status = p->rfd_top->status) & STAT_COMPL;)
p816drivers/net/ni52.crbd = rbd_first = (struct rbd_struct *) make32(p->rfd_top->rbd_offset);
p821drivers/net/ni52.cif(rbd1==p->rbd_last)
p827drivers/net/ni52.cif(rbd1 == p->rbd_last)
p834drivers/net/ni52.cstruct rfd_struct *rfd1 = p->rfd_top;
p835drivers/net/ni52.cif(rfd1==p->rfd_last)
p839drivers/net/ni52.cfor(;rfd1 != p->rfd_top;rfd1 = (struct rfd_struct *)  make32(rfd1->next))
p841drivers/net/ni52.cif(rfd1 == p->rfd_last)
p849drivers/net/ni52.cp->rfd_top->status = 0;
p850drivers/net/ni52.cp->rfd_top->last = RFD_LAST;
p851drivers/net/ni52.cp->rfd_last->last = 0;        /* delete RFD_LAST, no RU suspend */
p852drivers/net/ni52.cp->rfd_last = p->rfd_top;
p853drivers/net/ni52.cp->rfd_top = (struct rfd_struct *) make32(p->rfd_top->next);
p876drivers/net/ni52.cpnt = p->max_cbuff24 - rbd_first->buffer;
p877drivers/net/ni52.cmemcpy( (char *) skb->data,p->max_cbuff32-pnt,pnt);
p878drivers/net/ni52.cmemcpy( (char *) skb->data+pnt,p->min_cbuff32,totlen-pnt);
p881drivers/net/ni52.cmemcpy( (char *) skb->data,(char *) p->base+(unsigned long) rbd_first->buffer, totlen);
p884drivers/net/ni52.cp->rbd_last->size &= ~RBD_LAST;
p885drivers/net/ni52.cp->rbd_last = rbd;
p888drivers/net/ni52.cp->stats.rx_packets++;
p893drivers/net/ni52.cp->rbd_last->size &= ~RBD_LAST;
p894drivers/net/ni52.cp->rbd_last = rbd;
p900drivers/net/ni52.cp->stats.rx_errors++;
p913drivers/net/ni52.cstruct priv *p = (struct priv *) dev->priv;
p915drivers/net/ni52.cp->stats.rx_errors++;
p917drivers/net/ni52.cwhile(p->scb->cmd);    /* wait for the last cmd */
p918drivers/net/ni52.cp->scb->cmd = RUC_ABORT;
p920drivers/net/ni52.cwhile(p->scb->cmd);    /* wait for accept cmd. */
p922drivers/net/ni52.calloc_rfa(dev,(char *)p->rfd_first);
p933drivers/net/ni52.cstruct priv *p = (struct priv *) dev->priv;
p940drivers/net/ni52.cif( (status=p->xmit_cmds[p->xmit_last]->cmd_status) & STAT_OK)
p942drivers/net/ni52.cp->stats.tx_packets++;
p943drivers/net/ni52.cp->stats.collisions += (status & TCMD_MAXCOLLMASK);
p949drivers/net/ni52.cp->stats.tx_errors++;
p952drivers/net/ni52.cp->stats.collisions++;
p955drivers/net/ni52.cp->stats.tx_carrier_errors++;
p965drivers/net/ni52.cp->stats.collisions += 16;
p970drivers/net/ni52.cif( (++p->xmit_last) == NUM_XMIT_BUFFS) 
p971drivers/net/ni52.cp->xmit_last = 0;
p982drivers/net/ni52.cstruct priv *p = (struct priv *) dev->priv;
p984drivers/net/ni52.cp->scb->rfa_offset = make16(p->rfd_first);
p985drivers/net/ni52.cp->scb->cmd = RUC_START;
p987drivers/net/ni52.cwhile(p->scb->cmd); /* wait for accept cmd. (no timeout!!) */
p991drivers/net/ni52.cp->scb->cmd = p->scb->status & STAT_MASK;
p1005drivers/net/ni52.cstruct priv *p = (struct priv *) dev->priv;
p1015drivers/net/ni52.cprintk("%s: xmitter timed out, try to restart! stat: %04x\n",dev->name,p->scb->status);
p1016drivers/net/ni52.cprintk("%s: command-stats: %04x %04x\n",dev->name,p->xmit_cmds[0]->cmd_status,p->xmit_cmds[1]->cmd_status);
p1037drivers/net/ni52.cmemcpy((char *)p->xmit_cbuffs[p->xmit_count],(char *)(skb->data),skb->len);
p1042drivers/net/ni52.cp->xmit_buffs[0]->size = TBD_LAST | len;
p1043drivers/net/ni52.cp->xmit_cmds[0]->cmd_status = 0;
p1044drivers/net/ni52.cp->scb->cbl_offset = make16(p->xmit_cmds[0]);
p1045drivers/net/ni52.cp->scb->cmd = CUC_START;
p1049drivers/net/ni52.cwhile(p->scb->cmd)
p1054drivers/net/ni52.cnext_nop = (p->nop_point + 1) & 0x1;
p1055drivers/net/ni52.cp->xmit_buffs[0]->size = TBD_LAST | len;
p1057drivers/net/ni52.cp->xmit_cmds[0]->cmd_cmd    = CMD_XMIT | CMD_INT;
p1058drivers/net/ni52.cp->xmit_cmds[0]->cmd_status = 0;
p1059drivers/net/ni52.cp->xmit_cmds[0]->cmd_link   = p->nop_cmds[next_nop]->cmd_link 
p1060drivers/net/ni52.c= make16((p->nop_cmds[next_nop]));
p1061drivers/net/ni52.cp->nop_cmds[next_nop]->cmd_status = 0;
p1063drivers/net/ni52.cp->nop_cmds[p->nop_point]->cmd_link = make16((p->xmit_cmds[0]));
p1065drivers/net/ni52.cp->nop_point = next_nop;
p1068drivers/net/ni52.cp->xmit_buffs[p->xmit_count]->size = TBD_LAST | len;
p1069drivers/net/ni52.cif( (next_nop = p->xmit_count + 1) == NUM_XMIT_BUFFS ) 
p1072drivers/net/ni52.cp->xmit_cmds[p->xmit_count]->cmd_cmd  = CMD_XMIT | CMD_INT;
p1073drivers/net/ni52.cp->xmit_cmds[p->xmit_count]->cmd_status  = 0;
p1074drivers/net/ni52.cp->xmit_cmds[p->xmit_count]->cmd_link = p->nop_cmds[next_nop]->cmd_link 
p1075drivers/net/ni52.c= make16((p->nop_cmds[next_nop]));
p1076drivers/net/ni52.cp->nop_cmds[next_nop]->cmd_status = 0;
p1078drivers/net/ni52.cp->nop_cmds[p->xmit_count]->cmd_link = make16((p->xmit_cmds[p->xmit_count]));
p1080drivers/net/ni52.cp->xmit_count = next_nop;
p1083drivers/net/ni52.cif(p->xmit_count != p->xmit_last)
p1096drivers/net/ni52.cstruct priv *p = (struct priv *) dev->priv;
p1098drivers/net/ni52.cprintk("ni52: errs, crc %d, align %d, resource %d, ovrn %d.\n",(int) p->scb->crc_errs,(int) p->scb->aln_errs,(int) p->scb->rsc_errs,(int) p->scb->ovrn_errs); 
p1100drivers/net/ni52.creturn &p->stats;
p1114drivers/net/ni52.cp->scb->cmd = CUC_SUSPEND;
p1116drivers/net/ni52.cwhile(p->scb->cmd);
p1117drivers/net/ni52.cp->scb->cmd = RUC_SUSPEND; 
p1119drivers/net/ni52.cwhile(p->scb->cmd);
p1121drivers/net/ni52.ccfg_cmd = (struct configure_cmd_struct *) p->xmit_cbuffs[0]; /* we're using a transmitcommand */
p1138drivers/net/ni52.cp->scb->cbl_offset = make16(cfg_cmd);
p1140drivers/net/ni52.cp->scb->cmd = CUC_START; /* cmd.-unit start */
p1142drivers/net/ni52.cwhile(p->scb->cmd);
p1144drivers/net/ni52.cp->scb->cbl_offset = p->nop_cmds[0]->cmd_link = make16(p->nop_cmds[0]);
p1145drivers/net/ni52.cp->scb->cmd = CUC_START;
p1147drivers/net/ni52.cwhile(p->scb->cmd);
p1148drivers/net/ni52.cp->scb->cmd = RUC_RESUME;
p1150drivers/net/ni52.cwhile(p->scb->cmd);
p211drivers/net/ni65.cstruct priv *p; 
p249drivers/net/ni65.cp = dev->priv = (void *) kmalloc(sizeof(struct priv),GFP_KERNEL);
p264drivers/net/ni65.cif( (p->memptr = kmalloc(MEMSIZE,GFP_KERNEL)) == NULL) {
p268drivers/net/ni65.cif( (unsigned long) (p->memptr + MEMSIZE) & 0xff000000) {
p272drivers/net/ni65.cp->tmdhead = (struct tmd *) ((( (unsigned long)p->memptr ) + 8) & 0xfffffff8);
p273drivers/net/ni65.cp->rmdhead = (struct rmd *) (p->tmdhead + TMDNUM);   
p278drivers/net/ni65.cif( (p->tmdbufs[i] = kmalloc(T_BUF_SIZE,GFP_ATOMIC)) == NULL) {
p282drivers/net/ni65.cif( (unsigned long) (p->tmdbufs[i]+T_BUF_SIZE) & 0xff000000) {
p291drivers/net/ni65.cif( (p->recv_skb[i] = (struct sk_buff *) alloc_skb(R_BUF_SIZE,GFP_ATOMIC)) == NULL) {
p295drivers/net/ni65.cif( (unsigned long) (p->recv_skb[i]->data + R_BUF_SIZE) & 0xff000000) {
p313drivers/net/ni65.cstruct priv *p = (struct priv *) dev->priv;
p315drivers/net/ni65.cp->lock = 0;
p316drivers/net/ni65.cp->xmit_queued = 0;
p334drivers/net/ni65.cmemset(p->memptr,0,MEMSIZE);
p336drivers/net/ni65.cp->tmdnum = 0; p->tmdlast = 0;
p339drivers/net/ni65.ctmdp = p->tmdhead + i;
p341drivers/net/ni65.ctmdp->u.buffer = (unsigned long) p->tmdbufs[i];     
p346drivers/net/ni65.cp->rmdnum = 0;
p349drivers/net/ni65.crmdp = p->rmdhead + i;
p350drivers/net/ni65.crmdp->u.buffer = (unsigned long) p->recv_skb[i]->data;
p358drivers/net/ni65.cp->ib.eaddr[i] = dev->dev_addr[i];
p360drivers/net/ni65.cp->ib.mode = 0;
p362drivers/net/ni65.cp->ib.filter[i] = 0;
p363drivers/net/ni65.cp->ib.trplow = (unsigned short) (( (unsigned long) p->tmdhead ) & 0xffff);
p364drivers/net/ni65.cp->ib.trphigh = (unsigned short) ((( (unsigned long) p->tmdhead )>>16) & 0x00ff) | TMDNUMMASK; 
p365drivers/net/ni65.cp->ib.rrplow = (unsigned short) (( (unsigned long) p->rmdhead ) & 0xffff);
p366drivers/net/ni65.cp->ib.rrphigh = (unsigned short) ((( (unsigned long) p->rmdhead )>>16) & 0x00ff) | RMDNUMMASK;
p369drivers/net/ni65.cwritereg((unsigned short) (((unsigned long) &(p->ib)) & 0xffff),CSR1);
p370drivers/net/ni65.cwritereg((unsigned short) (((unsigned long) &(p->ib))>>16),CSR2);
p419drivers/net/ni65.cstruct priv *p = (struct priv *) dev->priv;
p422drivers/net/ni65.cp->stats.tx_errors++;
p424drivers/net/ni65.cp->stats.rx_errors++;
p451drivers/net/ni65.cstruct priv *p = (struct priv *) dev->priv;
p457drivers/net/ni65.cwhile(p->xmit_queued)
p459drivers/net/ni65.ctmdp = p->tmdhead + p->tmdlast;
p464drivers/net/ni65.cskb = (struct sk_buff *) p->tmdbufs[p->tmdlast];
p476drivers/net/ni65.cp->stats.tx_aborted_errors++;
p478drivers/net/ni65.cp->stats.tx_carrier_errors++;
p479drivers/net/ni65.cp->stats.tx_errors++;
p483drivers/net/ni65.cp->stats.tx_packets++;
p485drivers/net/ni65.cp->tmdlast = (p->tmdlast + 1) & (TMDNUM-1);
p486drivers/net/ni65.cif(p->tmdlast == p->tmdnum)
p487drivers/net/ni65.cp->xmit_queued = 0;
p503drivers/net/ni65.cstruct priv *p = (struct priv *) dev->priv;
p505drivers/net/ni65.crmdp = p->rmdhead + p->rmdnum;
p512drivers/net/ni65.cp->stats.rx_errors++;
p513drivers/net/ni65.cp->stats.rx_length_errors++;
p521drivers/net/ni65.cp->stats.rx_errors++;
p522drivers/net/ni65.cif(rmdstat & RCV_FRAM) p->stats.rx_frame_errors++;
p523drivers/net/ni65.cif(rmdstat & RCV_OFLO) p->stats.rx_over_errors++;
p524drivers/net/ni65.cif(rmdstat & RCV_CRC)  p->stats.rx_crc_errors++;
p535drivers/net/ni65.cmemcpy(skb->data,p->recv_skb[p->rmdnum]->data,len);
p539drivers/net/ni65.cskb1 = p->recv_skb[p->rmdnum];
p540drivers/net/ni65.cp->recv_skb[p->rmdnum] = skb;
p547drivers/net/ni65.cp->stats.rx_packets++;
p554drivers/net/ni65.cp->stats.rx_dropped++;
p557drivers/net/ni65.cp->rmdnum++; p->rmdnum &= RMDNUM-1;
p558drivers/net/ni65.crmdp = p->rmdhead + p->rmdnum;
p568drivers/net/ni65.cstruct priv *p = (struct priv *) dev->priv;
p597drivers/net/ni65.cif(set_bit(0,(void*) &p->lock) != 0)
p606drivers/net/ni65.ctmdp = p->tmdhead + p->tmdnum;
p610drivers/net/ni65.cp->tmdbufs[p->tmdnum] = skb;
p619drivers/net/ni65.cp->xmit_queued = 1;
p621drivers/net/ni65.cp->tmdnum++; p->tmdnum &= TMDNUM-1;
p623drivers/net/ni65.cif( !((p->tmdhead + p->tmdnum)->u.s.status & XMIT_OWN) ) 
p625drivers/net/ni65.cp->lock = 0;
p76drivers/net/ppp.c#define PRINTK(p) printk p ;
p77drivers/net/ppp.c#define ASSERT(p) if (!p) PRINTK ((KERN_CRIT "assertion failed: " # p))
p78drivers/net/ppp.c#define PRINTKN(n,p) {if (ppp_debug >= n) PRINTK (p)}
p86drivers/net/ppp.c#define bset(p,b)  ((p)[(b) >> 5] |= (1 << ((b) & 0x1f)))
p1681drivers/net/ppp.cunsigned char *p;
p1694drivers/net/ppp.cp     = (unsigned char *) (skb + 1);
p1725drivers/net/ppp.cif (ppp_us_queue (ppp, proto, p, len))
p1743drivers/net/ppp.clen = slhc_compress(ppp->slcomp, p, len, ppp->cbuff, &p, 0);
p1744drivers/net/ppp.cif (p[0] & SL_TYPE_COMPRESSED_TCP)
p1747drivers/net/ppp.cif (p[0] >= SL_TYPE_UNCOMPRESSED_TCP) {
p1749drivers/net/ppp.cp[0] = (p[0] & 0x0f) | 0x40; 
p1788drivers/net/ppp.cppp_stuff_char(ppp, *p++);
p643drivers/net/sk_g16.cstruct priv *p;         /* SK_G16 private structure */
p791drivers/net/sk_g16.cp = dev->priv = (void *) kmalloc(sizeof(struct priv), GFP_KERNEL);
p812drivers/net/sk_g16.cp->ram = (struct SK_ram *) rom_addr; /* Set dual ported RAM addr */
p813drivers/net/sk_g16.cp->tmdhead = &(p->ram)->tmde[0];     /* Set TMD head */
p814drivers/net/sk_g16.cp->rmdhead = &(p->ram)->rmde[0];     /* Set RMD head */
p820drivers/net/sk_g16.cp->tmdbufs[i] = &(p->ram)->tmdbuf[i];
p825drivers/net/sk_g16.cp->rmdbufs[i] = &(p->ram)->rmdbuf[i]; 
p871drivers/net/sk_g16.cstruct priv *p = (struct priv *)dev->priv;
p960drivers/net/sk_g16.c(int) dev->irq, (unsigned int) p->ram);
p1031drivers/net/sk_g16.cstruct priv *p = (struct priv *) dev->priv; 
p1042drivers/net/sk_g16.cp->tmdnum = 0;                   /* First descriptor for transmitting */ 
p1043drivers/net/sk_g16.cp->tmdlast = 0;                  /* First descriptor for reading stats */
p1047drivers/net/sk_g16.ctmdp = p->tmdhead + i; 
p1049drivers/net/sk_g16.ctmdp->u.buffer = (unsigned long) p->tmdbufs[i]; /* assign buffer */
p1058drivers/net/sk_g16.cp->rmdnum = 0;                   /* First RMD which will be used */
p1062drivers/net/sk_g16.crmdp = p->rmdhead + i;
p1065drivers/net/sk_g16.crmdp->u.buffer = (unsigned long) p->rmdbufs[i]; /* assign buffer */
p1082drivers/net/sk_g16.c(p->ram)->ib.mode = mode;        /* Set operation mode */
p1086drivers/net/sk_g16.c(p->ram)->ib.paddr[i] = dev->dev_addr[i]; 
p1091drivers/net/sk_g16.c(p->ram)->ib.laddr[i] = 0;   /* We do not use logical addressing */
p1096drivers/net/sk_g16.c(p->ram)->ib.rdrp = (int)  p->rmdhead | RMDNUMMASK;
p1097drivers/net/sk_g16.c(p->ram)->ib.tdrp = (int)  p->tmdhead | TMDNUMMASK;
p1150drivers/net/sk_g16.c(unsigned int) &(p->ram)->ib);
p1196drivers/net/sk_g16.cstruct priv *p = (struct priv *) dev->priv;
p1253drivers/net/sk_g16.ctmdp = p->tmdhead + p->tmdnum; /* Which descriptor for transmitting */
p1278drivers/net/sk_g16.cp->tmdnum++; 
p1279drivers/net/sk_g16.cp->tmdnum &= TMDNUM-1; 
p1282drivers/net/sk_g16.cif (! ((p->tmdhead + p->tmdnum)->u.s.status & TX_OWN) )
p1318drivers/net/sk_g16.cstruct priv *p = (struct priv *) dev->priv;
p1352drivers/net/sk_g16.cp->stats.rx_dropped++;
p1393drivers/net/sk_g16.cstruct priv *p = (struct priv *) dev->priv;
p1399drivers/net/sk_g16.ctmdp = p->tmdhead + p->tmdlast;     /* Which buffer we sent at last ? */
p1402drivers/net/sk_g16.cp->tmdlast++;
p1403drivers/net/sk_g16.cp->tmdlast &= TMDNUM-1;
p1422drivers/net/sk_g16.cp->stats.tx_aborted_errors++;   
p1424drivers/net/sk_g16.cp->stats.tx_window_errors++; 
p1426drivers/net/sk_g16.cp->stats.tx_carrier_errors++;
p1429drivers/net/sk_g16.cp->stats.tx_fifo_errors++;
p1439drivers/net/sk_g16.cp->stats.tx_errors++;
p1457drivers/net/sk_g16.cp->stats.collisions++; 
p1461drivers/net/sk_g16.cp->stats.tx_packets++; 
p1513drivers/net/sk_g16.cstruct priv *p = (struct priv *) dev->priv;
p1518drivers/net/sk_g16.crmdp = p->rmdhead + p->rmdnum;
p1540drivers/net/sk_g16.cp->stats.rx_errors++;        /* bad packet received */
p1541drivers/net/sk_g16.cp->stats.rx_length_errors++; /* packet to long */
p1561drivers/net/sk_g16.cp->stats.rx_errors++;
p1563drivers/net/sk_g16.cif (rmdstat & RX_FRAM) p->stats.rx_frame_errors++;
p1564drivers/net/sk_g16.cif (rmdstat & RX_CRC)  p->stats.rx_crc_errors++;
p1588drivers/net/sk_g16.cp->stats.rx_dropped++;
p1624drivers/net/sk_g16.cp->stats.rx_packets++;
p1627drivers/net/sk_g16.cp->rmdnum++;
p1628drivers/net/sk_g16.cp->rmdnum %= RMDNUM;
p1630drivers/net/sk_g16.crmdp = p->rmdhead + p->rmdnum;
p1697drivers/net/sk_g16.cstruct priv *p = (struct priv *) dev->priv;
p1702drivers/net/sk_g16.creturn &p->stats;             /* Return Device status */
p2086drivers/net/sk_g16.cstruct priv *p = (struct priv *) dev->priv;
p2091drivers/net/sk_g16.c(unsigned int) p->ram,
p2092drivers/net/sk_g16.c(unsigned int) p->tmdhead, 
p2093drivers/net/sk_g16.c(unsigned int) p->rmdhead, 
p2094drivers/net/sk_g16.c(unsigned int) &(p->ram)->ib);
p2104drivers/net/sk_g16.cprintk("tmdbufs%d: %#08x ", (i+1), (int) p->tmdbufs[i]);
p2114drivers/net/sk_g16.cprintk("rmdbufs%d: %#08x ", (i+1), (int) p->rmdbufs[i]);
p361drivers/net/slip.cunsigned char *p;
p378drivers/net/slip.cp = icp;
p381drivers/net/slip.clen = slhc_compress(sl->slcomp, p, len, sl->cbuff, &p, 1);
p384drivers/net/slip.ccount=slip_esc6(p, (unsigned char *)sl->xbuff,len);
p386drivers/net/slip.ccount=slip_esc(p, (unsigned char *)sl->xbuff,len);
p543drivers/net/slip.cunsigned char *p;
p569drivers/net/slip.cp = (unsigned char *) kmalloc(l + 4, GFP_KERNEL);
p570drivers/net/slip.cif (p == NULL) {
p579drivers/net/slip.csl->dev->mem_start  = (unsigned long) p;
p582drivers/net/slip.cp = (unsigned char *) kmalloc(l + 4, GFP_KERNEL);
p583drivers/net/slip.cif (p == NULL) {
p587drivers/net/slip.csl->dev->rmem_start  = (unsigned long) p;
p599drivers/net/slip.cp = (unsigned char *) kmalloc(l + 4, GFP_KERNEL);
p600drivers/net/slip.cif (p == NULL) {
p605drivers/net/slip.csl->cbuff    = p;
p207drivers/net/znet.cchar *p;
p210drivers/net/znet.cfor(p = (char *)0xf0000; p < (char *)0x100000; p++)
p211drivers/net/znet.cif (*p == 'N'  &&  strncmp(p, "NETIDBLK", 8) == 0)
p214drivers/net/znet.cif (p >= (char *)0x100000) {
p219drivers/net/znet.cnetinfo = (struct netidblk *)p;
p1467drivers/scsi/NCR5380.cregister unsigned char p = *phase, tmp;
p1478drivers/scsi/NCR5380.cNCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
p1492drivers/scsi/NCR5380.cif ((tmp & PHASE_MASK) != p) {
p1501drivers/scsi/NCR5380.cif (!(p & SR_IO)) 
p1515drivers/scsi/NCR5380.cif (!(p & SR_IO)) {
p1516drivers/scsi/NCR5380.cif (!((p & SR_MSG) && c > 1)) {
p1557drivers/scsi/NCR5380.cif (!(p == PHASE_MSGIN && c == 1)) {  
p1558drivers/scsi/NCR5380.cif (p == PHASE_MSGOUT && c > 1)
p1577drivers/scsi/NCR5380.cif (!c || (*phase == p))
p1608drivers/scsi/NCR5380.cregister unsigned char p = *phase;
p1622drivers/scsi/NCR5380.cif ((tmp = (NCR5380_read(STATUS_REG) & PHASE_MASK)) != p) {
p1628drivers/scsi/NCR5380.cif (p & SR_IO) {
p1634drivers/scsi/NCR5380.cinstance->host_no, instance->dma_channel, (p & SR_IO) ? "reading" :
p1635drivers/scsi/NCR5380.c"writing", c, (p & SR_IO) ? "to" : "from", (unsigned) d);
p1637drivers/scsi/NCR5380.chostdata->dma_len = (p & SR_IO) ?
p1642drivers/scsi/NCR5380.cNCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
p1674drivers/scsi/NCR5380.cif (p & SR_IO) {
p1735drivers/scsi/NCR5380.cif (p & SR_IO) {
p1769drivers/scsi/NCR5380.cif (*phase == p && (p & SR_IO) && residue == 0) {
p1799drivers/scsi/NCR5380.cif (p & SR_IO) {
p94drivers/scsi/aha1542.h#define any2scsi(up, p)        \
p95drivers/scsi/aha1542.h(up)[0] = (((unsigned long)(p)) >> 16)  ;  \
p96drivers/scsi/aha1542.h(up)[1] = (((unsigned long)(p)) >> 8);    \
p97drivers/scsi/aha1542.h(up)[2] = ((unsigned long)(p));
p101drivers/scsi/aha1542.h#define xany2scsi(up, p)  \
p102drivers/scsi/aha1542.h(up)[0] = ((long)(p)) >> 24;  \
p103drivers/scsi/aha1542.h(up)[1] = ((long)(p)) >> 16;  \
p104drivers/scsi/aha1542.h(up)[2] = ((long)(p)) >> 8;  \
p105drivers/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));
p319drivers/scsi/aha274x.cchar *p;
p329drivers/scsi/aha274x.cfor (p = strtok(s, ","); p; p = strtok(NULL, ",")) {
p331drivers/scsi/aha274x.cif (!strcmp(options[i].name, p))
p427drivers/scsi/aha274x.c#define PAUSE_SEQUENCER(p)  \
p429drivers/scsi/aha274x.coutb(0xe, O_HCNTRL(p->base));  /* IRQMS|PAUSE|INTEN */  \
p431drivers/scsi/aha274x.cwhile ((inb(O_HCNTRL(p->base)) & 0x4) == 0)    \
p439drivers/scsi/aha274x.c#define UNPAUSE_SEQUENCER(p)  \
p440drivers/scsi/aha274x.coutb(p->unpause, O_HCNTRL(p->base))  /* IRQMS|INTEN */
p445drivers/scsi/aha274x.c#define RESTART_SEQUENCER(p)  \
p448drivers/scsi/aha274x.coutb(0x2, O_SEQCTL(p->base));  \
p449drivers/scsi/aha274x.c} while (inw(O_SEQADDR(p->base)) != 0);  \
p451drivers/scsi/aha274x.cUNPAUSE_SEQUENCER(p);      \
p462drivers/scsi/aha274x.cstruct aha274x_host *p;
p464drivers/scsi/aha274x.cp = (struct aha274x_host *)aha274x_boards[irq]->hostdata;
p465drivers/scsi/aha274x.cbase = p->base;
p473drivers/scsi/aha274x.cif (p->startup) {
p474drivers/scsi/aha274x.cp->unpause ^= 0x8;
p475drivers/scsi/aha274x.coutb(inb(O_HCNTRL(p->base)) ^ 0x8, O_HCNTRL(p->base));
p497drivers/scsi/aha274x.ccmd = (Scsi_Cmnd *)p->SCB_array[scbptr];
p506drivers/scsi/aha274x.cUNPAUSE_SEQUENCER(p);
p510drivers/scsi/aha274x.cp->SCB_array[scbptr] = NULL;
p549drivers/scsi/aha274x.cRESTART_SEQUENCER(p);
p569drivers/scsi/aha274x.cUNPAUSE_SEQUENCER(p);
p581drivers/scsi/aha274x.cUNPAUSE_SEQUENCER(p);
p601drivers/scsi/aha274x.ccmd = (Scsi_Cmnd *)p->SCB_array[complete];
p607drivers/scsi/aha274x.cp->SCB_array[complete] = NULL;
p609drivers/scsi/aha274x.cPAUSE_SEQUENCER(p);
p627drivers/scsi/aha274x.cUNPAUSE_SEQUENCER(p);
p680drivers/scsi/aha274x.cPAUSE_SEQUENCER(p);
p714drivers/scsi/aha274x.cUNPAUSE_SEQUENCER(p);
p864drivers/scsi/aha274x.cstruct aha274x_host *p;
p941drivers/scsi/aha274x.cp = (struct aha274x_host *)host->hostdata;
p943drivers/scsi/aha274x.cp->SCB_array[i] = NULL;
p944drivers/scsi/aha274x.cp->base = base;
p954drivers/scsi/aha274x.cp->unpause = (type != T_274X ? 0x2 : 0xa);
p955drivers/scsi/aha274x.cp->startup = !0;
p1002drivers/scsi/aha274x.cUNPAUSE_SEQUENCER(p);
p1059drivers/scsi/aha274x.cvoid aha274x_buildscb(struct aha274x_host *p,
p1152drivers/scsi/aha274x.cstruct aha274x_host *p;
p1163drivers/scsi/aha274x.cp = (struct aha274x_host *)cmd->host->hostdata;
p1169drivers/scsi/aha274x.caha274x_buildscb(p, cmd, &scb);
p1175drivers/scsi/aha274x.cp->startup = 0;
p1193drivers/scsi/aha274x.cif (!p->SCB_array[empty])
p1204drivers/scsi/aha274x.cPAUSE_SEQUENCER(p);
p1212drivers/scsi/aha274x.cold_scbptr = inb(O_SCBPTR(p->base));
p1213drivers/scsi/aha274x.coutb(empty, O_SCBPTR(p->base));
p1215drivers/scsi/aha274x.caha274x_putscb(p->base, &scb);
p1217drivers/scsi/aha274x.coutb(empty, O_QINFIFO(p->base));
p1218drivers/scsi/aha274x.coutb(old_scbptr, O_SCBPTR(p->base));
p1227drivers/scsi/aha274x.cp->SCB_array[empty] = cmd;
p1230drivers/scsi/aha274x.cUNPAUSE_SEQUENCER(p);
p1266drivers/scsi/aha274x.cstruct aha274x_host *p;
p1270drivers/scsi/aha274x.cp = (struct aha274x_host *)cmd->host->hostdata;
p1277drivers/scsi/aha274x.cif (p->SCB_array[scb] == cmd)
p1283drivers/scsi/aha274x.cPAUSE_SEQUENCER(p);
p1290drivers/scsi/aha274x.cqueued = inb(O_QINCNT(p->base));
p1293drivers/scsi/aha274x.cscbsave[i] = inb(O_QINFIFO(p->base));
p1303drivers/scsi/aha274x.coutb(scbsave[i], O_QINFIFO(p->base));
p1315drivers/scsi/aha274x.cif (inb(O_SCBPTR(p->base)) != scb) {
p1317drivers/scsi/aha274x.cUNPAUSE_SEQUENCER(p);
p1327drivers/scsi/aha274x.cif (inb(HA_MSG_FLAGS(p->base)) & 0x80) {
p1329drivers/scsi/aha274x.cUNPAUSE_SEQUENCER(p);
p1333drivers/scsi/aha274x.coutb(0x80, HA_MSG_FLAGS(p->base));    /* active message */
p1334drivers/scsi/aha274x.coutb(1, HA_MSG_LEN(p->base));      /* length = 1 */
p1335drivers/scsi/aha274x.coutb(message, HA_MSG_START(p->base));    /* message body */
p1342drivers/scsi/aha274x.coutb(inb(HA_SIGSTATE(p->base)) | 0x10, O_SCSISIGO(p->base));
p1349drivers/scsi/aha274x.cp->SCB_array[scb] = NULL;
p1351drivers/scsi/aha274x.cUNPAUSE_SEQUENCER(p);
p1391drivers/scsi/aha274x.cstruct aha274x_host *p;
p1393drivers/scsi/aha274x.cp = (struct aha274x_host *)cmd->host->hostdata;
p1406drivers/scsi/aha274x.coutb((1 << cmd->target), HA_NEEDSDTR(p->base));
p1407drivers/scsi/aha274x.cUNPAUSE_SEQUENCER(p);
p1415drivers/scsi/aha274x.cPAUSE_SEQUENCER(p);
p1434drivers/scsi/aha274x.coutb(1, O_SCSISEQ(p->base));    /* SCSIRSTO */
p1436drivers/scsi/aha274x.coutb(0, O_SCSISEQ(p->base));    /* !SCSIRSTO */
p1438drivers/scsi/aha274x.coutb(0xff, HA_NEEDSDTR(p->base));
p1439drivers/scsi/aha274x.cUNPAUSE_SEQUENCER(p);
p1447drivers/scsi/aha274x.cif (cmd == p->SCB_array[i]) {
p1448drivers/scsi/aha274x.creset = (Scsi_Cmnd *)p->SCB_array[i];
p1449drivers/scsi/aha274x.cp->SCB_array[i] = NULL;
p71drivers/scsi/aic7770.cvoid *p = malloc(size);
p72drivers/scsi/aic7770.cif (!p)
p74drivers/scsi/aic7770.creturn(p);
p79drivers/scsi/aic7770.cvoid *p = realloc(ptr, size);
p80drivers/scsi/aic7770.cif (!p)
p82drivers/scsi/aic7770.creturn(p);
p87drivers/scsi/aic7770.cchar *p = (char *)Malloc(strlen(s) + 1);
p88drivers/scsi/aic7770.cstrcpy(p, s);
p89drivers/scsi/aic7770.creturn(p);
p103drivers/scsi/aic7770.csym_t *p, *q;
p105drivers/scsi/aic7770.cfor (p = head, q = (sym_t *)&head; p; p = p->next) {
p106drivers/scsi/aic7770.cif (!strcmp(p->name, name))
p108drivers/scsi/aic7770.cq = p;
p111drivers/scsi/aic7770.cp = q->next = (sym_t *)Malloc(sizeof(sym_t));
p112drivers/scsi/aic7770.cp->next = NULL;
p113drivers/scsi/aic7770.cp->name = Strdup(name);
p114drivers/scsi/aic7770.cp->value = value;
p115drivers/scsi/aic7770.cp->npatch = 0;
p116drivers/scsi/aic7770.cp->patch = NULL;
p119drivers/scsi/aic7770.cfprintf(stderr, "\"%s\" ", p->name);
p120drivers/scsi/aic7770.cif (p->value != NOVALUE)
p121drivers/scsi/aic7770.cfprintf(stderr, "defined as 0x%x\n", p->value);
p129drivers/scsi/aic7770.csym_t *p;
p131drivers/scsi/aic7770.cfor (p = head; p; p = p->next)
p132drivers/scsi/aic7770.cif (!strcmp(p->name, name))
p133drivers/scsi/aic7770.creturn(p);
p137drivers/scsi/aic7770.cvoid patch(sym_t *p, int location)
p139drivers/scsi/aic7770.cp->npatch += 1;
p140drivers/scsi/aic7770.cp->patch = (int *)Realloc(p->patch, p->npatch * sizeof(int *));
p142drivers/scsi/aic7770.cp->patch[p->npatch - 1] = location;
p148drivers/scsi/aic7770.csym_t *p;
p150drivers/scsi/aic7770.cfor (p = head; p; p = p->next) {
p152drivers/scsi/aic7770.cif (p->value == NOVALUE) {
p155drivers/scsi/aic7770.cfilename, p->name);
p159drivers/scsi/aic7770.cif (p->npatch) {
p163drivers/scsi/aic7770.cp->name, p->value);
p165drivers/scsi/aic7770.cfor (i = 0; i < p->npatch; i++) {
p166drivers/scsi/aic7770.cM[p->patch[i]][0] &= ~1;
p167drivers/scsi/aic7770.cM[p->patch[i]][0] |= ((p->value >> 8) & 1);
p168drivers/scsi/aic7770.cM[p->patch[i]][1] = p->value & 0xff;
p171drivers/scsi/aic7770.cfprintf(stderr, " 0x%x", p->patch[i]);
p199drivers/scsi/aic7770.cchar *p;
p212drivers/scsi/aic7770.cp = strchr(buf, '#');
p213drivers/scsi/aic7770.cif (p)
p214drivers/scsi/aic7770.c*p = '\0';
p216drivers/scsi/aic7770.cfor (p = strtok(buf, ", \t\n"); p; p = strtok(NULL, ", \t\n"))
p218drivers/scsi/aic7770.ca[i++] = p;
p338drivers/scsi/aic7770.csym_t *p;
p352drivers/scsi/aic7770.cp = lookup(a[spec &~ (SL|SR|RL|RR)]);
p353drivers/scsi/aic7770.cif (!p)
p355drivers/scsi/aic7770.cval = p->value;
p396drivers/scsi/aic7770.cp = lookup(a[spec]);
p397drivers/scsi/aic7770.cif (p)
p398drivers/scsi/aic7770.creturn(p->value);
p407drivers/scsi/aic7770.csym_t *p;
p414drivers/scsi/aic7770.cp = lookup(a[spec]);
p416drivers/scsi/aic7770.cif (p) {
p417drivers/scsi/aic7770.cif (p->value != NOVALUE)
p418drivers/scsi/aic7770.creturn(p->value);
p419drivers/scsi/aic7770.cpatch(p, LC);
p422drivers/scsi/aic7770.cp = lookup(a[spec]);
p423drivers/scsi/aic7770.cpatch(p, LC);
p497drivers/scsi/aic7770.csym_t *p;
p503drivers/scsi/aic7770.cp = lookup(*a);
p504drivers/scsi/aic7770.cif (p)
p505drivers/scsi/aic7770.cp->value = LC;
p246drivers/scsi/eata.cushort *p;
p248drivers/scsi/eata.cfor (p = start; p <= end; p++) {
p254drivers/scsi/eata.c*p = inw(iobase);
p75drivers/scsi/in2000.h#define any2scsi(up, p)        \
p76drivers/scsi/in2000.h(up)[0] = (((unsigned long)(p)) >> 16);    \
p77drivers/scsi/in2000.h(up)[1] = (((unsigned long)(p)) >> 8);    \
p78drivers/scsi/in2000.h(up)[2] = ((unsigned long)(p));
p84drivers/scsi/in2000.h#define xany2scsi(up, p)  \
p85drivers/scsi/in2000.h(up)[0] = ((long)(p)) >> 24;  \
p86drivers/scsi/in2000.h(up)[1] = ((long)(p)) >> 16;  \
p87drivers/scsi/in2000.h(up)[2] = ((long)(p)) >> 8;  \
p88drivers/scsi/in2000.h(up)[3] = ((long)(p));
p158drivers/scsi/scsi_debug.cstruct partition * p;
p275drivers/scsi/scsi_debug.cp = (struct partition* ) (buff + 0x1be);
p278drivers/scsi/scsi_debug.cp->start_sect = starts[npart];
p279drivers/scsi/scsi_debug.cp->nr_sects = starts[npart+1] - starts [npart];
p280drivers/scsi/scsi_debug.cp->sys_ind = 0x81;  /* Linux partition */
p281drivers/scsi/scsi_debug.cp++;
p78drivers/scsi/scsicam.cstruct partition *p, *largest = NULL;
p85drivers/scsi/scsicam.cfor (largest_cyl = -1, p = (struct partition *) 
p86drivers/scsi/scsicam.c(0x1BE + bh->b_data), i = 0; i < 4; ++i, ++p) {
p87drivers/scsi/scsicam.cif (!p->sys_ind)
p93drivers/scsi/scsicam.ccyl = p->cyl + ((p->sector & 0xc0) << 2);
p96drivers/scsi/scsicam.clargest = p;
p847drivers/scsi/ultrastor.cunsigned char p = inb(port0 + i);
p848drivers/scsi/ultrastor.cout[28 + i * 3] = "0123456789abcdef"[p >> 4];
p849drivers/scsi/ultrastor.cout[29 + i * 3] = "0123456789abcdef"[p & 15];
p518drivers/scsi/wd7000.c#define any2scsi(up, p)      \
p519drivers/scsi/wd7000.c(up)[0] = (((unsigned long)(p)) >> 16);          \
p520drivers/scsi/wd7000.c(up)[1] = ((unsigned long)(p)) >> 8;    \
p521drivers/scsi/wd7000.c(up)[2] = ((unsigned long)(p));
p597drivers/scsi/wd7000.cregister Scb *scb, *p;
p634drivers/scsi/wd7000.cfor (i = 0; i < needed; i++)  { p = scbfree;  scbfree = p->next; }
p635drivers/scsi/wd7000.cp->next = NULL;
p168drivers/sound/audio.cint             c, p, l;
p173drivers/sound/audio.cp = 0;
p221drivers/sound/audio.cCOPY_FROM_USER (&wr_dma_buf[dev][wr_buff_ptr[dev]], buf, p, l);
p225drivers/sound/audio.cwr_dma_buf[dev], wr_buff_ptr[dev], buf, p, l);
p244drivers/sound/audio.cp += l;
p265drivers/sound/audio.cint             c, p, l;
p270drivers/sound/audio.cp = 0;
p309drivers/sound/audio.cCOPY_TO_USER (buf, p, dmabuf, l);
p313drivers/sound/audio.cp += l;
p57drivers/sound/dmabuf.cunsigned        i, p, n;
p126drivers/sound/dmabuf.cp = 0;
p128drivers/sound/dmabuf.cwhile ((p + bsz) <= dsp_dev->buffsize &&
p132drivers/sound/dmabuf.cdmap->buf[n] = dmap->raw_buf[i] + p;
p133drivers/sound/dmabuf.cdmap->buf_phys[n] = dmap->raw_buf_phys[i] + p;
p134drivers/sound/dmabuf.cp += bsz;
p373drivers/sound/dmabuf.cint             p = dmap->counts[dmap->qhead] + c;
p375drivers/sound/dmabuf.cif (p >= dmap->fragment_size)
p385drivers/sound/dmabuf.cdmap->counts[dmap->qhead] = p;
p2606drivers/sound/gus_wave.cint             i, p;
p2608drivers/sound/gus_wave.cp = alloc->ptr;
p2615drivers/sound/gus_wave.cif (alloc->map[p] == 0)
p2617drivers/sound/gus_wave.calloc->ptr = p;
p2618drivers/sound/gus_wave.creturn p;
p2620drivers/sound/gus_wave.cp = (p + 1) % alloc->max_voice;
p2629drivers/sound/gus_wave.cif (alloc->map[p] == 0xffff)
p2631drivers/sound/gus_wave.calloc->ptr = p;
p2632drivers/sound/gus_wave.creturn p;
p2634drivers/sound/gus_wave.cp = (p + 1) % alloc->max_voice;
p2638drivers/sound/gus_wave.calloc->ptr = p;
p2639drivers/sound/gus_wave.creturn p;
p1079drivers/sound/opl3.cint             i, p, avail_voices;
p1100drivers/sound/opl3.cp = 0;
p1106drivers/sound/opl3.cp = 6;
p1108drivers/sound/opl3.cp = 0;
p1118drivers/sound/opl3.cif (alloc->map[p] == 0)
p1120drivers/sound/opl3.creturn p;
p1122drivers/sound/opl3.cp = (p + 1) % nr_voices;
p812drivers/sound/pss.cint             c, p;
p819drivers/sound/pss.cp = 0;
p100drivers/sound/sequencer.cint             c = count, p = 0;
p128drivers/sound/sequencer.cCOPY_TO_USER (buf, p, &iqueue[iqhead * IEV_SZ], ev_len);
p129drivers/sound/sequencer.cp += ev_len;
p234drivers/sound/sequencer.cint             p = 0, c, ev_size;
p254drivers/sound/sequencer.cCOPY_FROM_USER (event, buf, p, 4);
p268drivers/sound/sequencer.cerr = synth_devs[dev]->load_patch (dev, *(short *) &event[0], buf, p + 4, c, 0);
p292drivers/sound/sequencer.cCOPY_FROM_USER (&event[4], buf, p + 4, 4);
p342drivers/sound/sequencer.cp += ev_size;
p76fs/binfmt_elf.cunsigned long * create_elf_tables(char * p,int argc,int envc,struct elfhdr * exec, unsigned int load_addr, int ibcs)
p85fs/binfmt_elf.cmpnt->vm_start = PAGE_MASK & (unsigned long) p;
p105fs/binfmt_elf.csp = (unsigned long *) (0xfffffffc & (unsigned long) p);
p134fs/binfmt_elf.ccurrent->mm->arg_start = (unsigned long) p;
p136fs/binfmt_elf.cput_fs_long((unsigned long) p,argv++);
p137fs/binfmt_elf.cwhile (get_fs_byte(p++)) /* nothing */ ;
p140fs/binfmt_elf.ccurrent->mm->arg_end = current->mm->env_start = (unsigned long) p;
p142fs/binfmt_elf.cput_fs_long((unsigned long) p,envp++);
p143fs/binfmt_elf.cwhile (get_fs_byte(p++)) /* nothing */ ;
p146fs/binfmt_elf.ccurrent->mm->env_end = (unsigned long) p;
p476fs/binfmt_elf.cbprm->p = copy_strings(1,&passed_p,bprm->page,bprm->p,2);
p480fs/binfmt_elf.cif (!bprm->p) {
p504fs/binfmt_elf.cbprm->p += change_ldt(0, bprm->page);
p505fs/binfmt_elf.ccurrent->mm->start_stack = bprm->p;
p597fs/binfmt_elf.ccurrent->start_stack = p = elf_stack - 4;
p599fs/binfmt_elf.cbprm->p -= MAX_ARG_PAGES*PAGE_SIZE;
p600fs/binfmt_elf.cbprm->p = (unsigned long) 
p601fs/binfmt_elf.ccreate_elf_tables((char *)bprm->p,
p613fs/binfmt_elf.ccurrent->mm->start_stack = bprm->p;
p641fs/binfmt_elf.cregs->esp = bprm->p;      /* stack pointer */
p33fs/block_dev.cregister char * p;
p115fs/block_dev.cp = offset + bh->b_data;
p120fs/block_dev.cmemcpy_fromfs(p,buf,chars);
p121fs/block_dev.cp += chars;
p1045fs/buffer.cint * p;
p1052fs/buffer.cp = b;
p1054fs/buffer.cblock = *(p++);
p1061fs/buffer.cp = b;
p1071fs/buffer.cbh->b_blocknr = *(p++);
p1222fs/buffer.cstruct buffer_head * tmp, * p;
p1238fs/buffer.cp = tmp;
p1242fs/buffer.cif (p == *bhp)
p1244fs/buffer.c*bhp = p->b_prev_free;
p1245fs/buffer.cif (p == *bhp) /* Was this the last in the list? */
p1248fs/buffer.cremove_from_queues(p);
p1249fs/buffer.cput_unused_buffer_head(p);
p1437fs/buffer.cstruct buffer_head * tmp, * p;
p1460fs/buffer.cp = tmp;
p1462fs/buffer.cremove_from_queues(p);
p1463fs/buffer.cp->b_dev=dev;
p1464fs/buffer.cp->b_uptodate = 0;
p1465fs/buffer.cp->b_req = 0;
p1466fs/buffer.cp->b_blocknr=starting_block++;
p1467fs/buffer.cinsert_into_queues(p);
p216fs/dcache.cstruct dir_cache_entry * p;
p221fs/dcache.cp = level1_cache;
p223fs/dcache.cp[1].prev_lru = p;
p224fs/dcache.cp[0].next_lru = p+1;
p225fs/dcache.cp[0].lru_head = &level1_head;
p226fs/dcache.c} while (++p < level1_cache + DCACHE_SIZE-1);
p227fs/dcache.clevel1_cache[0].prev_lru = p;
p228fs/dcache.cp[0].next_lru = &level1_cache[0];
p229fs/dcache.cp[0].lru_head = &level1_head;
p235fs/dcache.cp = level2_cache;
p237fs/dcache.cp[1].prev_lru = p;
p238fs/dcache.cp[0].next_lru = p+1;
p239fs/dcache.cp[0].lru_head = &level2_head;
p240fs/dcache.c} while (++p < level2_cache + DCACHE_SIZE-1);
p241fs/dcache.clevel2_cache[0].prev_lru = p;
p242fs/dcache.cp[0].next_lru = &level2_cache[0];
p243fs/dcache.cp[0].lru_head = &level2_head;
p316fs/exec.cunsigned long * create_tables(char * p,int argc,int envc,int ibcs)
p325fs/exec.cmpnt->vm_start = PAGE_MASK & (unsigned long) p;
p335fs/exec.csp = (unsigned long *) (0xfffffffc & (unsigned long) p);
p345fs/exec.ccurrent->mm->arg_start = (unsigned long) p;
p347fs/exec.cput_fs_long((unsigned long) p,argv++);
p348fs/exec.cwhile (get_fs_byte(p++)) /* nothing */ ;
p351fs/exec.ccurrent->mm->arg_end = current->mm->env_start = (unsigned long) p;
p353fs/exec.cput_fs_long((unsigned long) p,envp++);
p354fs/exec.cwhile (get_fs_byte(p++)) /* nothing */ ;
p357fs/exec.ccurrent->mm->env_end = (unsigned long) p;
p370fs/exec.cchar ** tmp, *p;
p376fs/exec.cwhile ((p = (char *) get_fs_long((unsigned long *) (tmp++))) != NULL) {
p378fs/exec.cerror = verify_area(VERIFY_READ, p, 1);
p404fs/exec.cunsigned long p, int from_kmem)
p410fs/exec.cif (!p)
p427fs/exec.cif (p < len) {  /* this shouldn't happen - 128kB */
p432fs/exec.c--p; --tmp; --len;
p434fs/exec.coffset = p % PAGE_SIZE;
p437fs/exec.cif (!(pag = (char *) page[p/PAGE_SIZE]) &&
p438fs/exec.c!(pag = (char *) page[p/PAGE_SIZE] =
p450fs/exec.creturn p;
p603fs/exec.cbprm.p = PAGE_SIZE*MAX_ARG_PAGES-4;
p699fs/exec.cbprm.p = copy_strings(bprm.envc, envp, bprm.page, bprm.p, 0);
p700fs/exec.cbprm.p = copy_strings(--bprm.argc, argv+1, bprm.page, bprm.p, 0);
p710fs/exec.cbprm.p = copy_strings(1, &bprm.filename, bprm.page, bprm.p, 2);
p713fs/exec.cbprm.p = copy_strings(1, &i_arg, bprm.page, bprm.p, 2);
p716fs/exec.cbprm.p = copy_strings(1, &i_name, bprm.page, bprm.p, 2);
p718fs/exec.cif (!bprm.p) {
p733fs/exec.cbprm.p = copy_strings(bprm.envc,envp,bprm.page,bprm.p,0);
p734fs/exec.cbprm.p = copy_strings(bprm.argc,argv,bprm.page,bprm.p,0);
p735fs/exec.cif (!bprm.p) {
p800fs/exec.cunsigned long p = bprm->p;
p895fs/exec.cp += change_ldt(ex.a_text,bprm->page);
p896fs/exec.cp -= MAX_ARG_PAGES*PAGE_SIZE;
p897fs/exec.cp = (unsigned long)create_tables((char *)p,
p900fs/exec.ccurrent->mm->start_stack = p;
p902fs/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;
p257fs/ext2/balloc.cchar * p, * r;
p341fs/ext2/balloc.cp = ((char *) bh->b_data) + (j >> 3);
p342fs/ext2/balloc.cr = memscan(p, 0, (EXT2_BLOCKS_PER_GROUP(sb) - j + 7) >> 3);
p238fs/ext2/file.cchar * p;
p300fs/ext2/file.cp = (pos2 % sb->s_blocksize) + bh->b_data;
p304fs/ext2/file.cmemcpy_fromfs (p, buf, c);
p185fs/ext2/inode.cunsigned long * p;
p189fs/ext2/inode.cp = inode->u.ext2_i.i_data + nr;
p191fs/ext2/inode.ctmp = *p;
p194fs/ext2/inode.cif (tmp == *p)
p229fs/ext2/inode.cif (*p) {
p234fs/ext2/inode.c*p = tmp;
p252fs/ext2/inode.cunsigned long * p;
p266fs/ext2/inode.cp = (unsigned long *) bh->b_data + nr;
p268fs/ext2/inode.ctmp = *p;
p271fs/ext2/inode.cif (tmp == *p) {
p303fs/ext2/inode.cif (*p) {
p308fs/ext2/inode.c*p = tmp;
p327fs/ext2/inode.cunsigned long * p;
p340fs/ext2/inode.cp = (unsigned long *) bh->b_data + nr + i;
p343fs/ext2/inode.cif(*p == 0) goto out;
p346fs/ext2/inode.cif(i==0) firstblock = *p;
p347fs/ext2/inode.celse if(*p != firstblock + i) goto out;
p350fs/ext2/inode.cp = (unsigned long *) bh->b_data + nr;
p351fs/ext2/inode.cresult = generate_cluster(bh->b_dev, (int *) p, blocksize);
p49fs/ext2/truncate.cunsigned long * p;
p61fs/ext2/truncate.cp = inode->u.ext2_i.i_data + i;
p62fs/ext2/truncate.ctmp = *p;
p75fs/ext2/truncate.cif ((bh && bh->b_count != 1) || tmp != *p) {
p80fs/ext2/truncate.c*p = 0;
p105fs/ext2/truncate.cstatic int trunc_indirect (struct inode * inode, int offset, unsigned long * p)
p119fs/ext2/truncate.ctmp = *p;
p123fs/ext2/truncate.cif (tmp != *p) {
p128fs/ext2/truncate.c*p = 0;
p187fs/ext2/truncate.ctmp = *p;
p188fs/ext2/truncate.c*p = 0;
p202fs/ext2/truncate.cunsigned long * p)
p213fs/ext2/truncate.ctmp = *p;
p217fs/ext2/truncate.cif (tmp != *p) {
p222fs/ext2/truncate.c*p = 0;
p247fs/ext2/truncate.ctmp = *p;
p248fs/ext2/truncate.c*p = 0;
p265fs/ext2/truncate.cunsigned long * tind, * p;
p274fs/ext2/truncate.cp = inode->u.ext2_i.i_data + EXT2_TIND_BLOCK;
p275fs/ext2/truncate.cif (!(tmp = *p))
p278fs/ext2/truncate.cif (tmp != *p) {
p283fs/ext2/truncate.c*p = 0;
p306fs/ext2/truncate.ctmp = *p;
p307fs/ext2/truncate.c*p = 0;
p69fs/fcntl.cstruct task_struct *p;
p145fs/fcntl.cfor_each_task(p) {
p146fs/fcntl.cif ((p->pid == arg) || (p->pid == -arg) || 
p147fs/fcntl.c(p->pgrp == -arg)) {
p149fs/fcntl.cif ((p->session != current->session) &&
p150fs/fcntl.c(p->uid != current->uid) &&
p151fs/fcntl.c(p->euid != current->euid) &&
p256fs/hpfs/hpfs_fs.cstatic unsigned choose_conv(unsigned char *p, unsigned len);
p534fs/hpfs/hpfs_fs.cunsigned char *p = addr;
p535fs/hpfs/hpfs_fs.creturn p[0] == 0 && memcmp(p, p + 1, len - 1) == 0;
p545fs/hpfs/hpfs_fs.cchar *p, *rhs;
p556fs/hpfs/hpfs_fs.cfor (p = strtok(opts, ","); p != 0; p = strtok(0, ",")) {
p557fs/hpfs/hpfs_fs.cif ((rhs = strchr(p, '=')) != 0)
p559fs/hpfs/hpfs_fs.cif (!strcmp(p, "uid")) {
p566fs/hpfs/hpfs_fs.celse if (!strcmp(p, "gid")) {
p573fs/hpfs/hpfs_fs.celse if (!strcmp(p, "umask")) {
p580fs/hpfs/hpfs_fs.celse if (!strcmp(p, "case")) {
p588fs/hpfs/hpfs_fs.celse if (!strcmp(p, "conv")) {
p947fs/hpfs/hpfs_fs.cstatic unsigned choose_conv(unsigned char *p, unsigned len)
p955fs/hpfs/hpfs_fs.cc = *p++;
p957fs/hpfs/hpfs_fs.cif (c == '\r' && len && *p == '\n')
p290fs/isofs/rock.c{ int p;
p291fs/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;
p230fs/minix/file.cp = (pos % BLOCK_SIZE) + bh->b_data;
p233fs/minix/file.cmemcpy_fromfs(p,buf,c);
p278fs/minix/inode.cunsigned short *p;
p281fs/minix/inode.cp = inode->u.minix_i.i_data + nr;
p283fs/minix/inode.ctmp = *p;
p286fs/minix/inode.cif (tmp == *p)
p297fs/minix/inode.cif (*p) {
p302fs/minix/inode.c*p = tmp;
p312fs/minix/inode.cunsigned short *p;
p325fs/minix/inode.cp = nr + (unsigned short *) bh->b_data;
p327fs/minix/inode.ctmp = *p;
p330fs/minix/inode.cif (tmp == *p) {
p347fs/minix/inode.cif (*p) {
p352fs/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;
p129fs/namei.cstruct task_struct ** p;
p132fs/namei.cfor (p = &LAST_TASK ; p > &FIRST_TASK ; --p) {
p134fs/namei.cif (!*p)
p136fs/namei.cfor(mpnt = (*p)->mm->mmap; mpnt; mpnt = mpnt->vm_next) {
p66fs/nfs/proc.cstatic int *nfs_rpc_header(int *p, int procedure, int ruid);
p67fs/nfs/proc.cstatic int *nfs_rpc_verify(int *p);
p88fs/nfs/proc.cstatic inline void nfs_rpc_free(int *p)
p90fs/nfs/proc.ckfree((void *)p);
p100fs/nfs/proc.cstatic inline int *xdr_encode_fhandle(int *p, struct nfs_fh *fhandle)
p102fs/nfs/proc.c*((struct nfs_fh *) p) = *fhandle;
p103fs/nfs/proc.creturn p + QUADLEN(sizeof(*fhandle));
p106fs/nfs/proc.cstatic inline int *xdr_decode_fhandle(int *p, struct nfs_fh *fhandle)
p108fs/nfs/proc.c*fhandle = *((struct nfs_fh *) p);
p109fs/nfs/proc.creturn p + QUADLEN(sizeof(*fhandle));
p112fs/nfs/proc.cstatic inline int *xdr_encode_string(int *p, const char *string)
p117fs/nfs/proc.cp[quadlen] = 0;
p118fs/nfs/proc.c*p++ = htonl(len);
p119fs/nfs/proc.cmemcpy(p, string, len);
p120fs/nfs/proc.creturn p + quadlen;
p123fs/nfs/proc.cstatic inline int *xdr_decode_string(int *p, char *string, unsigned int maxlen)
p125fs/nfs/proc.cunsigned int len = ntohl(*p++);
p128fs/nfs/proc.cmemcpy(string, p, len);
p130fs/nfs/proc.creturn p + QUADLEN(len);
p133fs/nfs/proc.cstatic inline int *xdr_decode_string2(int *p, char **string, unsigned int *len,
p136fs/nfs/proc.c*len = ntohl(*p++);
p139fs/nfs/proc.c*string = (char *) p;
p140fs/nfs/proc.creturn p + QUADLEN(*len);
p144fs/nfs/proc.cstatic inline int *xdr_encode_data(int *p, char *data, int len)
p148fs/nfs/proc.cp[quadlen] = 0;
p149fs/nfs/proc.c*p++ = htonl(len);
p150fs/nfs/proc.cmemcpy_fromfs(p, data, len);
p151fs/nfs/proc.creturn p + quadlen;
p154fs/nfs/proc.cstatic inline int *xdr_decode_data(int *p, char *data, int *lenp, int maxlen,
p157fs/nfs/proc.cunsigned len = *lenp = ntohl(*p++);
p161fs/nfs/proc.cmemcpy_tofs(data, p, len);
p163fs/nfs/proc.cmemcpy(data, p, len);
p164fs/nfs/proc.creturn p + QUADLEN(len);
p167fs/nfs/proc.cstatic int *xdr_decode_fattr(int *p, struct nfs_fattr *fattr)
p169fs/nfs/proc.cfattr->type = (enum nfs_ftype) ntohl(*p++);
p170fs/nfs/proc.cfattr->mode = ntohl(*p++);
p171fs/nfs/proc.cfattr->nlink = ntohl(*p++);
p172fs/nfs/proc.cfattr->uid = ntohl(*p++);
p173fs/nfs/proc.cfattr->gid = ntohl(*p++);
p174fs/nfs/proc.cfattr->size = ntohl(*p++);
p175fs/nfs/proc.cfattr->blocksize = ntohl(*p++);
p176fs/nfs/proc.cfattr->rdev = ntohl(*p++);
p177fs/nfs/proc.cfattr->blocks = ntohl(*p++);
p178fs/nfs/proc.cfattr->fsid = ntohl(*p++);
p179fs/nfs/proc.cfattr->fileid = ntohl(*p++);
p180fs/nfs/proc.cfattr->atime.seconds = ntohl(*p++);
p181fs/nfs/proc.cfattr->atime.useconds = ntohl(*p++);
p182fs/nfs/proc.cfattr->mtime.seconds = ntohl(*p++);
p183fs/nfs/proc.cfattr->mtime.useconds = ntohl(*p++);
p184fs/nfs/proc.cfattr->ctime.seconds = ntohl(*p++);
p185fs/nfs/proc.cfattr->ctime.useconds = ntohl(*p++);
p186fs/nfs/proc.creturn p;
p189fs/nfs/proc.cstatic int *xdr_encode_sattr(int *p, struct nfs_sattr *sattr)
p191fs/nfs/proc.c*p++ = htonl(sattr->mode);
p192fs/nfs/proc.c*p++ = htonl(sattr->uid);
p193fs/nfs/proc.c*p++ = htonl(sattr->gid);
p194fs/nfs/proc.c*p++ = htonl(sattr->size);
p195fs/nfs/proc.c*p++ = htonl(sattr->atime.seconds);
p196fs/nfs/proc.c*p++ = htonl(sattr->atime.useconds);
p197fs/nfs/proc.c*p++ = htonl(sattr->mtime.seconds);
p198fs/nfs/proc.c*p++ = htonl(sattr->mtime.useconds);
p199fs/nfs/proc.creturn p;
p202fs/nfs/proc.cstatic int *xdr_decode_entry(int *p, struct nfs_entry *entry)
p204fs/nfs/proc.centry->fileid = ntohl(*p++);
p205fs/nfs/proc.cif (!(p = xdr_decode_string(p, entry->name, NFS_MAXNAMLEN)))
p207fs/nfs/proc.centry->cookie = ntohl(*p++);
p209fs/nfs/proc.creturn p;
p212fs/nfs/proc.cstatic int *xdr_decode_fsinfo(int *p, struct nfs_fsinfo *res)
p214fs/nfs/proc.cres->tsize = ntohl(*p++);
p215fs/nfs/proc.cres->bsize = ntohl(*p++);
p216fs/nfs/proc.cres->blocks = ntohl(*p++);
p217fs/nfs/proc.cres->bfree = ntohl(*p++);
p218fs/nfs/proc.cres->bavail = ntohl(*p++);
p219fs/nfs/proc.creturn p;
p229fs/nfs/proc.cint *p, *p0;
p237fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_GETATTR, ruid);
p238fs/nfs/proc.cp = xdr_encode_fhandle(p, fhandle);
p239fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->rsize)) < 0) {
p243fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p245fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p246fs/nfs/proc.cp = xdr_decode_fattr(p, fattr);
p265fs/nfs/proc.cint *p, *p0;
p273fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_SETATTR, ruid);
p274fs/nfs/proc.cp = xdr_encode_fhandle(p, fhandle);
p275fs/nfs/proc.cp = xdr_encode_sattr(p, sattr);
p276fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
p280fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p282fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p283fs/nfs/proc.cp = xdr_decode_fattr(p, fattr);
p302fs/nfs/proc.cint *p, *p0;
p314fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_LOOKUP, ruid);
p315fs/nfs/proc.cp = xdr_encode_fhandle(p, dir);
p316fs/nfs/proc.cp = xdr_encode_string(p, name);
p317fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->rsize)) < 0) {
p321fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p323fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p324fs/nfs/proc.cp = xdr_decode_fhandle(p, fhandle);
p325fs/nfs/proc.cp = xdr_decode_fattr(p, fattr);
p344fs/nfs/proc.cint *p;
p351fs/nfs/proc.cp = nfs_rpc_header(*p0, NFSPROC_READLINK, ruid);
p352fs/nfs/proc.cp = xdr_encode_fhandle(p, fhandle);
p353fs/nfs/proc.cif ((status = nfs_rpc_call(server, *p0, p, server->rsize)) < 0)
p355fs/nfs/proc.cif (!(p = nfs_rpc_verify(*p0)))
p357fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p358fs/nfs/proc.cif (!(p = xdr_decode_string2(p, string, len, maxlen))) {
p379fs/nfs/proc.cint *p, *p0;
p388fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_READ, ruid);
p389fs/nfs/proc.cp = xdr_encode_fhandle(p, fhandle);
p390fs/nfs/proc.c*p++ = htonl(offset);
p391fs/nfs/proc.c*p++ = htonl(count);
p392fs/nfs/proc.c*p++ = htonl(count); /* traditional, could be any value */
p393fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->rsize)) < 0) {
p397fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p399fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p400fs/nfs/proc.cp = xdr_decode_fattr(p, fattr);
p401fs/nfs/proc.cif (!(p = xdr_decode_data(p, data, &len, count, fs))) {
p425fs/nfs/proc.cint *p, *p0;
p433fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_WRITE, ruid);
p434fs/nfs/proc.cp = xdr_encode_fhandle(p, fhandle);
p435fs/nfs/proc.c*p++ = htonl(offset); /* traditional, could be any value */
p436fs/nfs/proc.c*p++ = htonl(offset);
p437fs/nfs/proc.c*p++ = htonl(count); /* traditional, could be any value */
p438fs/nfs/proc.cp = xdr_encode_data(p, data, count);
p439fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
p443fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p445fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p446fs/nfs/proc.cp = xdr_decode_fattr(p, fattr);
p466fs/nfs/proc.cint *p, *p0;
p474fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_CREATE, ruid);
p475fs/nfs/proc.cp = xdr_encode_fhandle(p, dir);
p476fs/nfs/proc.cp = xdr_encode_string(p, name);
p477fs/nfs/proc.cp = xdr_encode_sattr(p, sattr);
p478fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
p482fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p484fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p485fs/nfs/proc.cp = xdr_decode_fhandle(p, fhandle);
p486fs/nfs/proc.cp = xdr_decode_fattr(p, fattr);
p504fs/nfs/proc.cint *p, *p0;
p512fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_REMOVE, ruid);
p513fs/nfs/proc.cp = xdr_encode_fhandle(p, dir);
p514fs/nfs/proc.cp = xdr_encode_string(p, name);
p515fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
p519fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p521fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p541fs/nfs/proc.cint *p, *p0;
p549fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_RENAME, ruid);
p550fs/nfs/proc.cp = xdr_encode_fhandle(p, old_dir);
p551fs/nfs/proc.cp = xdr_encode_string(p, old_name);
p552fs/nfs/proc.cp = xdr_encode_fhandle(p, new_dir);
p553fs/nfs/proc.cp = xdr_encode_string(p, new_name);
p554fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
p558fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p560fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p579fs/nfs/proc.cint *p, *p0;
p587fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_LINK, ruid);
p588fs/nfs/proc.cp = xdr_encode_fhandle(p, fhandle);
p589fs/nfs/proc.cp = xdr_encode_fhandle(p, dir);
p590fs/nfs/proc.cp = xdr_encode_string(p, name);
p591fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
p595fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p597fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p616fs/nfs/proc.cint *p, *p0;
p624fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_SYMLINK, ruid);
p625fs/nfs/proc.cp = xdr_encode_fhandle(p, dir);
p626fs/nfs/proc.cp = xdr_encode_string(p, name);
p627fs/nfs/proc.cp = xdr_encode_string(p, path);
p628fs/nfs/proc.cp = xdr_encode_sattr(p, sattr);
p629fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
p633fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p635fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p655fs/nfs/proc.cint *p, *p0;
p663fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_MKDIR, ruid);
p664fs/nfs/proc.cp = xdr_encode_fhandle(p, dir);
p665fs/nfs/proc.cp = xdr_encode_string(p, name);
p666fs/nfs/proc.cp = xdr_encode_sattr(p, sattr);
p667fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
p671fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p673fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p674fs/nfs/proc.cp = xdr_decode_fhandle(p, fhandle);
p675fs/nfs/proc.cp = xdr_decode_fattr(p, fattr);
p693fs/nfs/proc.cint *p, *p0;
p701fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_RMDIR, ruid);
p702fs/nfs/proc.cp = xdr_encode_fhandle(p, dir);
p703fs/nfs/proc.cp = xdr_encode_string(p, name);
p704fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
p708fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p710fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p729fs/nfs/proc.cint *p, *p0;
p741fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_READDIR, ruid);
p742fs/nfs/proc.cp = xdr_encode_fhandle(p, fhandle);
p743fs/nfs/proc.c*p++ = htonl(cookie);
p744fs/nfs/proc.c*p++ = htonl(size);
p745fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->rsize)) < 0) {
p749fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p751fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p752fs/nfs/proc.cfor (i = 0; i < count && *p++; i++) {
p753fs/nfs/proc.cif (!(p = xdr_decode_entry(p, entry++)))
p756fs/nfs/proc.cif (!p) {
p761fs/nfs/proc.ceof = (i == count && !*p++ && *p++)
p762fs/nfs/proc.c|| (i < count && *p++);
p785fs/nfs/proc.cint *p, *p0;
p793fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_STATFS, ruid);
p794fs/nfs/proc.cp = xdr_encode_fhandle(p, fhandle);
p795fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->rsize)) < 0) {
p799fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p801fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p802fs/nfs/proc.cp = xdr_decode_fsinfo(p, res);
p822fs/nfs/proc.cstatic int *nfs_rpc_header(int *p, int procedure, int ruid)
p833fs/nfs/proc.c*p++ = htonl(++xid);
p834fs/nfs/proc.c*p++ = htonl(RPC_CALL);
p835fs/nfs/proc.c*p++ = htonl(RPC_VERSION);
p836fs/nfs/proc.c*p++ = htonl(NFS_PROGRAM);
p837fs/nfs/proc.c*p++ = htonl(NFS_VERSION);
p838fs/nfs/proc.c*p++ = htonl(procedure);
p839fs/nfs/proc.c*p++ = htonl(RPC_AUTH_UNIX);
p840fs/nfs/proc.cp1 = p++;
p841fs/nfs/proc.c*p++ = htonl(CURRENT_TIME); /* traditional, could be anything */
p842fs/nfs/proc.cp = xdr_encode_string(p, (char *) sys);
p843fs/nfs/proc.c*p++ = htonl(ruid ? current->uid : current->fsuid);
p844fs/nfs/proc.c*p++ = htonl(current->egid);
p845fs/nfs/proc.cp2 = p++;
p847fs/nfs/proc.c*p++ = htonl(current->groups[i]);
p849fs/nfs/proc.c*p1 = htonl((p - (p1 + 1)) << 2);
p850fs/nfs/proc.c*p++ = htonl(RPC_AUTH_NULL);
p851fs/nfs/proc.c*p++ = htonl(0);
p852fs/nfs/proc.creturn p;
p855fs/nfs/proc.cstatic int *nfs_rpc_verify(int *p)
p859fs/nfs/proc.cp++;
p860fs/nfs/proc.cif ((n = ntohl(*p++)) != RPC_REPLY) {
p864fs/nfs/proc.cif ((n = ntohl(*p++)) != RPC_MSG_ACCEPTED) {
p868fs/nfs/proc.cswitch (n = ntohl(*p++)) {
p875fs/nfs/proc.cif ((n = ntohl(*p++)) > 400) {
p879fs/nfs/proc.cp += QUADLEN(n);
p880fs/nfs/proc.cif ((n = ntohl(*p++)) != RPC_SUCCESS) {
p884fs/nfs/proc.creturn p;
p42fs/proc/array.cunsigned long p = file->f_pos;
p54fs/proc/array.cif (p >= high_memory + PAGE_SIZE)
p56fs/proc/array.cif (count > high_memory + PAGE_SIZE - p)
p57fs/proc/array.ccount = high_memory + PAGE_SIZE - p;
p60fs/proc/array.cif (p < sizeof(struct user) && count > 0) {
p62fs/proc/array.cif (p + count1 > sizeof(struct user))
p63fs/proc/array.ccount1 = sizeof(struct user)-p;
p64fs/proc/array.cpnt = (char *) &dump + p;
p67fs/proc/array.cp += count1;
p72fs/proc/array.cwhile (p < 2*PAGE_SIZE && count > 0) {
p75fs/proc/array.cp++;
p79fs/proc/array.cmemcpy_tofs(buf,(void *) (p - PAGE_SIZE),count);
p181fs/proc/array.cstruct task_struct ** p;
p183fs/proc/array.cp = task;
p184fs/proc/array.cwhile (++p < task+NR_TASKS) {
p185fs/proc/array.cif (*p && (*p)->pid == pid)
p186fs/proc/array.creturn p;
p191fs/proc/array.cstatic unsigned long get_phys_addr(struct task_struct ** p, unsigned long ptr)
p195fs/proc/array.cif (!p || !*p || ptr >= TASK_SIZE)
p197fs/proc/array.cpage = *PAGE_DIR_OFFSET((*p)->tss.cr3,ptr);
p210fs/proc/array.cstatic int get_array(struct task_struct ** p, unsigned long start, unsigned long end, char * buffer)
p219fs/proc/array.caddr = get_phys_addr(p, start);
p245fs/proc/array.cstruct task_struct ** p = get_task(pid);
p247fs/proc/array.cif (!p || !*p)
p249fs/proc/array.creturn get_array(p, (*p)->mm->env_start, (*p)->mm->env_end, buffer);
p254fs/proc/array.cstruct task_struct ** p = get_task(pid);
p256fs/proc/array.cif (!p || !*p)
p258fs/proc/array.creturn get_array(p, (*p)->mm->arg_start, (*p)->mm->arg_end, buffer);
p261fs/proc/array.cstatic unsigned long get_wchan(struct task_struct *p)
p267fs/proc/array.cif (!p || p == current || p->state == TASK_RUNNING)
p269fs/proc/array.cstack_page = p->kernel_stack_page;
p272fs/proc/array.cebp = p->tss.ebp;
p290fs/proc/array.cstruct task_struct ** p = get_task(pid);
p296fs/proc/array.cif (!p || !*p)
p298fs/proc/array.cif ((*p)->state < 0 || (*p)->state > 5)
p301fs/proc/array.cstate = "RSDZTD"[(*p)->state];
p303fs/proc/array.cvsize = (*p)->kernel_stack_page;
p307fs/proc/array.cvsize = (*p)->mm->brk - (*p)->mm->start_code + PAGE_SIZE-1;
p311fs/proc/array.cwchan = get_wchan(*p);
p313fs/proc/array.cswitch((int) (*p)->sigaction[i].sa_handler) {
p319fs/proc/array.cif ((*p)->tty)
p320fs/proc/array.ctty_pgrp = (*p)->tty->pgrp;
p327fs/proc/array.c(*p)->comm,
p329fs/proc/array.c(*p)->p_pptr->pid,
p330fs/proc/array.c(*p)->pgrp,
p331fs/proc/array.c(*p)->session,
p332fs/proc/array.c(*p)->tty ? (*p)->tty->device : 0,
p334fs/proc/array.c(*p)->flags,
p335fs/proc/array.c(*p)->mm->min_flt,
p336fs/proc/array.c(*p)->mm->cmin_flt,
p337fs/proc/array.c(*p)->mm->maj_flt,
p338fs/proc/array.c(*p)->mm->cmaj_flt,
p339fs/proc/array.c(*p)->utime,
p340fs/proc/array.c(*p)->stime,
p341fs/proc/array.c(*p)->cutime,
p342fs/proc/array.c(*p)->cstime,
p343fs/proc/array.c(*p)->counter,  /* this is the kernel priority ---
p345fs/proc/array.c(*p)->priority, /* this is the nice value ---
p347fs/proc/array.c(*p)->timeout,
p348fs/proc/array.c(*p)->it_real_value,
p349fs/proc/array.c(*p)->start_time,
p351fs/proc/array.c(*p)->mm->rss, /* you might want to shift this left 3 */
p352fs/proc/array.c(*p)->rlim[RLIMIT_RSS].rlim_cur,
p353fs/proc/array.c(*p)->mm->start_code,
p354fs/proc/array.c(*p)->mm->end_code,
p355fs/proc/array.c(*p)->mm->start_stack,
p358fs/proc/array.c(*p)->signal,
p359fs/proc/array.c(*p)->blocked,
p367fs/proc/array.cstruct task_struct ** p = get_task(pid);
p372fs/proc/array.cif (!p || !*p)
p374fs/proc/array.ctpag = (*p)->mm->end_code / PAGE_SIZE;
p375fs/proc/array.cif ((*p)->state != TASK_ZOMBIE) {
p376fs/proc/array.cpagedir = (unsigned long *) (*p)->tss.cr3;
p415fs/proc/array.cstruct task_struct **p = get_task(pid);
p418fs/proc/array.cif (!p || !*p)
p421fs/proc/array.cfor(map = (*p)->mm->mmap; map != NULL; map = map->vm_next) {
p57fs/proc/fd.cstruct task_struct * p;
p102fs/proc/fd.cif ((p = task[i]) && p->pid == pid)
p107fs/proc/fd.cif (fd >= NR_OPEN || !p->files->fd[fd] || !p->files->fd[fd]->f_inode)
p120fs/proc/fd.cstruct task_struct * p;
p149fs/proc/fd.cif ((p = task[i]) && p->pid == pid)
p156fs/proc/fd.cif (!p->files->fd[fd] || !p->files->fd[fd]->f_inode)
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)
p138fs/proc/inode.cinode->i_uid = p->euid;
p139fs/proc/inode.cinode->i_gid = p->egid;
p174fs/proc/inode.cif (ino >= NR_OPEN || !p->files->fd[ino])
p179fs/proc/inode.cif (p->files->fd[ino]->f_mode & 1)
p181fs/proc/inode.cif (p->files->fd[ino]->f_mode & 2)
p69fs/proc/link.cstruct task_struct * p;
p83fs/proc/link.cif ((p = task[i]) && p->pid == pid)
p87fs/proc/link.c((ino >> 8) != 1) || !(new_f = p->files->fd[ino & 0x0ff]))
p104fs/proc/link.cstruct task_struct * p;
p121fs/proc/link.cif ((p = task[i]) && p->pid == pid)
p130fs/proc/link.cnew_inode = p->fs->pwd;
p133fs/proc/link.cnew_inode = p->fs->root;
p136fs/proc/link.cstruct vm_area_struct * vma = p->mm->mmap;
p150fs/proc/link.cif (ino < NR_OPEN && p->files->fd[ino]) {
p157fs/proc/link.cnew_inode = p->files->fd[ino]->f_inode;
p139fs/proc/root.cstruct task_struct * p;
p164fs/proc/root.cp = task[nr];
p165fs/proc/root.cif (!p || !(pid = p->pid))
p47fs/select.cstatic void free_wait(select_table * p)
p49fs/select.cstruct select_table_entry * entry = p->entry + p->nr;
p51fs/select.cwhile (p->nr > 0) {
p52fs/select.cp->nr--;
p203fs/sysv/file.cchar * p;
p246fs/sysv/file.cp = (pos & sb->sv_block_size_1) + bh->b_data;
p253fs/sysv/file.cmemcpy_fromfs(p,buf,c);
p624fs/sysv/inode.cunsigned long *p;
p628fs/sysv/inode.cp = inode->u.sysv_i.i_data + nr;
p630fs/sysv/inode.ctmp = *p;
p633fs/sysv/inode.cif (tmp == *p)
p644fs/sysv/inode.cif (*p) {
p649fs/sysv/inode.c*p = tmp;
p660fs/sysv/inode.csysv_zone_t *p;
p674fs/sysv/inode.cp = nr + (sysv_zone_t *) bh->b_data;
p676fs/sysv/inode.cblock = tmp = *p;
p681fs/sysv/inode.cif (tmp == *p) {
p698fs/sysv/inode.cif (*p) {
p703fs/sysv/inode.c*p = (sb->sv_convert ? to_coh_ulong(block) : block);
p758fs/sysv/inode.cstatic inline unsigned long read3byte (char * p)
p760fs/sysv/inode.creturn (unsigned long)(*(unsigned short *)p)
p761fs/sysv/inode.c| (unsigned long)(*(unsigned char *)(p+2)) << 16;
p764fs/sysv/inode.cstatic inline void write3byte (char * p, unsigned long val)
p766fs/sysv/inode.c*(unsigned short *)p = (unsigned short) val;
p767fs/sysv/inode.c*(unsigned char *)(p+2) = val >> 16;
p770fs/sysv/inode.cstatic inline unsigned long coh_read3byte (char * p)
p772fs/sysv/inode.creturn (unsigned long)(*(unsigned char *)p) << 16
p773fs/sysv/inode.c| (unsigned long)(*(unsigned short *)(p+1));
p776fs/sysv/inode.cstatic inline void coh_write3byte (char * p, unsigned long val)
p778fs/sysv/inode.c*(unsigned char *)p = val >> 16;
p779fs/sysv/inode.c*(unsigned short *)(p+1) = (unsigned short) val;
p44fs/sysv/truncate.cunsigned long * p;
p52fs/sysv/truncate.cp = inode->u.sysv_i.i_data + i;
p53fs/sysv/truncate.cblock = *p;
p61fs/sysv/truncate.cif ((bh && bh->b_count != 1) || (block != *p)) {
p66fs/sysv/truncate.c*p = 0;
p74fs/sysv/truncate.cstatic int trunc_indirect(struct inode * inode, unsigned long offset, unsigned long * p, int convert, unsigned char * dirt)
p85fs/sysv/truncate.cindblock = indtmp = *p;
p92fs/sysv/truncate.cif (indtmp != *p) {
p97fs/sysv/truncate.c*p = 0;
p131fs/sysv/truncate.cif ((indbh->b_count != 1) || (indtmp != *p)) {
p135fs/sysv/truncate.c*p = 0;
p143fs/sysv/truncate.cstatic int trunc_dindirect(struct inode * inode, unsigned long offset, unsigned long * p, int convert, unsigned char * dirt)
p153fs/sysv/truncate.cindblock = indtmp = *p;
p160fs/sysv/truncate.cif (indtmp != *p) {
p165fs/sysv/truncate.c*p = 0;
p185fs/sysv/truncate.cif ((indbh->b_count != 1) || (indtmp != *p)) {
p189fs/sysv/truncate.c*p = 0;
p197fs/sysv/truncate.cstatic int trunc_tindirect(struct inode * inode, unsigned long offset, unsigned long * p, int convert, unsigned char * dirt)
p207fs/sysv/truncate.cindblock = indtmp = *p;
p214fs/sysv/truncate.cif (indtmp != *p) {
p219fs/sysv/truncate.c*p = 0;
p239fs/sysv/truncate.cif ((indbh->b_count != 1) || (indtmp != *p)) {
p243fs/sysv/truncate.c*p = 0;
p240fs/umsdos/inode.c|| inode->u.umsdos_i.u.dir_info.p != NULL)){
p244fs/umsdos/inode.c,inode->u.umsdos_i.u.dir_info.p));
p36fs/umsdos/namei.csleep_on(&dir->u.umsdos_i.u.dir_info.p);
p47fs/umsdos/namei.csleep_on(&dir->u.umsdos_i.u.dir_info.p);
p137fs/umsdos/namei.cwake_up (&dir->u.umsdos_i.u.dir_info.p);
p149fs/umsdos/namei.cwake_up (&dir->u.umsdos_i.u.dir_info.p);
p449ibcs/binfmt_coff.cbprm->p += change_ldt (0, bprm->page);
p450ibcs/binfmt_coff.cbprm->p -= MAX_ARG_PAGES*PAGE_SIZE;
p451ibcs/binfmt_coff.cbprm->p  = (unsigned long) create_tables ((char *) bprm->p,
p471ibcs/binfmt_coff.ccurrent->mm->start_stack = bprm->p;
p57ibcs/binfmt_elf.cunsigned long * create_elf_tables(char * p,int argc,int envc,struct elfhdr * exec, unsigned int load_addr, int ibcs)
p66ibcs/binfmt_elf.cmpnt->vm_start = PAGE_MASK & (unsigned long) p;
p76ibcs/binfmt_elf.csp = (unsigned long *) (0xfffffffc & (unsigned long) p);
p105ibcs/binfmt_elf.ccurrent->mm->arg_start = (unsigned long) p;
p107ibcs/binfmt_elf.cput_fs_long((unsigned long) p,argv++);
p108ibcs/binfmt_elf.cwhile (get_fs_byte(p++)) /* nothing */ ;
p111ibcs/binfmt_elf.ccurrent->mm->arg_end = current->mm->env_start = (unsigned long) p;
p113ibcs/binfmt_elf.cput_fs_long((unsigned long) p,envp++);
p114ibcs/binfmt_elf.cwhile (get_fs_byte(p++)) /* nothing */ ;
p117ibcs/binfmt_elf.ccurrent->mm->env_end = (unsigned long) p;
p411ibcs/binfmt_elf.cbprm->p = copy_strings(1,&passed_p,bprm->page,bprm->p,2);
p415ibcs/binfmt_elf.cif (!bprm->p) {
p436ibcs/binfmt_elf.cbprm->p += change_ldt(0, bprm->page);
p437ibcs/binfmt_elf.ccurrent->mm->start_stack = bprm->p;
p521ibcs/binfmt_elf.ccurrent->start_stack = p = elf_stack - 4;
p523ibcs/binfmt_elf.cbprm->p -= MAX_ARG_PAGES*PAGE_SIZE;
p524ibcs/binfmt_elf.cbprm->p = (unsigned long) 
p525ibcs/binfmt_elf.ccreate_elf_tables((char *)bprm->p,
p537ibcs/binfmt_elf.ccurrent->mm->start_stack = bprm->p;
p556ibcs/binfmt_elf.cregs->esp = bprm->p;      /* stack pointer */
p119include/asm-alpha/bitops.hunsigned long * p = ((unsigned long *) addr) + (offset >> 6);
p128include/asm-alpha/bitops.htmp = *(p++);
p138include/asm-alpha/bitops.hif (~(tmp = *(p++)))
p145include/asm-alpha/bitops.htmp = *p;
p124include/asm-generic/string.hconst char *p;
p128include/asm-generic/string.hfor (p = s; *p != '\0'; ++p)
p131include/asm-generic/string.hif (*p == *a)
p97include/asm-i386/bitops.hunsigned long * p = ((unsigned long *) addr) + (offset >> 5);
p110include/asm-i386/bitops.h: "r" (~(*p >> bit)));
p114include/asm-i386/bitops.hp++;
p119include/asm-i386/bitops.hres = find_first_zero_bit (p, size - 32 * (p - (unsigned long *) addr));
p19include/linux/binfmts.hunsigned long p;
p49include/linux/binfmts.hextern unsigned long * create_tables(char * p,int argc,int envc,int ibcs);
p51include/linux/binfmts.hunsigned long p, int from_kmem);
p367include/linux/sched.hextern void sleep_on(struct wait_queue ** p);
p368include/linux/sched.hextern void interruptible_sleep_on(struct wait_queue ** p);
p369include/linux/sched.hextern void wake_up(struct wait_queue ** p);
p370include/linux/sched.hextern void wake_up_interruptible(struct wait_queue ** p);
p373include/linux/sched.hextern int send_sig(unsigned long sig,struct task_struct * p,int priv);
p457include/linux/sched.hextern inline void add_wait_queue(struct wait_queue ** p, struct wait_queue * wait)
p471include/linux/sched.hif (!*p) {
p473include/linux/sched.h*p = wait;
p475include/linux/sched.hwait->next = (*p)->next;
p476include/linux/sched.h(*p)->next = wait;
p481include/linux/sched.hextern inline void remove_wait_queue(struct wait_queue ** p, struct wait_queue * wait)
p491include/linux/sched.hif ((*p == wait) &&
p495include/linux/sched.h((*p = wait->next) == wait)) {
p496include/linux/sched.h*p = NULL;
p502include/linux/sched.hif (tmp == *p)
p513include/linux/sched.hprintk("list = %08x, queue = %08x\n",(unsigned long) p, (unsigned long) wait);
p520include/linux/sched.hextern inline void select_wait(struct wait_queue ** wait_address, select_table * p)
p524include/linux/sched.hif (!p || !wait_address)
p526include/linux/sched.hif (p->nr >= __MAX_SELECT_TABLE_ENTRIES)
p528include/linux/sched.hentry = p->entry + p->nr;
p533include/linux/sched.hp->nr++;
p578include/linux/sched.h#define REMOVE_LINKS(p) do { unsigned long flags; \
p580include/linux/sched.h(p)->next_task->prev_task = (p)->prev_task; \
p581include/linux/sched.h(p)->prev_task->next_task = (p)->next_task; \
p583include/linux/sched.hif ((p)->p_osptr) \
p584include/linux/sched.h(p)->p_osptr->p_ysptr = (p)->p_ysptr; \
p585include/linux/sched.hif ((p)->p_ysptr) \
p586include/linux/sched.h(p)->p_ysptr->p_osptr = (p)->p_osptr; \
p588include/linux/sched.h(p)->p_pptr->p_cptr = (p)->p_osptr; \
p591include/linux/sched.h#define SET_LINKS(p) do { unsigned long flags; \
p593include/linux/sched.h(p)->next_task = &init_task; \
p594include/linux/sched.h(p)->prev_task = init_task.prev_task; \
p595include/linux/sched.hinit_task.prev_task->next_task = (p); \
p596include/linux/sched.hinit_task.prev_task = (p); \
p598include/linux/sched.h(p)->p_ysptr = NULL; \
p599include/linux/sched.hif (((p)->p_osptr = (p)->p_pptr->p_cptr) != NULL) \
p600include/linux/sched.h(p)->p_osptr->p_ysptr = p; \
p601include/linux/sched.h(p)->p_pptr->p_cptr = p; \
p604include/linux/sched.h#define for_each_task(p) \
p605include/linux/sched.hfor (p = &init_task ; (p = p->next_task) != &init_task ; )
p141include/linux/tqueue.hregister struct tq_struct *p;
p146include/linux/tqueue.hp = &tq_last;
p147include/linux/tqueue.h__asm__ __volatile__("xchgl %0,%2" : "=r" (p) :
p148include/linux/tqueue.h"0" (p), "m" (*list) : "memory");
p149include/linux/tqueue.hif(p == &tq_last)
p153include/linux/tqueue.harg    = p -> data;
p154include/linux/tqueue.hf      = p -> routine;
p155include/linux/tqueue.hsave_p = p -> next;
p156include/linux/tqueue.hp -> sync = 0;
p158include/linux/tqueue.hp = save_p;
p159include/linux/tqueue.h} while(p != &tq_last);
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)
p48include/linux/umsdos_fs_i.hstruct wait_queue *p;
p118include/linux/umsdos_fs_i.hstruct wait_queue *p;
p54kernel/dma.cstatic __inline__ unsigned int mutex_atomic_swap(volatile unsigned int * p, unsigned int newval)
p67kernel/dma.c: /* inputs: newval, p */ "0" (semval), "m" (*p)
p24kernel/exit.cstatic int generate(unsigned long sig, struct task_struct * p)
p27kernel/exit.cstruct sigaction * sa = sig + p->sigaction - 1;
p30kernel/exit.cif (p->flags & PF_PTRACED) {
p31kernel/exit.cp->signal |= mask;
p41kernel/exit.cp->signal |= mask;
p45kernel/exit.cint send_sig(unsigned long sig,struct task_struct * p,int priv)
p47kernel/exit.cif (!p || sig > 32)
p49kernel/exit.cif (!priv && ((sig != SIGCONT) || (current->session != p->session)) &&
p50kernel/exit.c(current->euid != p->euid) && (current->uid != p->uid) && !suser())
p57kernel/exit.cif (p->state == TASK_ZOMBIE)
p60kernel/exit.cif (p->state == TASK_STOPPED)
p61kernel/exit.cp->state = TASK_RUNNING;
p62kernel/exit.cp->exit_code = 0;
p63kernel/exit.cp->signal &= ~( (1<<(SIGSTOP-1)) | (1<<(SIGTSTP-1)) |
p68kernel/exit.cp->signal &= ~(1<<(SIGCONT-1));
p70kernel/exit.cgenerate(sig,p);
p82kernel/exit.cvoid release(struct task_struct * p)
p86kernel/exit.cif (!p)
p88kernel/exit.cif (p == current) {
p93kernel/exit.cif (task[i] == p) {
p95kernel/exit.cREMOVE_LINKS(p);
p96kernel/exit.cif (STACK_MAGIC != *(unsigned long *)p->kernel_stack_page)
p97kernel/exit.cprintk(KERN_ALERT "release: %s kernel stack corruption. Aiee\n", p->comm);
p98kernel/exit.cfree_page(p->kernel_stack_page);
p99kernel/exit.cfree_page((long) p);
p110kernel/exit.cint bad_task_ptr(struct task_struct *p)
p114kernel/exit.cif (!p)
p117kernel/exit.cif (task[i] == p)
p205kernel/exit.cstruct task_struct *p;
p209kernel/exit.cfor_each_task(p) {
p210kernel/exit.cif (p->session <= 0)
p212kernel/exit.cif (p->pgrp == pgrp)
p213kernel/exit.creturn p->session;
p214kernel/exit.cif (p->pid == pgrp)
p215kernel/exit.cfallback = p->session;
p226kernel/exit.cstruct task_struct *p;
p232kernel/exit.cfor_each_task(p) {
p233kernel/exit.cif (p->pgrp == pgrp) {
p234kernel/exit.cif ((err = send_sig(sig,p,priv)) != 0)
p250kernel/exit.cstruct task_struct *p;
p256kernel/exit.cfor_each_task(p) {
p257kernel/exit.cif (p->session == sess && p->leader) {
p258kernel/exit.cif ((err = send_sig(sig,p,priv)) != 0)
p269kernel/exit.cstruct task_struct *p;
p273kernel/exit.cfor_each_task(p) {
p274kernel/exit.cif (p && p->pid == pid)
p275kernel/exit.creturn send_sig(sig,p,priv);
p291kernel/exit.cstruct task_struct * p;
p292kernel/exit.cfor_each_task(p) {
p293kernel/exit.cif (p->pid > 1 && p != current) {
p295kernel/exit.cif ((err = send_sig(sig,p,0)) != -EPERM)
p317kernel/exit.cstruct task_struct *p;
p319kernel/exit.cfor_each_task(p) {
p320kernel/exit.cif ((p->pgrp != pgrp) || 
p321kernel/exit.c(p->state == TASK_ZOMBIE) ||
p322kernel/exit.c(p->p_pptr->pid == 1))
p324kernel/exit.cif ((p->p_pptr->pgrp != pgrp) &&
p325kernel/exit.c(p->p_pptr->session == p->session))
p333kernel/exit.cstruct task_struct * p;
p335kernel/exit.cfor_each_task(p) {
p336kernel/exit.cif (p->pgrp != pgrp)
p338kernel/exit.cif (p->state == TASK_STOPPED)
p346kernel/exit.cstruct task_struct * p;
p348kernel/exit.cfor_each_task(p) {
p349kernel/exit.cif (p->p_opptr == father)
p351kernel/exit.cp->p_opptr = task[1];
p353kernel/exit.cp->p_opptr = task[0];
p407kernel/exit.cstruct task_struct *p;
p447kernel/exit.cwhile ((p = current->p_cptr) != NULL) {
p448kernel/exit.ccurrent->p_cptr = p->p_osptr;
p449kernel/exit.cp->p_ysptr = NULL;
p450kernel/exit.cp->flags &= ~(PF_PTRACED|PF_TRACESYS);
p452kernel/exit.cp->p_pptr = task[1];
p454kernel/exit.cp->p_pptr = task[0];
p455kernel/exit.cp->p_osptr = p->p_pptr->p_cptr;
p456kernel/exit.cp->p_osptr->p_ysptr = p;
p457kernel/exit.cp->p_pptr->p_cptr = p;
p458kernel/exit.cif (p->state == TASK_ZOMBIE)
p459kernel/exit.cnotify_parent(p);
p466kernel/exit.cif ((p->pgrp != current->pgrp) &&
p467kernel/exit.c(p->session == current->session) &&
p468kernel/exit.cis_orphaned_pgrp(p->pgrp) &&
p469kernel/exit.chas_stopped_jobs(p->pgrp)) {
p470kernel/exit.ckill_pg(p->pgrp,SIGHUP,1);
p471kernel/exit.ckill_pg(p->pgrp,SIGCONT,1);
p514kernel/exit.cstruct task_struct *p;
p524kernel/exit.cfor (p = current->p_cptr ; p ; p = p->p_osptr) {
p526kernel/exit.cif (p->pid != pid)
p529kernel/exit.cif (p->pgrp != current->pgrp)
p532kernel/exit.cif (p->pgrp != -pid)
p536kernel/exit.cif ((p->exit_signal != SIGCHLD) ^ ((options & __WCLONE) != 0))
p539kernel/exit.cswitch (p->state) {
p541kernel/exit.cif (!p->exit_code)
p543kernel/exit.cif (!(options & WUNTRACED) && !(p->flags & PF_PTRACED))
p546kernel/exit.cput_fs_long((p->exit_code << 8) | 0x7f,
p548kernel/exit.cp->exit_code = 0;
p550kernel/exit.cgetrusage(p, RUSAGE_BOTH, ru);
p551kernel/exit.cretval = p->pid;
p554kernel/exit.ccurrent->cutime += p->utime + p->cutime;
p555kernel/exit.ccurrent->cstime += p->stime + p->cstime;
p556kernel/exit.ccurrent->mm->cmin_flt += p->mm->min_flt + p->mm->cmin_flt;
p557kernel/exit.ccurrent->mm->cmaj_flt += p->mm->maj_flt + p->mm->cmaj_flt;
p559kernel/exit.cgetrusage(p, RUSAGE_BOTH, ru);
p560kernel/exit.cflag = p->pid;
p562kernel/exit.cput_fs_long(p->exit_code, stat_addr);
p563kernel/exit.cif (p->p_opptr != p->p_pptr) {
p564kernel/exit.cREMOVE_LINKS(p);
p565kernel/exit.cp->p_pptr = p->p_opptr;
p566kernel/exit.cSET_LINKS(p);
p567kernel/exit.cnotify_parent(p);
p569kernel/exit.crelease(p);
p92kernel/fork.cstruct vm_area_struct * mpnt, **p, *tmp;
p95kernel/fork.cp = &tsk->mm->mmap;
p112kernel/fork.c*p = tmp;
p113kernel/fork.cp = &tmp->vm_next;
p121kernel/fork.cstatic void copy_files(unsigned long clone_flags, struct task_struct * p)
p128kernel/fork.cif ((f = p->files->fd[i]) != NULL)
p129kernel/fork.cp->files->fd[i] = copy_fd(f);
p132kernel/fork.cif ((f = p->files->fd[i]) != NULL)
p141kernel/fork.cstatic int copy_mm(unsigned long clone_flags, struct task_struct * p)
p144kernel/fork.cp->mm->swappable = 1;
p145kernel/fork.cp->mm->min_flt = p->mm->maj_flt = 0;
p146kernel/fork.cp->mm->cmin_flt = p->mm->cmaj_flt = 0;
p147kernel/fork.cif (copy_page_tables(p))
p149kernel/fork.creturn dup_mmap(p);
p151kernel/fork.cif (clone_page_tables(p))
p153kernel/fork.creturn dup_mmap(p);    /* wrong.. */
p157kernel/fork.cstatic void copy_fs(unsigned long clone_flags, struct task_struct * p)
p175kernel/fork.cstruct task_struct *p;
p179kernel/fork.cif(!(p = (struct task_struct*)__get_free_page(GFP_KERNEL)))
p184kernel/fork.ctask[nr] = p;
p185kernel/fork.c*p = *current;
p187kernel/fork.cif (p->exec_domain && p->exec_domain->use_count)
p188kernel/fork.c(*p->exec_domain->use_count)++;
p189kernel/fork.cif (p->binfmt && p->binfmt->use_count)
p190kernel/fork.c(*p->binfmt->use_count)++;
p192kernel/fork.cp->did_exec = 0;
p193kernel/fork.cp->kernel_stack_page = 0;
p194kernel/fork.cp->state = TASK_UNINTERRUPTIBLE;
p195kernel/fork.cp->flags &= ~(PF_PTRACED|PF_TRACESYS);
p196kernel/fork.cp->pid = last_pid;
p197kernel/fork.cp->p_pptr = p->p_opptr = current;
p198kernel/fork.cp->p_cptr = NULL;
p199kernel/fork.cSET_LINKS(p);
p200kernel/fork.cp->signal = 0;
p201kernel/fork.cp->it_real_value = p->it_virt_value = p->it_prof_value = 0;
p202kernel/fork.cp->it_real_incr = p->it_virt_incr = p->it_prof_incr = 0;
p203kernel/fork.cp->leader = 0;    /* process leadership doesn't inherit */
p204kernel/fork.cp->utime = p->stime = 0;
p205kernel/fork.cp->cutime = p->cstime = 0;
p206kernel/fork.cp->start_time = jiffies;
p210kernel/fork.cif (!(p->kernel_stack_page = get_free_page(GFP_KERNEL)))
p212kernel/fork.c*(unsigned long *)p->kernel_stack_page = STACK_MAGIC;
p213kernel/fork.cp->tss.es = KERNEL_DS;
p214kernel/fork.cp->tss.cs = KERNEL_CS;
p215kernel/fork.cp->tss.ss = KERNEL_DS;
p216kernel/fork.cp->tss.ds = KERNEL_DS;
p217kernel/fork.cp->tss.fs = USER_DS;
p218kernel/fork.cp->tss.gs = KERNEL_DS;
p219kernel/fork.cp->tss.ss0 = KERNEL_DS;
p220kernel/fork.cp->tss.esp0 = p->kernel_stack_page + PAGE_SIZE;
p221kernel/fork.cp->tss.tr = _TSS(nr);
p222kernel/fork.cchildregs = ((struct pt_regs *) (p->kernel_stack_page + PAGE_SIZE)) - 1;
p223kernel/fork.cp->tss.esp = (unsigned long) childregs;
p224kernel/fork.cp->tss.eip = (unsigned long) ret_from_sys_call;
p227kernel/fork.cp->tss.back_link = 0;
p228kernel/fork.cp->tss.eflags = regs.eflags & 0xffffcfff;  /* iopl is always 0 for a new process */
p236kernel/fork.cp->exit_signal = clone_flags & CSIGNAL;
p237kernel/fork.cp->tss.ldt = _LDT(nr);
p238kernel/fork.cif (p->ldt) {
p239kernel/fork.cp->ldt = (struct desc_struct*) vmalloc(LDT_ENTRIES*LDT_ENTRY_SIZE);
p240kernel/fork.cif (p->ldt != NULL)
p241kernel/fork.cmemcpy(p->ldt, current->ldt, LDT_ENTRIES*LDT_ENTRY_SIZE);
p243kernel/fork.cp->tss.bitmap = offsetof(struct tss_struct,io_bitmap);
p245kernel/fork.cp->tss.io_bitmap[i] = ~0;
p247kernel/fork.c__asm__("clts ; fnsave %0 ; frstor %0":"=m" (p->tss.i387));
p248kernel/fork.cif (copy_mm(clone_flags, p))
p250kernel/fork.cp->semundo = NULL;
p251kernel/fork.ccopy_files(clone_flags, p);
p252kernel/fork.ccopy_fs(clone_flags, p);
p253kernel/fork.cset_tss_desc(gdt+(nr<<1)+FIRST_TSS_ENTRY,&(p->tss));
p254kernel/fork.cif (p->ldt)
p255kernel/fork.cset_ldt_desc(gdt+(nr<<1)+FIRST_LDT_ENTRY,p->ldt, 512);
p259kernel/fork.cp->counter = current->counter >> 1;
p260kernel/fork.cp->state = TASK_RUNNING;  /* do this last, just in case */
p261kernel/fork.creturn p->pid;
p264kernel/fork.cREMOVE_LINKS(p);
p265kernel/fork.cfree_page(p->kernel_stack_page);
p267kernel/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++;
p491kernel/module.cchar *p;
p498kernel/module.cp = buf;
p501kernel/module.cif (p - buf > 4096 - 100)
p506kernel/module.c*p++ = *q++;
p514kernel/module.c*p++ = ' ';
p517kernel/module.c*p++ = *q++;
p527kernel/module.c*p++ = *q++;
p530kernel/module.c*p++ = '\t';
p531kernel/module.c*p++ = '[';
p535kernel/module.c*p++ = *q++;
p537kernel/module.c*p++ = ' ';
p539kernel/module.c*p++ = ']';
p541kernel/module.c*p++ = '\n';
p543kernel/module.creturn p - buf;
p555kernel/module.cchar *p = buf;
p564kernel/module.cif (p - buf > 4096 - 100) {
p565kernel/module.cstrcat(p, "...\n");
p566kernel/module.cp += strlen(p);
p567kernel/module.creturn p - buf; /* avoid overflowing buffer */
p571kernel/module.csprintf(p, "%08lx %s\t[%s]\n",
p575kernel/module.csprintf(p, "%08lx %s\n",
p578kernel/module.cp += strlen(p);
p583kernel/module.creturn p - buf;
p145kernel/printk.cchar *msg, *p, *buf_end;
p155kernel/printk.cfor (p = buf + 3; p < buf_end; p++) {
p156kernel/printk.cmsg = p;
p159kernel/printk.cp[0] != '<' ||
p160kernel/printk.cp[1] < '0' || 
p161kernel/printk.cp[1] > '7' ||
p162kernel/printk.cp[2] != '>'
p164kernel/printk.cp -= 3;
p165kernel/printk.cp[0] = '<';
p166kernel/printk.cp[1] = DEFAULT_MESSAGE_LOGLEVEL - 1 + '0';
p167kernel/printk.cp[2] = '>';
p170kernel/printk.cmsg_level = p[1] - '0';
p172kernel/printk.cfor (; p < buf_end; p++) {
p173kernel/printk.clog_buf[(log_start+log_size) & (LOG_BUF_LEN-1)] = *p;
p179kernel/printk.cif (*p == '\n')
p183kernel/printk.cchar tmp = p[1];
p184kernel/printk.cp[1] = '\0';
p186kernel/printk.cp[1] = tmp;
p188kernel/printk.cif (*p == '\n')
p205kernel/printk.cint  p = log_start;
p213kernel/printk.cbuf[j++] = log_buf[p];
p214kernel/printk.cp++; p &= LOG_BUF_LEN-1;
p171kernel/sched.cstruct task_struct * p;
p187kernel/sched.cp = &init_task;
p189kernel/sched.cif ((p = p->next_task) == &init_task)
p191kernel/sched.cif (ticks && p->it_real_value) {
p192kernel/sched.cif (p->it_real_value <= ticks) {
p193kernel/sched.csend_sig(SIGALRM, p, 1);
p194kernel/sched.cif (!p->it_real_incr) {
p195kernel/sched.cp->it_real_value = 0;
p199kernel/sched.cp->it_real_value += p->it_real_incr;
p200kernel/sched.c} while (p->it_real_value <= ticks);
p202kernel/sched.cp->it_real_value -= ticks;
p203kernel/sched.cif (p->it_real_value < itimer_next)
p204kernel/sched.citimer_next = p->it_real_value;
p207kernel/sched.cif (p->state != TASK_INTERRUPTIBLE)
p209kernel/sched.cif (p->signal & ~p->blocked) {
p210kernel/sched.cp->state = TASK_RUNNING;
p213kernel/sched.cif (p->timeout && p->timeout <= jiffies) {
p214kernel/sched.cp->timeout = 0;
p215kernel/sched.cp->state = TASK_RUNNING;
p232kernel/sched.cnext = p = &init_task;
p234kernel/sched.cif ((p = p->next_task) == &init_task)
p236kernel/sched.cif (p->state == TASK_RUNNING && p->counter > c)
p237kernel/sched.cc = p->counter, next = p;
p241kernel/sched.cfor_each_task(p)
p242kernel/sched.cp->counter = (p->counter >> 1) + p->priority;
p276kernel/sched.cstruct task_struct * p;
p281kernel/sched.cif ((p = tmp->task) != NULL) {
p282kernel/sched.cif ((p->state == TASK_UNINTERRUPTIBLE) ||
p283kernel/sched.c(p->state == TASK_INTERRUPTIBLE)) {
p284kernel/sched.cp->state = TASK_RUNNING;
p285kernel/sched.cif (p->counter > current->counter + 3)
p304kernel/sched.cstruct task_struct * p;
p309kernel/sched.cif ((p = tmp->task) != NULL) {
p310kernel/sched.cif (p->state == TASK_INTERRUPTIBLE) {
p311kernel/sched.cp->state = TASK_RUNNING;
p312kernel/sched.cif (p->counter > current->counter + 3)
p341kernel/sched.cstatic inline void __sleep_on(struct wait_queue **p, int state)
p346kernel/sched.cif (!p)
p351kernel/sched.cadd_wait_queue(p, &wait);
p355kernel/sched.cremove_wait_queue(p, &wait);
p359kernel/sched.cvoid interruptible_sleep_on(struct wait_queue **p)
p361kernel/sched.c__sleep_on(p,TASK_INTERRUPTIBLE);
p364kernel/sched.cvoid sleep_on(struct wait_queue **p)
p366kernel/sched.c__sleep_on(p,TASK_UNINTERRUPTIBLE);
p379kernel/sched.cstruct timer_list *p;
p388kernel/sched.cp = &timer_head;
p393kernel/sched.cp = p->next;
p394kernel/sched.c} while (timer->expires > p->expires);
p395kernel/sched.ctimer->next = p;
p396kernel/sched.ctimer->prev = p->prev;
p397kernel/sched.cp->prev = timer;
p406kernel/sched.cstruct timer_list * p;
p408kernel/sched.cp = &timer_head;
p411kernel/sched.cwhile ((p = p->next) != &timer_head) {
p412kernel/sched.cif (p == timer) {
p458kernel/sched.cstruct task_struct **p;
p461kernel/sched.cfor(p = &LAST_TASK; p > &FIRST_TASK; --p)
p462kernel/sched.cif (*p && ((*p)->state == TASK_RUNNING ||
p463kernel/sched.c(*p)->state == TASK_UNINTERRUPTIBLE ||
p464kernel/sched.c(*p)->state == TASK_SWAPPING))
p787kernel/sched.cstatic void show_task(int nr,struct task_struct * p)
p792kernel/sched.cprintk("%-8s %3d ", p->comm, (p == current) ? -nr : nr);
p793kernel/sched.cif (((unsigned) p->state) < sizeof(stat_nam)/sizeof(char *))
p794kernel/sched.cprintk(stat_nam[p->state]);
p797kernel/sched.cif (p == current)
p800kernel/sched.cprintk(" %08lX ", ((unsigned long *)p->tss.esp)[3]);
p802kernel/sched.cif (((unsigned long *)p->kernel_stack_page)[free])
p805kernel/sched.cprintk("%5lu %5d %6d ", free << 2, p->pid, p->p_pptr->pid);
p806kernel/sched.cif (p->p_cptr)
p807kernel/sched.cprintk("%5d ", p->p_cptr->pid);
p810kernel/sched.cif (p->p_ysptr)
p811kernel/sched.cprintk("%7d", p->p_ysptr->pid);
p814kernel/sched.cif (p->p_osptr)
p815kernel/sched.cprintk(" %5d\n", p->p_osptr->pid);
p834kernel/sched.cstruct desc_struct * p;
p844kernel/sched.cp = gdt+2+FIRST_TSS_ENTRY;
p847kernel/sched.cp->a=p->b=0;
p848kernel/sched.cp++;
p849kernel/sched.cp->a=p->b=0;
p850kernel/sched.cp++;
p115kernel/signal.cstruct sigaction *p;
p117kernel/signal.cp = signum - 1 + current->sigaction;
p118kernel/signal.cif (p->sa_handler == SIG_IGN) {
p124kernel/signal.cif (p->sa_handler == SIG_DFL) {
p155kernel/signal.cstruct sigaction new_sa, *p;
p161kernel/signal.cp = signum - 1 + current->sigaction;
p180kernel/signal.cmemcpy_tofs(oldaction, p, sizeof(struct sigaction));
p183kernel/signal.c*p = new_sa;
p58kernel/sys.cstatic int proc_sel(struct task_struct *p, int which, int who)
p62kernel/sys.cif (!who && p == current)
p64kernel/sys.creturn(p->pid == who);
p68kernel/sys.creturn(p->pgrp == who);
p72kernel/sys.creturn(p->uid == who);
p79kernel/sys.cstruct task_struct **p;
p89kernel/sys.cfor(p = &LAST_TASK; p > &FIRST_TASK; --p) {
p90kernel/sys.cif (!*p || !proc_sel(*p, which, who))
p92kernel/sys.cif ((*p)->uid != current->euid &&
p93kernel/sys.c(*p)->uid != current->uid && !suser()) {
p99kernel/sys.cif (priority > (*p)->priority && !suser())
p102kernel/sys.c(*p)->priority = priority;
p109kernel/sys.cstruct task_struct **p;
p115kernel/sys.cfor(p = &LAST_TASK; p > &FIRST_TASK; --p) {
p116kernel/sys.cif (!*p || !proc_sel(*p, which, who))
p118kernel/sys.cif ((*p)->priority > max_prio)
p119kernel/sys.cmax_prio = (*p)->priority;
p476kernel/sys.cstruct task_struct * p;
p484kernel/sys.cfor_each_task(p) {
p485kernel/sys.cif (p->pid == pid)
p491kernel/sys.cif (p->p_pptr == current || p->p_opptr == current) {
p492kernel/sys.cif (p->session != current->session)
p494kernel/sys.cif (p->did_exec)
p496kernel/sys.c} else if (p != current)
p498kernel/sys.cif (p->leader)
p511kernel/sys.cp->pgrp = pgid;
p517kernel/sys.cstruct task_struct * p;
p521kernel/sys.cfor_each_task(p) {
p522kernel/sys.cif (p->pid == pid)
p523kernel/sys.creturn p->pgrp;
p735kernel/sys.cint getrusage(struct task_struct *p, int who, struct rusage *ru)
p746kernel/sys.cr.ru_utime.tv_sec = CT_TO_SECS(p->utime);
p747kernel/sys.cr.ru_utime.tv_usec = CT_TO_USECS(p->utime);
p748kernel/sys.cr.ru_stime.tv_sec = CT_TO_SECS(p->stime);
p749kernel/sys.cr.ru_stime.tv_usec = CT_TO_USECS(p->stime);
p750kernel/sys.cr.ru_minflt = p->mm->min_flt;
p751kernel/sys.cr.ru_majflt = p->mm->maj_flt;
p754kernel/sys.cr.ru_utime.tv_sec = CT_TO_SECS(p->cutime);
p755kernel/sys.cr.ru_utime.tv_usec = CT_TO_USECS(p->cutime);
p756kernel/sys.cr.ru_stime.tv_sec = CT_TO_SECS(p->cstime);
p757kernel/sys.cr.ru_stime.tv_usec = CT_TO_USECS(p->cstime);
p758kernel/sys.cr.ru_minflt = p->mm->cmin_flt;
p759kernel/sys.cr.ru_majflt = p->mm->cmaj_flt;
p762kernel/sys.cr.ru_utime.tv_sec = CT_TO_SECS(p->utime + p->cutime);
p763kernel/sys.cr.ru_utime.tv_usec = CT_TO_USECS(p->utime + p->cutime);
p764kernel/sys.cr.ru_stime.tv_sec = CT_TO_SECS(p->stime + p->cstime);
p765kernel/sys.cr.ru_stime.tv_usec = CT_TO_USECS(p->stime + p->cstime);
p766kernel/sys.cr.ru_minflt = p->mm->min_flt + p->mm->cmin_flt;
p767kernel/sys.cr.ru_majflt = p->mm->maj_flt + p->mm->cmaj_flt;
p36mm/filemap.cint i, *p;
p42mm/filemap.cp = nr;
p44mm/filemap.c*p = bmap(inode,block);
p47mm/filemap.cp++;
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))
p169mm/kmalloc.cstruct block_header *p;
p202mm/kmalloc.c(p    =  page->firstfree))
p204mm/kmalloc.cif (p->bh_flags == MF_FREE)
p206mm/kmalloc.cpage->firstfree = p->bh_next;
p217mm/kmalloc.cp->bh_flags =  MF_USED; /* As of now this block is officially in use */
p218mm/kmalloc.cp->bh_length = size;
p219mm/kmalloc.creturn p+1; /* Pointer arithmetic: increments past header */
p221mm/kmalloc.cprintk ("Problem: block on freelist at %08lx isn't free.\n",(long)p);
p251mm/kmalloc.cfor (i=NBLOCKS(order),p=BH (page+1);i > 1;i--,p=p->bh_next) 
p253mm/kmalloc.cp->bh_flags = MF_FREE;
p254mm/kmalloc.cp->bh_next = BH ( ((long)p)+sz);
p257mm/kmalloc.cp->bh_flags = MF_FREE;
p258mm/kmalloc.cp->bh_next = NULL;
p299mm/kmalloc.cregister struct block_header *p=((struct block_header *)ptr) -1;
p302mm/kmalloc.cpage = PAGE_DESC (p);
p307mm/kmalloc.c(p->bh_flags != MF_USED))
p310mm/kmalloc.cp, page->next, page->order);
p314mm/kmalloc.csize != p->bh_length)
p317mm/kmalloc.cp,size,p->bh_length);
p320mm/kmalloc.csize = p->bh_length;
p321mm/kmalloc.cp->bh_flags = MF_FREE; /* As of now this block is officially free */
p324mm/kmalloc.cp->bh_next = page->firstfree;
p325mm/kmalloc.cpage->firstfree = p;
p79mm/memory.c#define CODE_SPACE(addr,p) ((addr) < (p)->end_code)
p855mm/memory.cunsigned long *p;
p857mm/memory.cp = PAGE_DIR_OFFSET(tsk->tss.cr3,address);
p858mm/memory.cif (PAGE_PRESENT & *p)
p859mm/memory.creturn *p;
p860mm/memory.cif (*p) {
p862mm/memory.c*p = 0;
p865mm/memory.cp = PAGE_DIR_OFFSET(tsk->tss.cr3,address);
p866mm/memory.cif (PAGE_PRESENT & *p) {
p868mm/memory.creturn *p;
p870mm/memory.cif (*p) {
p872mm/memory.c*p = 0;
p875mm/memory.c*p = page | PAGE_TABLE;
p876mm/memory.creturn *p;
p879mm/memory.c*p = BAD_PAGETABLE | PAGE_TABLE;
p367mm/mmap.cstruct vm_area_struct **p, *mpnt, *share;
p370mm/mmap.cp = &t->mm->mmap;
p371mm/mmap.cwhile ((mpnt = *p) != NULL) {
p376mm/mmap.cp = &mpnt->vm_next;
p379mm/mmap.c*p = vmp;
p75mm/swap.cstruct swap_info_struct * p = &swap_info[SWP_TYPE(entry)];
p80mm/swap.cif ((p->flags & SWP_WRITEOK) == SWP_WRITEOK) { 
p114mm/swap.cstruct swap_info_struct * p;
p121mm/swap.cp = &swap_info[type];
p123mm/swap.cif (offset >= p->max) {
p127mm/swap.cif (!(p->flags & SWP_USED)) {
p131mm/swap.cwhile (set_bit(offset,p->swap_lockmap))
p137mm/swap.cif (p->swap_device) {
p138mm/swap.cll_rw_page(rw,p->swap_device,offset,buf);
p139mm/swap.c} else if (p->swap_file) {
p140mm/swap.cstruct inode *swapf = p->swap_file;
p180mm/swap.cif (offset && !clear_bit(offset,p->swap_lockmap))
p187mm/swap.cstruct swap_info_struct * p;
p190mm/swap.cp = swap_info;
p191mm/swap.cfor (type = 0 ; type < nr_swapfiles ; type++,p++) {
p192mm/swap.cif ((p->flags & SWP_WRITEOK) != SWP_WRITEOK)
p194mm/swap.cfor (offset = p->lowest_bit; offset <= p->highest_bit ; offset++) {
p195mm/swap.cif (p->swap_map[offset])
p197mm/swap.cp->swap_map[offset] = 1;
p199mm/swap.cif (offset == p->highest_bit)
p200mm/swap.cp->highest_bit--;
p201mm/swap.cp->lowest_bit = offset;
p210mm/swap.cstruct swap_info_struct * p;
p223mm/swap.cp = type + swap_info;
p224mm/swap.cif (offset >= p->max) {
p228mm/swap.cif (!p->swap_map[offset]) {
p232mm/swap.cp->swap_map[offset]++;
p238mm/swap.cstruct swap_info_struct * p;
p250mm/swap.cp = & swap_info[type];
p252mm/swap.cif (offset >= p->max) {
p256mm/swap.cif (!(p->flags & SWP_USED)) {
p260mm/swap.cwhile (set_bit(offset,p->swap_lockmap))
p262mm/swap.cif (offset < p->lowest_bit)
p263mm/swap.cp->lowest_bit = offset;
p264mm/swap.cif (offset > p->highest_bit)
p265mm/swap.cp->highest_bit = offset;
p266mm/swap.cif (!p->swap_map[offset])
p269mm/swap.cif (!--p->swap_map[offset])
p271mm/swap.cif (!clear_bit(offset,p->swap_lockmap))
p373mm/swap.cstatic int swap_out_process(struct task_struct * p)
p384mm/swap.caddress = p->mm->swap_address;
p385mm/swap.cp->mm->swap_address = 0;
p390mm/swap.cvma = p->mm->mmap;
p401mm/swap.cpgdir = (address >> PGDIR_SHIFT) + (unsigned long *) p->tss.cr3;
p413mm/swap.cp->comm, address + offset, pg_table);
p439mm/swap.cp->mm->rss--;
p441mm/swap.cp->mm->swap_address = address + offset + PAGE_SIZE;
p445mm/swap.cp->mm->rss--;
p462mm/swap.cstruct task_struct *p;
p480mm/swap.cp = task[swap_task];
p481mm/swap.cif (p && p->mm->swappable && p->mm->rss)
p490mm/swap.cif (!p->mm->swap_cnt) {
p491mm/swap.cp->mm->dec_flt = (p->mm->dec_flt * 3) / 4 + p->mm->maj_flt - p->mm->old_maj_flt;
p492mm/swap.cp->mm->old_maj_flt = p->mm->maj_flt;
p494mm/swap.cif (p->mm->dec_flt >= SWAP_RATIO / SWAP_MIN) {
p495mm/swap.cp->mm->dec_flt = SWAP_RATIO / SWAP_MIN;
p496mm/swap.cp->mm->swap_cnt = SWAP_MIN;
p497mm/swap.c} else if (p->mm->dec_flt <= SWAP_RATIO / SWAP_MAX)
p498mm/swap.cp->mm->swap_cnt = SWAP_MAX;
p500mm/swap.cp->mm->swap_cnt = SWAP_RATIO / p->mm->dec_flt;
p502mm/swap.cif (swap_out_process(p)) {
p503mm/swap.cif ((--p->mm->swap_cnt) == 0)
p744mm/swap.cstruct task_struct *p;
p754mm/swap.cp = task[nr];
p755mm/swap.cif (!p)
p758mm/swap.cppage = pgt + ((unsigned long *) p->tss.cr3);
p790mm/swap.c++p->mm->rss;
p804mm/swap.cstruct swap_info_struct * p;
p814mm/swap.cp = swap_info;
p815mm/swap.cfor (type = 0 ; type < nr_swapfiles ; type++,p++) {
p816mm/swap.cif ((p->flags & SWP_WRITEOK) != SWP_WRITEOK)
p818mm/swap.cif (p->swap_file) {
p819mm/swap.cif (p->swap_file == inode)
p824mm/swap.cif (p->swap_device == inode->i_rdev)
p831mm/swap.cp->flags = SWP_USED;
p834mm/swap.cp->flags = SWP_WRITEOK;
p837mm/swap.cnr_swap_pages -= p->pages;
p838mm/swap.ciput(p->swap_file);
p839mm/swap.cp->swap_file = NULL;
p840mm/swap.cp->swap_device = 0;
p841mm/swap.cvfree(p->swap_map);
p842mm/swap.cp->swap_map = NULL;
p843mm/swap.cfree_page((long) p->swap_lockmap);
p844mm/swap.cp->swap_lockmap = NULL;
p845mm/swap.cp->flags = 0;
p856mm/swap.cstruct swap_info_struct * p;
p864mm/swap.cp = swap_info;
p865mm/swap.cfor (type = 0 ; type < nr_swapfiles ; type++,p++)
p866mm/swap.cif (!(p->flags & SWP_USED))
p872mm/swap.cp->flags = SWP_USED;
p873mm/swap.cp->swap_file = NULL;
p874mm/swap.cp->swap_device = 0;
p875mm/swap.cp->swap_map = NULL;
p876mm/swap.cp->swap_lockmap = NULL;
p877mm/swap.cp->lowest_bit = 0;
p878mm/swap.cp->highest_bit = 0;
p879mm/swap.cp->max = 1;
p883mm/swap.cp->swap_file = swap_inode;
p889mm/swap.cp->swap_device = swap_inode->i_rdev;
p890mm/swap.cp->swap_file = NULL;
p893mm/swap.cif (!p->swap_device)
p899mm/swap.cif (p->swap_device == swap_info[i].swap_device)
p904mm/swap.cp->swap_lockmap = (unsigned char *) get_free_page(GFP_USER);
p905mm/swap.cif (!p->swap_lockmap) {
p910mm/swap.cread_swap_page(SWP_ENTRY(type,0), (char *) p->swap_lockmap);
p911mm/swap.cif (memcmp("SWAP-SPACE",p->swap_lockmap+4086,10)) {
p916mm/swap.cmemset(p->swap_lockmap+PAGE_SIZE-10,0,10);
p918mm/swap.cp->lowest_bit = 0;
p919mm/swap.cp->highest_bit = 0;
p921mm/swap.cif (test_bit(i,p->swap_lockmap)) {
p922mm/swap.cif (!p->lowest_bit)
p923mm/swap.cp->lowest_bit = i;
p924mm/swap.cp->highest_bit = i;
p925mm/swap.cp->max = i+1;
p934mm/swap.cp->swap_map = (unsigned char *) vmalloc(p->max);
p935mm/swap.cif (!p->swap_map) {
p939mm/swap.cfor (i = 1 ; i < p->max ; i++) {
p940mm/swap.cif (test_bit(i,p->swap_lockmap))
p941mm/swap.cp->swap_map[i] = 0;
p943mm/swap.cp->swap_map[i] = 0x80;
p945mm/swap.cp->swap_map[0] = 0x80;
p946mm/swap.cmemset(p->swap_lockmap,0,PAGE_SIZE);
p947mm/swap.cp->flags = SWP_WRITEOK;
p948mm/swap.cp->pages = j;
p953mm/swap.cfree_page((long) p->swap_lockmap);
p954mm/swap.cvfree(p->swap_map);
p955mm/swap.ciput(p->swap_file);
p956mm/swap.cp->swap_device = 0;
p957mm/swap.cp->swap_file = NULL;
p958mm/swap.cp->swap_map = NULL;
p959mm/swap.cp->swap_lockmap = NULL;
p960mm/swap.cp->flags = 0;
p995mm/swap.cunsigned short * p;
p1009mm/swap.cp = mem_map + MAP_NR(end_mem);
p1010mm/swap.cstart_mem = (unsigned long) p;
p1011mm/swap.cwhile (p > mem_map)
p1012mm/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) {
p1452net/inet/af_inet.cstruct inet_protocol *p;
p1478net/inet/af_inet.cfor(p = inet_protocol_base; p != NULL;) 
p1480net/inet/af_inet.cstruct inet_protocol *tmp = (struct inet_protocol *) p->next;
p1481net/inet/af_inet.cinet_add_protocol(p);
p1482net/inet/af_inet.cprintk("%s%s",p->name,tmp?", ":"\n");
p1483net/inet/af_inet.cp = tmp;
p240net/inet/packet.cstruct packet_type *p;
p242net/inet/packet.cp = (struct packet_type *) kmalloc(sizeof(*p), GFP_KERNEL);
p243net/inet/packet.cif (p == NULL) 
p246net/inet/packet.cp->func = packet_rcv;
p247net/inet/packet.cp->type = sk->num;
p248net/inet/packet.cp->data = (void *)sk;
p249net/inet/packet.cdev_add_pack(p);
p255net/inet/packet.csk->pair = (struct sock *)p;
p106net/inet/protocol.cstruct inet_protocol *p;
p109net/inet/protocol.cfor (p = inet_protos[hash] ; p != NULL; p=p->next) {
p110net/inet/protocol.cif (p->protocol == prot) return((struct inet_protocol *) p);
p142net/inet/protocol.cstruct inet_protocol *p;
p152net/inet/protocol.cp = (struct inet_protocol *) inet_protos[hash];
p153net/inet/protocol.cwhile(p != NULL) {
p159net/inet/protocol.cif (p->next != NULL && p->next == prot) {
p164net/inet/protocol.cif (p->copy == 0 && lp != NULL) lp->copy = 0;
p165net/inet/protocol.cp->next = prot->next;
p169net/inet/protocol.cif (p->next != NULL && p->next->protocol == prot->protocol) {
p170net/inet/protocol.clp = p;
p173net/inet/protocol.cp = (struct inet_protocol *) p->next;
p256net/inet/tcp.cstruct sk_buff *p=skb_peek(&s->receive_queue);
p257net/inet/tcp.cif(p==NULL)
p261net/inet/tcp.cif(p->sk->state == TCP_ESTABLISHED || p->sk->state >= TCP_FIN_WAIT1)
p262net/inet/tcp.creturn p;
p263net/inet/tcp.cp=p->next;
p265net/inet/tcp.cwhile(p!=skb_peek(&s->receive_queue));
p279net/inet/tcp.cstruct sk_buff *p, *old_p;
p283net/inet/tcp.cp=skb_peek(&sk->receive_queue);
p285net/inet/tcp.cif(p==NULL) 
p293net/inet/tcp.ctcp_close (p->sk, timeout);
p294net/inet/tcp.cskb_unlink (p);
p295net/inet/tcp.cold_p = p;
p296net/inet/tcp.cp=p->next;
p299net/inet/tcp.cwhile(p!=skb_peek(&sk->receive_queue));
p52net/inet/utils.cchar *p;
p54net/inet/utils.cp = (char *) &in;
p56net/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 */
p264zBoot/inflate.cif (p >= v + n)
p266zBoot/inflate.celse if (*p < s)
p268zBoot/inflate.cr.e = (uch)(*p < 256 ? 16 : 15);    /* 256 is end-of-block code */
p269zBoot/inflate.cr.v.n = *p++;           /* simple code is just the value */
p273zBoot/inflate.cr.e = (uch)e[*p - s];   /* non-simple--look up in lists */
p274zBoot/inflate.cr.v.n = d[*p++ - s];
p313zBoot/inflate.cregister struct huft *p, *q;
p317zBoot/inflate.cp = t;
p318zBoot/inflate.cwhile (p != (struct huft *)NULL)
p320zBoot/inflate.cq = (--p)->v.t;
p321zBoot/inflate.cfree(p);
p322zBoot/inflate.cp = q;
p85zBoot/misc.cvoid *p;
p93zBoot/misc.cp = (void *)free_mem_ptr;
p106zBoot/misc.creturn p;
p109zBoot/misc.creturn p;
p275zBoot/misc.cstatic int p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
p279zBoot/misc.cfor (i = 0; i < sizeof(p)/sizeof(int); i++)
p280zBoot/misc.ce |= 1L << (31 - p[i]);