taglinefilesource code
p120arch/alpha/kernel/process.cstruct task_struct * p, struct pt_regs * regs)
p129arch/alpha/kernel/process.cchildregs = (struct pt_regs *) (p->kernel_stack_page + stack_offset);
p140arch/alpha/kernel/process.cp->tss.usp = usp;
p141arch/alpha/kernel/process.cp->tss.ksp = (unsigned long) childstack;
p142arch/alpha/kernel/process.cp->tss.flags = 1;
p216arch/i386/boot/compressed/gzip.h#define SH(p) ((ush)(uch)((p)[0]) | ((ush)(uch)((p)[1]) << 8))
p217arch/i386/boot/compressed/gzip.h#define LG(p) ((ulg)(SH(p)) | ((ulg)(SH((p)+2)) << 16))
p122arch/i386/boot/compressed/inflate.cregister unsigned *p;         /* pointer into c[], b[], or v[] */
p137arch/i386/boot/compressed/inflate.cp = b;  i = n;
p139arch/i386/boot/compressed/inflate.cc[*p++]++;                  /* assume all entries <= BMAX */
p180arch/i386/boot/compressed/inflate.cp = c + 1;  xp = x + 2;
p182arch/i386/boot/compressed/inflate.c*xp++ = (j += *p++);
p188arch/i386/boot/compressed/inflate.cp = b;  i = 0;
p190arch/i386/boot/compressed/inflate.cif ((j = *p++) != 0)
p198arch/i386/boot/compressed/inflate.cp = v;                        /* grab values in bit order */
p264arch/i386/boot/compressed/inflate.cif (p >= v + n)
p266arch/i386/boot/compressed/inflate.celse if (*p < s)
p268arch/i386/boot/compressed/inflate.cr.e = (uch)(*p < 256 ? 16 : 15);    /* 256 is end-of-block code */
p269arch/i386/boot/compressed/inflate.cr.v.n = *p++;           /* simple code is just the value */
p273arch/i386/boot/compressed/inflate.cr.e = (uch)e[*p - s];   /* non-simple--look up in lists */
p274arch/i386/boot/compressed/inflate.cr.v.n = d[*p++ - s];
p313arch/i386/boot/compressed/inflate.cregister struct huft *p, *q;
p317arch/i386/boot/compressed/inflate.cp = t;
p318arch/i386/boot/compressed/inflate.cwhile (p != (struct huft *)NULL)
p320arch/i386/boot/compressed/inflate.cq = (--p)->v.t;
p321arch/i386/boot/compressed/inflate.cfree(p);
p322arch/i386/boot/compressed/inflate.cp = q;
p86arch/i386/boot/compressed/misc.cvoid *p;
p94arch/i386/boot/compressed/misc.cp = (void *)free_mem_ptr;
p107arch/i386/boot/compressed/misc.creturn p;
p110arch/i386/boot/compressed/misc.creturn p;
p276arch/i386/boot/compressed/misc.cstatic int p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
p280arch/i386/boot/compressed/misc.cfor (i = 0; i < sizeof(p)/sizeof(int); i++)
p281arch/i386/boot/compressed/misc.ce |= 1L << (31 - p[i]);
p185arch/i386/kernel/process.cstruct task_struct * p, struct pt_regs * regs)
p190arch/i386/kernel/process.cp->tss.es = KERNEL_DS;
p191arch/i386/kernel/process.cp->tss.cs = KERNEL_CS;
p192arch/i386/kernel/process.cp->tss.ss = KERNEL_DS;
p193arch/i386/kernel/process.cp->tss.ds = KERNEL_DS;
p194arch/i386/kernel/process.cp->tss.fs = USER_DS;
p195arch/i386/kernel/process.cp->tss.gs = KERNEL_DS;
p196arch/i386/kernel/process.cp->tss.ss0 = KERNEL_DS;
p197arch/i386/kernel/process.cp->tss.esp0 = p->kernel_stack_page + PAGE_SIZE;
p198arch/i386/kernel/process.cp->tss.tr = _TSS(nr);
p199arch/i386/kernel/process.cchildregs = ((struct pt_regs *) (p->kernel_stack_page + PAGE_SIZE)) - 1;
p200arch/i386/kernel/process.cp->tss.esp = (unsigned long) childregs;
p201arch/i386/kernel/process.cp->tss.eip = (unsigned long) ret_from_sys_call;
p205arch/i386/kernel/process.cp->tss.back_link = 0;
p206arch/i386/kernel/process.cp->tss.eflags = regs->eflags & 0xffffcfff;  /* iopl is always 0 for a new process */
p207arch/i386/kernel/process.cp->tss.ldt = _LDT(nr);
p208arch/i386/kernel/process.cif (p->ldt) {
p209arch/i386/kernel/process.cp->ldt = (struct desc_struct*) vmalloc(LDT_ENTRIES*LDT_ENTRY_SIZE);
p210arch/i386/kernel/process.cif (p->ldt != NULL)
p211arch/i386/kernel/process.cmemcpy(p->ldt, current->ldt, LDT_ENTRIES*LDT_ENTRY_SIZE);
p213arch/i386/kernel/process.cset_tss_desc(gdt+(nr<<1)+FIRST_TSS_ENTRY,&(p->tss));
p214arch/i386/kernel/process.cif (p->ldt)
p215arch/i386/kernel/process.cset_ldt_desc(gdt+(nr<<1)+FIRST_LDT_ENTRY,p->ldt, 512);
p218arch/i386/kernel/process.cp->tss.bitmap = offsetof(struct thread_struct,io_bitmap);
p220arch/i386/kernel/process.cp->tss.io_bitmap[i] = ~0;
p222arch/i386/kernel/process.c__asm__("clts ; fnsave %0 ; frstor %0":"=m" (p->tss.i387));
p604arch/i386/kernel/smp.cint p=smp_processor_id();
p626arch/i386/kernel/smp.cif(smp_cpu_in_msg[p])
p648arch/i386/kernel/smp.csmp_cpu_in_msg[p]++;
p656arch/i386/kernel/smp.csmp_src_cpu=p;
p742arch/i386/kernel/smp.csmp_cpu_in_msg[p]--;
p351arch/i386/kernel/traps.cstruct desc_struct * p;
p386arch/i386/kernel/traps.cp = gdt+FIRST_TSS_ENTRY;
p387arch/i386/kernel/traps.cset_tss_desc(p, &init_task.tss);
p388arch/i386/kernel/traps.cp++;
p389arch/i386/kernel/traps.cset_ldt_desc(p, &default_ldt, 1);
p390arch/i386/kernel/traps.cp++;
p392arch/i386/kernel/traps.cp->a=p->b=0;
p393arch/i386/kernel/traps.cp++;
p394arch/i386/kernel/traps.cp->a=p->b=0;
p395arch/i386/kernel/traps.cp++;
p87arch/mips/kernel/ioport.cresource_entry_t *p;
p93arch/mips/kernel/ioport.cfor (p = root; ; p = p->next) {
p94arch/mips/kernel/ioport.cif ((p != root) && (p->from+p->num-1 >= from)) {
p95arch/mips/kernel/ioport.cp = NULL;
p98arch/mips/kernel/ioport.cif ((p->next == NULL) || (p->next->from > from+num-1))
p102arch/mips/kernel/ioport.creturn p;
p97arch/mips/kernel/process.cvoid copy_thread(int nr, unsigned long clone_flags, struct task_struct * p, struct pt_regs * regs)
p104arch/mips/kernel/process.cp->tss.fs = KERNEL_DS;
p105arch/mips/kernel/process.cp->tss.ksp = (p->kernel_stack_page + PAGE_SIZE - 4) | KSEG0;
p106arch/mips/kernel/process.cchildregs = ((struct pt_regs *) (p->kernel_stack_page + PAGE_SIZE)) - 1;
p107arch/mips/kernel/process.cp->tss.reg29 = ((unsigned long) childregs) | KSEG0; /* new sp */
p108arch/mips/kernel/process.cp->tss.reg31 = (unsigned long) ret_from_sys_call;
p116arch/mips/kernel/process.cp->tss.cp0_status = regs->cp0_status &
p94arch/sparc/kernel/process.cstruct task_struct * p, struct pt_regs * regs)
p102arch/sparc/kernel/process.cp->tss.context = -1;
p106arch/sparc/kernel/process.c((p->kernel_stack_page + PAGE_SIZE - 80)&(~7)));
p110arch/sparc/kernel/process.cp->tss.usp = sp;    /* both processes have the same user stack */
p116arch/sparc/kernel/process.cp->tss.ksp = (unsigned long) ((p->kernel_stack_page + PAGE_SIZE - 80 - 96)&(~7));
p117arch/sparc/kernel/process.cnew_stack = (unsigned char *) (p->tss.ksp);
p127arch/sparc/kernel/process.cp->tss.pc = (((unsigned long) ret_sys_call) - 8);
p128arch/sparc/kernel/process.cp->tss.npc = p->tss.pc+4;
p131arch/sparc/kernel/process.cregs->u_regs[8] = p->pid;
p62arch/sparc/kernel/setup.cvoid sparc_console_print(const char * p)
p66arch/sparc/kernel/setup.cwhile ((c = *(p++)) != 0)
p73drivers/block/genhd.cstatic inline int is_extended_partition(struct partition *p)
p75drivers/block/genhd.creturn (p->sys_ind == DOS_EXTENDED_PARTITION ||
p76drivers/block/genhd.cp->sys_ind == LINUX_EXTENDED_PARTITION);
p94drivers/block/genhd.cstruct partition *p;
p119drivers/block/genhd.cp = (struct partition *) (0x1BE + bh->b_data);
p135drivers/block/genhd.cfor (i=0; i<4; i++, p++) {
p136drivers/block/genhd.cif (!p->nr_sects || is_extended_partition(p))
p142drivers/block/genhd.c&& p->start_sect + p->nr_sects > this_size
p143drivers/block/genhd.c&& (this_sector + p->start_sect < first_sector ||
p144drivers/block/genhd.cthis_sector + p->start_sect + p->nr_sects >
p148drivers/block/genhd.cadd_partition(hd, current_minor, this_sector+p->start_sect, p->nr_sects);
p163drivers/block/genhd.cp -= 4;
p164drivers/block/genhd.cfor (i=0; i<4; i++, p++)
p165drivers/block/genhd.cif(p->nr_sects && is_extended_partition(p))
p170drivers/block/genhd.chd->part[current_minor].nr_sects = p->nr_sects;
p171drivers/block/genhd.chd->part[current_minor].start_sect = first_sector + p->start_sect;
p172drivers/block/genhd.cthis_sector = first_sector + p->start_sect;
p184drivers/block/genhd.cstruct partition *p;
p207drivers/block/genhd.cp = (struct partition *) (0x1be + data);
p216drivers/block/genhd.cif (p->sys_ind == EZD_PARTITION) {
p229drivers/block/genhd.c} else if (p->sys_ind == DM6_PARTITION) {
p255drivers/block/genhd.cif (p->sys_ind == DM6_AUX1PARTITION
p256drivers/block/genhd.c|| p->sys_ind == DM6_AUX3PARTITION)
p266drivers/block/genhd.cfor (i=1 ; i<=4 ; minor++,i++,p++) {
p267drivers/block/genhd.cif (!p->nr_sects)
p269drivers/block/genhd.cadd_partition(hd, minor, first_sector+p->start_sect, p->nr_sects);
p270drivers/block/genhd.cif (is_extended_partition(p)) {
p292drivers/block/genhd.cp = (struct partition *) (0x1be + data);
p294drivers/block/genhd.cp--;
p297drivers/block/genhd.cif (!(p->start_sect && p->nr_sects))
p299drivers/block/genhd.cadd_partition(hd, current_minor, p->start_sect, p->nr_sects);
p409drivers/block/genhd.cstruct sun_partition *p;
p418drivers/block/genhd.cp = label->partitions;
p435drivers/block/genhd.cfor(i=0; i < 8; i++, p++) {
p441drivers/block/genhd.cst_sector = first_sector + (p->start_cylinder * spc);
p442drivers/block/genhd.cadd_partition(hd, current_minor, st_sector, p->num_sectors);
p544drivers/block/genhd.cstruct gendisk *p;
p558drivers/block/genhd.cfor (p = gendisk_head ; p ; p=p->next) {
p559drivers/block/genhd.csetup_dev(p);
p560drivers/block/genhd.cnr += p->nr_real;
p258drivers/block/hd.cunsigned char *p, *end = &s[bytecount &= ~1];  /* bytecount must be even */
p261drivers/block/hd.cfor (p = end ; p != s;) {
p262drivers/block/hd.cunsigned short *pp = (unsigned short *) (p -= 2);
p273drivers/block/hd.c*p++ = *(s-1);
p277drivers/block/hd.cwhile (p != end)
p278drivers/block/hd.c*p++ = '\0';
p1375drivers/block/ide-cd.cstruct request **p, **pfirst;
p1388drivers/block/ide-cd.cp = &blk_dev[major].current_request;
p1389drivers/block/ide-cd.cpfirst = p;
p1390drivers/block/ide-cd.cwhile ((*p) != NULL)
p1392drivers/block/ide-cd.cp = &((*p)->next);
p1394drivers/block/ide-cd.c*p = req;
p1395drivers/block/ide-cd.cif (p == pfirst)
p264drivers/block/ide.cbyte *p;
p276drivers/block/ide.cp = ((byte *) ide_hwifs) + sizeof(ide_hwifs);
p278drivers/block/ide.c*--p = 0;
p279drivers/block/ide.c} while (p > (byte *) ide_hwifs);
p1721drivers/block/ide.cunsigned int p, major, minor;
p1738drivers/block/ide.cfor (p = 0; p < (1<<PARTN_BITS); ++p) {
p1739drivers/block/ide.cif (drive->part[p].nr_sects > 0) {
p1740drivers/block/ide.ckdev_t devp = MKDEV(major, minor+p);
p1745drivers/block/ide.cdrive->part[p].start_sect = 0;
p1746drivers/block/ide.cdrive->part[p].nr_sects   = 0;
p1955drivers/block/ide.cbyte *p = s, *end = &s[bytecount & ~1]; /* bytecount must be even */
p1959drivers/block/ide.cfor (p = end ; p != s;) {
p1960drivers/block/ide.cunsigned short *pp = (unsigned short *) (p -= 2);
p1972drivers/block/ide.c*p++ = *(s-1);
p1976drivers/block/ide.cwhile (p != end)
p1977drivers/block/ide.c*p++ = '\0';
p116drivers/block/ide.h#define OUT_BYTE(b,p)    outb((b),p)
p117drivers/block/ide.h#define IN_BYTE(p)    (byte)inb(p)
p119drivers/block/ide.h#define OUT_BYTE(b,p)    outb_p((b),p)
p120drivers/block/ide.h#define IN_BYTE(p)    (byte)inb_p(p)
p272drivers/cdrom/aztcd.cstatic void azt_bin2bcd(unsigned char *p);
p1703drivers/cdrom/aztcd.cstatic void azt_bin2bcd(unsigned char *p)
p1706drivers/cdrom/aztcd.cu = *p % 10;
p1707drivers/cdrom/aztcd.ct = *p / 10;
p1708drivers/cdrom/aztcd.c*p = u | (t << 4);
p1234drivers/cdrom/cm206.cvoid cm206_setup(char *s, int *p)
p1238drivers/cdrom/cm206.cfor(i=1; i<=p[0]; i++) {
p1239drivers/cdrom/cm206.cif (0x300 <= p[i] && i<= 0x370 && p[i] % 0x10 == 0) {
p1240drivers/cdrom/cm206.ccm206_base = p[i];
p1243drivers/cdrom/cm206.celse if (3 <= p[i] && p[i] <= 15) {
p1244drivers/cdrom/cm206.ccm206_irq = p[i];
p90drivers/cdrom/gscd.cstatic void gscd_bin2bcd          (unsigned char *p);
p1101drivers/cdrom/gscd.cstatic void gscd_bin2bcd (unsigned char *p)
p1105drivers/cdrom/gscd.cu = *p % 10;
p1106drivers/cdrom/gscd.ct = *p / 10;
p1107drivers/cdrom/gscd.c*p = u | (t << 4);
p191drivers/cdrom/mcd.cstatic void bin2bcd(unsigned char *p);
p1287drivers/cdrom/mcd.cbin2bcd(unsigned char *p)
p1291drivers/cdrom/mcd.cu = *p % 10;
p1292drivers/cdrom/mcd.ct = *p / 10;
p1293drivers/cdrom/mcd.c*p = u | (t << 4);
p1184drivers/cdrom/mcdx.cchar *p, int sector, int nr_sectors)
p1258drivers/cdrom/mcdx.cinsb((unsigned int) stuffp->rreg_data, p, HEAD);
p1264drivers/cdrom/mcdx.cinsb((unsigned int) stuffp->rreg_data, p, 512); 
p1277drivers/cdrom/mcdx.cp += 512;
p1499drivers/cdrom/mcdx.cstruct s_subqcode* p;
p1504drivers/cdrom/mcdx.cif (ti) p = &stuffp->toc[ti->cdti_trk0 - stuffp->di.n_first];
p1505drivers/cdrom/mcdx.celse p = &stuffp->start;
p1507drivers/cdrom/mcdx.cmsf.cdmsf_min0 = p->dt.minute;
p1508drivers/cdrom/mcdx.cmsf.cdmsf_sec0 = p->dt.second;
p1509drivers/cdrom/mcdx.cmsf.cdmsf_frame0 = p->dt.frame;
p1512drivers/cdrom/mcdx.cp = &stuffp->toc[ti->cdti_trk1 - stuffp->di.n_first + 1];
p1513drivers/cdrom/mcdx.cstuffp->stop = *p;
p1514drivers/cdrom/mcdx.c} else p = &stuffp->stop;
p1516drivers/cdrom/mcdx.cmsf.cdmsf_min1 = p->dt.minute;
p1517drivers/cdrom/mcdx.cmsf.cdmsf_sec1 = p->dt.second;
p1518drivers/cdrom/mcdx.cmsf.cdmsf_frame1 = p->dt.frame;
p406drivers/cdrom/optcd.cinline static unsigned char bin2bcd(unsigned char p) {
p408drivers/cdrom/optcd.cif (p > 99)
p409drivers/cdrom/optcd.cprintk("optcd: error bin2bcd %d\n", p);
p411drivers/cdrom/optcd.creturn (p % 10) | ((p / 10) << 4);
p1506drivers/cdrom/optcd.c#define ISP16_IN(p) (outb(isp16_ctrl,ISP16_CTRL_PORT), inb(p))
p1507drivers/cdrom/optcd.c#define ISP16_OUT(p,b) (outb(isp16_ctrl,ISP16_CTRL_PORT), outb(b,p))
p804drivers/cdrom/sbpcd.cstatic INLINE void bin2bcdx(u_char *p)  /* must work only up to 75 or 99 */
p806drivers/cdrom/sbpcd.c*p=((*p/10)<<4)|(*p%10);
p2721drivers/cdrom/sbpcd.cstatic int convert_UPC(u_char *p)
p2725drivers/cdrom/sbpcd.cp++;
p2726drivers/cdrom/sbpcd.cif (fam0L_drive) p[13]=0;
p2729drivers/cdrom/sbpcd.cif (fam1_drive) D_S[d].UPC_buf[i]=swap_nibbles(*p++);
p2732drivers/cdrom/sbpcd.cD_S[d].UPC_buf[i]=((*p++)<<4)&0xFF;
p2733drivers/cdrom/sbpcd.cD_S[d].UPC_buf[i] |= *p++;
p4127drivers/cdrom/sbpcd.cu_char *p;
p4245drivers/cdrom/sbpcd.cp = D_S[d].aud_buf;
p4247drivers/cdrom/sbpcd.cinsb(CDi_data, p, read_audio.nframes*CD_FRAMESIZE_RAW);
p4571drivers/cdrom/sbpcd.cu_char *p;
p4656drivers/cdrom/sbpcd.cp = D_S[d].sbp_buf + frame *  CD_FRAMESIZE;
p4659drivers/cdrom/sbpcd.cinsb(CDi_data, p, CD_FRAMESIZE);
p5004drivers/cdrom/sbpcd.cvoid sbpcd_setup(const char *s, int *p)
p5007drivers/cdrom/sbpcd.cmsg(DBG_INI,"sbpcd_setup called with %04X,%s\n",p[1], s);
p5009drivers/cdrom/sbpcd.cif (p[0]>1) sbpro_type=p[2];
p5016drivers/cdrom/sbpcd.cif (p[0]>0) sbpcd_ioaddr=p[1];
p1670drivers/cdrom/sjcd.c#define ISP16_IN(p) (outb(isp16_ctrl,ISP16_CTRL_PORT), inb(p))
p1671drivers/cdrom/sjcd.c#define ISP16_OUT(p,b) (outb(isp16_ctrl,ISP16_CTRL_PORT), outb(b,p))
p36drivers/char/conmakehash.cchar *p = *p0;
p38drivers/char/conmakehash.cwhile (*p == ' ' || *p == '\t')
p39drivers/char/conmakehash.cp++;
p40drivers/char/conmakehash.cif (*p != 'U' || p[1] != '+' ||
p41drivers/char/conmakehash.c!isxdigit(p[2]) || !isxdigit(p[3]) || !isxdigit(p[4]) ||
p42drivers/char/conmakehash.c!isxdigit(p[5]) || isxdigit(p[6]))
p44drivers/char/conmakehash.c*p0 = p+6;
p45drivers/char/conmakehash.creturn strtol(p+2,0,16);
p88drivers/char/conmakehash.cchar *p, *p1;
p120drivers/char/conmakehash.cif ( (p = strchr(buffer, '\n')) != NULL )
p121drivers/char/conmakehash.c*p = '\0';
p125drivers/char/conmakehash.cp = buffer;
p138drivers/char/conmakehash.cwhile (*p == ' ' || *p == '\t')
p139drivers/char/conmakehash.cp++;
p140drivers/char/conmakehash.cif (!*p || *p == '#')
p143drivers/char/conmakehash.cfp0 = strtol(p, &p1, 0);
p144drivers/char/conmakehash.cif (p1 == p)
p149drivers/char/conmakehash.cp = p1;
p151drivers/char/conmakehash.cwhile (*p == ' ' || *p == '\t')
p152drivers/char/conmakehash.cp++;
p153drivers/char/conmakehash.cif (*p == '-')
p155drivers/char/conmakehash.cp++;
p156drivers/char/conmakehash.cfp1 = strtol(p, &p1, 0);
p157drivers/char/conmakehash.cif (p1 == p)
p162drivers/char/conmakehash.cp = p1;
p186drivers/char/conmakehash.cwhile (*p == ' ' || *p == '\t')
p187drivers/char/conmakehash.cp++;
p188drivers/char/conmakehash.cif (!strncmp(p, "idem", 4))
p192drivers/char/conmakehash.cp += 4;
p196drivers/char/conmakehash.cun0 = getunicode(&p);
p197drivers/char/conmakehash.cwhile (*p == ' ' || *p == '\t')
p198drivers/char/conmakehash.cp++;
p199drivers/char/conmakehash.cif (*p != '-')
p206drivers/char/conmakehash.cp++;
p207drivers/char/conmakehash.cun1 = getunicode(&p);
p230drivers/char/conmakehash.cwhile ( (un0 = getunicode(&p)) >= 0 )
p233drivers/char/conmakehash.cwhile (*p == ' ' || *p == '\t')
p234drivers/char/conmakehash.cp++;
p235drivers/char/conmakehash.cif (*p && *p != '#')
p236drivers/char/conmakehash.cfprintf(stderr, "%s: trailing junk (%s) ignored\n", tblname, p);
p299drivers/char/console.clong p, q;
p311drivers/char/console.cp = (long) kmalloc(structsize, GFP_KERNEL);
p312drivers/char/console.cif (!p) {
p317drivers/char/console.cvc_cons[i].d = (struct vc_data *) p;
p318drivers/char/console.cp += sizeof(struct vc_data);
p319drivers/char/console.cvt_cons[i] = (struct vt_struct *) p;
p337drivers/char/console.cunsigned short *p;
p360drivers/char/console.cp = (unsigned short *) kmalloc(ss, GFP_USER);
p361drivers/char/console.cif (!p) {
p367drivers/char/console.cnewscreens[currcons] = p;
p914drivers/char/console.cstatic void respond_string(const char * p, struct tty_struct * tty)
p916drivers/char/console.cwhile (*p) {
p917drivers/char/console.ctty_insert_flip_char(tty, *p, 0);
p918drivers/char/console.cp++;
p960drivers/char/console.cunsigned short *p = (unsigned short *)(origin + offset);
p962drivers/char/console.cp -= (__real_origin - __origin);
p963drivers/char/console.creturn p;
p969drivers/char/console.cunsigned short *p;
p972drivers/char/console.cp = screenpos(currcons, offset, viewed);
p975drivers/char/console.cunsigned short old = scr_readw(p);
p976drivers/char/console.cscr_writew(reverse_video_short(old), p);
p977drivers/char/console.cp++;
p981drivers/char/console.cunsigned short old = scr_readw(p);
p983drivers/char/console.c? 0x7000 : 0x7700), p);
p984drivers/char/console.cp++;
p991drivers/char/console.cstatic unsigned short *p = NULL;
p994drivers/char/console.cif (p)
p995drivers/char/console.cscr_writew(old, p);
p997drivers/char/console.cp = NULL;
p999drivers/char/console.cp = screenpos(currcons, offset, 1);
p1000drivers/char/console.cold = scr_readw(p);
p1001drivers/char/console.cscr_writew(old ^ 0x7700, p);
p1025drivers/char/console.cvoid getconsxy(int currcons, char *p)
p1027drivers/char/console.cp[0] = x;
p1028drivers/char/console.cp[1] = y;
p1031drivers/char/console.cvoid putconsxy(int currcons, char *p)
p1033drivers/char/console.cgotoxy(currcons, p[0], p[1]);
p1136drivers/char/console.cunsigned short * p = (unsigned short *) pos;
p1139drivers/char/console.ctmp = scr_readw(p);
p1140drivers/char/console.cscr_writew(old, p);
p1142drivers/char/console.cp++;
p1156drivers/char/console.cunsigned short * p = (unsigned short *) pos;
p1159drivers/char/console.cscr_writew(scr_readw(p+1), p);
p1160drivers/char/console.cp++;
p1162drivers/char/console.cscr_writew(video_erase_char, p);
p172drivers/char/consolemap.cunsigned short *p = translations[i];
p187drivers/char/consolemap.cglyph = conv_uni_to_pc(p[j]);
p230drivers/char/consolemap.cunsigned short *p = translations[USER_MAP];
p237drivers/char/consolemap.cp[i] = UNI_DIRECT_BASE | get_user(arg+i);
p246drivers/char/consolemap.cunsigned short *p = translations[USER_MAP];
p254drivers/char/consolemap.cch = conv_uni_to_pc(p[i]);
p263drivers/char/consolemap.cunsigned short *p = translations[USER_MAP];
p271drivers/char/consolemap.cp[i] = get_user(arg+i);
p280drivers/char/consolemap.cunsigned short *p = translations[USER_MAP];
p288drivers/char/consolemap.cput_user(p[i], arg+i);
p398drivers/char/consolemap.cu16 *p;
p404drivers/char/consolemap.cp = dfont_unitable;
p407drivers/char/consolemap.ccon_insert_unipair(*(p++), i);
p41drivers/char/mem.cunsigned long p = file->f_pos;
p44drivers/char/mem.cp += PAGE_OFFSET;
p47drivers/char/mem.cif (MAP_NR(p) >= MAP_NR(high_memory))
p49drivers/char/mem.cif (count > high_memory - p)
p50drivers/char/mem.ccount = high_memory - p;
p53drivers/char/mem.cwhile (p < PAGE_OFFSET + PAGE_SIZE && count > 0) {
p56drivers/char/mem.cp++;
p61drivers/char/mem.cmemcpy_tofs(buf, (void *) p, count);
p69drivers/char/mem.cunsigned long p = file->f_pos;
p72drivers/char/mem.cp += PAGE_OFFSET;
p75drivers/char/mem.cif (MAP_NR(p) >= MAP_NR(high_memory))
p77drivers/char/mem.cif (count > high_memory - p)
p78drivers/char/mem.ccount = high_memory - p;
p81drivers/char/mem.cwhile (PAGE_OFFSET + p < PAGE_SIZE && count > 0) {
p84drivers/char/mem.cp++;
p89drivers/char/mem.cmemcpy_fromfs((void *) p, buf, count);
p538drivers/char/n_tty.cconst unsigned char *p;
p560drivers/char/n_tty.cfor (i=count, p = cp, f = fp; i; i--, p++) {
p565drivers/char/n_tty.cn_tty_receive_char(tty, *p);
p572drivers/char/n_tty.cn_tty_receive_parity_error(tty, *p);
p631drivers/char/random.c__u32 word, *p;
p633drivers/char/random.cfor (i = count, p = (__u32 *)buffer;
p635drivers/char/random.ci-= sizeof(__u32), p++) {
p636drivers/char/random.cmemcpy_fromfs(&word, p, sizeof(__u32));
p641drivers/char/random.cmemcpy_fromfs(&word, p, i);
p651drivers/char/random.cint *p, max_size;
p667drivers/char/random.cp = (int *) arg;
p668drivers/char/random.cput_user(random_state.entropy_count, p);
p669drivers/char/random.cmax_size = get_user(++p);
p670drivers/char/random.cput_user(POOLWORDS, p);
p675drivers/char/random.cmemcpy_tofs(++p, random_state.pool,
p459drivers/char/scc.cregister struct mbuf *p;
p472drivers/char/scc.cfor(p = *bph ; p->next != NULLBUF ; p = p->next)
p474drivers/char/scc.cp->next = bp;
p485drivers/char/scc.cregister struct mbuf *p;
p498drivers/char/scc.cfor(p = *queue ; p->anext != NULLBUF ; p = p->anext)
p500drivers/char/scc.cp->anext = bp;
p542drivers/char/scc.cregister io_port *p;
p583drivers/char/scc.cp = SCC_ctrl;
p587drivers/char/scc.cif (!(q=*p++)) break;
p593drivers/char/scc.cif (!(q=*p++)) break;
p614drivers/char/scc.cp = SCC_ctrl;
p616drivers/char/scc.c} else p++;
p2143drivers/char/scc.cunsigned char tbuf[BUFSIZE], *p;
p2169drivers/char/scc.cp=tbuf;
p2172drivers/char/scc.cif (kiss_decode(scc, *p++))
p99drivers/char/selection.cstatic inline int atedge(const int p)
p101drivers/char/selection.creturn (!(p % video_size_row) || !((p + 2) % video_size_row));
p57drivers/char/selection.hextern void getconsxy(int currcons, char *p);
p58drivers/char/selection.hextern void putconsxy(int currcons, char *p);
p251drivers/char/tty_io.cstruct tty_driver *p;
p256drivers/char/tty_io.cfor (p = tty_drivers; p; p = p->next) {
p257drivers/char/tty_io.cif (p->major != major)
p259drivers/char/tty_io.cif (minor < p->minor_start)
p261drivers/char/tty_io.cif (minor >= p->minor_start + p->num)
p263drivers/char/tty_io.creturn p;
p349drivers/char/tty_io.cstruct task_struct *p;
p395drivers/char/tty_io.cfor_each_task(p) {
p396drivers/char/tty_io.cif ((tty->session > 0) && (p->session == tty->session) &&
p397drivers/char/tty_io.cp->leader) {
p398drivers/char/tty_io.csend_sig(SIGHUP,p,1);
p399drivers/char/tty_io.csend_sig(SIGCONT,p,1);
p401drivers/char/tty_io.cp->tty_old_pgrp = tty->pgrp;
p403drivers/char/tty_io.cif (p->tty == tty)
p404drivers/char/tty_io.cp->tty = NULL;
p450drivers/char/tty_io.cstruct task_struct *p;
p468drivers/char/tty_io.cfor_each_task(p)
p469drivers/char/tty_io.cif (p->session == current->session)
p470drivers/char/tty_io.cp->tty = NULL;
p948drivers/char/tty_io.cstruct task_struct **p;
p1063drivers/char/tty_io.cfor (p = &LAST_TASK ; p > &FIRST_TASK ; --p) {
p1064drivers/char/tty_io.cif (*p == 0)
p1066drivers/char/tty_io.cif ((*p)->tty == tty)
p1067drivers/char/tty_io.c(*p)->tty = NULL;
p1068drivers/char/tty_io.cif (o_tty && (*p)->tty == o_tty)
p1069drivers/char/tty_io.c(*p)->tty = NULL;
p1309drivers/char/tty_io.cstruct task_struct **p;
p1316drivers/char/tty_io.cfor (p = &FIRST_TASK ; p <= &LAST_TASK ; p++, n++)
p1317drivers/char/tty_io.cif (*p)
p1319drivers/char/tty_io.cc = (char *)(*p);
p1441drivers/char/tty_io.cstruct task_struct *p;
p1443drivers/char/tty_io.cfor_each_task(p)
p1444drivers/char/tty_io.cif (p->tty == tty)
p1445drivers/char/tty_io.cp->tty = NULL;
p1586drivers/char/tty_io.cstruct task_struct **p;
p1598drivers/char/tty_io.cfor (p = &LAST_TASK ; p > &FIRST_TASK ; --p) {
p1599drivers/char/tty_io.cif (!(*p))
p1601drivers/char/tty_io.cif (((*p)->tty == tty) ||
p1602drivers/char/tty_io.c((session > 0) && ((*p)->session == session)))
p1603drivers/char/tty_io.csend_sig(SIGKILL, *p, 1);
p1606drivers/char/tty_io.cfilp = (*p)->files->fd[i];
p1609drivers/char/tty_io.csend_sig(SIGKILL, *p, 1);
p1712drivers/char/tty_io.cstruct tty_driver *p;
p1719drivers/char/tty_io.cfor (p = tty_drivers; p; p = p->next) {
p1720drivers/char/tty_io.cif (p == driver)
p1722drivers/char/tty_io.celse if (p->major == driver->major)
p1723drivers/char/tty_io.cothername = p->name;
p65drivers/char/vc_screen.cunsigned long p = file->f_pos;
p84drivers/char/vc_screen.cif (count < 0 || p > size)
p86drivers/char/vc_screen.cif (count > size - p)
p87drivers/char/vc_screen.ccount = size - p;
p91drivers/char/vc_screen.corg = screen_pos(cons, p, viewed);
p95drivers/char/vc_screen.cif (p < HEADER_SIZE) {
p100drivers/char/vc_screen.cwhile (p < HEADER_SIZE && count-- > 0)
p101drivers/char/vc_screen.cput_user(header[p++], buf++);
p103drivers/char/vc_screen.cp -= HEADER_SIZE;
p104drivers/char/vc_screen.corg = screen_pos(cons, p/2, viewed);
p105drivers/char/vc_screen.cif ((p & 1) && count-- > 0)
p123drivers/char/vc_screen.cunsigned long p = file->f_pos;
p142drivers/char/vc_screen.cif (count < 0 || p > size)
p144drivers/char/vc_screen.cif (count > size - p)
p145drivers/char/vc_screen.ccount = size - p;
p149drivers/char/vc_screen.corg = screen_pos(cons, p, viewed);
p156drivers/char/vc_screen.cif (p < HEADER_SIZE) {
p159drivers/char/vc_screen.cwhile (p < HEADER_SIZE && count-- > 0)
p160drivers/char/vc_screen.cheader[p++] = get_user(buf++);
p164drivers/char/vc_screen.cp -= HEADER_SIZE;
p165drivers/char/vc_screen.corg = screen_pos(cons, p/2, viewed);
p166drivers/char/vc_screen.cif ((p & 1) && count-- > 0) {
p106drivers/char/vt.cstruct task_struct *p;
p120drivers/char/vt.cfor_each_task(p)
p122drivers/char/vt.cif ( p->tty && MAJOR(p->tty->device) == TTY_MAJOR &&
p123drivers/char/vt.cMINOR(p->tty->device) <= MAX_NR_CONSOLES && MINOR(p->tty->device) )
p125drivers/char/vt.csend_sig(SIGWINCH, p, 1);
p493drivers/char/vt.cchar *p;
p505drivers/char/vt.cp = func_table[i];
p506drivers/char/vt.cif(p)
p507drivers/char/vt.cfor ( ; *p && sz; p++, sz--)
p508drivers/char/vt.cput_user(*p, q++);
p510drivers/char/vt.creturn ((p && *p) ? -EOVERFLOW : 0);
p519drivers/char/vt.cu_char *p;
p541drivers/char/vt.cfor (p = a->kb_string; get_user(p) && sz; p++,sz--)
p583drivers/char/vt.cfor (p = a->kb_string, q = func_table[i]; ; p++, q++)
p584drivers/char/vt.cif (!(*q = get_user(p)))
p68drivers/net/3c505.c#define CHECK_NULL(p) \
p69drivers/net/3c505.cif (!p) printk(null_msg, filename,__FUNCTION__,__LINE__)
p703drivers/net/atp.cstatic void read_block(short ioaddr, int length, unsigned char *p, int data_mode)
p711drivers/net/atp.cdo  *p++ = read_byte_mode0(ioaddr);  while (--length > 0);
p713drivers/net/atp.cdo  *p++ = read_byte_mode2(ioaddr);  while (--length > 0);
p715drivers/net/atp.cdo      *p++ = read_byte_mode4(ioaddr);  while (--length > 0);
p717drivers/net/atp.cdo      *p++ = read_byte_mode6(ioaddr);  while (--length > 0);
p558drivers/net/bsd_comp.c#define dict_ptrx(p,idx) &(p->dict[idx])
p559drivers/net/bsd_comp.c#define lens_ptrx(p,idx) &(p->lens[idx])
p877drivers/net/bsd_comp.cunsigned char *p;
p1030drivers/net/bsd_comp.cp     = wptr;
p1060drivers/net/bsd_comp.c*--p    = dictp->f.hs.suffix;
p1063drivers/net/bsd_comp.c*--p = finchar;
p2261drivers/net/de4x5.cshort *p = (short *)&lp->srom;
p2263drivers/net/de4x5.c*p++ = srom_rd(aprom_addr, i);
p654drivers/net/depca.cstruct depca_init *p = (struct depca_init *)lp->sh_mem;
p712drivers/net/depca.cprintk("\tmode: 0x%4.4x\n",readw(&p->mode));
p715drivers/net/depca.cprintk("%2.2x:",(u_char)readb(&p->phys_addr[i]));
p717drivers/net/depca.cprintk("%2.2x\n",(u_char)readb(&p->phys_addr[i]));
p720drivers/net/depca.cprintk("%2.2x:",(u_char)readb(&p->mcast_table[i]));
p722drivers/net/depca.cprintk("%2.2x\n",(u_char)readb(&p->mcast_table[i]));
p723drivers/net/depca.cprintk("\trx_ring at: 0x%8.8x\n",readl(&p->rx_ring));
p724drivers/net/depca.cprintk("\ttx_ring at: 0x%8.8x\n",readl(&p->tx_ring));
p767drivers/net/depca.cu_long p;
p777drivers/net/depca.cwritel((p=lp->dma_buffs+i*RX_BUFF_SZ) | R_OWN, &lp->rx_ring[i].base);
p779drivers/net/depca.clp->rx_memcpy[i]=(char *)(p+lp->bus_offset);
p782drivers/net/depca.cwritel((p=lp->dma_buffs+(i+lp->txRingMask+1)*TX_BUFF_SZ) & 0x00ffffff,
p784drivers/net/depca.clp->tx_memcpy[i]=(char *)(p+lp->bus_offset);
p850drivers/net/ewrk3.cunsigned char *p = skb->data;
p857drivers/net/ewrk3.coutb(*p++, EWRK3_DATA);
p1041drivers/net/ewrk3.cunsigned char *p;
p1044drivers/net/ewrk3.cp = skb_put(skb,pkt_len);
p1047drivers/net/ewrk3.c*p = inb(EWRK3_DATA);         /* dummy read */
p1049drivers/net/ewrk3.c*p++ = inb(EWRK3_DATA);
p1052drivers/net/ewrk3.cmemcpy(p, buf, pkt_len);
p1258drivers/net/ewrk3.cshort *p = (short *) multicast_table;
p1276drivers/net/ewrk3.c*p++ = 0xffff;
p33drivers/net/i82586.h#define  toff(t,p,f)   (unsigned short)((void *)(&((t *)((void *)0 + (p)))->f) - (void *)0)
p121drivers/net/i82586.h#define  scboff(p,f)   toff(scb_t, p, f)
p175drivers/net/i82586.h#define  acoff(p,f)   toff(ach_t, p, f)
p363drivers/net/i82586.h#define  rbdoff(p,f)   toff(rbd_t, p, f)
p401drivers/net/i82586.h#define  fdoff(p,f)   toff(fd_t, p, f)
p103drivers/net/ni52.c#define make32(ptr16) (p->memtop + (short) (ptr16) )
p104drivers/net/ni52.c#define make24(ptr32) ((char *) (ptr32) - p->base)
p105drivers/net/ni52.c#define make16(ptr32) ((unsigned short) ((unsigned long) (ptr32) - (unsigned long) p->memtop ))
p143drivers/net/ni52.cif(!p->scb->cmd) break; \
p247drivers/net/ni52.cstruct priv *p = (struct priv *) dev->priv;
p251drivers/net/ni52.cp->base = (unsigned long) where + size - 0x01000000;
p252drivers/net/ni52.cp->memtop = where + size;
p253drivers/net/ni52.cp->scp = (struct scp_struct *)(p->base + SCP_DEFAULT_ADDRESS);
p254drivers/net/ni52.cmemset((char *)p->scp,0, sizeof(struct scp_struct));
p255drivers/net/ni52.cp->scp->sysbus = SYSBUSVAL;        /* 1 = 8Bit-Bus, 0 = 16 Bit */
p258drivers/net/ni52.ciscp_addrs[1]= (char *) p->scp - sizeof(struct iscp_struct);
p262drivers/net/ni52.cp->iscp = (struct iscp_struct *) iscp_addrs[i];
p263drivers/net/ni52.cmemset((char *)p->iscp,0, sizeof(struct iscp_struct));
p265drivers/net/ni52.cp->scp->iscp = make24(p->iscp);
p266drivers/net/ni52.cp->iscp->busy = 1;
p272drivers/net/ni52.cif(p->iscp->busy) /* i82586 clears 'busy' after successful init */
p284drivers/net/ni52.cstruct priv *p =  (struct priv *) dev->priv; 
p289drivers/net/ni52.cp->scp  = (struct scp_struct *)  (p->base + SCP_DEFAULT_ADDRESS);
p290drivers/net/ni52.cp->scb  = (struct scb_struct *)  (dev->mem_start);
p291drivers/net/ni52.cp->iscp = (struct iscp_struct *) ((char *)p->scp - sizeof(struct iscp_struct));
p293drivers/net/ni52.cmemset((char *) p->iscp,0,sizeof(struct iscp_struct));
p294drivers/net/ni52.cmemset((char *) p->scp ,0,sizeof(struct scp_struct));
p296drivers/net/ni52.cp->scp->iscp = make24(p->iscp);
p297drivers/net/ni52.cp->scp->sysbus = SYSBUSVAL;
p298drivers/net/ni52.cp->iscp->scb_offset = make16(p->scb);
p300drivers/net/ni52.cp->iscp->busy = 1;
p306drivers/net/ni52.cif(p->iscp->busy)
p309drivers/net/ni52.cmemset((char *)p->scb,0,sizeof(struct scb_struct));
p454drivers/net/ni52.cstruct priv *p = (struct priv *) dev->priv;
p460drivers/net/ni52.cptr = (void *) ((char *)p->scb + sizeof(struct scb_struct));
p478drivers/net/ni52.cp->scb->cbl_offset = make16(cfg_cmd);
p480drivers/net/ni52.cp->scb->cmd = CUC_START; /* cmd.-unit start */
p504drivers/net/ni52.cp->scb->cbl_offset = make16(ias_cmd);
p506drivers/net/ni52.cp->scb->cmd = CUC_START; /* cmd.-unit start */
p528drivers/net/ni52.cp->scb->cbl_offset = make16(tdr_cmd);
p530drivers/net/ni52.cp->scb->cmd = CUC_START; /* cmd.-unit start */
p545drivers/net/ni52.cp->scb->cmd = p->scb->status & STAT_MASK;
p565drivers/net/ni52.cp->scb->cmd = p->scb->status & STAT_MASK;
p574drivers/net/ni52.cp->nop_cmds[i] = (struct nop_cmd_struct *)ptr;
p575drivers/net/ni52.cp->nop_cmds[i]->cmd_cmd    = CMD_NOP;
p576drivers/net/ni52.cp->nop_cmds[i]->cmd_status = 0;
p577drivers/net/ni52.cp->nop_cmds[i]->cmd_link   = make16((p->nop_cmds[i]));
p580drivers/net/ni52.cp->xmit_cmds[0] = (struct transmit_cmd_struct *)ptr; /* transmit cmd/buff 0 */
p585drivers/net/ni52.cp->nop_cmds[i] = (struct nop_cmd_struct *)ptr;
p586drivers/net/ni52.cp->nop_cmds[i]->cmd_cmd    = CMD_NOP;
p587drivers/net/ni52.cp->nop_cmds[i]->cmd_status = 0;
p588drivers/net/ni52.cp->nop_cmds[i]->cmd_link   = make16((p->nop_cmds[i]));
p590drivers/net/ni52.cp->xmit_cmds[i] = (struct transmit_cmd_struct *)ptr; /*transmit cmd/buff 0*/
p603drivers/net/ni52.cint len = ((char *) p->iscp - (char *) ptr - 8) / 6;
p622drivers/net/ni52.cp->scb->cbl_offset = make16(mc_cmd);
p623drivers/net/ni52.cp->scb->cmd = CUC_START;
p639drivers/net/ni52.cp->xmit_cbuffs[i] = (char *)ptr; /* char-buffs */
p641drivers/net/ni52.cp->xmit_buffs[i] = (struct tbd_struct *)ptr; /* TBD */
p643drivers/net/ni52.cif((void *)ptr > (void *)p->iscp) 
p648drivers/net/ni52.cmemset((char *)(p->xmit_cmds[i]) ,0, sizeof(struct transmit_cmd_struct));
p649drivers/net/ni52.cmemset((char *)(p->xmit_buffs[i]),0, sizeof(struct tbd_struct));
p650drivers/net/ni52.cp->xmit_cmds[i]->cmd_status = STAT_COMPL;
p651drivers/net/ni52.cp->xmit_cmds[i]->cmd_cmd = CMD_XMIT | CMD_INT;
p652drivers/net/ni52.cp->xmit_cmds[i]->tbd_offset = make16((p->xmit_buffs[i]));
p653drivers/net/ni52.cp->xmit_buffs[i]->next = 0xffff;
p654drivers/net/ni52.cp->xmit_buffs[i]->buffer = make24((p->xmit_cbuffs[i]));
p657drivers/net/ni52.cp->xmit_count = 0; 
p658drivers/net/ni52.cp->xmit_last  = 0;
p660drivers/net/ni52.cp->nop_point  = 0;
p667drivers/net/ni52.cp->scb->cbl_offset = make16(p->nop_cmds[0]);
p668drivers/net/ni52.cp->scb->cmd = CUC_START;
p672drivers/net/ni52.cp->xmit_cmds[0]->cmd_link = 0xffff;
p673drivers/net/ni52.cp->xmit_cmds[0]->cmd_cmd  = CMD_XMIT | CMD_LAST | CMD_INT;
p689drivers/net/ni52.cstruct priv *p = (struct priv *) dev->priv;
p691drivers/net/ni52.cmemset((char *) rfd,0,sizeof(struct rfd_struct)*p->num_recv_buffs);
p692drivers/net/ni52.cp->rfd_first = rfd;
p694drivers/net/ni52.cfor(i = 0; i < p->num_recv_buffs; i++)
p695drivers/net/ni52.crfd[i].next = make16(rfd + (i+1) % p->num_recv_buffs);
p696drivers/net/ni52.crfd[p->num_recv_buffs-1].last = RFD_SUSP;   /* RU suspend */
p698drivers/net/ni52.cptr = (void *) (rfd + p->num_recv_buffs);
p701drivers/net/ni52.cptr = (void *) (rbd + p->num_recv_buffs);
p704drivers/net/ni52.cmemset((char *) rbd,0,sizeof(struct rbd_struct)*p->num_recv_buffs);
p706drivers/net/ni52.cfor(i=0;i<p->num_recv_buffs;i++)
p708drivers/net/ni52.crbd[i].next = make16((rbd + (i+1) % p->num_recv_buffs));
p714drivers/net/ni52.cp->rfd_top  = p->rfd_first;
p715drivers/net/ni52.cp->rfd_last = p->rfd_first + p->num_recv_buffs - 1;
p717drivers/net/ni52.cp->scb->rfa_offset    = make16(p->rfd_first);
p718drivers/net/ni52.cp->rfd_first->rbd_offset  = make16(rbd);
p732drivers/net/ni52.cstruct priv *p;
p738drivers/net/ni52.cp = (struct priv *) dev->priv;
p742drivers/net/ni52.cwhile((stat=p->scb->status & STAT_MASK))
p744drivers/net/ni52.cp->scb->cmd = stat;
p757drivers/net/ni52.cprintk("%s: oops! CU has left active state. stat: %04x/%04x.\n",dev->name,(int) stat,(int) p->scb->status);
p763drivers/net/ni52.cif(p->scb->status & RU_SUSPEND) /* special case: RU_SUSPEND */
p766drivers/net/ni52.cp->scb->cmd = RUC_RESUME;
p771drivers/net/ni52.cprintk("%s: Receiver-Unit went 'NOT READY': %04x/%04x.\n",dev->name,(int) stat,(int) p->scb->status);
p776drivers/net/ni52.cif(p->scb->cmd)   /* timed out? */
p793drivers/net/ni52.cstruct priv *p = (struct priv *) dev->priv;
p795drivers/net/ni52.cfor(;(status = p->rfd_top->status) & STAT_COMPL;)
p797drivers/net/ni52.crbd = (struct rbd_struct *) make32(p->rfd_top->rbd_offset);
p810drivers/net/ni52.cmemcpy(skb_put(skb,totlen),(char *) p->base+(unsigned long) rbd->buffer, totlen);
p813drivers/net/ni52.cp->stats.rx_packets++;
p816drivers/net/ni52.cp->stats.rx_dropped++;
p821drivers/net/ni52.cp->stats.rx_dropped++;
p827drivers/net/ni52.cp->stats.rx_errors++;
p829drivers/net/ni52.cp->rfd_top->status = 0;
p830drivers/net/ni52.cp->rfd_top->last = RFD_SUSP;
p831drivers/net/ni52.cp->rfd_last->last = 0;        /* delete RU_SUSP  */
p832drivers/net/ni52.cp->rfd_last = p->rfd_top;
p833drivers/net/ni52.cp->rfd_top = (struct rfd_struct *) make32(p->rfd_top->next); /* step to next RFD */
p843drivers/net/ni52.cstruct priv *p = (struct priv *) dev->priv;
p845drivers/net/ni52.cp->stats.rx_errors++;
p848drivers/net/ni52.cp->scb->cmd = RUC_ABORT; /* usually the RU is in the 'no resource'-state .. abort it now. */
p852drivers/net/ni52.calloc_rfa(dev,(char *)p->rfd_first);
p855drivers/net/ni52.cprintk("%s: Receive-Unit restarted. Status: %04x\n",dev->name,p->scb->status);
p866drivers/net/ni52.cstruct priv *p = (struct priv *) dev->priv;
p868drivers/net/ni52.cstatus = p->xmit_cmds[p->xmit_last]->cmd_status;
p874drivers/net/ni52.cp->stats.tx_packets++;
p875drivers/net/ni52.cp->stats.collisions += (status & TCMD_MAXCOLLMASK);
p879drivers/net/ni52.cp->stats.tx_errors++;
p882drivers/net/ni52.cp->stats.collisions++;
p885drivers/net/ni52.cp->stats.tx_carrier_errors++;
p891drivers/net/ni52.cp->stats.tx_fifo_errors++;
p896drivers/net/ni52.cp->stats.collisions += 16;
p901drivers/net/ni52.cif( (++p->xmit_last) == NUM_XMIT_BUFFS) 
p902drivers/net/ni52.cp->xmit_last = 0;
p915drivers/net/ni52.cstruct priv *p = (struct priv *) dev->priv;
p917drivers/net/ni52.cp->scb->rfa_offset = make16(p->rfd_first);
p918drivers/net/ni52.cp->scb->cmd = RUC_START;
p933drivers/net/ni52.cstruct priv *p = (struct priv *) dev->priv;
p941drivers/net/ni52.cif(p->scb->status & CU_ACTIVE) /* COMMAND-UNIT active? */
p946drivers/net/ni52.cprintk("%s: X0: %04x N0: %04x N1: %04x %d\n",dev->name,(int)p->xmit_cmds[0]->cmd_status,(int)p->nop_cmds[0]->cmd_status,(int)p->nop_cmds[1]->cmd_status,(int)p->nop_point);
p948drivers/net/ni52.cp->scb->cmd = CUC_ABORT;
p951drivers/net/ni52.cp->scb->cbl_offset = make16(p->nop_cmds[p->nop_point]);
p952drivers/net/ni52.cp->scb->cmd = CUC_START;
p961drivers/net/ni52.cprintk("%s: xmitter timed out, try to restart! stat: %04x\n",dev->name,p->scb->status);
p962drivers/net/ni52.cprintk("%s: command-stats: %04x %04x\n",dev->name,p->xmit_cmds[0]->cmd_status,p->xmit_cmds[1]->cmd_status);
p989drivers/net/ni52.cmemcpy((char *)p->xmit_cbuffs[p->xmit_count],(char *)(skb->data),skb->len);
p994drivers/net/ni52.cp->xmit_buffs[0]->size = TBD_LAST | len;
p997drivers/net/ni52.cp->scb->cbl_offset = make16(p->xmit_cmds[0]);
p998drivers/net/ni52.cp->scb->cmd = CUC_START;
p999drivers/net/ni52.cp->xmit_cmds[0]->cmd_status = 0;
p1006drivers/net/ni52.cif( (p->scb->status & CU_ACTIVE)) /* test it, because CU sometimes doesn't start immediately */
p1008drivers/net/ni52.cif(p->xmit_cmds[0]->cmd_status)
p1014drivers/net/ni52.cnext_nop = (p->nop_point + 1) & 0x1;
p1015drivers/net/ni52.cp->xmit_buffs[0]->size = TBD_LAST | len;
p1017drivers/net/ni52.cp->xmit_cmds[0]->cmd_link   = p->nop_cmds[next_nop]->cmd_link 
p1018drivers/net/ni52.c= make16((p->nop_cmds[next_nop]));
p1019drivers/net/ni52.cp->xmit_cmds[0]->cmd_status = p->nop_cmds[next_nop]->cmd_status = 0;
p1021drivers/net/ni52.cp->nop_cmds[p->nop_point]->cmd_link = make16((p->xmit_cmds[0]));
p1023drivers/net/ni52.cp->nop_point = next_nop;
p1027drivers/net/ni52.cp->xmit_buffs[p->xmit_count]->size = TBD_LAST | len;
p1028drivers/net/ni52.cif( (next_nop = p->xmit_count + 1) == NUM_XMIT_BUFFS ) 
p1031drivers/net/ni52.cp->xmit_cmds[p->xmit_count]->cmd_status  = 0;
p1032drivers/net/ni52.cp->xmit_cmds[p->xmit_count]->cmd_link = p->nop_cmds[next_nop]->cmd_link 
p1033drivers/net/ni52.c= make16((p->nop_cmds[next_nop]));
p1034drivers/net/ni52.cp->nop_cmds[next_nop]->cmd_status = 0;
p1036drivers/net/ni52.cp->nop_cmds[p->xmit_count]->cmd_link = make16((p->xmit_cmds[p->xmit_count]));
p1038drivers/net/ni52.cp->xmit_count = next_nop;
p1041drivers/net/ni52.cif(p->xmit_count != p->xmit_last)
p1056drivers/net/ni52.cstruct priv *p = (struct priv *) dev->priv;
p1059drivers/net/ni52.ccrc = p->scb->crc_errs; /* get error-statistic from the ni82586 */
p1060drivers/net/ni52.cp->scb->crc_errs -= crc;
p1061drivers/net/ni52.caln = p->scb->aln_errs;
p1062drivers/net/ni52.cp->scb->aln_errs -= aln;
p1063drivers/net/ni52.crsc = p->scb->rsc_errs;
p1064drivers/net/ni52.cp->scb->rsc_errs -= rsc;
p1065drivers/net/ni52.covrn = p->scb->ovrn_errs;
p1066drivers/net/ni52.cp->scb->ovrn_errs -= ovrn;
p1068drivers/net/ni52.cp->stats.rx_crc_errors += crc;
p1069drivers/net/ni52.cp->stats.rx_fifo_errors += ovrn;
p1070drivers/net/ni52.cp->stats.rx_frame_errors += aln;
p1071drivers/net/ni52.cp->stats.rx_dropped += rsc;
p1073drivers/net/ni52.creturn &p->stats;
p208drivers/net/ni65.cstruct priv *p; 
p246drivers/net/ni65.cp = dev->priv = (void *) kmalloc(sizeof(struct priv),GFP_KERNEL);
p247drivers/net/ni65.cif (p == NULL)
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] = dev_alloc_skb(R_BUF_SIZE)) == 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);
p418drivers/net/ni65.cstruct priv *p = (struct priv *) dev->priv;
p421drivers/net/ni65.cp->stats.tx_errors++;
p423drivers/net/ni65.cp->stats.rx_errors++;
p450drivers/net/ni65.cstruct priv *p = (struct priv *) dev->priv;
p456drivers/net/ni65.cwhile(p->xmit_queued)
p458drivers/net/ni65.ctmdp = p->tmdhead + p->tmdlast;
p463drivers/net/ni65.cskb = (struct sk_buff *) p->tmdbufs[p->tmdlast];
p475drivers/net/ni65.cp->stats.tx_aborted_errors++;
p477drivers/net/ni65.cp->stats.tx_carrier_errors++;
p478drivers/net/ni65.cp->stats.tx_errors++;
p482drivers/net/ni65.cp->stats.tx_packets++;
p484drivers/net/ni65.cp->tmdlast = (p->tmdlast + 1) & (TMDNUM-1);
p485drivers/net/ni65.cif(p->tmdlast == p->tmdnum)
p486drivers/net/ni65.cp->xmit_queued = 0;
p502drivers/net/ni65.cstruct priv *p = (struct priv *) dev->priv;
p504drivers/net/ni65.crmdp = p->rmdhead + p->rmdnum;
p511drivers/net/ni65.cp->stats.rx_errors++;
p512drivers/net/ni65.cp->stats.rx_length_errors++;
p520drivers/net/ni65.cp->stats.rx_errors++;
p521drivers/net/ni65.cif(rmdstat & RCV_FRAM) p->stats.rx_frame_errors++;
p522drivers/net/ni65.cif(rmdstat & RCV_OFLO) p->stats.rx_over_errors++;
p523drivers/net/ni65.cif(rmdstat & RCV_CRC)  p->stats.rx_crc_errors++;
p534drivers/net/ni65.cmemcpy(skb_put(skb,len),p->recv_skb[p->rmdnum]->data,len);
p538drivers/net/ni65.cskb1 = p->recv_skb[p->rmdnum];
p539drivers/net/ni65.cp->recv_skb[p->rmdnum] = skb;
p545drivers/net/ni65.cp->stats.rx_packets++;
p553drivers/net/ni65.cp->stats.rx_dropped++;
p556drivers/net/ni65.cp->rmdnum++; p->rmdnum &= RMDNUM-1;
p557drivers/net/ni65.crmdp = p->rmdhead + p->rmdnum;
p567drivers/net/ni65.cstruct priv *p = (struct priv *) dev->priv;
p596drivers/net/ni65.cif(set_bit(0,(void*) &p->lock) != 0)
p605drivers/net/ni65.ctmdp = p->tmdhead + p->tmdnum;
p609drivers/net/ni65.cp->tmdbufs[p->tmdnum] = skb;
p618drivers/net/ni65.cp->xmit_queued = 1;
p620drivers/net/ni65.cp->tmdnum++; p->tmdnum &= TMDNUM-1;
p622drivers/net/ni65.cif( !((p->tmdhead + p->tmdnum)->u.s.status & XMIT_OWN) ) 
p624drivers/net/ni65.cp->lock = 0;
p258drivers/net/ppp.c#define bset(p,b)  ((p)[(b) >> 5] |= (1 << ((b) & 0x1f)))
p377drivers/net/ppp.cextern inline u_char * store_long (register u_char *p, register int value) {
p378drivers/net/ppp.c*p++ = (u_char) (value >> 24);
p379drivers/net/ppp.c*p++ = (u_char) (value >> 16);
p380drivers/net/ppp.c*p++ = (u_char) (value >>  8);
p381drivers/net/ppp.c*p++ = (u_char) value;
p382drivers/net/ppp.creturn p;
p1553drivers/net/ppp.cregister u_char *p;
p1560drivers/net/ppp.cp = &data [48];
p1561drivers/net/ppp.cp = store_long (p, ++ppp->stats.ppp_ilqrs);
p1562drivers/net/ppp.cp = store_long (p, ppp->stats.ppp_ipackets);
p1563drivers/net/ppp.cp = store_long (p, ppp->stats.ppp_discards);
p1564drivers/net/ppp.cp = store_long (p, ppp->stats.ppp_ierrors);
p1565drivers/net/ppp.cp = store_long (p, ppp->stats.ppp_ioctects + len);
p2130drivers/net/ppp.cu_char *p;
p2139drivers/net/ppp.cp   = (u_char *) &data [40];  /* Point to last two items. */
p2140drivers/net/ppp.cp   = store_long (p, ppp->stats.ppp_opackets + 1);
p2141drivers/net/ppp.cp   = store_long (p, ppp->stats.ppp_ooctects + len);
p2797drivers/net/ppp.cmemcpy (&temp.p, &ppp->stats, sizeof (struct pppstat));
p549drivers/net/seeq8005.cchar * p = buf;
p552drivers/net/seeq8005.cprintk("%02x ",*(p++)&0xff);
p642drivers/net/sk_g16.cstruct priv *p;         /* SK_G16 private structure */
p790drivers/net/sk_g16.cp = dev->priv = (void *) kmalloc(sizeof(struct priv), GFP_KERNEL);
p791drivers/net/sk_g16.cif (p == NULL)
p815drivers/net/sk_g16.cp->ram = (struct SK_ram *) rom_addr; /* Set dual ported RAM addr */
p816drivers/net/sk_g16.cp->tmdhead = &(p->ram)->tmde[0];     /* Set TMD head */
p817drivers/net/sk_g16.cp->rmdhead = &(p->ram)->rmde[0];     /* Set RMD head */
p823drivers/net/sk_g16.cp->tmdbufs[i] = &(p->ram)->tmdbuf[i];
p828drivers/net/sk_g16.cp->rmdbufs[i] = &(p->ram)->rmdbuf[i]; 
p874drivers/net/sk_g16.cstruct priv *p = (struct priv *)dev->priv;
p963drivers/net/sk_g16.c(int) dev->irq, (unsigned int) p->ram);
p1034drivers/net/sk_g16.cstruct priv *p = (struct priv *) dev->priv; 
p1045drivers/net/sk_g16.cp->tmdnum = 0;                   /* First descriptor for transmitting */ 
p1046drivers/net/sk_g16.cp->tmdlast = 0;                  /* First descriptor for reading stats */
p1050drivers/net/sk_g16.ctmdp = p->tmdhead + i; 
p1052drivers/net/sk_g16.ctmdp->u.buffer = (unsigned long) p->tmdbufs[i]; /* assign buffer */
p1061drivers/net/sk_g16.cp->rmdnum = 0;                   /* First RMD which will be used */
p1065drivers/net/sk_g16.crmdp = p->rmdhead + i;
p1068drivers/net/sk_g16.crmdp->u.buffer = (unsigned long) p->rmdbufs[i]; /* assign buffer */
p1085drivers/net/sk_g16.c(p->ram)->ib.mode = mode;        /* Set operation mode */
p1089drivers/net/sk_g16.c(p->ram)->ib.paddr[i] = dev->dev_addr[i]; 
p1094drivers/net/sk_g16.c(p->ram)->ib.laddr[i] = 0;   /* We do not use logical addressing */
p1099drivers/net/sk_g16.c(p->ram)->ib.rdrp = (int)  p->rmdhead | RMDNUMMASK;
p1100drivers/net/sk_g16.c(p->ram)->ib.tdrp = (int)  p->tmdhead | TMDNUMMASK;
p1153drivers/net/sk_g16.c(unsigned int) &(p->ram)->ib);
p1199drivers/net/sk_g16.cstruct priv *p = (struct priv *) dev->priv;
p1256drivers/net/sk_g16.ctmdp = p->tmdhead + p->tmdnum; /* Which descriptor for transmitting */
p1281drivers/net/sk_g16.cp->tmdnum++; 
p1282drivers/net/sk_g16.cp->tmdnum &= TMDNUM-1; 
p1285drivers/net/sk_g16.cif (! ((p->tmdhead + p->tmdnum)->u.s.status & TX_OWN) )
p1320drivers/net/sk_g16.cstruct priv *p = (struct priv *) dev->priv;
p1354drivers/net/sk_g16.cp->stats.rx_dropped++;
p1395drivers/net/sk_g16.cstruct priv *p = (struct priv *) dev->priv;
p1401drivers/net/sk_g16.ctmdp = p->tmdhead + p->tmdlast;     /* Which buffer we sent at last ? */
p1404drivers/net/sk_g16.cp->tmdlast++;
p1405drivers/net/sk_g16.cp->tmdlast &= TMDNUM-1;
p1424drivers/net/sk_g16.cp->stats.tx_aborted_errors++;   
p1426drivers/net/sk_g16.cp->stats.tx_window_errors++; 
p1428drivers/net/sk_g16.cp->stats.tx_carrier_errors++;
p1431drivers/net/sk_g16.cp->stats.tx_fifo_errors++;
p1441drivers/net/sk_g16.cp->stats.tx_errors++;
p1459drivers/net/sk_g16.cp->stats.collisions++; 
p1463drivers/net/sk_g16.cp->stats.tx_packets++; 
p1515drivers/net/sk_g16.cstruct priv *p = (struct priv *) dev->priv;
p1520drivers/net/sk_g16.crmdp = p->rmdhead + p->rmdnum;
p1542drivers/net/sk_g16.cp->stats.rx_errors++;        /* bad packet received */
p1543drivers/net/sk_g16.cp->stats.rx_length_errors++; /* packet to long */
p1563drivers/net/sk_g16.cp->stats.rx_errors++;
p1565drivers/net/sk_g16.cif (rmdstat & RX_FRAM) p->stats.rx_frame_errors++;
p1566drivers/net/sk_g16.cif (rmdstat & RX_CRC)  p->stats.rx_crc_errors++;
p1590drivers/net/sk_g16.cp->stats.rx_dropped++;
p1627drivers/net/sk_g16.cp->stats.rx_packets++;
p1630drivers/net/sk_g16.cp->rmdnum++;
p1631drivers/net/sk_g16.cp->rmdnum %= RMDNUM;
p1633drivers/net/sk_g16.crmdp = p->rmdhead + p->rmdnum;
p1700drivers/net/sk_g16.cstruct priv *p = (struct priv *) dev->priv;
p1705drivers/net/sk_g16.creturn &p->stats;             /* Return Device status */
p2089drivers/net/sk_g16.cstruct priv *p = (struct priv *) dev->priv;
p2094drivers/net/sk_g16.c(unsigned int) p->ram,
p2095drivers/net/sk_g16.c(unsigned int) p->tmdhead, 
p2096drivers/net/sk_g16.c(unsigned int) p->rmdhead, 
p2097drivers/net/sk_g16.c(unsigned int) &(p->ram)->ib);
p2107drivers/net/sk_g16.cprintk("tmdbufs%d: %#08x ", (i+1), (int) p->tmdbufs[i]);
p2117drivers/net/sk_g16.cprintk("rmdbufs%d: %#08x ", (i+1), (int) p->rmdbufs[i]);
p103drivers/net/slip.cstatic int slip_esc(unsigned char *p, unsigned char *d, int len);
p106drivers/net/slip.cstatic int slip_esc6(unsigned char *p, unsigned char *d, int len);
p400drivers/net/slip.cunsigned char *p;
p420drivers/net/slip.cp = icp;
p423drivers/net/slip.clen = slhc_compress(sl->slcomp, p, len, sl->cbuff, &p, 1);
p428drivers/net/slip.ccount = slip_esc6(p, (unsigned char *) sl->xbuff, len);
p431drivers/net/slip.ccount = slip_esc(p, (unsigned char *) sl->xbuff, len);
p2213drivers/net/wavelan.cwavelan_cu_show_one(device *dev, net_local *lp, int i, unsigned short p)
p2220drivers/net/wavelan.cprintk("%d: 0x%x:", i, p);
p2222drivers/net/wavelan.cobram_read(ioaddr, p, (unsigned char *)&actx, sizeof(actx));
p2241drivers/net/wavelan.cwavelan_psa_show(psa_t *p)
p2245drivers/net/wavelan.cprintk("psa_io_base_addr_1: 0x%02x,", p->psa_io_base_addr_1);
p2246drivers/net/wavelan.cprintk("psa_io_base_addr_2: 0x%02x,", p->psa_io_base_addr_2);
p2247drivers/net/wavelan.cprintk("psa_io_base_addr_3: 0x%02x,", p->psa_io_base_addr_3);
p2248drivers/net/wavelan.cprintk("psa_io_base_addr_4: 0x%02x,", p->psa_io_base_addr_4);
p2249drivers/net/wavelan.cprintk("psa_rem_boot_addr_1: 0x%02x,", p->psa_rem_boot_addr_1);
p2250drivers/net/wavelan.cprintk("psa_rem_boot_addr_2: 0x%02x,", p->psa_rem_boot_addr_2);
p2251drivers/net/wavelan.cprintk("psa_rem_boot_addr_3: 0x%02x,", p->psa_rem_boot_addr_3);
p2252drivers/net/wavelan.cprintk("psa_holi_params: 0x%02x,", p->psa_holi_params);
p2253drivers/net/wavelan.cprintk("psa_int_req_no: %d,", p->psa_int_req_no);
p2257drivers/net/wavelan.cp->psa_univ_mac_addr[0],
p2258drivers/net/wavelan.cp->psa_univ_mac_addr[1],
p2259drivers/net/wavelan.cp->psa_univ_mac_addr[2],
p2260drivers/net/wavelan.cp->psa_univ_mac_addr[3],
p2261drivers/net/wavelan.cp->psa_univ_mac_addr[4],
p2262drivers/net/wavelan.cp->psa_univ_mac_addr[5]
p2267drivers/net/wavelan.cp->psa_local_mac_addr[0],
p2268drivers/net/wavelan.cp->psa_local_mac_addr[1],
p2269drivers/net/wavelan.cp->psa_local_mac_addr[2],
p2270drivers/net/wavelan.cp->psa_local_mac_addr[3],
p2271drivers/net/wavelan.cp->psa_local_mac_addr[4],
p2272drivers/net/wavelan.cp->psa_local_mac_addr[5]
p2274drivers/net/wavelan.cprintk("psa_univ_local_sel: %d,", p->psa_univ_local_sel);
p2275drivers/net/wavelan.cprintk("psa_comp_number: %d,", p->psa_comp_number);
p2276drivers/net/wavelan.cprintk("psa_thr_pre_set: 0x%02x,", p->psa_thr_pre_set);
p2277drivers/net/wavelan.cprintk("psa_feature_select/decay_prm: 0x%02x,", p->psa_feature_select);
p2278drivers/net/wavelan.cprintk("psa_subband/decay_update_prm: %d,", p->psa_subband);
p2279drivers/net/wavelan.cprintk("psa_quality_thr: 0x%02x,", p->psa_quality_thr);
p2280drivers/net/wavelan.cprintk("psa_mod_delay: 0x%02x,", p->psa_mod_delay);
p2281drivers/net/wavelan.cprintk("psa_nwid: 0x%02x%02x,", p->psa_nwid[0], p->psa_nwid[1]);
p2282drivers/net/wavelan.cprintk("psa_undefined: %d,", p->psa_undefined);
p2283drivers/net/wavelan.cprintk("psa_encryption_select: %d,", p->psa_encryption_select);
p2287drivers/net/wavelan.cp->psa_encryption_key[0],
p2288drivers/net/wavelan.cp->psa_encryption_key[1],
p2289drivers/net/wavelan.cp->psa_encryption_key[2],
p2290drivers/net/wavelan.cp->psa_encryption_key[3],
p2291drivers/net/wavelan.cp->psa_encryption_key[4],
p2292drivers/net/wavelan.cp->psa_encryption_key[5],
p2293drivers/net/wavelan.cp->psa_encryption_key[6],
p2294drivers/net/wavelan.cp->psa_encryption_key[7]
p2296drivers/net/wavelan.cprintk("psa_databus_width: %d,", p->psa_databus_width);
p2297drivers/net/wavelan.cprintk("psa_call_code/auto_squelch: 0x%02x,", p->psa_call_code);
p2298drivers/net/wavelan.cprintk("psa_no_of_retries: %d,", p->psa_no_of_retries);
p2299drivers/net/wavelan.cprintk("psa_acr: %d,", p->psa_acr);
p2300drivers/net/wavelan.cprintk("psa_dump_count: %d,", p->psa_dump_count);
p2301drivers/net/wavelan.cprintk("psa_nwid_prefix: 0x%02x,", p->psa_nwid_prefix);
p2302drivers/net/wavelan.cprintk("psa_conf_status: %d,", p->psa_conf_status);
p2303drivers/net/wavelan.cprintk("psa_crc: 0x%02x%02x,", p->psa_crc[0], p->psa_crc[1]);
p2304drivers/net/wavelan.cprintk("psa_crc_status: 0x%02x,", p->psa_crc_status);
p2443drivers/net/wavelan.cunsigned short  p;
p2450drivers/net/wavelan.cfor (i = 0, p = lp->tx_first_in_use; i < NTXBLOCKS; i++)
p2452drivers/net/wavelan.cwavelan_cu_show_one(dev, lp, i, p);
p2454drivers/net/wavelan.cp += TXBLOCKZ;
p2455drivers/net/wavelan.cif (p >= OFFSET_CU + NTXBLOCKS * TXBLOCKZ)
p2456drivers/net/wavelan.cp -= NTXBLOCKS * TXBLOCKZ;
p115drivers/net/wavelan.h#define  mmwoff(p,f)   (unsigned short)((void *)(&((mmw_t *)((void *)0 + (p)))->f) - (void *)0)
p156drivers/net/wavelan.h#define  mmroff(p,f)   (unsigned short)((void *)(&((mmr_t *)((void *)0 + (p)))->f) - (void *)0)
p201drivers/net/wavelan.h#define  hoff(p,f)   (unsigned short)((void *)(&((ha_t *)((void *)0 + (p)))->f) - (void *)0)
p202drivers/net/wavelan.h#define  HACR(p)    hoff(p, ha_command)
p203drivers/net/wavelan.h#define  HASR(p)    hoff(p, ha_status)
p204drivers/net/wavelan.h#define  MMCR(p)    hoff(p, ha_mmcr)
p205drivers/net/wavelan.h#define  PIOR0(p)  hoff(p, ha_pior0)
p206drivers/net/wavelan.h#define  PIOP0(p)  hoff(p, ha_piop0)
p207drivers/net/wavelan.h#define  PIOR1(p)  hoff(p, ha_pior1)
p208drivers/net/wavelan.h#define  PIOP1(p)  hoff(p, ha_piop1)
p209drivers/net/wavelan.h#define  PIOR2(p)  hoff(p, ha_pior2)
p210drivers/net/wavelan.h#define  PIOP2(p)  hoff(p, ha_piop2)
p206drivers/net/znet.cchar *p;
p209drivers/net/znet.cfor(p = (char *)0xf0000; p < (char *)0x100000; p++)
p210drivers/net/znet.cif (*p == 'N'  &&  strncmp(p, "NETIDBLK", 8) == 0)
p213drivers/net/znet.cif (p >= (char *)0x100000) {
p218drivers/net/znet.cnetinfo = (struct netidblk *)p;
p1468drivers/scsi/NCR5380.cregister unsigned char p = *phase, tmp;
p1479drivers/scsi/NCR5380.cNCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
p1493drivers/scsi/NCR5380.cif ((tmp & PHASE_MASK) != p) {
p1502drivers/scsi/NCR5380.cif (!(p & SR_IO)) 
p1516drivers/scsi/NCR5380.cif (!(p & SR_IO)) {
p1517drivers/scsi/NCR5380.cif (!((p & SR_MSG) && c > 1)) {
p1558drivers/scsi/NCR5380.cif (!(p == PHASE_MSGIN && c == 1)) {  
p1559drivers/scsi/NCR5380.cif (p == PHASE_MSGOUT && c > 1)
p1578drivers/scsi/NCR5380.cif (!c || (*phase == p))
p1609drivers/scsi/NCR5380.cregister unsigned char p = *phase;
p1623drivers/scsi/NCR5380.cif ((tmp = (NCR5380_read(STATUS_REG) & PHASE_MASK)) != p) {
p1629drivers/scsi/NCR5380.cif (p & SR_IO) {
p1635drivers/scsi/NCR5380.cinstance->host_no, instance->dma_channel, (p & SR_IO) ? "reading" :
p1636drivers/scsi/NCR5380.c"writing", c, (p & SR_IO) ? "to" : "from", (unsigned) d);
p1638drivers/scsi/NCR5380.chostdata->dma_len = (p & SR_IO) ?
p1643drivers/scsi/NCR5380.cNCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
p1675drivers/scsi/NCR5380.cif (p & SR_IO) {
p1736drivers/scsi/NCR5380.cif (p & SR_IO) {
p1770drivers/scsi/NCR5380.cif (*phase == p && (p & SR_IO) && residue == 0) {
p1800drivers/scsi/NCR5380.cif (p & SR_IO) {
p95drivers/scsi/aha1542.h#define any2scsi(up, p)        \
p96drivers/scsi/aha1542.h(up)[0] = (((unsigned long)(p)) >> 16)  ;  \
p97drivers/scsi/aha1542.h(up)[1] = (((unsigned long)(p)) >> 8);    \
p98drivers/scsi/aha1542.h(up)[2] = ((unsigned long)(p));
p102drivers/scsi/aha1542.h#define xany2scsi(up, p)  \
p103drivers/scsi/aha1542.h(up)[0] = ((long)(p)) >> 24;  \
p104drivers/scsi/aha1542.h(up)[1] = ((long)(p)) >> 16;  \
p105drivers/scsi/aha1542.h(up)[2] = ((long)(p)) >> 8;  \
p106drivers/scsi/aha1542.h(up)[3] = ((long)(p));
p90drivers/scsi/aha1740.h#define any2scsi(up, p)        \
p91drivers/scsi/aha1740.h(up)[0] = (((unsigned long)(p)) >> 16)  ;  \
p92drivers/scsi/aha1740.h(up)[1] = (((unsigned long)(p)) >> 8);    \
p93drivers/scsi/aha1740.h(up)[2] = ((unsigned long)(p));
p97drivers/scsi/aha1740.h#define xany2scsi(up, p)  \
p98drivers/scsi/aha1740.h(up)[0] = ((long)(p)) >> 24;  \
p99drivers/scsi/aha1740.h(up)[1] = ((long)(p)) >> 16;  \
p100drivers/scsi/aha1740.h(up)[2] = ((long)(p)) >> 8;  \
p101drivers/scsi/aha1740.h(up)[3] = ((long)(p));
p766drivers/scsi/aic7xxx.c#define PAUSE_SEQUENCER(p) \
p767drivers/scsi/aic7xxx.coutb(p->pause, HCNTRL(p->base));      \
p768drivers/scsi/aic7xxx.cwhile ((inb(HCNTRL(p->base)) & PAUSE) == 0)    \
p775drivers/scsi/aic7xxx.c#define UNPAUSE_SEQUENCER(p) \
p776drivers/scsi/aic7xxx.coutb(p->unpause, HCNTRL(p->base))
p781drivers/scsi/aic7xxx.c#define RESTART_SEQUENCER(p) \
p783drivers/scsi/aic7xxx.coutb(SEQRESET | FASTMODE, SEQCTL(p->base));  \
p784drivers/scsi/aic7xxx.c} while (inb(SEQADDR0(p->base)) != 0 &&    \
p785drivers/scsi/aic7xxx.cinb(SEQADDR1(p->base)) != 0);    \
p786drivers/scsi/aic7xxx.cUNPAUSE_SEQUENCER(p);
p1058drivers/scsi/aic7xxx.cdebug_config(struct aic7xxx_host_config *p)
p1068drivers/scsi/aic7xxx.chost_conf = inb(HA_HOSTCONF(p->base));
p1069drivers/scsi/aic7xxx.cscsi_conf = inb(HA_SCSICONF(p->base));
p1078drivers/scsi/aic7xxx.cif ((p->type == AIC_274x) || (p->type == AIC_284x))
p1087drivers/scsi/aic7xxx.cbrelease = p->busrtime;
p1093drivers/scsi/aic7xxx.cswitch (p->type)
p1096drivers/scsi/aic7xxx.cprintk("AIC7770%s AT EISA SLOT %d:\n", BUSW[p->bus_type], p->base >> 12);
p1100drivers/scsi/aic7xxx.cprintk("AIC7770%s AT VLB SLOT %d:\n", BUSW[p->bus_type], p->base >> 12);
p1104drivers/scsi/aic7xxx.cprintk("AIC7870%s (PCI-bus):\n", BUSW[p->bus_type]);
p1108drivers/scsi/aic7xxx.cprintk("AIC7850%s (PCI-bus):\n", BUSW[p->bus_type]);
p1112drivers/scsi/aic7xxx.cprintk("AIC7872%s (PCI-bus):\n", BUSW[p->bus_type]);
p1122drivers/scsi/aic7xxx.cp->irq,
p1134drivers/scsi/aic7xxx.cif (((p->type == AIC_274x) || (p->type == AIC_284x)) && p->parity == AIC_UNKNOWN)
p1139drivers/scsi/aic7xxx.cp->parity = (scsi_conf & 0x20) ? AIC_ENABLED : AIC_DISABLED;
p1141drivers/scsi/aic7xxx.cif (p->parity != AIC_UNKNOWN)
p1144drivers/scsi/aic7xxx.c(p->parity == AIC_ENABLED) ? "en" : "dis");
p1147drivers/scsi/aic7xxx.cif (p->type == AIC_274x)
p1149drivers/scsi/aic7xxx.cp->low_term = (scsi_conf & 0x80) ? AIC_ENABLED : AIC_DISABLED;
p1151drivers/scsi/aic7xxx.cif (p->low_term != AIC_UNKNOWN)
p1154drivers/scsi/aic7xxx.c(p->low_term == AIC_ENABLED) ? "en" : "dis");
p1156drivers/scsi/aic7xxx.cif ((p->bus_type == AIC_WIDE) && (p->high_term != AIC_UNKNOWN))
p1159drivers/scsi/aic7xxx.c(p->high_term == AIC_ENABLED) ? "en" : "dis");
p1212drivers/scsi/aic7xxx.cchar *p;
p1223drivers/scsi/aic7xxx.cfor (p = strtok(s, ","); p; p = strtok(NULL, ","))
p1227drivers/scsi/aic7xxx.cif (!strcmp(options[i].name, p))
p1325drivers/scsi/aic7xxx.caic7xxx_poll_scb(struct aic7xxx_host *p,
p1389drivers/scsi/aic7xxx.caic7xxx_scb_tsleep(struct aic7xxx_host *p,
p1395drivers/scsi/aic7xxx.cUNPAUSE_SEQUENCER(p);
p1396drivers/scsi/aic7xxx.caic7xxx_poll_scb(p, scb, ticks);
p1403drivers/scsi/aic7xxx.cUNPAUSE_SEQUENCER(p);
p1691drivers/scsi/aic7xxx.caic7xxx_done(struct aic7xxx_host *p, struct aic7xxx_scb *scb)
p1718drivers/scsi/aic7xxx.cscb->next = p->free_scb;
p1719drivers/scsi/aic7xxx.cp->free_scb = &(p->scb_array[scb->position]);
p1808drivers/scsi/aic7xxx.caic7xxx_abort_waiting_scb(struct aic7xxx_host *p, struct aic7xxx_scb *scb,
p1814drivers/scsi/aic7xxx.cint base = p->base;
p1865drivers/scsi/aic7xxx.caic7xxx_done(p, scb);
p1879drivers/scsi/aic7xxx.caic7xxx_reset_device(struct aic7xxx_host *p, int target, char channel,
p1882drivers/scsi/aic7xxx.cint base = p->base;
p1903drivers/scsi/aic7xxx.cscb = &(p->scb_array[saved_queue[i]]);
p1911drivers/scsi/aic7xxx.caic7xxx_done(p, scb);
p1938drivers/scsi/aic7xxx.cscb = &(p->scb_array[next]);
p1944drivers/scsi/aic7xxx.cnext = aic7xxx_abort_waiting_scb(p, scb, prev, timedout_scb);
p1962drivers/scsi/aic7xxx.cfor(i = 0; i < p->numscb; i++)
p1964drivers/scsi/aic7xxx.cscb = &(p->scb_array[i]);
p1975drivers/scsi/aic7xxx.caic7xxx_done(p, scb);
p2007drivers/scsi/aic7xxx.caic7xxx_reset_channel(struct aic7xxx_host *p, char channel,
p2010drivers/scsi/aic7xxx.cint base = p->base;
p2020drivers/scsi/aic7xxx.cfound = aic7xxx_reset_device(p, ALL_TARGETS, channel, timedout_scb);
p2024drivers/scsi/aic7xxx.cp->needsdtr |= (p->needsdtr_copy & 0xFF00);
p2025drivers/scsi/aic7xxx.cp->sdtr_pending &= 0x00FF;
p2032drivers/scsi/aic7xxx.cif (p->bus_type == AIC_WIDE)
p2034drivers/scsi/aic7xxx.cp->needsdtr = p->needsdtr_copy;
p2035drivers/scsi/aic7xxx.cp->needwdtr = p->needwdtr_copy;
p2036drivers/scsi/aic7xxx.cp->sdtr_pending = 0;
p2037drivers/scsi/aic7xxx.cp->wdtr_pending = 0;
p2045drivers/scsi/aic7xxx.cp->needsdtr |= (p->needsdtr_copy & 0x00FF);
p2046drivers/scsi/aic7xxx.cp->sdtr_pending &= 0xFF00;
p2082drivers/scsi/aic7xxx.cUNPAUSE_SEQUENCER(p);
p2090drivers/scsi/aic7xxx.cRESTART_SEQUENCER(p);
p2110drivers/scsi/aic7xxx.cstruct aic7xxx_host *p;
p2123drivers/scsi/aic7xxx.cp = (struct aic7xxx_host *) aic7xxx_boards[irq]->hostdata;
p2129drivers/scsi/aic7xxx.cwhile ((p != NULL) && !(inb(INTSTAT(p->base)) & INT_PEND))
p2131drivers/scsi/aic7xxx.cif (p->next == NULL)
p2133drivers/scsi/aic7xxx.cp = NULL;
p2137drivers/scsi/aic7xxx.cp = (struct aic7xxx_host *) p->next->hostdata;
p2141drivers/scsi/aic7xxx.cif (p == NULL)
p2155drivers/scsi/aic7xxx.cp = (struct aic7xxx_host *) aic7xxx_boards[irq]->hostdata;
p2162drivers/scsi/aic7xxx.cp->isr_count++;
p2164drivers/scsi/aic7xxx.cif ((p->a_scanned == 0) && (p->isr_count == 1))
p2176drivers/scsi/aic7xxx.cbase = p->base;
p2208drivers/scsi/aic7xxx.cPAUSE_SEQUENCER(p);
p2236drivers/scsi/aic7xxx.cscb = &(p->scb_array[scb_index]);
p2258drivers/scsi/aic7xxx.cRESTART_SEQUENCER(p);
p2304drivers/scsi/aic7xxx.cif (p->sdtr_pending & target_mask)
p2323drivers/scsi/aic7xxx.cp->needsdtr &= ~target_mask;
p2324drivers/scsi/aic7xxx.cp->sdtr_pending &= ~target_mask;
p2327drivers/scsi/aic7xxx.cscb = &(p->scb_array[scb_index]);
p2337drivers/scsi/aic7xxx.c"needwdtr = 0x%x\n", scsi_id, channel, p->needwdtr);
p2340drivers/scsi/aic7xxx.cif (p->wdtr_pending & target_mask)
p2386drivers/scsi/aic7xxx.cp->needwdtr &= ~target_mask;
p2387drivers/scsi/aic7xxx.cp->wdtr_pending &= ~target_mask;
p2404drivers/scsi/aic7xxx.cif (p->wdtr_pending & target_mask)
p2410drivers/scsi/aic7xxx.cp->needwdtr &= ~target_mask;
p2411drivers/scsi/aic7xxx.cp->wdtr_pending &= ~target_mask;
p2418drivers/scsi/aic7xxx.cif (p->sdtr_pending & target_mask)
p2424drivers/scsi/aic7xxx.cp->needsdtr &= ~target_mask;
p2425drivers/scsi/aic7xxx.cp->sdtr_pending &= ~target_mask;
p2441drivers/scsi/aic7xxx.cscb = &(p->scb_array[scb_index]);
p2563drivers/scsi/aic7xxx.cscb = &(p->scb_array[scb_index]);
p2605drivers/scsi/aic7xxx.cscb = &(p->scb_array[scb_index]);
p2624drivers/scsi/aic7xxx.caic7xxx_done(p, scb);
p2630drivers/scsi/aic7xxx.cscb = &(p->scb_array[scb_index]);
p2659drivers/scsi/aic7xxx.cscb = &(p->scb_array[scb_index]);
p2668drivers/scsi/aic7xxx.cp->needsdtr |= (p->needsdtr_copy & target_mask);
p2669drivers/scsi/aic7xxx.cp->needwdtr |= (p->needwdtr_copy & target_mask);
p2670drivers/scsi/aic7xxx.cp->sdtr_pending &= ~target_mask;
p2671drivers/scsi/aic7xxx.cp->wdtr_pending &= ~target_mask;
p2675drivers/scsi/aic7xxx.cfound = aic7xxx_reset_device(p, (int) scsi_id, channel, SCB_LIST_NULL);
p2689drivers/scsi/aic7xxx.cUNPAUSE_SEQUENCER(p);
p2697drivers/scsi/aic7xxx.cscb = &(p->scb_array[scb_index]);
p2707drivers/scsi/aic7xxx.cUNPAUSE_SEQUENCER(p);
p2783drivers/scsi/aic7xxx.cRESTART_SEQUENCER(p);
p2784drivers/scsi/aic7xxx.caic7xxx_done(p, scb);
p2809drivers/scsi/aic7xxx.cUNPAUSE_SEQUENCER(p);
p2824drivers/scsi/aic7xxx.cUNPAUSE_SEQUENCER(p);
p2845drivers/scsi/aic7xxx.cscb = &(p->scb_array[complete]);
p2868drivers/scsi/aic7xxx.cscb->state, (unsigned int) scb->cmd, (unsigned int) p->free_scb);
p2881drivers/scsi/aic7xxx.caic7xxx_done(p, scb);
p2883drivers/scsi/aic7xxx.cif (scb != &p->scb_array[scb->position])
p2888drivers/scsi/aic7xxx.cscb->state, (unsigned int) scb->cmd, (unsigned int) p->free_scb);
p2903drivers/scsi/aic7xxx.csp = &p->stats[cmd->channel & 0x01][cmd->target & 0x0F][cmd->lun & 0x07];
p3068drivers/scsi/aic7xxx.c#define CLOCK_PULSE(p) \
p3294drivers/scsi/aic7xxx.cstruct aic7xxx_host *p;
p3609drivers/scsi/aic7xxx.cp = (struct aic7xxx_host *) host->hostdata;
p3616drivers/scsi/aic7xxx.cp->scb_array[i].state = SCB_FREE;
p3617drivers/scsi/aic7xxx.cp->scb_array[i].next = NULL;
p3618drivers/scsi/aic7xxx.cp->scb_array[i].cmd = NULL;
p3621drivers/scsi/aic7xxx.cp->isr_count = 0;
p3622drivers/scsi/aic7xxx.cp->a_scanned = 0;
p3623drivers/scsi/aic7xxx.cp->b_scanned = 0;
p3624drivers/scsi/aic7xxx.cp->base = config.base;
p3625drivers/scsi/aic7xxx.cp->maxscb = config.maxscb;
p3626drivers/scsi/aic7xxx.cp->numscb = 0;
p3627drivers/scsi/aic7xxx.cp->extended = config.extended;
p3628drivers/scsi/aic7xxx.cp->type = config.type;
p3629drivers/scsi/aic7xxx.cp->bus_type = config.bus_type;
p3630drivers/scsi/aic7xxx.cp->have_seeprom = have_seeprom;
p3631drivers/scsi/aic7xxx.cp->seeprom = sc;
p3632drivers/scsi/aic7xxx.cp->free_scb = NULL;
p3633drivers/scsi/aic7xxx.cp->next = NULL;
p3635drivers/scsi/aic7xxx.cp->unpause = config.unpause;
p3636drivers/scsi/aic7xxx.cp->pause = config.pause;
p3666drivers/scsi/aic7xxx.cp->next = aic7xxx_boards[config.irq];
p3685drivers/scsi/aic7xxx.cif ((p->type == AIC_274x) || (p->type == AIC_284x))
p3695drivers/scsi/aic7xxx.cif (p->bus_type == AIC_TWIN)
p3723drivers/scsi/aic7xxx.cp->needsdtr_copy = 0;
p3724drivers/scsi/aic7xxx.cp->sdtr_pending = 0;
p3725drivers/scsi/aic7xxx.cp->needwdtr_copy = 0;
p3726drivers/scsi/aic7xxx.cp->wdtr_pending = 0;
p3727drivers/scsi/aic7xxx.cif (p->bus_type == AIC_SINGLE)
p3740drivers/scsi/aic7xxx.cp->discenable = 0;
p3748drivers/scsi/aic7xxx.cp->discenable = 0xFFFF;
p3752drivers/scsi/aic7xxx.cp->discenable = ~(inw(HA_DISC_DSB(base)));
p3763drivers/scsi/aic7xxx.cp->needsdtr_copy |= (0x01 << i);
p3765drivers/scsi/aic7xxx.cif ((sc.device_flags[i] & CFWIDEB) && (p->bus_type == AIC_WIDE))
p3767drivers/scsi/aic7xxx.cp->needwdtr_copy |= (0x01 << i);
p3771drivers/scsi/aic7xxx.cp->discenable |= (0x01 << i);
p3779drivers/scsi/aic7xxx.cp->needsdtr_copy |= (0x01 << i);
p3790drivers/scsi/aic7xxx.cif ((target_settings & 0x80) && (p->bus_type == AIC_WIDE))
p3792drivers/scsi/aic7xxx.cp->needwdtr_copy |= (0x01 << i);
p3799drivers/scsi/aic7xxx.cp->needsdtr = p->needsdtr_copy;
p3800drivers/scsi/aic7xxx.cp->needwdtr = p->needwdtr_copy;
p3802drivers/scsi/aic7xxx.cprintk("NeedSdtr = 0x%x, 0x%x\n", p->needsdtr_copy, p->needsdtr);
p3803drivers/scsi/aic7xxx.cprintk("NeedWdtr = 0x%x, 0x%x\n", p->needwdtr_copy, p->needwdtr);
p3850drivers/scsi/aic7xxx.cif (p->bus_type == AIC_TWIN)
p3876drivers/scsi/aic7xxx.cUNPAUSE_SEQUENCER(p);
p4094drivers/scsi/aic7xxx.caic7xxx_buildscb(struct aic7xxx_host *p,
p4122drivers/scsi/aic7xxx.cif (p->discenable & mask)
p4126drivers/scsi/aic7xxx.cif ((p->needwdtr & mask) && !(p->wdtr_pending & mask))
p4128drivers/scsi/aic7xxx.cp->wdtr_pending |= mask;
p4136drivers/scsi/aic7xxx.cif ((p->needsdtr & mask) && !(p->sdtr_pending & mask))
p4138drivers/scsi/aic7xxx.cp->sdtr_pending |= mask;
p4148drivers/scsi/aic7xxx.ccmd->target, cmd->cmnd[0], cmd->cmd_len, p->needwdtr, mask);
p4227drivers/scsi/aic7xxx.cstruct aic7xxx_host *p;
p4231drivers/scsi/aic7xxx.cp = (struct aic7xxx_host *) cmd->host->hostdata;
p4236drivers/scsi/aic7xxx.cif (!p->a_scanned && (cmd->channel == 0))
p4239drivers/scsi/aic7xxx.cp->a_scanned = 1;
p4243drivers/scsi/aic7xxx.cif (!p->b_scanned && (cmd->channel == 1))
p4246drivers/scsi/aic7xxx.cp->b_scanned = 1;
p4275drivers/scsi/aic7xxx.cscb = p->free_scb;
p4278drivers/scsi/aic7xxx.cp->free_scb = scb->next;   /* remove and update head of list */
p4286drivers/scsi/aic7xxx.cscb = &(p->scb_array[scb->position]);
p4292drivers/scsi/aic7xxx.cif (p->numscb >= p->maxscb)
p4303drivers/scsi/aic7xxx.cscb = &(p->scb_array[p->numscb]);
p4306drivers/scsi/aic7xxx.cscb->position = p->numscb;
p4307drivers/scsi/aic7xxx.cp->numscb++;
p4312drivers/scsi/aic7xxx.cPAUSE_SEQUENCER(p);
p4313drivers/scsi/aic7xxx.ccurscb = inb(SCBPTR(p->base));
p4314drivers/scsi/aic7xxx.coutb(scb->position, SCBPTR(p->base));
p4315drivers/scsi/aic7xxx.caic7xxx_putscb_dma(p->base, scb);
p4316drivers/scsi/aic7xxx.coutb(curscb, SCBPTR(p->base));
p4317drivers/scsi/aic7xxx.cUNPAUSE_SEQUENCER(p);
p4332drivers/scsi/aic7xxx.caic7xxx_buildscb(p, cmd, scb);
p4335drivers/scsi/aic7xxx.cif (scb != &p->scb_array[scb->position])
p4341drivers/scsi/aic7xxx.cscb->state, (unsigned int) p->free_scb);
p4349drivers/scsi/aic7xxx.cPAUSE_SEQUENCER(p);
p4357drivers/scsi/aic7xxx.caic7xxx_putscb(p->base, scb);
p4372drivers/scsi/aic7xxx.cUNPAUSE_SEQUENCER(p);
p4392drivers/scsi/aic7xxx.caic7xxx_abort_scb(struct aic7xxx_host *p, struct aic7xxx_scb *scb)
p4394drivers/scsi/aic7xxx.cint base = p->base;
p4402drivers/scsi/aic7xxx.cPAUSE_SEQUENCER(p);
p4415drivers/scsi/aic7xxx.cfound = aic7xxx_reset_channel(p, channel, scb->position);
p4436drivers/scsi/aic7xxx.cactive_scbp = &(p->scb_array[active_scb]);
p4459drivers/scsi/aic7xxx.caic7xxx_scb_tsleep(p, scb, 2 * HZ);  /* unpauses the sequencer */
p4477drivers/scsi/aic7xxx.caic7xxx_reset_channel(p, channel, scb->position);
p4498drivers/scsi/aic7xxx.caic7xxx_scb_tsleep(p, active_scbp, 2 * HZ);
p4507drivers/scsi/aic7xxx.caic7xxx_reset_channel(p, channel, scb->position);
p4524drivers/scsi/aic7xxx.cstruct aic7xxx_host *p;
p4527drivers/scsi/aic7xxx.cp = (struct aic7xxx_host *) cmd->host->hostdata;
p4528drivers/scsi/aic7xxx.cscb = &(p->scb_array[aic7xxx_position(cmd)]);
p4533drivers/scsi/aic7xxx.caic7xxx_abort_scb(p, scb);
p4566drivers/scsi/aic7xxx.cstruct aic7xxx_host *p;
p4568drivers/scsi/aic7xxx.cp = (struct aic7xxx_host *) disk->device->host->hostdata;
p4579drivers/scsi/aic7xxx.cif (p->extended && cylinders > 1024)
p67drivers/scsi/aic7xxx_asm.cvoid *p = malloc(size);
p68drivers/scsi/aic7xxx_asm.cif (!p)
p70drivers/scsi/aic7xxx_asm.creturn(p);
p76drivers/scsi/aic7xxx_asm.cvoid *p = realloc(ptr, size);
p77drivers/scsi/aic7xxx_asm.cif (!p)
p79drivers/scsi/aic7xxx_asm.creturn(p);
p85drivers/scsi/aic7xxx_asm.cchar *p = (char *)Malloc(strlen(s) + 1);
p86drivers/scsi/aic7xxx_asm.cstrcpy(p, s);
p87drivers/scsi/aic7xxx_asm.creturn(p);
p103drivers/scsi/aic7xxx_asm.csym_t *p, *q;
p105drivers/scsi/aic7xxx_asm.cfor (p = head, q = (sym_t *)&head; p; p = p->next) {
p106drivers/scsi/aic7xxx_asm.cif (!strcmp(p->name, name))
p108drivers/scsi/aic7xxx_asm.cq = p;
p111drivers/scsi/aic7xxx_asm.cp = q->next = (sym_t *)Malloc(sizeof(sym_t));
p112drivers/scsi/aic7xxx_asm.cp->next = NULL;
p113drivers/scsi/aic7xxx_asm.cp->name = Strdup(name);
p114drivers/scsi/aic7xxx_asm.cp->value = value;
p115drivers/scsi/aic7xxx_asm.cp->npatch = 0;
p116drivers/scsi/aic7xxx_asm.cp->patch = NULL;
p119drivers/scsi/aic7xxx_asm.cfprintf(stderr, "\"%s\" ", p->name);
p120drivers/scsi/aic7xxx_asm.cif (p->value != NOVALUE)
p121drivers/scsi/aic7xxx_asm.cfprintf(stderr, "defined as 0x%x\n", p->value);
p130drivers/scsi/aic7xxx_asm.csym_t *p;
p132drivers/scsi/aic7xxx_asm.cfor (p = head; p; p = p->next)
p133drivers/scsi/aic7xxx_asm.cif (!strcmp(p->name, name))
p134drivers/scsi/aic7xxx_asm.creturn(p);
p139drivers/scsi/aic7xxx_asm.cpatch(sym_t *p, int location)
p141drivers/scsi/aic7xxx_asm.cp->npatch += 1;
p142drivers/scsi/aic7xxx_asm.cp->patch = (int *)Realloc(p->patch, p->npatch * sizeof(int *));
p144drivers/scsi/aic7xxx_asm.cp->patch[p->npatch - 1] = location;
p150drivers/scsi/aic7xxx_asm.csym_t *p;
p152drivers/scsi/aic7xxx_asm.cfor (p = head; p; p = p->next) {
p154drivers/scsi/aic7xxx_asm.cif (p->value == NOVALUE) {
p157drivers/scsi/aic7xxx_asm.cfilename, p->name);
p161drivers/scsi/aic7xxx_asm.cif (p->npatch) {
p165drivers/scsi/aic7xxx_asm.cp->name, p->value);
p167drivers/scsi/aic7xxx_asm.cfor (i = 0; i < p->npatch; i++) {
p168drivers/scsi/aic7xxx_asm.cM[p->patch[i]][0] &= ~1;
p169drivers/scsi/aic7xxx_asm.cM[p->patch[i]][0] |= ((p->value >> 8) & 1);
p170drivers/scsi/aic7xxx_asm.cM[p->patch[i]][1] = p->value & 0xff;
p173drivers/scsi/aic7xxx_asm.cfprintf(stderr, " 0x%x", p->patch[i]);
p204drivers/scsi/aic7xxx_asm.cchar *p, *quote;
p217drivers/scsi/aic7xxx_asm.cp = strchr(buf, '#');
p218drivers/scsi/aic7xxx_asm.cif (p)
p219drivers/scsi/aic7xxx_asm.c*p = '\0';
p220drivers/scsi/aic7xxx_asm.cp = buf;
p222drivers/scsi/aic7xxx_asm.cquote = strchr(p, '\"');
p225drivers/scsi/aic7xxx_asm.cfor (p = strtok(p, ", \t\n"); p; p = strtok(NULL, ", \t\n"))
p227drivers/scsi/aic7xxx_asm.ca[i++] = p;
p232drivers/scsi/aic7xxx_asm.cp = strchr(quote, '\"');
p233drivers/scsi/aic7xxx_asm.cif (!p)
p237drivers/scsi/aic7xxx_asm.c*p = '\0';
p238drivers/scsi/aic7xxx_asm.cp++;
p362drivers/scsi/aic7xxx_asm.csym_t *p;
p376drivers/scsi/aic7xxx_asm.cp = lookup(a[spec &~ (SL|SR|RL|RR)]);
p377drivers/scsi/aic7xxx_asm.cif (!p)
p379drivers/scsi/aic7xxx_asm.cval = p->value;
p420drivers/scsi/aic7xxx_asm.cp = lookup(a[spec]);
p421drivers/scsi/aic7xxx_asm.cif (p)
p422drivers/scsi/aic7xxx_asm.creturn(p->value);
p432drivers/scsi/aic7xxx_asm.csym_t *p;
p439drivers/scsi/aic7xxx_asm.cp = lookup(a[spec]);
p441drivers/scsi/aic7xxx_asm.cif (p) {
p442drivers/scsi/aic7xxx_asm.cif (p->value != NOVALUE)
p443drivers/scsi/aic7xxx_asm.creturn(p->value);
p444drivers/scsi/aic7xxx_asm.cpatch(p, LC);
p447drivers/scsi/aic7xxx_asm.cp = lookup(a[spec]);
p448drivers/scsi/aic7xxx_asm.cpatch(p, LC);
p527drivers/scsi/aic7xxx_asm.csym_t *p;
p533drivers/scsi/aic7xxx_asm.cp = lookup(*a);
p534drivers/scsi/aic7xxx_asm.cif (p)
p535drivers/scsi/aic7xxx_asm.cp->value = LC;
p574drivers/scsi/aic7xxx_asm.cchar *p;
p575drivers/scsi/aic7xxx_asm.cif ((p = strchr(optarg, '=')) != NULL) {
p576drivers/scsi/aic7xxx_asm.c*p = '\0';
p577drivers/scsi/aic7xxx_asm.cdefine(optarg, strtol(p + 1, NULL, 0));
p78drivers/scsi/aic7xxx_proc.cstruct aic7xxx_host *p;
p128drivers/scsi/aic7xxx_proc.cp = (struct aic7xxx_host *) HBAptr->hostdata;
p170drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "          SCSI Adapter: %s\n", board_name[p->type]);
p171drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "              Host Bus: %s\n", bus_name[p->bus_type]);
p172drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "               Base IO: %#.4x\n", p->base);
p174drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "                   SCB: %d (%d)\n", p->numscb, p->maxscb);
p175drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "            Interrupts: %d", p->isr_count);
p176drivers/scsi/aic7xxx_proc.cif ((p->type == AIC_274x) || (p->type == AIC_284x))
p179drivers/scsi/aic7xxx_proc.c(p->pause & IRQMS) ? "(Level Sensitive)" : "(Edge Triggered)");
p186drivers/scsi/aic7xxx_proc.cp->have_seeprom ? "True" : "False");
p187drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "         Pause/Unpause: %#.2x/%#.2x\n", p->pause,
p188drivers/scsi/aic7xxx_proc.cp->unpause);
p190drivers/scsi/aic7xxx_proc.cp->extended ? "En" : "Dis");
p211drivers/scsi/aic7xxx_proc.csp = &p->stats[channel][target][lun];
p354drivers/scsi/eata.cushort *p;
p356drivers/scsi/eata.cfor (p = start; p <= end; p++) {
p362drivers/scsi/eata.c*p = inw(iobase);
p786drivers/scsi/eata_dma.cu16 *p;
p802drivers/scsi/eata_dma.cfor (p = (u16 *) buf; 
p803drivers/scsi/eata_dma.c(long)p <= ((long)buf + (sizeof(struct get_conf) / 2)); p++) {
p809drivers/scsi/eata_dma.c*p = inw(base + HA_RDATA);
p2drivers/scsi/eata_dma_proc.cvoid swap_statistics(u8 *p)
p9drivers/scsi/eata_dma_proc.clp = (u32 *)p;
p22drivers/scsi/eata_dma_proc.c}while ((u32)lp < ((u32)p) + 4 + h_sp);
p585drivers/scsi/eata_pio.cushort *p;
p601drivers/scsi/eata_pio.cfor (p = (ushort *) buf; 
p602drivers/scsi/eata_pio.c(long)p <= ((long)buf + (sizeof(struct get_conf) / 2)); p++) {
p608drivers/scsi/eata_pio.c*p = inw(base + HA_RDATA);
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));
p2397drivers/scsi/scsi.cchar *p;
p2447drivers/scsi/scsi.cp = buffer + 17;
p2449drivers/scsi/scsi.cparameter[0] = simple_strtoul(p , &p, 0);
p2450drivers/scsi/scsi.cparameter[1] = simple_strtoul(p , &p, 0);
p2451drivers/scsi/scsi.cparameter[2] = simple_strtoul(p , &p, 0);
p2452drivers/scsi/scsi.cparameter[3] = simple_strtoul(p , &p, 0);
p179drivers/scsi/scsi_debug.cstruct partition * p;
p308drivers/scsi/scsi_debug.cp = (struct partition* ) (buff + 0x1be);
p311drivers/scsi/scsi_debug.cp->start_sect = starts[npart];
p312drivers/scsi/scsi_debug.cp->nr_sects = starts[npart+1] - starts [npart];
p313drivers/scsi/scsi_debug.cp->sys_ind = 0x81;  /* Linux partition */
p314drivers/scsi/scsi_debug.cp++;
p93drivers/scsi/scsicam.cstruct partition *p, *largest = NULL;
p100drivers/scsi/scsicam.cfor (largest_cyl = -1, p = (struct partition *) 
p101drivers/scsi/scsicam.c(0x1BE + bh->b_data), i = 0; i < 4; ++i, ++p) {
p102drivers/scsi/scsicam.cif (!p->sys_ind)
p108drivers/scsi/scsicam.ccyl = p->cyl + ((p->sector & 0xc0) << 2);
p111drivers/scsi/scsicam.clargest = p;
p862drivers/scsi/ultrastor.cunsigned char p = inb(port0 + i);
p863drivers/scsi/ultrastor.cout[28 + i * 3] = "0123456789abcdef"[p >> 4];
p864drivers/scsi/ultrastor.cout[29 + i * 3] = "0123456789abcdef"[p & 15];
p529drivers/scsi/wd7000.c#define any2scsi(up, p)      \
p530drivers/scsi/wd7000.c(up)[0] = (((unsigned long)(p)) >> 16);    \
p531drivers/scsi/wd7000.c(up)[1] = ((unsigned long)(p)) >> 8;    \
p532drivers/scsi/wd7000.c(up)[2] = ((unsigned long)(p));
p608drivers/scsi/wd7000.cregister Scb *scb, *p;
p645drivers/scsi/wd7000.cfor (i = 0; i < needed; i++)  { p = scbfree;  scbfree = p->next; }
p646drivers/scsi/wd7000.cp->next = NULL;
p191drivers/sound/audio.cint             c, p, l;
p196drivers/sound/audio.cp = 0;
p236drivers/sound/audio.creturn p;  /* No more space. Return # of accepted bytes */
p250drivers/sound/audio.cmemcpy_fromfs (&wr_dma_buf[dev][wr_buff_ptr[dev]], &((buf)[p]), l);
p254drivers/sound/audio.cwr_dma_buf[dev], wr_buff_ptr[dev], buf, p, l);
p271drivers/sound/audio.cp += l;
p292drivers/sound/audio.cint             c, p, l;
p297drivers/sound/audio.cp = 0;
p324drivers/sound/audio.creturn p;
p346drivers/sound/audio.cmemcpy_tofs (&((buf)[p]), dmabuf, l);
p350drivers/sound/audio.cp += l;
p300drivers/sound/configure.cchar           *method, *new, *old, *var, *p;
p302drivers/sound/configure.cmethod = p = line;
p304drivers/sound/configure.cwhile (*p && *p != ' ')
p305drivers/sound/configure.cp++;
p306drivers/sound/configure.c*p++ = 0;
p308drivers/sound/configure.cold = p;
p309drivers/sound/configure.cwhile (*p && *p != ' ')
p310drivers/sound/configure.cp++;
p311drivers/sound/configure.c*p++ = 0;
p313drivers/sound/configure.cnew = p;
p314drivers/sound/configure.cwhile (*p && *p != ' ')
p315drivers/sound/configure.cp++;
p316drivers/sound/configure.c*p++ = 0;
p318drivers/sound/configure.cvar = p;
p319drivers/sound/configure.cwhile (*p && *p != ' ')
p320drivers/sound/configure.cp++;
p321drivers/sound/configure.c*p++ = 0;
p560drivers/sound/dmabuf.cint             p = dmap->counts[dmap->qhead] + c;
p562drivers/sound/dmabuf.cif (p >= dmap->fragment_size)
p572drivers/sound/dmabuf.cdmap->counts[dmap->qhead] = p;
p2717drivers/sound/gus_wave.cint             i, p, best = -1, best_time = 0x7fffffff;
p2719drivers/sound/gus_wave.cp = alloc->ptr;
p2726drivers/sound/gus_wave.cif (alloc->map[p] == 0)
p2728drivers/sound/gus_wave.calloc->ptr = p;
p2729drivers/sound/gus_wave.creturn p;
p2731drivers/sound/gus_wave.cif (alloc->alloc_times[p] < best_time)
p2733drivers/sound/gus_wave.cbest = p;
p2734drivers/sound/gus_wave.cbest_time = alloc->alloc_times[p];
p2736drivers/sound/gus_wave.cp = (p + 1) % alloc->max_voice;
p2745drivers/sound/gus_wave.cif (alloc->map[p] == 0xffff)
p2747drivers/sound/gus_wave.calloc->ptr = p;
p2748drivers/sound/gus_wave.creturn p;
p2750drivers/sound/gus_wave.cp = (p + 1) % alloc->max_voice;
p2754drivers/sound/gus_wave.cp = best;
p2756drivers/sound/gus_wave.calloc->ptr = p;
p2757drivers/sound/gus_wave.creturn p;
p1070drivers/sound/opl3.cint             i, p, best, first, avail, best_time = 0x7fffffff;
p1091drivers/sound/opl3.cfirst = p = 0;
p1097drivers/sound/opl3.cfirst = p = 6;
p1099drivers/sound/opl3.cfirst = p = 0;
p1110drivers/sound/opl3.cif (alloc->map[p] == 0)
p1112drivers/sound/opl3.creturn p;
p1114drivers/sound/opl3.cif (alloc->alloc_times[p] < best_time)  /* Find oldest playing note */
p1116drivers/sound/opl3.cbest_time = alloc->alloc_times[p];
p1117drivers/sound/opl3.cbest = p;
p1119drivers/sound/opl3.cp = (p + 1) % avail;
p106drivers/sound/sequencer.cint             c = count, p = 0;
p158drivers/sound/sequencer.cmemcpy_tofs (&((buf)[p]), (char *) &iqueue[iqhead * IEV_SZ], ev_len);
p159drivers/sound/sequencer.cp += ev_len;
p268drivers/sound/sequencer.cint             p = 0, c, ev_size;
p288drivers/sound/sequencer.cmemcpy_fromfs ((char *) event, &((buf)[p]), 4);
p302drivers/sound/sequencer.cerr = synth_devs[dev]->load_patch (dev, *(short *) &event[0], buf, p + 4, c, 0);
p326drivers/sound/sequencer.cmemcpy_fromfs ((char *) &event[4], &((buf)[p + 4]), 4);
p383drivers/sound/sequencer.cp += ev_size;
p92fs/binfmt_elf.cunsigned long * create_elf_tables(char * p,int argc,int envc,struct elfhdr * exec, unsigned int load_addr, unsigned int interp_load_addr, int ibcs)
p101fs/binfmt_elf.cmpnt->vm_start = PAGE_MASK & (unsigned long) p;
p121fs/binfmt_elf.csp = (unsigned long *) (0xfffffffc & (unsigned long) p);
p156fs/binfmt_elf.ccurrent->mm->arg_start = (unsigned long) p;
p158fs/binfmt_elf.cput_user(p,argv++);
p159fs/binfmt_elf.cwhile (get_user(p++)) /* nothing */ ;
p162fs/binfmt_elf.ccurrent->mm->arg_end = current->mm->env_start = (unsigned long) p;
p164fs/binfmt_elf.cput_user(p,envp++);
p165fs/binfmt_elf.cwhile (get_user(p++)) /* nothing */ ;
p168fs/binfmt_elf.ccurrent->mm->env_end = (unsigned long) p;
p534fs/binfmt_elf.cbprm->p = copy_strings(1,&passed_p,bprm->page,bprm->p,2);
p538fs/binfmt_elf.cif (!bprm->p) {
p560fs/binfmt_elf.cbprm->p += setup_arg_pages(0, bprm->page);
p561fs/binfmt_elf.ccurrent->mm->start_stack = bprm->p;
p659fs/binfmt_elf.ccurrent->start_stack = p = elf_stack - 4;
p663fs/binfmt_elf.cbprm->p -= MAX_ARG_PAGES*PAGE_SIZE;
p664fs/binfmt_elf.cbprm->p = (unsigned long) 
p665fs/binfmt_elf.ccreate_elf_tables((char *)bprm->p,
p678fs/binfmt_elf.ccurrent->mm->start_stack = bprm->p;
p715fs/binfmt_elf.cstart_thread(regs, elf_entry, bprm->p);
p36fs/block_dev.cregister char * p;
p118fs/block_dev.cp = offset + bh->b_data;
p123fs/block_dev.cmemcpy_fromfs(p,buf,chars);
p124fs/block_dev.cp += chars;
p1102fs/buffer.cint * p;
p1109fs/buffer.cp = b;
p1111fs/buffer.cblock = *(p++);
p1118fs/buffer.cp = b;
p1129fs/buffer.cbh->b_blocknr = *(p++);
p1312fs/buffer.cstruct buffer_head * tmp, * p;
p1330fs/buffer.cp = tmp;
p1334fs/buffer.cif (p == *bhp)
p1336fs/buffer.c*bhp = p->b_prev_free;
p1337fs/buffer.cif (p == *bhp) /* Was this the last in the list? */
p1340fs/buffer.cremove_from_queues(p);
p1341fs/buffer.cput_unused_buffer_head(p);
p1586fs/buffer.cstruct buffer_head * tmp, * p;
p1609fs/buffer.cp = tmp;
p1611fs/buffer.cremove_from_queues(p);
p1612fs/buffer.cp->b_dev = dev;
p1613fs/buffer.cp->b_uptodate = 0;
p1614fs/buffer.cp->b_req = 0;
p1615fs/buffer.cp->b_blocknr = starting_block++;
p1616fs/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;
p310fs/exec.cunsigned long * create_tables(char * p, struct linux_binprm * bprm, int ibcs)
p321fs/exec.cmpnt->vm_start = PAGE_MASK & (unsigned long) p;
p331fs/exec.csp = (unsigned long *) ((-(unsigned long)sizeof(char *)) & (unsigned long) p);
p356fs/exec.ccurrent->mm->arg_start = (unsigned long) p;
p358fs/exec.cput_user(p,argv++);
p359fs/exec.cwhile (get_user(p++)) /* nothing */ ;
p362fs/exec.ccurrent->mm->arg_end = current->mm->env_start = (unsigned long) p;
p364fs/exec.cput_user(p,envp++);
p365fs/exec.cwhile (get_user(p++)) /* nothing */ ;
p368fs/exec.ccurrent->mm->env_end = (unsigned long) p;
p381fs/exec.cchar ** tmp, *p;
p387fs/exec.cwhile ((p = get_user(tmp++)) != NULL) {
p389fs/exec.cerror = verify_area(VERIFY_READ, p, 1);
p415fs/exec.cunsigned long p, int from_kmem)
p421fs/exec.cif (!p)
p438fs/exec.cif (p < len) {  /* this shouldn't happen - 128kB */
p443fs/exec.c--p; --tmp; --len;
p445fs/exec.coffset = p % PAGE_SIZE;
p448fs/exec.cif (!(pag = (char *) page[p/PAGE_SIZE]) &&
p449fs/exec.c!(pag = (char *) page[p/PAGE_SIZE] =
p461fs/exec.creturn p;
p616fs/exec.cbprm.p = PAGE_SIZE*MAX_ARG_PAGES-sizeof(void *);
p712fs/exec.cbprm.p = copy_strings(bprm.envc, envp, bprm.page, bprm.p, 0);
p713fs/exec.cbprm.p = copy_strings(--bprm.argc, argv+1, bprm.page, bprm.p, 0);
p723fs/exec.cbprm.p = copy_strings(1, &bprm.filename, bprm.page, bprm.p, 2);
p726fs/exec.cbprm.p = copy_strings(1, &i_arg, bprm.page, bprm.p, 2);
p729fs/exec.cbprm.p = copy_strings(1, &i_name, bprm.page, bprm.p, 2);
p731fs/exec.cif (!bprm.p) {
p751fs/exec.cbprm.p = copy_strings(1, dynloader, bprm.page, bprm.p, 2);
p752fs/exec.cbprm.loader = bprm.p;
p760fs/exec.cbprm.p = copy_strings(1, &bprm.filename, bprm.page, bprm.p, 2);
p761fs/exec.cbprm.exec = bprm.p;
p762fs/exec.cbprm.p = copy_strings(bprm.envc,envp,bprm.page,bprm.p,0);
p763fs/exec.cbprm.p = copy_strings(bprm.argc,argv,bprm.page,bprm.p,0);
p764fs/exec.cif (!bprm.p) {
p814fs/exec.cunsigned long p = bprm->p;
p915fs/exec.cp += fd_offset;
p920fs/exec.cp = (unsigned long)create_tables((char *)p, bprm,
p922fs/exec.ccurrent->mm->start_stack = p;
p926fs/exec.cstart_thread(regs, ex.a_entry, p);
p202fs/ext/file.cchar * p;
p241fs/ext/file.cp = (pos % BLOCK_SIZE) + bh->b_data;
p248fs/ext/file.cmemcpy_fromfs(p,buf,c);
p238fs/ext/inode.cunsigned long * p;
p241fs/ext/inode.cp = inode->u.ext_i.i_data + nr;
p243fs/ext/inode.ctmp = *p;
p246fs/ext/inode.cif (tmp == *p)
p257fs/ext/inode.cif (*p) {
p262fs/ext/inode.c*p = tmp;
p272fs/ext/inode.cunsigned long * p;
p285fs/ext/inode.cp = nr + (unsigned long *) bh->b_data;
p287fs/ext/inode.ctmp = *p;
p290fs/ext/inode.cif (tmp == *p) {
p307fs/ext/inode.cif (*p) {
p312fs/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;
p258fs/ext2/balloc.cchar * p, * r;
p335fs/ext2/balloc.cp = ((char *) bh->b_data) + (j >> 3);
p336fs/ext2/balloc.cr = memscan(p, 0, (EXT2_BLOCKS_PER_GROUP(sb) - j + 7) >> 3);
p187fs/ext2/inode.cu32 * p;
p192fs/ext2/inode.cp = inode->u.ext2_i.i_data + nr;
p194fs/ext2/inode.ctmp = *p;
p197fs/ext2/inode.cif (tmp == *p)
p232fs/ext2/inode.cif (*p) {
p237fs/ext2/inode.c*p = tmp;
p255fs/ext2/inode.cu32 * p;
p269fs/ext2/inode.cp = (u32 *) bh->b_data + nr;
p271fs/ext2/inode.ctmp = *p;
p274fs/ext2/inode.cif (tmp == *p) {
p306fs/ext2/inode.cif (*p) {
p311fs/ext2/inode.c*p = tmp;
p330fs/ext2/inode.cu32 * p;
p344fs/ext2/inode.cp = (u32 *) bh->b_data + nr + i;
p347fs/ext2/inode.cif(*p == 0) goto out;
p350fs/ext2/inode.cif(i==0) firstblock = *p;
p351fs/ext2/inode.celse if(*p != firstblock + i) goto out;
p354fs/ext2/inode.cp = (u32 *) bh->b_data + nr;
p355fs/ext2/inode.cresult = generate_cluster(bh->b_dev, (int *) p, blocksize);
p61fs/ext2/truncate.cu32 * p;
p74fs/ext2/truncate.cp = inode->u.ext2_i.i_data + i;
p75fs/ext2/truncate.ctmp = *p;
p84fs/ext2/truncate.cif ((bh && bh->b_count != 1) || tmp != *p) {
p89fs/ext2/truncate.c*p = 0;
p110fs/ext2/truncate.cstatic int trunc_indirect (struct inode * inode, int offset, u32 * p)
p124fs/ext2/truncate.ctmp = *p;
p128fs/ext2/truncate.cif (tmp != *p) {
p133fs/ext2/truncate.c*p = 0;
p185fs/ext2/truncate.ctmp = *p;
p186fs/ext2/truncate.c*p = 0;
p200fs/ext2/truncate.cu32 * p)
p211fs/ext2/truncate.ctmp = *p;
p215fs/ext2/truncate.cif (tmp != *p) {
p220fs/ext2/truncate.c*p = 0;
p246fs/ext2/truncate.ctmp = *p;
p247fs/ext2/truncate.c*p = 0;
p264fs/ext2/truncate.cu32 * tind, * p;
p273fs/ext2/truncate.cp = inode->u.ext2_i.i_data + EXT2_TIND_BLOCK;
p274fs/ext2/truncate.cif (!(tmp = *p))
p277fs/ext2/truncate.cif (tmp != *p) {
p282fs/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) &&
p260fs/hpfs/hpfs_fs.cstatic unsigned choose_conv(unsigned char *p, unsigned len);
p544fs/hpfs/hpfs_fs.cunsigned char *p = addr;
p545fs/hpfs/hpfs_fs.creturn p[0] == 0 && memcmp(p, p + 1, len - 1) == 0;
p555fs/hpfs/hpfs_fs.cchar *p, *rhs;
p566fs/hpfs/hpfs_fs.cfor (p = strtok(opts, ","); p != 0; p = strtok(0, ",")) {
p567fs/hpfs/hpfs_fs.cif ((rhs = strchr(p, '=')) != 0)
p569fs/hpfs/hpfs_fs.cif (!strcmp(p, "uid")) {
p576fs/hpfs/hpfs_fs.celse if (!strcmp(p, "gid")) {
p583fs/hpfs/hpfs_fs.celse if (!strcmp(p, "umask")) {
p590fs/hpfs/hpfs_fs.celse if (!strcmp(p, "case")) {
p598fs/hpfs/hpfs_fs.celse if (!strcmp(p, "conv")) {
p959fs/hpfs/hpfs_fs.cstatic unsigned choose_conv(unsigned char *p, unsigned len)
p967fs/hpfs/hpfs_fs.cc = *p++;
p969fs/hpfs/hpfs_fs.cif (c == '\r' && len && *p == '\n')
p293fs/isofs/rock.c{ int p;
p294fs/isofs/rock.cfor(p=0;p<rr->u.ER.len_id;p++) printk("%c",rr->u.ER.data[p]);
p18fs/isofs/util.cisonum_711 (char * p)
p20fs/isofs/util.creturn (*p & 0xff);
p24fs/isofs/util.cisonum_712 (char * p)
p28fs/isofs/util.cval = *p;
p35fs/isofs/util.cisonum_721 (char * p)
p37fs/isofs/util.creturn ((p[0] & 0xff) | ((p[1] & 0xff) << 8));
p41fs/isofs/util.cisonum_722 (char * p)
p43fs/isofs/util.creturn (((p[0] & 0xff) << 8) | (p[1] & 0xff));
p47fs/isofs/util.cisonum_723 (char * p)
p50fs/isofs/util.cif (p[0] != p[3] || p[1] != p[2]) {
p55fs/isofs/util.creturn (isonum_721 (p));
p59fs/isofs/util.cisonum_731 (char * p)
p61fs/isofs/util.creturn ((p[0] & 0xff)
p62fs/isofs/util.c| ((p[1] & 0xff) << 8)
p63fs/isofs/util.c| ((p[2] & 0xff) << 16)
p64fs/isofs/util.c| ((p[3] & 0xff) << 24));
p68fs/isofs/util.cisonum_732 (char * p)
p70fs/isofs/util.creturn (((p[0] & 0xff) << 24)
p71fs/isofs/util.c| ((p[1] & 0xff) << 16)
p72fs/isofs/util.c| ((p[2] & 0xff) << 8)
p73fs/isofs/util.c| (p[3] & 0xff));
p77fs/isofs/util.cisonum_733 (char * p)
p83fs/isofs/util.cif (p[i] != p[7-i]) {
p89fs/isofs/util.creturn (isonum_731 (p));
p96fs/isofs/util.cint iso_date(char * p, int flag)
p101fs/isofs/util.cyear = p[0] - 70;
p102fs/isofs/util.cmonth = p[1];
p103fs/isofs/util.cday = p[2];
p104fs/isofs/util.chour = p[3];
p105fs/isofs/util.cminute = p[4];
p106fs/isofs/util.csecond = p[5];
p107fs/isofs/util.cif (flag == 0) tz = p[6]; /* High sierra has no time zone */
p198fs/minix/file.cchar * p;
p234fs/minix/file.cp = (pos % BLOCK_SIZE) + bh->b_data;
p237fs/minix/file.cmemcpy_fromfs(p,buf,c);
p291fs/minix/inode.cunsigned short *p;
p294fs/minix/inode.cp = inode->u.minix_i.i_data + nr;
p296fs/minix/inode.ctmp = *p;
p299fs/minix/inode.cif (tmp == *p)
p310fs/minix/inode.cif (*p) {
p315fs/minix/inode.c*p = tmp;
p325fs/minix/inode.cunsigned short *p;
p338fs/minix/inode.cp = nr + (unsigned short *) bh->b_data;
p340fs/minix/inode.ctmp = *p;
p343fs/minix/inode.cif (tmp == *p) {
p360fs/minix/inode.cif (*p) {
p365fs/minix/inode.c*p = tmp;
p32fs/minix/truncate.cunsigned short * p;
p40fs/minix/truncate.cp = i + inode->u.minix_i.i_data;
p41fs/minix/truncate.cif (!(tmp = *p))
p48fs/minix/truncate.cif ((bh && bh->b_count != 1) || tmp != *p) {
p53fs/minix/truncate.c*p = 0;
p64fs/minix/truncate.cstatic int trunc_indirect(struct inode * inode, int offset, unsigned short * p)
p73fs/minix/truncate.ctmp = *p;
p77fs/minix/truncate.cif (tmp != *p) {
p82fs/minix/truncate.c*p = 0;
p118fs/minix/truncate.ctmp = *p;
p119fs/minix/truncate.c*p = 0;
p130fs/minix/truncate.cunsigned short * dind, * p;
p134fs/minix/truncate.cp = 8 + inode->u.minix_i.i_data;
p135fs/minix/truncate.cif (!(tmp = *p))
p138fs/minix/truncate.cif (tmp != *p) {
p143fs/minix/truncate.c*p = 0;
p164fs/minix/truncate.ctmp = *p;
p165fs/minix/truncate.c*p = 0;
p125fs/namei.cstruct task_struct * p;
p128fs/namei.cfor_each_task(p) {
p130fs/namei.cif (!p->mm)
p132fs/namei.cfor(mpnt = p->mm->mmap; mpnt; mpnt = mpnt->vm_next) {
p69fs/nfs/proc.cstatic int *nfs_rpc_header(int *p, int procedure, int ruid);
p70fs/nfs/proc.cstatic int *nfs_rpc_verify(int *p);
p91fs/nfs/proc.cstatic inline void nfs_rpc_free(int *p)
p93fs/nfs/proc.ckfree((void *)p);
p103fs/nfs/proc.cstatic inline int *xdr_encode_fhandle(int *p, struct nfs_fh *fhandle)
p105fs/nfs/proc.c*((struct nfs_fh *) p) = *fhandle;
p106fs/nfs/proc.creturn p + QUADLEN(sizeof(*fhandle));
p109fs/nfs/proc.cstatic inline int *xdr_decode_fhandle(int *p, struct nfs_fh *fhandle)
p111fs/nfs/proc.c*fhandle = *((struct nfs_fh *) p);
p112fs/nfs/proc.creturn p + QUADLEN(sizeof(*fhandle));
p115fs/nfs/proc.cstatic inline int *xdr_encode_string(int *p, const char *string)
p120fs/nfs/proc.cp[quadlen] = 0;
p121fs/nfs/proc.c*p++ = htonl(len);
p122fs/nfs/proc.cmemcpy(p, string, len);
p123fs/nfs/proc.creturn p + quadlen;
p126fs/nfs/proc.cstatic inline int *xdr_decode_string(int *p, char *string, unsigned int maxlen)
p128fs/nfs/proc.cunsigned int len = ntohl(*p++);
p131fs/nfs/proc.cmemcpy(string, p, len);
p133fs/nfs/proc.creturn p + QUADLEN(len);
p136fs/nfs/proc.cstatic inline int *xdr_decode_string2(int *p, char **string, unsigned int *len,
p139fs/nfs/proc.c*len = ntohl(*p++);
p142fs/nfs/proc.c*string = (char *) p;
p143fs/nfs/proc.creturn p + QUADLEN(*len);
p147fs/nfs/proc.cstatic inline int *xdr_encode_data(int *p, const char *data, int len)
p151fs/nfs/proc.cp[quadlen] = 0;
p152fs/nfs/proc.c*p++ = htonl(len);
p153fs/nfs/proc.cmemcpy_fromfs(p, data, len);
p154fs/nfs/proc.creturn p + quadlen;
p157fs/nfs/proc.cstatic inline int *xdr_decode_data(int *p, char *data, int *lenp, int maxlen,
p160fs/nfs/proc.cunsigned len = *lenp = ntohl(*p++);
p164fs/nfs/proc.cmemcpy_tofs(data, p, len);
p166fs/nfs/proc.cmemcpy(data, p, len);
p167fs/nfs/proc.creturn p + QUADLEN(len);
p170fs/nfs/proc.cstatic int *xdr_decode_fattr(int *p, struct nfs_fattr *fattr)
p172fs/nfs/proc.cfattr->type = (enum nfs_ftype) ntohl(*p++);
p173fs/nfs/proc.cfattr->mode = ntohl(*p++);
p174fs/nfs/proc.cfattr->nlink = ntohl(*p++);
p175fs/nfs/proc.cfattr->uid = ntohl(*p++);
p176fs/nfs/proc.cfattr->gid = ntohl(*p++);
p177fs/nfs/proc.cfattr->size = ntohl(*p++);
p178fs/nfs/proc.cfattr->blocksize = ntohl(*p++);
p179fs/nfs/proc.cfattr->rdev = ntohl(*p++);
p180fs/nfs/proc.cfattr->blocks = ntohl(*p++);
p181fs/nfs/proc.cfattr->fsid = ntohl(*p++);
p182fs/nfs/proc.cfattr->fileid = ntohl(*p++);
p183fs/nfs/proc.cfattr->atime.seconds = ntohl(*p++);
p184fs/nfs/proc.cfattr->atime.useconds = ntohl(*p++);
p185fs/nfs/proc.cfattr->mtime.seconds = ntohl(*p++);
p186fs/nfs/proc.cfattr->mtime.useconds = ntohl(*p++);
p187fs/nfs/proc.cfattr->ctime.seconds = ntohl(*p++);
p188fs/nfs/proc.cfattr->ctime.useconds = ntohl(*p++);
p189fs/nfs/proc.creturn p;
p192fs/nfs/proc.cstatic int *xdr_encode_sattr(int *p, struct nfs_sattr *sattr)
p194fs/nfs/proc.c*p++ = htonl(sattr->mode);
p195fs/nfs/proc.c*p++ = htonl(sattr->uid);
p196fs/nfs/proc.c*p++ = htonl(sattr->gid);
p197fs/nfs/proc.c*p++ = htonl(sattr->size);
p198fs/nfs/proc.c*p++ = htonl(sattr->atime.seconds);
p199fs/nfs/proc.c*p++ = htonl(sattr->atime.useconds);
p200fs/nfs/proc.c*p++ = htonl(sattr->mtime.seconds);
p201fs/nfs/proc.c*p++ = htonl(sattr->mtime.useconds);
p202fs/nfs/proc.creturn p;
p205fs/nfs/proc.cstatic int *xdr_decode_entry(int *p, struct nfs_entry *entry)
p207fs/nfs/proc.centry->fileid = ntohl(*p++);
p208fs/nfs/proc.cif (!(p = xdr_decode_string(p, entry->name, NFS_MAXNAMLEN)))
p210fs/nfs/proc.centry->cookie = ntohl(*p++);
p212fs/nfs/proc.creturn p;
p215fs/nfs/proc.cstatic int *xdr_decode_fsinfo(int *p, struct nfs_fsinfo *res)
p217fs/nfs/proc.cres->tsize = ntohl(*p++);
p218fs/nfs/proc.cres->bsize = ntohl(*p++);
p219fs/nfs/proc.cres->blocks = ntohl(*p++);
p220fs/nfs/proc.cres->bfree = ntohl(*p++);
p221fs/nfs/proc.cres->bavail = ntohl(*p++);
p222fs/nfs/proc.creturn p;
p232fs/nfs/proc.cint *p, *p0;
p240fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_GETATTR, ruid);
p241fs/nfs/proc.cp = xdr_encode_fhandle(p, fhandle);
p242fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->rsize)) < 0) {
p246fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p248fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p249fs/nfs/proc.cp = xdr_decode_fattr(p, fattr);
p268fs/nfs/proc.cint *p, *p0;
p276fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_SETATTR, ruid);
p277fs/nfs/proc.cp = xdr_encode_fhandle(p, fhandle);
p278fs/nfs/proc.cp = xdr_encode_sattr(p, sattr);
p279fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
p283fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p285fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p286fs/nfs/proc.cp = xdr_decode_fattr(p, fattr);
p305fs/nfs/proc.cint *p, *p0;
p317fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_LOOKUP, ruid);
p318fs/nfs/proc.cp = xdr_encode_fhandle(p, dir);
p319fs/nfs/proc.cp = xdr_encode_string(p, name);
p320fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->rsize)) < 0) {
p324fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p326fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p327fs/nfs/proc.cp = xdr_decode_fhandle(p, fhandle);
p328fs/nfs/proc.cp = xdr_decode_fattr(p, fattr);
p347fs/nfs/proc.cint *p;
p354fs/nfs/proc.cp = nfs_rpc_header(*p0, NFSPROC_READLINK, ruid);
p355fs/nfs/proc.cp = xdr_encode_fhandle(p, fhandle);
p356fs/nfs/proc.cif ((status = nfs_rpc_call(server, *p0, p, server->rsize)) < 0)
p358fs/nfs/proc.cif (!(p = nfs_rpc_verify(*p0)))
p360fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p361fs/nfs/proc.cif (!(p = xdr_decode_string2(p, string, len, maxlen))) {
p382fs/nfs/proc.cint *p, *p0;
p391fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_READ, ruid);
p392fs/nfs/proc.cp = xdr_encode_fhandle(p, fhandle);
p393fs/nfs/proc.c*p++ = htonl(offset);
p394fs/nfs/proc.c*p++ = htonl(count);
p395fs/nfs/proc.c*p++ = htonl(count); /* traditional, could be any value */
p396fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->rsize)) < 0) {
p400fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p402fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p403fs/nfs/proc.cp = xdr_decode_fattr(p, fattr);
p404fs/nfs/proc.cif (!(p = xdr_decode_data(p, data, &len, count, fs))) {
p428fs/nfs/proc.cint *p, *p0;
p436fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_WRITE, ruid);
p437fs/nfs/proc.cp = xdr_encode_fhandle(p, fhandle);
p438fs/nfs/proc.c*p++ = htonl(offset); /* traditional, could be any value */
p439fs/nfs/proc.c*p++ = htonl(offset);
p440fs/nfs/proc.c*p++ = htonl(count); /* traditional, could be any value */
p441fs/nfs/proc.cp = xdr_encode_data(p, data, count);
p442fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
p446fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p448fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p449fs/nfs/proc.cp = xdr_decode_fattr(p, fattr);
p469fs/nfs/proc.cint *p, *p0;
p477fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_CREATE, ruid);
p478fs/nfs/proc.cp = xdr_encode_fhandle(p, dir);
p479fs/nfs/proc.cp = xdr_encode_string(p, name);
p480fs/nfs/proc.cp = xdr_encode_sattr(p, sattr);
p481fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
p485fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p487fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p488fs/nfs/proc.cp = xdr_decode_fhandle(p, fhandle);
p489fs/nfs/proc.cp = xdr_decode_fattr(p, fattr);
p507fs/nfs/proc.cint *p, *p0;
p515fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_REMOVE, ruid);
p516fs/nfs/proc.cp = xdr_encode_fhandle(p, dir);
p517fs/nfs/proc.cp = xdr_encode_string(p, name);
p518fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
p522fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p524fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p544fs/nfs/proc.cint *p, *p0;
p552fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_RENAME, ruid);
p553fs/nfs/proc.cp = xdr_encode_fhandle(p, old_dir);
p554fs/nfs/proc.cp = xdr_encode_string(p, old_name);
p555fs/nfs/proc.cp = xdr_encode_fhandle(p, new_dir);
p556fs/nfs/proc.cp = xdr_encode_string(p, new_name);
p557fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
p561fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p563fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p582fs/nfs/proc.cint *p, *p0;
p590fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_LINK, ruid);
p591fs/nfs/proc.cp = xdr_encode_fhandle(p, fhandle);
p592fs/nfs/proc.cp = xdr_encode_fhandle(p, dir);
p593fs/nfs/proc.cp = xdr_encode_string(p, name);
p594fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
p598fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p600fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p619fs/nfs/proc.cint *p, *p0;
p627fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_SYMLINK, ruid);
p628fs/nfs/proc.cp = xdr_encode_fhandle(p, dir);
p629fs/nfs/proc.cp = xdr_encode_string(p, name);
p630fs/nfs/proc.cp = xdr_encode_string(p, path);
p631fs/nfs/proc.cp = xdr_encode_sattr(p, sattr);
p632fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
p636fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p638fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p658fs/nfs/proc.cint *p, *p0;
p666fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_MKDIR, ruid);
p667fs/nfs/proc.cp = xdr_encode_fhandle(p, dir);
p668fs/nfs/proc.cp = xdr_encode_string(p, name);
p669fs/nfs/proc.cp = xdr_encode_sattr(p, sattr);
p670fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
p674fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p676fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p677fs/nfs/proc.cp = xdr_decode_fhandle(p, fhandle);
p678fs/nfs/proc.cp = xdr_decode_fattr(p, fattr);
p696fs/nfs/proc.cint *p, *p0;
p704fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_RMDIR, ruid);
p705fs/nfs/proc.cp = xdr_encode_fhandle(p, dir);
p706fs/nfs/proc.cp = xdr_encode_string(p, name);
p707fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
p711fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p713fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p732fs/nfs/proc.cint *p, *p0;
p744fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_READDIR, ruid);
p745fs/nfs/proc.cp = xdr_encode_fhandle(p, fhandle);
p746fs/nfs/proc.c*p++ = htonl(cookie);
p747fs/nfs/proc.c*p++ = htonl(size);
p748fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->rsize)) < 0) {
p752fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p754fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p755fs/nfs/proc.cfor (i = 0; i < count && *p++; i++) {
p756fs/nfs/proc.cif (!(p = xdr_decode_entry(p, entry++)))
p759fs/nfs/proc.cif (!p) {
p764fs/nfs/proc.ceof = (i == count && !*p++ && *p++)
p765fs/nfs/proc.c|| (i < count && *p++);
p788fs/nfs/proc.cint *p, *p0;
p796fs/nfs/proc.cp = nfs_rpc_header(p0, NFSPROC_STATFS, ruid);
p797fs/nfs/proc.cp = xdr_encode_fhandle(p, fhandle);
p798fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->rsize)) < 0) {
p802fs/nfs/proc.cif (!(p = nfs_rpc_verify(p0)))
p804fs/nfs/proc.celse if ((status = ntohl(*p++)) == NFS_OK) {
p805fs/nfs/proc.cp = xdr_decode_fsinfo(p, res);
p825fs/nfs/proc.cstatic int *nfs_rpc_header(int *p, int procedure, int ruid)
p836fs/nfs/proc.c*p++ = htonl(++xid);
p837fs/nfs/proc.c*p++ = htonl(RPC_CALL);
p838fs/nfs/proc.c*p++ = htonl(RPC_VERSION);
p839fs/nfs/proc.c*p++ = htonl(NFS_PROGRAM);
p840fs/nfs/proc.c*p++ = htonl(NFS_VERSION);
p841fs/nfs/proc.c*p++ = htonl(procedure);
p842fs/nfs/proc.c*p++ = htonl(RPC_AUTH_UNIX);
p843fs/nfs/proc.cp1 = p++;
p844fs/nfs/proc.c*p++ = htonl(CURRENT_TIME); /* traditional, could be anything */
p845fs/nfs/proc.cp = xdr_encode_string(p, (char *) sys);
p846fs/nfs/proc.c*p++ = htonl(ruid ? current->uid : current->fsuid);
p847fs/nfs/proc.c*p++ = htonl(current->egid);
p848fs/nfs/proc.cp2 = p++;
p850fs/nfs/proc.c*p++ = htonl(current->groups[i]);
p852fs/nfs/proc.c*p1 = htonl((p - (p1 + 1)) << 2);
p853fs/nfs/proc.c*p++ = htonl(RPC_AUTH_NULL);
p854fs/nfs/proc.c*p++ = htonl(0);
p855fs/nfs/proc.creturn p;
p858fs/nfs/proc.cstatic int *nfs_rpc_verify(int *p)
p862fs/nfs/proc.cp++;
p863fs/nfs/proc.cif ((n = ntohl(*p++)) != RPC_REPLY) {
p867fs/nfs/proc.cif ((n = ntohl(*p++)) != RPC_MSG_ACCEPTED) {
p871fs/nfs/proc.cswitch (n = ntohl(*p++)) {
p878fs/nfs/proc.cif ((n = ntohl(*p++)) > 400) {
p882fs/nfs/proc.cp += QUADLEN(n);
p883fs/nfs/proc.cif ((n = ntohl(*p++)) != RPC_SUCCESS) {
p887fs/nfs/proc.creturn p;
p59fs/proc/array.cunsigned long p = file->f_pos, memsize;
p80fs/proc/array.cif (p >= memsize)
p82fs/proc/array.cif (count > memsize - p)
p83fs/proc/array.ccount = memsize - p;
p86fs/proc/array.cif (p < sizeof(struct user) && count > 0) {
p88fs/proc/array.cif (p + count1 > sizeof(struct user))
p89fs/proc/array.ccount1 = sizeof(struct user)-p;
p90fs/proc/array.cpnt = (char *) &dump + p;
p93fs/proc/array.cp += count1;
p98fs/proc/array.cwhile (count > 0 && p < PAGE_SIZE + FIRST_MAPPED) {
p101fs/proc/array.cp++;
p105fs/proc/array.cmemcpy_tofs(buf, (void *) (PAGE_OFFSET + p - PAGE_SIZE), count);
p132fs/proc/array.cunsigned long p = file->f_pos;
p139fs/proc/array.cif (p >= (prof_len+1)*sizeof(unsigned long))
p141fs/proc/array.cif (count > (prof_len+1)*sizeof(unsigned long) - p)
p142fs/proc/array.ccount = (prof_len+1)*sizeof(unsigned long) - p;
p145fs/proc/array.cwhile (p < sizeof(unsigned long) && count > 0) {
p146fs/proc/array.cput_user(*((char *)(&sample_step)+p),buf);
p147fs/proc/array.cbuf++; p++; count--; read++;
p149fs/proc/array.cpnt = (char *)prof_buffer + p - sizeof(unsigned long);
p283fs/proc/array.cstruct task_struct ** p;
p285fs/proc/array.cp = task;
p286fs/proc/array.cwhile (++p < task+NR_TASKS) {
p287fs/proc/array.cif (*p && (*p)->pid == pid)
p288fs/proc/array.creturn p;
p293fs/proc/array.cstatic unsigned long get_phys_addr(struct task_struct * p, unsigned long ptr)
p299fs/proc/array.cif (!p || !p->mm || ptr >= TASK_SIZE)
p301fs/proc/array.cpage_dir = pgd_offset(p->mm,ptr);
p323fs/proc/array.cstatic int get_array(struct task_struct ** p, unsigned long start, unsigned long end, char * buffer)
p332fs/proc/array.caddr = get_phys_addr(*p, start);
p358fs/proc/array.cstruct task_struct ** p = get_task(pid);
p360fs/proc/array.cif (!p || !*p || !(*p)->mm)
p362fs/proc/array.creturn get_array(p, (*p)->mm->env_start, (*p)->mm->env_end, buffer);
p367fs/proc/array.cstruct task_struct ** p = get_task(pid);
p369fs/proc/array.cif (!p || !*p || !(*p)->mm)
p371fs/proc/array.creturn get_array(p, (*p)->mm->arg_start, (*p)->mm->arg_end, buffer);
p374fs/proc/array.cstatic unsigned long get_wchan(struct task_struct *p)
p376fs/proc/array.cif (!p || p == current || p->state == TASK_RUNNING)
p384fs/proc/array.cstack_page = p->kernel_stack_page;
p387fs/proc/array.cebp = p->tss.ebp;
p412fs/proc/array.cpc = thread_saved_pc(&p->tss);
p414fs/proc/array.cschedule_frame = ((unsigned long *)p->tss.ksp)[6];
p438fs/proc/array.cstruct task_struct ** p = get_task(pid), *tsk;
p445fs/proc/array.cif (!p || (tsk = *p) == NULL)
p607fs/proc/array.cstruct task_struct ** p = get_task(pid), *tsk;
p610fs/proc/array.cif (!p || (tsk = *p) == NULL)
p666fs/proc/array.cstruct task_struct ** p = get_task(pid);
p673fs/proc/array.cif (!p || !*p)
p676fs/proc/array.cif (!(*p)->mm || count == 0)
p684fs/proc/array.cfor (map = (*p)->mm->mmap, i = 0; map && (i < lineno); map = map->vm_next, i++)
p744fs/proc/array.cif (*p != current)
p52fs/proc/base.cstruct task_struct * p;
p56fs/proc/base.cfor_each_task(p) {
p57fs/proc/base.cif (p->pid == pid) {
p58fs/proc/base.cif (p->dumpable || ino == PROC_PID_INO) {
p59fs/proc/base.cinode->i_uid = p->euid;
p60fs/proc/base.cinode->i_gid = p->gid;
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)
p124fs/proc/fd.cstruct task_struct * p;
p146fs/proc/fd.cif ((p = task[task_nr]) && p->pid == pid)
p153fs/proc/fd.cif (!p->files)
p155fs/proc/fd.cif (!p->files->fd[fd] || !p->files->fd[fd]->f_inode)
p171fs/proc/fd.cif (p != task[task_nr] || p->pid != pid)
p135fs/proc/inode.cstruct task_struct * p;
p149fs/proc/inode.cp = task[0];
p151fs/proc/inode.cif ((p = task[i]) && (p->pid == pid))
p153fs/proc/inode.cif (!p || i >= NR_TASKS)
p196fs/proc/inode.cif (ino == PROC_PID_INO || p->dumpable) {
p197fs/proc/inode.cinode->i_uid = p->euid;
p198fs/proc/inode.cinode->i_gid = p->egid;
p238fs/proc/inode.cif (ino >= NR_OPEN || !p->files->fd[ino])
p243fs/proc/inode.cif (p->files->fd[ino]->f_mode & 1)
p245fs/proc/inode.cif (p->files->fd[ino]->f_mode & 2)
p67fs/proc/link.cstruct task_struct * p;
p84fs/proc/link.cif ((p = task[i]) && p->pid == pid)
p93fs/proc/link.cif (!p->fs)
p95fs/proc/link.cnew_inode = p->fs->pwd;
p98fs/proc/link.cif (!p->fs)
p100fs/proc/link.cnew_inode = p->fs->root;
p104fs/proc/link.cif (!p->mm)
p106fs/proc/link.cvma = p->mm->mmap;
p119fs/proc/link.cif (!p->files)
p122fs/proc/link.cif (ino < NR_OPEN && p->files->fd[ino]) {
p123fs/proc/link.cnew_inode = p->files->fd[ino]->f_inode;
p147fs/proc/root.cstruct proc_dir_entry **p = &dir->subdir, *dp;
p149fs/proc/root.cwhile ((dp = *p) != NULL) {
p151fs/proc/root.c*p = dp->next;
p157fs/proc/root.cp = &dp->next;
p495fs/proc/root.cstruct task_struct * p = task[nr];
p497fs/proc/root.cif (!p || !(pid = p->pid))
p48fs/select.cstatic void free_wait(select_table * p)
p50fs/select.cstruct select_table_entry * entry = p->entry + p->nr;
p52fs/select.cwhile (p->nr > 0) {
p53fs/select.cp->nr--;
p44fs/smbfs/proc.csmb_encode_word(byte *p, word data)
p47fs/smbfs/proc.c*((word *)p) = data;
p49fs/smbfs/proc.cp[0] = data & 0x00ffU;
p50fs/smbfs/proc.cp[1] = (data & 0xff00U) >> 8;
p53fs/smbfs/proc.creturn &p[2];
p57fs/smbfs/proc.csmb_decode_word(byte *p, word *data)
p60fs/smbfs/proc.c*data = *(word *)p;
p62fs/smbfs/proc.c*data = (word) p[0] | p[1] << 8;
p64fs/smbfs/proc.creturn &p[2];
p68fs/smbfs/proc.csmb_encode_smb_length(byte *p, dword len)
p70fs/smbfs/proc.cp[0] = p[1] = 0;
p71fs/smbfs/proc.cp[2] = (len & 0xFF00) >> 8;
p72fs/smbfs/proc.cp[3] = (len & 0xFF);
p74fs/smbfs/proc.cp[1] |= 0x01;
p75fs/smbfs/proc.creturn &p[4];
p79fs/smbfs/proc.csmb_encode_dialect(byte *p, const byte *name, int len)
p81fs/smbfs/proc.c*p ++ = 2;
p82fs/smbfs/proc.cstrcpy(p, name);
p83fs/smbfs/proc.creturn p + len + 1;
p87fs/smbfs/proc.csmb_encode_ascii(byte *p, const byte *name, int len)
p89fs/smbfs/proc.c*p ++ = 4;
p90fs/smbfs/proc.cstrcpy(p, name);
p91fs/smbfs/proc.creturn p + len + 1;
p95fs/smbfs/proc.csmb_encode_vblock(byte *p, const byte *data, word len, int fs)
p97fs/smbfs/proc.c*p ++ = 5;
p98fs/smbfs/proc.cp = smb_encode_word(p, len);
p100fs/smbfs/proc.cmemcpy_fromfs(p, data, len);
p102fs/smbfs/proc.cmemcpy(p, data, len);
p103fs/smbfs/proc.creturn p + len;
p107fs/smbfs/proc.csmb_decode_data(byte *p, byte *data, word *data_len, int fs)
p111fs/smbfs/proc.cif (!(*p == 1 || *p == 5)) {
p116fs/smbfs/proc.clen = WVAL(p, 1);
p117fs/smbfs/proc.cp += 3;
p120fs/smbfs/proc.cmemcpy_tofs(data, p, len);
p122fs/smbfs/proc.cmemcpy(data, p, len);
p126fs/smbfs/proc.creturn p + len;
p130fs/smbfs/proc.csmb_name_mangle(byte *p, const byte *name)
p139fs/smbfs/proc.c*p ++ = 2 * (len + pad);
p142fs/smbfs/proc.c*p ++ = (*name >> 4) + 'A';
p143fs/smbfs/proc.c*p ++ = (*name & 0x0F) + 'A';
p147fs/smbfs/proc.c*p ++ = 'C';
p148fs/smbfs/proc.c*p ++ = 'A';
p150fs/smbfs/proc.c*p++ = '\0';
p152fs/smbfs/proc.creturn p;
p479fs/smbfs/proc.cbyte *p = server->packet;
p482fs/smbfs/proc.cp = smb_encode_smb_length(p, xmit_len);
p484fs/smbfs/proc.cBSET(p,0,0xff);
p485fs/smbfs/proc.cBSET(p,1,'S');
p486fs/smbfs/proc.cBSET(p,2,'M');
p487fs/smbfs/proc.cBSET(p,3,'B');
p488fs/smbfs/proc.cBSET(p,4,command);
p490fs/smbfs/proc.cp += 5;
p491fs/smbfs/proc.cmemset(p, '\0', 19);
p492fs/smbfs/proc.cp += 19;
p493fs/smbfs/proc.cp += 8;
p505fs/smbfs/proc.c*p++ = wct;    /* wct */
p506fs/smbfs/proc.cp += 2*wct;
p507fs/smbfs/proc.cWSET(p, 0, bcc);
p508fs/smbfs/proc.creturn p+2;
p535fs/smbfs/proc.cchar* p;
p544fs/smbfs/proc.cp = smb_setup_header(server, SMBopen, 2, 2 + len);
p547fs/smbfs/proc.csmb_encode_ascii(p, pathname, len);
p560fs/smbfs/proc.cp = smb_setup_header(server, SMBopen, 2, 2 + len);
p563fs/smbfs/proc.csmb_encode_ascii(p, pathname, len);
p678fs/smbfs/proc.cbyte *p;
p680fs/smbfs/proc.cp = smb_setup_header_exclusive(server, SMBwrite, 5, count + 3);
p686fs/smbfs/proc.c*p++ = 1;
p687fs/smbfs/proc.cWSET(p, 0, count);
p688fs/smbfs/proc.cmemcpy_fromfs(p+2, data, count);
p761fs/smbfs/proc.cchar *p;
p766fs/smbfs/proc.cp = smb_setup_header(server, command, 3, len + 2);
p769fs/smbfs/proc.csmb_encode_ascii(p, path, len);
p807fs/smbfs/proc.cchar *p;
p814fs/smbfs/proc.cp = smb_setup_header(server, SMBmv, 1, olen + nlen + 4);
p816fs/smbfs/proc.cp = smb_encode_ascii(p, opath, olen);
p817fs/smbfs/proc.csmb_encode_ascii(p, npath, olen);
p831fs/smbfs/proc.cchar *p;
p837fs/smbfs/proc.cp = smb_setup_header(server, SMBmkdir, 0, 2 + len);
p838fs/smbfs/proc.csmb_encode_ascii(p, path, len);
p852fs/smbfs/proc.cchar *p;
p858fs/smbfs/proc.cp = smb_setup_header(server, SMBrmdir, 0, 2 + len);
p859fs/smbfs/proc.csmb_encode_ascii(p, path, len);
p873fs/smbfs/proc.cchar *p;
p880fs/smbfs/proc.cp = smb_setup_header(server, SMBunlink, 1, 2 + len);
p882fs/smbfs/proc.csmb_encode_ascii(p, path, len);
p896fs/smbfs/proc.cchar *p;
p903fs/smbfs/proc.cp = smb_setup_header(server, SMBwrite, 5, 3);
p908fs/smbfs/proc.csmb_encode_ascii(p, "", 0);
p920fs/smbfs/proc.csmb_decode_dirent(char *p, struct smb_dirent *entry)
p922fs/smbfs/proc.cp += SMB_STATUS_SIZE;                  /* reserved (search_status) */
p923fs/smbfs/proc.centry->attr = BVAL(p, 0);
p925fs/smbfs/proc.cdate_dos2unix(WVAL(p, 1), WVAL(p, 3));
p926fs/smbfs/proc.centry->size = DVAL(p, 5);
p927fs/smbfs/proc.cmemcpy(entry->path, p+9, 13);
p929fs/smbfs/proc.creturn p + 22;
p940fs/smbfs/proc.cchar *p;
p971fs/smbfs/proc.cp = smb_setup_header(server, SMBsearch, 2,
p975fs/smbfs/proc.cp = smb_encode_ascii(p, mask, strlen(mask));
p976fs/smbfs/proc.c*p ++ = 5;
p977fs/smbfs/proc.cp = smb_encode_word(p, 0);
p979fs/smbfs/proc.cp = smb_setup_header(server, SMBsearch, 2,
p983fs/smbfs/proc.cp = smb_encode_ascii(p, "", 0);
p984fs/smbfs/proc.cp = smb_encode_vblock(p, status, SMB_STATUS_SIZE, 0);
p1003fs/smbfs/proc.cp = SMB_VWV(server->packet);
p1004fs/smbfs/proc.cp = smb_decode_word(p, &count); /* vwv[0] = count-returned */
p1005fs/smbfs/proc.cp = smb_decode_word(p, &bcc);           
p1018fs/smbfs/proc.cp += 3; /* Skipping VBLOCK header (5, length lo, length hi). */
p1030fs/smbfs/proc.cp += SMB_DIRINFO_SIZE;
p1041fs/smbfs/proc.cp = smb_decode_dirent(p, current_entry);
p1061fs/smbfs/proc.csmb_decode_long_dirent(char *p, struct smb_dirent *finfo, int level)
p1077fs/smbfs/proc.cstrcpy(finfo->path,p+27);
p1079fs/smbfs/proc.cfinfo->size = DVAL(p,16);
p1080fs/smbfs/proc.cfinfo->attr = BVAL(p,24);
p1082fs/smbfs/proc.cfinfo->ctime = date_dos2unix(WVAL(p, 6), WVAL(p, 4));
p1083fs/smbfs/proc.cfinfo->atime = date_dos2unix(WVAL(p, 10), WVAL(p, 8));
p1084fs/smbfs/proc.cfinfo->mtime = date_dos2unix(WVAL(p, 14), WVAL(p, 12));
p1086fs/smbfs/proc.cresult = p + 28 + BVAL(p,26);
p1092fs/smbfs/proc.cstrcpy(finfo->path,p+31);
p1094fs/smbfs/proc.cfinfo->size = DVAL(p,16);
p1095fs/smbfs/proc.cfinfo->attr = BVAL(p,24);
p1097fs/smbfs/proc.cfinfo->atime = make_unix_date2(p+8);
p1098fs/smbfs/proc.cfinfo->mtime = make_unix_date2(p+12);
p1101fs/smbfs/proc.cresult = p + 32 + BVAL(p,30);
p1105fs/smbfs/proc.cresult = p + WVAL(p,0);
p1109fs/smbfs/proc.cp += 4; /* next entry offset */
p1110fs/smbfs/proc.cp += 4; /* fileindex */
p1112fs/smbfs/proc.cp += 8;
p1114fs/smbfs/proc.cp += 8;
p1115fs/smbfs/proc.cp += 8; /* write time */
p1117fs/smbfs/proc.cp += 8;
p1118fs/smbfs/proc.cfinfo->size = DVAL(p,0);
p1119fs/smbfs/proc.cp += 8;
p1120fs/smbfs/proc.cp += 8; /* alloc size */
p1121fs/smbfs/proc.cfinfo->attr = BVAL(p,0);
p1122fs/smbfs/proc.cp += 4;
p1123fs/smbfs/proc.cnamelen = min(DVAL(p,0), SMB_MAXNAMELEN);
p1124fs/smbfs/proc.cp += 4;
p1125fs/smbfs/proc.cp += 4; /* EA size */
p1126fs/smbfs/proc.cp += 2; /* short name len? */
p1127fs/smbfs/proc.cp += 24; /* short name? */    
p1128fs/smbfs/proc.cstrncpy(finfo->path,p,namelen);
p1135fs/smbfs/proc.cresult = p + WVAL(p,0);
p1149fs/smbfs/proc.cchar *p;
p1220fs/smbfs/proc.cp = SMB_BUF(outbuf);
p1221fs/smbfs/proc.c*p++=0;         /* put in a null smb_name */
p1222fs/smbfs/proc.c*p++='D'; *p++ = ' '; /* this was added because OS/2 does it */
p1226fs/smbfs/proc.cWSET(p,0,attribute); /* attribute */
p1227fs/smbfs/proc.cWSET(p,2,max_matches); /* max count */
p1228fs/smbfs/proc.cWSET(p,4,8+4+2); /* resume required + close on end +
p1230fs/smbfs/proc.cWSET(p,6,info_level); 
p1231fs/smbfs/proc.cDSET(p,8,0);
p1232fs/smbfs/proc.cp += 12;
p1233fs/smbfs/proc.cstrncpy(p, mask, masklen);
p1234fs/smbfs/proc.cp += masklen;
p1235fs/smbfs/proc.c*p++ = 0; *p++ = 0;
p1241fs/smbfs/proc.cWSET(p,0,ff_dir_handle);
p1242fs/smbfs/proc.cWSET(p,2,max_matches); /* max count */
p1243fs/smbfs/proc.cWSET(p,4,info_level); 
p1244fs/smbfs/proc.cDSET(p,6,ff_resume_key); /* ff_resume_key */
p1245fs/smbfs/proc.cWSET(p,10,8+4+2); /* resume required + close on end +
p1247fs/smbfs/proc.cp += 12;
p1248fs/smbfs/proc.cstrncpy(p, mask, masklen);
p1249fs/smbfs/proc.cp += masklen;
p1250fs/smbfs/proc.c*p++ = 0; *p++ = 0;
p1273fs/smbfs/proc.cp = resp_param;
p1276fs/smbfs/proc.cff_dir_handle = WVAL(p,0);
p1277fs/smbfs/proc.cff_searchcount = WVAL(p,2);
p1278fs/smbfs/proc.cff_eos = WVAL(p,4);
p1279fs/smbfs/proc.cff_lastname = WVAL(p,8);
p1283fs/smbfs/proc.cff_searchcount = WVAL(p,0);
p1284fs/smbfs/proc.cff_eos = WVAL(p,2);
p1285fs/smbfs/proc.cff_lastname = WVAL(p,6);
p1292fs/smbfs/proc.cp = resp_data;
p1301fs/smbfs/proc.cstrcpy(mask,p+ff_lastname+94);
p1304fs/smbfs/proc.cstrcpy(mask,p + ff_lastname + 1);
p1316fs/smbfs/proc.cp = smb_decode_long_dirent(p, NULL,
p1327fs/smbfs/proc.cp = smb_decode_long_dirent(p, current_entry,
p1384fs/smbfs/proc.cchar *p;
p1392fs/smbfs/proc.cp = smb_setup_header(server, SMBgetatr, 0, 2 + len);
p1393fs/smbfs/proc.csmb_encode_ascii(p, path, len);
p1478fs/smbfs/proc.cchar *p;
p1485fs/smbfs/proc.cp = smb_setup_header(server, SMBsetatr, 8, 4 + len);
p1488fs/smbfs/proc.cp = smb_encode_ascii(p, path, len);
p1489fs/smbfs/proc.cp = smb_encode_ascii(p, "", 0);
p1551fs/smbfs/proc.cchar *p;
p1567fs/smbfs/proc.cp = SMB_VWV(server->packet);
p1568fs/smbfs/proc.cp = smb_decode_word(p, &attr->total);
p1569fs/smbfs/proc.cp = smb_decode_word(p, &attr->allocblocks);
p1570fs/smbfs/proc.cp = smb_decode_word(p, &attr->blocksize);
p1571fs/smbfs/proc.cp = smb_decode_word(p, &attr->free);
p1611fs/smbfs/proc.cbyte *p;
p1638fs/smbfs/proc.cp = server->packet + 4;
p1640fs/smbfs/proc.cp = smb_name_mangle(p, server->m.server_name);
p1641fs/smbfs/proc.cp = smb_name_mangle(p, server->m.client_name);
p1644fs/smbfs/proc.c(void *)p - (void *)(server->packet));
p1682fs/smbfs/proc.cp = SMB_BUF(server->packet);
p1685fs/smbfs/proc.cp = smb_encode_dialect(p,prots[i].name, strlen(prots[i].name));
p1698fs/smbfs/proc.cp = SMB_VWV(server->packet);
p1699fs/smbfs/proc.cp = smb_decode_word(p, (word *)&i);
p1736fs/smbfs/proc.cp = SMB_BUF(server->packet);
p1737fs/smbfs/proc.cstrcpy(p, server->m.password);
p1738fs/smbfs/proc.cp += passlen + 1;
p1739fs/smbfs/proc.cstrcpy(p, server->m.username);
p1763fs/smbfs/proc.cp = SMB_BUF(server->packet);
p1764fs/smbfs/proc.cp = smb_encode_ascii(p, server->m.service, strlen(server->m.service));
p1765fs/smbfs/proc.cp = smb_encode_ascii(p,server->m.password, strlen(server->m.password));
p1766fs/smbfs/proc.cp = smb_encode_ascii(p, dev, strlen(dev));
p1776fs/smbfs/proc.cp = SMB_VWV(server->packet);
p1777fs/smbfs/proc.cp = smb_decode_word(p, &server->max_xmit);
p1782fs/smbfs/proc.cp = smb_decode_word(p, &server->tid);
p209fs/sysv/file.cchar * p;
p252fs/sysv/file.cp = (pos & sb->sv_block_size_1) + bh->b_data;
p259fs/sysv/file.cmemcpy_fromfs(p,buf,c);
p646fs/sysv/inode.cunsigned long *p;
p650fs/sysv/inode.cp = inode->u.sysv_i.i_data + nr;
p652fs/sysv/inode.ctmp = *p;
p655fs/sysv/inode.cif (tmp == *p)
p666fs/sysv/inode.cif (*p) {
p671fs/sysv/inode.c*p = tmp;
p682fs/sysv/inode.csysv_zone_t *p;
p696fs/sysv/inode.cp = nr + (sysv_zone_t *) bh->b_data;
p698fs/sysv/inode.cblock = tmp = *p;
p703fs/sysv/inode.cif (tmp == *p) {
p720fs/sysv/inode.cif (*p) {
p725fs/sysv/inode.c*p = (sb->sv_convert ? to_coh_ulong(block) : block);
p780fs/sysv/inode.cstatic inline unsigned long read3byte (char * p)
p782fs/sysv/inode.creturn (unsigned long)(*(unsigned short *)p)
p783fs/sysv/inode.c| (unsigned long)(*(unsigned char *)(p+2)) << 16;
p786fs/sysv/inode.cstatic inline void write3byte (char * p, unsigned long val)
p788fs/sysv/inode.c*(unsigned short *)p = (unsigned short) val;
p789fs/sysv/inode.c*(unsigned char *)(p+2) = val >> 16;
p792fs/sysv/inode.cstatic inline unsigned long coh_read3byte (char * p)
p794fs/sysv/inode.creturn (unsigned long)(*(unsigned char *)p) << 16
p795fs/sysv/inode.c| (unsigned long)(*(unsigned short *)(p+1));
p798fs/sysv/inode.cstatic inline void coh_write3byte (char * p, unsigned long val)
p800fs/sysv/inode.c*(unsigned char *)p = val >> 16;
p801fs/sysv/inode.c*(unsigned short *)(p+1) = (unsigned short) val;
p48fs/sysv/truncate.cunsigned long * p;
p56fs/sysv/truncate.cp = inode->u.sysv_i.i_data + i;
p57fs/sysv/truncate.cblock = *p;
p65fs/sysv/truncate.cif ((bh && bh->b_count != 1) || (block != *p)) {
p70fs/sysv/truncate.c*p = 0;
p78fs/sysv/truncate.cstatic int trunc_indirect(struct inode * inode, unsigned long offset, unsigned long * p, int convert, unsigned char * dirt)
p89fs/sysv/truncate.cindblock = indtmp = *p;
p96fs/sysv/truncate.cif (indtmp != *p) {
p101fs/sysv/truncate.c*p = 0;
p135fs/sysv/truncate.cif ((indbh->b_count != 1) || (indtmp != *p)) {
p139fs/sysv/truncate.c*p = 0;
p147fs/sysv/truncate.cstatic int trunc_dindirect(struct inode * inode, unsigned long offset, unsigned long * p, int convert, unsigned char * dirt)
p157fs/sysv/truncate.cindblock = indtmp = *p;
p164fs/sysv/truncate.cif (indtmp != *p) {
p169fs/sysv/truncate.c*p = 0;
p189fs/sysv/truncate.cif ((indbh->b_count != 1) || (indtmp != *p)) {
p193fs/sysv/truncate.c*p = 0;
p201fs/sysv/truncate.cstatic int trunc_tindirect(struct inode * inode, unsigned long offset, unsigned long * p, int convert, unsigned char * dirt)
p211fs/sysv/truncate.cindblock = indtmp = *p;
p218fs/sysv/truncate.cif (indtmp != *p) {
p223fs/sysv/truncate.c*p = 0;
p243fs/sysv/truncate.cif ((indbh->b_count != 1) || (indtmp != *p)) {
p247fs/sysv/truncate.c*p = 0;
p236fs/umsdos/inode.c|| inode->u.umsdos_i.u.dir_info.p != NULL)){
p240fs/umsdos/inode.c,inode->u.umsdos_i.u.dir_info.p));
p40fs/umsdos/namei.csleep_on(&dir->u.umsdos_i.u.dir_info.p);
p51fs/umsdos/namei.csleep_on(&dir->u.umsdos_i.u.dir_info.p);
p140fs/umsdos/namei.cwake_up (&dir->u.umsdos_i.u.dir_info.p);
p152fs/umsdos/namei.cwake_up (&dir->u.umsdos_i.u.dir_info.p);
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;
p106include/asm-alpha/io.h# define inb(p)    _inb((p))
p109include/asm-alpha/io.h# define inw(p)    _inw((p))
p112include/asm-alpha/io.h# define inl(p)    _inl((p))
p115include/asm-alpha/io.h# define outb(b,p)  _outb((b),(p))
p118include/asm-alpha/io.h# define outw(w,p)  _outw((w),(p))
p121include/asm-alpha/io.h# define outl(l,p)  _outl((l),(p))
p57include/asm-alpha/system.h#define switch_to(p) do { \
p58include/asm-alpha/system.hcurrent_set[0] = p; \
p59include/asm-alpha/system.halpha_switch_to((unsigned long) &(p)->tss - 0xfffffc0000000000); \
p119include/asm-alpha/types.hstatic __inline__ int __FD_ISSET(unsigned long fd, fd_set *p)
p123include/asm-alpha/types.hreturn (p->fds_bits[_tmp] & (1UL<<_rem)) != 0;
p131include/asm-alpha/types.hstatic __inline__ void __FD_ZERO(fd_set *p)
p133include/asm-alpha/types.hunsigned int *tmp = p->fds_bits;
p104include/asm-i386/bitops.hunsigned long * p = ((unsigned long *) addr) + (offset >> 5);
p117include/asm-i386/bitops.h: "r" (~(*p >> bit)));
p121include/asm-i386/bitops.hp++;
p126include/asm-i386/bitops.hres = find_first_zero_bit (p, size - 32 * (p - (unsigned long *) addr));
p63include/asm-m68k/bitops.hunsigned long *p;
p80include/asm-m68k/bitops.h: "=d" (res), "=a" (p)
p83include/asm-m68k/bitops.hreturn ((p - addr) << 5) + res;
p90include/asm-m68k/bitops.hunsigned long *p = addr + (offset >> 5);
p97include/asm-m68k/bitops.h: "d" (~*p << bit));
p101include/asm-m68k/bitops.hp++;
p104include/asm-m68k/bitops.hres = find_first_zero_bit (p, size - 32 * (p - addr));
p185include/asm-mips/bitops.hunsigned long * p = ((unsigned long *) addr) + (offset >> 5);
p202include/asm-mips/bitops.h: "r" (*p >> bit),
p209include/asm-mips/bitops.hp++;
p214include/asm-mips/bitops.hres = find_first_zero_bit (p, size - 32 * (p - (unsigned long *) addr));
p291include/asm-sparc/bitops.hunsigned long *p = ((unsigned long *) addr) + (offset >> 6);
p301include/asm-sparc/bitops.htmp = *(p++);
p312include/asm-sparc/bitops.hif (~(tmp = *(p++)))
p319include/asm-sparc/bitops.htmp = *p;
p108include/asm-sparc/pgtable.hextern inline int alloc_mmu_ctx(struct task_struct *p)
p116include/asm-sparc/pgtable.hp->tss.context = i;
p117include/asm-sparc/pgtable.hctx_tasks[i] = p;
p128include/asm-sparc/pgtable.hctx_tasks[ctx_tasks_last_frd] = p;
p129include/asm-sparc/pgtable.hp->tss.context = ctx_tasks_last_frd;
p116include/asm-sparc/string.hconst char *p;
p120include/asm-sparc/string.hfor (p = s; *p != '\0'; ++p) {
p122include/asm-sparc/string.hif (*p == *a)
p83include/asm-sparc/system.h#define switch_to(p) sparc_switch_to(p)
p19include/linux/binfmts.hunsigned long p;
p51include/linux/binfmts.hextern unsigned long * create_tables(char * p,struct linux_binprm * bprm,int ibcs);
p53include/linux/binfmts.hunsigned long p, int from_kmem);
p52include/linux/ppp_defs.h#define PPP_ADDRESS(p)  (((u_char *)(p))[0])
p53include/linux/ppp_defs.h#define PPP_CONTROL(p)  (((u_char *)(p))[1])
p54include/linux/ppp_defs.h#define PPP_PROTOCOL(p)  ((((u_char *)(p))[2] << 8) + ((u_char *)(p))[3])
p149include/linux/ppp_defs.hstruct pppstat  p;  /* basic PPP statistics */
p194include/linux/proc_fs.hstruct proc_dir_entry **p = &driver->subdir, *dp;
p197include/linux/proc_fs.hwhile ((dp = *p) != NULL) {
p200include/linux/proc_fs.hp = &dp->next;
p309include/linux/sched.hextern void sleep_on(struct wait_queue ** p);
p310include/linux/sched.hextern void interruptible_sleep_on(struct wait_queue ** p);
p311include/linux/sched.hextern void wake_up(struct wait_queue ** p);
p312include/linux/sched.hextern void wake_up_interruptible(struct wait_queue ** p);
p316include/linux/sched.hextern int send_sig(unsigned long sig,struct task_struct * p,int priv);
p340include/linux/sched.hextern inline void add_wait_queue(struct wait_queue ** p, struct wait_queue * wait)
p355include/linux/sched.hif (!*p) {
p357include/linux/sched.h*p = wait;
p359include/linux/sched.hwait->next = (*p)->next;
p360include/linux/sched.h(*p)->next = wait;
p365include/linux/sched.hextern inline void remove_wait_queue(struct wait_queue ** p, struct wait_queue * wait)
p375include/linux/sched.hif ((*p == wait) &&
p379include/linux/sched.h((*p = wait->next) == wait)) {
p380include/linux/sched.h*p = NULL;
p386include/linux/sched.hif (tmp == *p)
p399include/linux/sched.hprintk("list = %08lx, queue = %08lx\n",(unsigned long) p, (unsigned long) wait);
p406include/linux/sched.hextern inline void select_wait(struct wait_queue ** wait_address, select_table * p)
p410include/linux/sched.hif (!p || !wait_address)
p412include/linux/sched.hif (p->nr >= __MAX_SELECT_TABLE_ENTRIES)
p414include/linux/sched.hentry = p->entry + p->nr;
p419include/linux/sched.hp->nr++;
p440include/linux/sched.h#define REMOVE_LINKS(p) do { unsigned long flags; \
p442include/linux/sched.h(p)->next_task->prev_task = (p)->prev_task; \
p443include/linux/sched.h(p)->prev_task->next_task = (p)->next_task; \
p445include/linux/sched.hif ((p)->p_osptr) \
p446include/linux/sched.h(p)->p_osptr->p_ysptr = (p)->p_ysptr; \
p447include/linux/sched.hif ((p)->p_ysptr) \
p448include/linux/sched.h(p)->p_ysptr->p_osptr = (p)->p_osptr; \
p450include/linux/sched.h(p)->p_pptr->p_cptr = (p)->p_osptr; \
p453include/linux/sched.h#define SET_LINKS(p) do { unsigned long flags; \
p455include/linux/sched.h(p)->next_task = &init_task; \
p456include/linux/sched.h(p)->prev_task = init_task.prev_task; \
p457include/linux/sched.hinit_task.prev_task->next_task = (p); \
p458include/linux/sched.hinit_task.prev_task = (p); \
p460include/linux/sched.h(p)->p_ysptr = NULL; \
p461include/linux/sched.hif (((p)->p_osptr = (p)->p_pptr->p_cptr) != NULL) \
p462include/linux/sched.h(p)->p_osptr->p_ysptr = p; \
p463include/linux/sched.h(p)->p_pptr->p_cptr = p; \
p466include/linux/sched.h#define for_each_task(p) \
p467include/linux/sched.hfor (p = &init_task ; (p = p->next_task) != &init_task ; )
p36include/linux/smb.h#define BVAL(p,off)      (*((byte  *)(((void *)p)+off)))
p37include/linux/smb.h#define WVAL(p,off)      (*((word  *)(((void *)p)+off)))
p38include/linux/smb.h#define DVAL(p,off)      (*((dword *)(((void *)p)+off)))
p39include/linux/smb.h#define BSET(p,off,new)  (*((byte  *)(((void *)p)+off))=(new))
p40include/linux/smb.h#define WSET(p,off,new)  (*((word  *)(((void *)p)+off))=(new))
p41include/linux/smb.h#define DSET(p,off,new)  (*((dword *)(((void *)p)+off))=(new))
p81include/linux/smb_fs.h#define smb_kmalloc(s,p) kmalloc(s,p)
p127include/linux/smb_fs.hbyte *smb_encode_smb_length(byte *p, dword len);
p141include/linux/tqueue.hregister struct tq_struct *p;
p146include/linux/tqueue.hp = xchg(list,&tq_last);
p147include/linux/tqueue.hif(p == &tq_last)
p151include/linux/tqueue.harg    = p -> data;
p152include/linux/tqueue.hf      = p -> routine;
p153include/linux/tqueue.hsave_p = p -> next;
p154include/linux/tqueue.hp -> sync = 0;
p156include/linux/tqueue.hp = save_p;
p157include/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;
p24kernel/exit.cstatic int generate(unsigned long sig, struct task_struct * p)
p27kernel/exit.cstruct sigaction * sa = sig + p->sig->action - 1;
p30kernel/exit.cif (!(p->flags & PF_PTRACED)) {
p39kernel/exit.cp->signal |= mask;
p40kernel/exit.cif (p->state == TASK_INTERRUPTIBLE && (p->signal & ~p->blocked))
p41kernel/exit.cwake_up_process(p);
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->euid != p->uid) && !suser())
p57kernel/exit.cif (!p->sig)
p60kernel/exit.cif (p->state == TASK_STOPPED)
p61kernel/exit.cwake_up_process(p);
p62kernel/exit.cp->exit_code = 0;
p63kernel/exit.cp->signal &= ~( (1<<(SIGSTOP-1)) | (1<<(SIGTSTP-1)) |
p67kernel/exit.cp->signal &= ~(1<<(SIGCONT-1));
p69kernel/exit.cgenerate(sig,p);
p81kernel/exit.cvoid release(struct task_struct * p)
p85kernel/exit.cif (!p)
p87kernel/exit.cif (p == current) {
p92kernel/exit.cif (task[i] == p) {
p95kernel/exit.cREMOVE_LINKS(p);
p96kernel/exit.crelease_thread(p);
p97kernel/exit.cif (STACK_MAGIC != *(unsigned long *)p->kernel_stack_page)
p98kernel/exit.cprintk(KERN_ALERT "release: %s kernel stack corruption. Aiee\n", p->comm);
p99kernel/exit.cfree_page(p->kernel_stack_page);
p100kernel/exit.ccurrent->cmin_flt += p->min_flt + p->cmin_flt;
p101kernel/exit.ccurrent->cmaj_flt += p->maj_flt + p->cmaj_flt;
p102kernel/exit.ccurrent->cnswap += p->nswap + p->cnswap;
p103kernel/exit.ckfree(p);
p114kernel/exit.cint bad_task_ptr(struct task_struct *p)
p118kernel/exit.cif (!p)
p121kernel/exit.cif (task[i] == p)
p209kernel/exit.cstruct task_struct *p;
p213kernel/exit.cfor_each_task(p) {
p214kernel/exit.cif (p->session <= 0)
p216kernel/exit.cif (p->pgrp == pgrp)
p217kernel/exit.creturn p->session;
p218kernel/exit.cif (p->pid == pgrp)
p219kernel/exit.cfallback = p->session;
p230kernel/exit.cstruct task_struct *p;
p236kernel/exit.cfor_each_task(p) {
p237kernel/exit.cif (p->pgrp == pgrp) {
p238kernel/exit.cif ((err = send_sig(sig,p,priv)) != 0)
p254kernel/exit.cstruct task_struct *p;
p260kernel/exit.cfor_each_task(p) {
p261kernel/exit.cif (p->session == sess && p->leader) {
p262kernel/exit.cif ((err = send_sig(sig,p,priv)) != 0)
p273kernel/exit.cstruct task_struct *p;
p277kernel/exit.cfor_each_task(p) {
p278kernel/exit.cif (p && p->pid == pid)
p279kernel/exit.creturn send_sig(sig,p,priv);
p295kernel/exit.cstruct task_struct * p;
p296kernel/exit.cfor_each_task(p) {
p297kernel/exit.cif (p->pid > 1 && p != current) {
p299kernel/exit.cif ((err = send_sig(sig,p,0)) != -EPERM)
p321kernel/exit.cstruct task_struct *p;
p323kernel/exit.cfor_each_task(p) {
p324kernel/exit.cif ((p->pgrp != pgrp) || 
p325kernel/exit.c(p->state == TASK_ZOMBIE) ||
p326kernel/exit.c(p->p_pptr->pid == 1))
p328kernel/exit.cif ((p->p_pptr->pgrp != pgrp) &&
p329kernel/exit.c(p->p_pptr->session == p->session))
p337kernel/exit.cstruct task_struct * p;
p339kernel/exit.cfor_each_task(p) {
p340kernel/exit.cif (p->pgrp != pgrp)
p342kernel/exit.cif (p->state == TASK_STOPPED)
p350kernel/exit.cstruct task_struct * p;
p352kernel/exit.cfor_each_task(p) {
p353kernel/exit.cif (p->p_opptr == father)
p355kernel/exit.cp->p_opptr = task[smp_num_cpus];
p357kernel/exit.cp->p_opptr = task[0];
p428kernel/exit.cstruct task_struct * p;
p458kernel/exit.cwhile ((p = current->p_cptr) != NULL) {
p459kernel/exit.ccurrent->p_cptr = p->p_osptr;
p460kernel/exit.cp->p_ysptr = NULL;
p461kernel/exit.cp->flags &= ~(PF_PTRACED|PF_TRACESYS);
p463kernel/exit.cp->p_pptr = task[smp_num_cpus];
p465kernel/exit.cp->p_pptr = task[0];
p466kernel/exit.cp->p_osptr = p->p_pptr->p_cptr;
p467kernel/exit.cp->p_osptr->p_ysptr = p;
p468kernel/exit.cp->p_pptr->p_cptr = p;
p469kernel/exit.cif (p->state == TASK_ZOMBIE)
p470kernel/exit.cnotify_parent(p);
p477kernel/exit.cif ((p->pgrp != current->pgrp) &&
p478kernel/exit.c(p->session == current->session) &&
p479kernel/exit.cis_orphaned_pgrp(p->pgrp) &&
p480kernel/exit.chas_stopped_jobs(p->pgrp)) {
p481kernel/exit.ckill_pg(p->pgrp,SIGHUP,1);
p482kernel/exit.ckill_pg(p->pgrp,SIGCONT,1);
p540kernel/exit.cstruct task_struct *p;
p550kernel/exit.cfor (p = current->p_cptr ; p ; p = p->p_osptr) {
p552kernel/exit.cif (p->pid != pid)
p555kernel/exit.cif (p->pgrp != current->pgrp)
p558kernel/exit.cif (p->pgrp != -pid)
p562kernel/exit.cif ((p->exit_signal != SIGCHLD) ^ ((options & __WCLONE) != 0))
p565kernel/exit.cswitch (p->state) {
p567kernel/exit.cif (!p->exit_code)
p569kernel/exit.cif (!(options & WUNTRACED) && !(p->flags & PF_PTRACED))
p572kernel/exit.cput_user((p->exit_code << 8) | 0x7f,
p574kernel/exit.cp->exit_code = 0;
p576kernel/exit.cgetrusage(p, RUSAGE_BOTH, ru);
p577kernel/exit.cretval = p->pid;
p580kernel/exit.ccurrent->cutime += p->utime + p->cutime;
p581kernel/exit.ccurrent->cstime += p->stime + p->cstime;
p583kernel/exit.cgetrusage(p, RUSAGE_BOTH, ru);
p584kernel/exit.cflag = p->pid;
p586kernel/exit.cput_user(p->exit_code, stat_addr);
p587kernel/exit.cif (p->p_opptr != p->p_pptr) {
p588kernel/exit.cREMOVE_LINKS(p);
p589kernel/exit.cp->p_pptr = p->p_opptr;
p590kernel/exit.cSET_LINKS(p);
p591kernel/exit.cnotify_parent(p);
p593kernel/exit.crelease(p);
p35kernel/fork.cstruct task_struct *p;
p45kernel/fork.cfor_each_task (p) {
p46kernel/fork.cif (p->uid == current->uid)
p62kernel/fork.cstruct task_struct *p;
p69kernel/fork.cfor_each_task (p) {
p70kernel/fork.cif (p->pid == last_pid ||
p71kernel/fork.cp->pgrp == last_pid ||
p72kernel/fork.cp->session == last_pid)
p80kernel/fork.cstruct vm_area_struct * mpnt, **p, *tmp;
p83kernel/fork.cp = &mm->mmap;
p106kernel/fork.c*p = tmp;
p107kernel/fork.cp = &tmp->vm_next;
p202kernel/fork.cstruct task_struct *p;
p204kernel/fork.cp = (struct task_struct *) kmalloc(sizeof(*p), GFP_KERNEL);
p205kernel/fork.cif (!p)
p215kernel/fork.c*p = *current;
p217kernel/fork.cif (p->exec_domain && p->exec_domain->use_count)
p218kernel/fork.c(*p->exec_domain->use_count)++;
p219kernel/fork.cif (p->binfmt && p->binfmt->use_count)
p220kernel/fork.c(*p->binfmt->use_count)++;
p222kernel/fork.cp->did_exec = 0;
p223kernel/fork.cp->swappable = 0;
p224kernel/fork.cp->kernel_stack_page = new_stack;
p225kernel/fork.c*(unsigned long *) p->kernel_stack_page = STACK_MAGIC;
p226kernel/fork.cp->state = TASK_UNINTERRUPTIBLE;
p227kernel/fork.cp->flags &= ~(PF_PTRACED|PF_TRACESYS);
p228kernel/fork.cp->pid = get_pid(clone_flags);
p229kernel/fork.cp->next_run = NULL;
p230kernel/fork.cp->prev_run = NULL;
p231kernel/fork.cp->p_pptr = p->p_opptr = current;
p232kernel/fork.cp->p_cptr = NULL;
p233kernel/fork.cp->signal = 0;
p234kernel/fork.cp->it_real_value = p->it_virt_value = p->it_prof_value = 0;
p235kernel/fork.cp->it_real_incr = p->it_virt_incr = p->it_prof_incr = 0;
p236kernel/fork.cinit_timer(&p->real_timer);
p237kernel/fork.cp->real_timer.data = (unsigned long) p;
p238kernel/fork.cp->leader = 0;    /* process leadership doesn't inherit */
p239kernel/fork.cp->tty_old_pgrp = 0;
p240kernel/fork.cp->utime = p->stime = 0;
p241kernel/fork.cp->cutime = p->cstime = 0;
p243kernel/fork.cp->processor = NO_PROC_ID;
p244kernel/fork.cp->lock_depth = 1;
p246kernel/fork.cp->start_time = jiffies;
p247kernel/fork.ctask[nr] = p;
p248kernel/fork.cSET_LINKS(p);
p253kernel/fork.cif (copy_files(clone_flags, p))
p255kernel/fork.cif (copy_fs(clone_flags, p))
p257kernel/fork.cif (copy_sighand(clone_flags, p))
p259kernel/fork.cif (copy_mm(clone_flags, p))
p261kernel/fork.ccopy_thread(nr, clone_flags, usp, p, regs);
p262kernel/fork.cp->semundo = NULL;
p265kernel/fork.cp->swappable = 1;
p266kernel/fork.cp->exit_signal = clone_flags & CSIGNAL;
p267kernel/fork.cp->counter = current->counter >> 1;
p268kernel/fork.cwake_up_process(p);      /* do this last, just in case */
p269kernel/fork.creturn p->pid;
p272kernel/fork.cexit_sighand(p);
p274kernel/fork.cexit_fs(p);
p276kernel/fork.cexit_files(p);
p278kernel/fork.cif (p->exec_domain && p->exec_domain->use_count)
p279kernel/fork.c(*p->exec_domain->use_count)--;
p280kernel/fork.cif (p->binfmt && p->binfmt->use_count)
p281kernel/fork.c(*p->binfmt->use_count)--;
p283kernel/fork.cREMOVE_LINKS(p);
p288kernel/fork.ckfree(p);
p100kernel/itimer.cstruct task_struct * p = (struct task_struct *) __data;
p103kernel/itimer.csend_sig(SIGALRM, p, 1);
p104kernel/itimer.cinterval = p->it_real_incr;
p110kernel/itimer.cp->real_timer.expires = timeout;
p111kernel/itimer.cadd_timer(&p->real_timer);
p519kernel/module.cchar *p;
p526kernel/module.cp = buf;
p529kernel/module.cif (p - buf > 4096 - 100)
p536kernel/module.c*p++ = *q++;
p544kernel/module.c*p++ = ' ';
p547kernel/module.c*p++ = *q++;
p557kernel/module.c*p++ = *q++;
p560kernel/module.c*p++ = '\t';
p561kernel/module.c*p++ = '[';
p565kernel/module.c*p++ = *q++;
p567kernel/module.c*p++ = ' ';
p569kernel/module.c*p++ = ']';
p571kernel/module.c*p++ = '\n';
p573kernel/module.creturn p - buf;
p585kernel/module.cchar *p = buf;
p598kernel/module.cp = buf + len;
p600kernel/module.clen += sprintf(p, "%08lx %s\t[%s]\n",
p604kernel/module.clen += sprintf(p, "%08lx %s\n",
p152kernel/printk.cchar *msg, *p, *buf_end;
p162kernel/printk.cfor (p = buf + 3; p < buf_end; p++) {
p163kernel/printk.cmsg = p;
p166kernel/printk.cp[0] != '<' ||
p167kernel/printk.cp[1] < '0' || 
p168kernel/printk.cp[1] > '7' ||
p169kernel/printk.cp[2] != '>'
p171kernel/printk.cp -= 3;
p172kernel/printk.cp[0] = '<';
p173kernel/printk.cp[1] = DEFAULT_MESSAGE_LOGLEVEL + '0';
p174kernel/printk.cp[2] = '>';
p177kernel/printk.cmsg_level = p[1] - '0';
p179kernel/printk.cfor (; p < buf_end; p++) {
p180kernel/printk.clog_buf[(log_start+log_size) & (LOG_BUF_LEN-1)] = *p;
p188kernel/printk.cif (*p == '\n')
p192kernel/printk.cchar tmp = p[1];
p193kernel/printk.cp[1] = '\0';
p195kernel/printk.cp[1] = tmp;
p197kernel/printk.cif (*p == '\n')
p214kernel/printk.cint  p = log_start;
p222kernel/printk.cbuf[j++] = log_buf[p];
p223kernel/printk.cp++; p &= LOG_BUF_LEN-1;
p33kernel/resource.cresource_entry_t *p;
p36kernel/resource.cfor (p = iolist.next; (p) && (len < 4000); p = p->next)
p38kernel/resource.cp->from, p->from+p->num-1, p->name);
p39kernel/resource.cif (p)
p51kernel/resource.cresource_entry_t *p;
p57kernel/resource.cfor (p = root; ; p = p->next) {
p58kernel/resource.cif ((p != root) && (p->from+p->num-1 >= from)) {
p59kernel/resource.cp = NULL;
p62kernel/resource.cif ((p->next == NULL) || (p->next->from > from+num-1))
p66kernel/resource.creturn p;
p74kernel/resource.cresource_entry_t *p;
p83kernel/resource.cp = find_gap(&iolist, from, num);
p84kernel/resource.cif (p == NULL)
p89kernel/resource.ciotable[i].next = p->next;
p90kernel/resource.cp->next = &iotable[i];
p109kernel/resource.cresource_entry_t *p, *q;
p111kernel/resource.cfor (p = &iolist; ; p = q) {
p112kernel/resource.cq = p->next;
p117kernel/resource.cp->next = q->next;
p98kernel/sched.cstatic inline void add_to_runqueue(struct task_struct * p)
p101kernel/sched.cif (p->next_run || p->prev_run) {
p106kernel/sched.cif (p->counter > current->counter + 3)
p109kernel/sched.c(p->next_run = init_task.next_run)->prev_run = p;
p110kernel/sched.cp->prev_run = &init_task;
p111kernel/sched.cinit_task.next_run = p;
p114kernel/sched.cstatic inline void del_from_runqueue(struct task_struct * p)
p116kernel/sched.cstruct task_struct *next = p->next_run;
p117kernel/sched.cstruct task_struct *prev = p->prev_run;
p125kernel/sched.cif (p == &init_task) {
p136kernel/sched.cp->next_run = NULL;
p137kernel/sched.cp->prev_run = NULL;
p148kernel/sched.cinline void wake_up_process(struct task_struct * p)
p154kernel/sched.cp->state = TASK_RUNNING;
p155kernel/sched.cif (!p->next_run)
p156kernel/sched.cadd_to_runqueue(p);
p162kernel/sched.cstruct task_struct * p = (struct task_struct *) __data;
p164kernel/sched.cp->timeout = 0;
p165kernel/sched.cwake_up_process(p);
p181kernel/sched.cstatic inline int goodness(struct task_struct * p, int this_cpu)
p187kernel/sched.cif (p->processor != NO_PROC_ID)
p198kernel/sched.cweight = p->counter;
p204kernel/sched.cif (p->last_processor == this_cpu)
p209kernel/sched.cif (p == current)
p229kernel/sched.cstruct task_struct * p;
p260kernel/sched.cp = init_task.next_run;
p278kernel/sched.cwhile (p != &init_task) {
p279kernel/sched.cint weight = goodness(p, this_cpu);
p281kernel/sched.cc = weight, next = p;
p282kernel/sched.cp = p->next_run;
p287kernel/sched.cfor_each_task(p)
p288kernel/sched.cp->counter = (p->counter >> 1) + p->priority;
p340kernel/sched.cstruct task_struct * p;
p345kernel/sched.cif ((p = tmp->task) != NULL) {
p346kernel/sched.cif ((p->state == TASK_UNINTERRUPTIBLE) ||
p347kernel/sched.c(p->state == TASK_INTERRUPTIBLE))
p348kernel/sched.cwake_up_process(p);
p365kernel/sched.cstruct task_struct * p;
p370kernel/sched.cif ((p = tmp->task) != NULL) {
p371kernel/sched.cif (p->state == TASK_INTERRUPTIBLE)
p372kernel/sched.cwake_up_process(p);
p399kernel/sched.cstatic inline void __sleep_on(struct wait_queue **p, int state)
p404kernel/sched.cif (!p)
p409kernel/sched.cadd_wait_queue(p, &wait);
p413kernel/sched.cremove_wait_queue(p, &wait);
p417kernel/sched.cvoid interruptible_sleep_on(struct wait_queue **p)
p419kernel/sched.c__sleep_on(p,TASK_INTERRUPTIBLE);
p422kernel/sched.cvoid sleep_on(struct wait_queue **p)
p424kernel/sched.c__sleep_on(p,TASK_UNINTERRUPTIBLE);
p437kernel/sched.cstruct timer_list *p;
p446kernel/sched.cp = &timer_head;
p450kernel/sched.cp = p->next;
p451kernel/sched.c} while (timer->expires > p->expires);
p452kernel/sched.ctimer->next = p;
p453kernel/sched.ctimer->prev = p->prev;
p454kernel/sched.cp->prev = timer;
p463kernel/sched.cstruct timer_list * p;
p465kernel/sched.cp = &timer_head;
p468kernel/sched.cwhile ((p = p->next) != &timer_head) {
p469kernel/sched.cif (p == timer) {
p513kernel/sched.cstruct task_struct **p;
p516kernel/sched.cfor(p = &LAST_TASK; p > &FIRST_TASK; --p)
p517kernel/sched.cif (*p && ((*p)->state == TASK_RUNNING ||
p518kernel/sched.c(*p)->state == TASK_UNINTERRUPTIBLE ||
p519kernel/sched.c(*p)->state == TASK_SWAPPING))
p914kernel/sched.cstatic void show_task(int nr,struct task_struct * p)
p919kernel/sched.cprintk("%-8s %3d ", p->comm, (p == current) ? -nr : nr);
p920kernel/sched.cif (((unsigned) p->state) < sizeof(stat_nam)/sizeof(char *))
p921kernel/sched.cprintk(stat_nam[p->state]);
p925kernel/sched.cif (p == current)
p928kernel/sched.cprintk(" %08lX ", thread_saved_pc(&p->tss));
p930kernel/sched.cif (p == current)
p933kernel/sched.cprintk(" %016lx ", thread_saved_pc(&p->tss));
p936kernel/sched.cif (((unsigned long *)p->kernel_stack_page)[free])
p939kernel/sched.cprintk("%5lu %5d %6d ", free*sizeof(long), p->pid, p->p_pptr->pid);
p940kernel/sched.cif (p->p_cptr)
p941kernel/sched.cprintk("%5d ", p->p_cptr->pid);
p944kernel/sched.cif (p->p_ysptr)
p945kernel/sched.cprintk("%7d", p->p_ysptr->pid);
p948kernel/sched.cif (p->p_osptr)
p949kernel/sched.cprintk(" %5d\n", p->p_osptr->pid);
p95kernel/signal.cstruct sigaction *p;
p97kernel/signal.cp = signum - 1 + current->sig->action;
p98kernel/signal.cif (p->sa_handler == SIG_IGN) {
p104kernel/signal.cif (p->sa_handler == SIG_DFL) {
p138kernel/signal.cstruct sigaction new_sa, *p;
p144kernel/signal.cp = signum - 1 + current->sig->action;
p164kernel/signal.cmemcpy_tofs(oldaction, p, sizeof(struct sigaction));
p167kernel/signal.c*p = new_sa;
p36kernel/sys.cstatic int proc_sel(struct task_struct *p, int which, int who)
p40kernel/sys.cif (!who && p == current)
p42kernel/sys.creturn(p->pid == who);
p46kernel/sys.creturn(p->pgrp == who);
p50kernel/sys.creturn(p->uid == who);
p57kernel/sys.cstruct task_struct *p;
p78kernel/sys.cfor_each_task(p) {
p79kernel/sys.cif (!proc_sel(p, which, who))
p81kernel/sys.cif (p->uid != current->euid &&
p82kernel/sys.cp->uid != current->uid && !suser()) {
p88kernel/sys.cif (priority > p->priority && !suser())
p91kernel/sys.cp->priority = priority;
p103kernel/sys.cstruct task_struct *p;
p109kernel/sys.cfor_each_task (p) {
p110kernel/sys.cif (!proc_sel(p, which, who))
p112kernel/sys.cif (p->priority > max_prio)
p113kernel/sys.cmax_prio = p->priority;
p491kernel/sys.cstruct task_struct * p;
p499kernel/sys.cfor_each_task(p) {
p500kernel/sys.cif (p->pid == pid)
p506kernel/sys.cif (p->p_pptr == current || p->p_opptr == current) {
p507kernel/sys.cif (p->session != current->session)
p509kernel/sys.cif (p->did_exec)
p511kernel/sys.c} else if (p != current)
p513kernel/sys.cif (p->leader)
p526kernel/sys.cp->pgrp = pgid;
p532kernel/sys.cstruct task_struct * p;
p536kernel/sys.cfor_each_task(p) {
p537kernel/sys.cif (p->pid == pid)
p538kernel/sys.creturn p->pgrp;
p770kernel/sys.cint getrusage(struct task_struct *p, int who, struct rusage *ru)
p781kernel/sys.cr.ru_utime.tv_sec = CT_TO_SECS(p->utime);
p782kernel/sys.cr.ru_utime.tv_usec = CT_TO_USECS(p->utime);
p783kernel/sys.cr.ru_stime.tv_sec = CT_TO_SECS(p->stime);
p784kernel/sys.cr.ru_stime.tv_usec = CT_TO_USECS(p->stime);
p785kernel/sys.cr.ru_minflt = p->min_flt;
p786kernel/sys.cr.ru_majflt = p->maj_flt;
p787kernel/sys.cr.ru_nswap = p->nswap;
p790kernel/sys.cr.ru_utime.tv_sec = CT_TO_SECS(p->cutime);
p791kernel/sys.cr.ru_utime.tv_usec = CT_TO_USECS(p->cutime);
p792kernel/sys.cr.ru_stime.tv_sec = CT_TO_SECS(p->cstime);
p793kernel/sys.cr.ru_stime.tv_usec = CT_TO_USECS(p->cstime);
p794kernel/sys.cr.ru_minflt = p->cmin_flt;
p795kernel/sys.cr.ru_majflt = p->cmaj_flt;
p796kernel/sys.cr.ru_nswap = p->cnswap;
p799kernel/sys.cr.ru_utime.tv_sec = CT_TO_SECS(p->utime + p->cutime);
p800kernel/sys.cr.ru_utime.tv_usec = CT_TO_USECS(p->utime + p->cutime);
p801kernel/sys.cr.ru_stime.tv_sec = CT_TO_SECS(p->stime + p->cstime);
p802kernel/sys.cr.ru_stime.tv_usec = CT_TO_USECS(p->stime + p->cstime);
p803kernel/sys.cr.ru_minflt = p->min_flt + p->cmin_flt;
p804kernel/sys.cr.ru_majflt = p->maj_flt + p->cmaj_flt;
p805kernel/sys.cr.ru_nswap = p->nswap + p->cnswap;
p140lib/string.cconst char *p;
p144lib/string.cfor (p = s; *p != '\0'; ++p) {
p146lib/string.cif (*p == *a)
p272lib/string.cunsigned char * p = (unsigned char *) addr;
p275lib/string.cif (*p == c)
p276lib/string.creturn (void *) p;
p277lib/string.cp++;
p280lib/string.creturn (void *) p;
p55mm/kmalloc.c#define BH(p) ((struct block_header *)(p))
p69mm/kmalloc.c#define PAGE_DESC(p) ((struct page_descriptor *)(((unsigned long)(p)) & PAGE_MASK))
p179mm/kmalloc.cstruct block_header *p;
p213mm/kmalloc.cp = page->firstfree;
p214mm/kmalloc.cif (p->bh_flags != MF_FREE) {
p216mm/kmalloc.cprintk("Problem: block on freelist at %08lx isn't free.\n", (long) p);
p243mm/kmalloc.cfor (i = NBLOCKS(order), p = BH(page + 1); i > 1; i--, p = p->bh_next) {
p244mm/kmalloc.cp->bh_flags = MF_FREE;
p245mm/kmalloc.cp->bh_next = BH(((long) p) + sz);
p248mm/kmalloc.cp->bh_flags = MF_FREE;
p249mm/kmalloc.cp->bh_next = NULL;
p253mm/kmalloc.cp = BH(page+1);
p264mm/kmalloc.cpage->firstfree = p->bh_next;
p271mm/kmalloc.cp->bh_flags = type;  /* As of now this block is officially in use */
p272mm/kmalloc.cp->bh_length = size;
p273mm/kmalloc.creturn p + 1;    /* Pointer arithmetic: increments past header */
p281mm/kmalloc.cregister struct block_header *p;
p286mm/kmalloc.cp = ((struct block_header *) ptr) - 1;
p287mm/kmalloc.cpage = PAGE_DESC(p);
p290mm/kmalloc.cif (p->bh_flags == MF_DMA) {
p291mm/kmalloc.cp->bh_flags = MF_USED;
p298mm/kmalloc.c(p->bh_flags != MF_USED)) {
p300mm/kmalloc.cp, page->next, page->order);
p303mm/kmalloc.csize = p->bh_length;
p304mm/kmalloc.cp->bh_flags = MF_FREE;  /* As of now this block is officially free */
p307mm/kmalloc.cp->bh_next = page->firstfree;
p308mm/kmalloc.cpage->firstfree = p;
p825mm/mmap.cstruct vm_area_struct **p, *mpnt;
p827mm/mmap.cp = &t->mm->mmap;
p828mm/mmap.cwhile ((mpnt = *p) != NULL) {
p833mm/mmap.cp = &mpnt->vm_next;
p836mm/mmap.c*p = vmp;
p106mm/swap.cstruct swap_info_struct * p = &swap_info[SWP_TYPE(entry)];
p111mm/swap.cif ((p->flags & SWP_WRITEOK) == SWP_WRITEOK) {
p181mm/swap.cstruct swap_info_struct * p;
p188mm/swap.cp = &swap_info[type];
p190mm/swap.cif (offset >= p->max) {
p194mm/swap.cif (p->swap_map && !p->swap_map[offset]) {
p198mm/swap.cif (!(p->flags & SWP_USED)) {
p202mm/swap.cwhile (set_bit(offset,p->swap_lockmap))
p208mm/swap.cif (p->swap_device) {
p209mm/swap.cll_rw_page(rw,p->swap_device,offset,buf);
p210mm/swap.c} else if (p->swap_file) {
p211mm/swap.cstruct inode *swapf = p->swap_file;
p251mm/swap.cif (offset && !clear_bit(offset,p->swap_lockmap))
p258mm/swap.cstruct swap_info_struct * p;
p267mm/swap.cp = &swap_info[type];
p268mm/swap.cif ((p->flags & SWP_WRITEOK) == SWP_WRITEOK) {
p269mm/swap.cfor (offset = p->lowest_bit; offset <= p->highest_bit ; offset++) {
p270mm/swap.cif (p->swap_map[offset])
p272mm/swap.cif (test_bit(offset, p->swap_lockmap))
p274mm/swap.cp->swap_map[offset] = 1;
p276mm/swap.cif (offset == p->highest_bit)
p277mm/swap.cp->highest_bit--;
p278mm/swap.cp->lowest_bit = offset;
p282mm/swap.cif (type < 0 || p->prio != swap_info[type].prio) {
p290mm/swap.ctype = p->next;
p292mm/swap.cif (type < 0 || p->prio != swap_info[type].prio) {
p304mm/swap.cstruct swap_info_struct * p;
p317mm/swap.cp = type + swap_info;
p318mm/swap.cif (offset >= p->max) {
p322mm/swap.cif (!p->swap_map[offset]) {
p326mm/swap.cp->swap_map[offset]++;
p332mm/swap.cstruct swap_info_struct * p;
p344mm/swap.cp = & swap_info[type];
p346mm/swap.cif (offset >= p->max) {
p350mm/swap.cif (!(p->flags & SWP_USED)) {
p354mm/swap.cif (offset < p->lowest_bit)
p355mm/swap.cp->lowest_bit = offset;
p356mm/swap.cif (offset > p->highest_bit)
p357mm/swap.cp->highest_bit = offset;
p358mm/swap.cif (!p->swap_map[offset])
p361mm/swap.cif (!--p->swap_map[offset])
p363mm/swap.cif (p->prio > swap_info[swap_list.next].prio) {
p589mm/swap.cstatic int swap_out_process(struct task_struct * p, unsigned long limit)
p597mm/swap.caddress = p->swap_address;
p598mm/swap.cp->swap_address = 0;
p603mm/swap.cvma = find_vma(p, address);
p610mm/swap.cint result = swap_out_vma(p, vma, pgd_offset(p->mm, address), address, limit);
p618mm/swap.cp->swap_address = 0;
p626mm/swap.cstruct task_struct *p;
p644mm/swap.cp = task[swap_task];
p645mm/swap.cif (p && p->swappable && p->mm->rss)
p654mm/swap.cif (!p->swap_cnt) {
p657mm/swap.cp->swap_cnt = AGE_CLUSTER_SIZE(p->mm->rss);
p659mm/swap.cif (!--p->swap_cnt)
p661mm/swap.cswitch (swap_out_process(p, limit)) {
p663mm/swap.cif (p->swap_cnt)
p1008mm/swap.cstatic int unuse_process(struct task_struct * p, unsigned int type, unsigned long page)
p1015mm/swap.cif (!p->mm || pgd_inuse(p->mm->pgd))
p1017mm/swap.cvma = p->mm->mmap;
p1019mm/swap.cpgd_t * pgd = pgd_offset(p->mm, vma->vm_start);
p1057mm/swap.cstruct swap_info_struct * p;
p1069mm/swap.cp = swap_info + type;
p1070mm/swap.cif ((p->flags & SWP_WRITEOK) == SWP_WRITEOK) {
p1071mm/swap.cif (p->swap_file) {
p1072mm/swap.cif (p->swap_file == inode)
p1076mm/swap.c&& (p->swap_device == inode->i_rdev))
p1087mm/swap.cswap_list.head = p->next;
p1089mm/swap.cswap_info[prev].next = p->next;
p1095mm/swap.cp->flags = SWP_USED;
p1099mm/swap.cp->flags = SWP_WRITEOK;
p1103mm/swap.cif(p->swap_device){
p1116mm/swap.cnr_swap_pages -= p->pages;
p1117mm/swap.ciput(p->swap_file);
p1118mm/swap.cp->swap_file = NULL;
p1119mm/swap.cp->swap_device = 0;
p1120mm/swap.cvfree(p->swap_map);
p1121mm/swap.cp->swap_map = NULL;
p1122mm/swap.cfree_page((long) p->swap_lockmap);
p1123mm/swap.cp->swap_lockmap = NULL;
p1124mm/swap.cp->flags = 0;
p1135mm/swap.cstruct swap_info_struct * p;
p1146mm/swap.cp = swap_info;
p1147mm/swap.cfor (type = 0 ; type < nr_swapfiles ; type++,p++)
p1148mm/swap.cif (!(p->flags & SWP_USED))
p1154mm/swap.cp->flags = SWP_USED;
p1155mm/swap.cp->swap_file = NULL;
p1156mm/swap.cp->swap_device = 0;
p1157mm/swap.cp->swap_map = NULL;
p1158mm/swap.cp->swap_lockmap = NULL;
p1159mm/swap.cp->lowest_bit = 0;
p1160mm/swap.cp->highest_bit = 0;
p1161mm/swap.cp->max = 1;
p1162mm/swap.cp->next = -1;
p1164mm/swap.cp->prio =
p1167mm/swap.cp->prio = --least_priority;
p1172mm/swap.cp->swap_file = swap_inode;
p1179mm/swap.cp->swap_device = swap_inode->i_rdev;
p1184mm/swap.cp->swap_file = NULL;
p1189mm/swap.cif (!p->swap_device)
p1195mm/swap.cif (p->swap_device == swap_info[i].swap_device)
p1200mm/swap.cp->swap_lockmap = (unsigned char *) get_free_page(GFP_USER);
p1201mm/swap.cif (!p->swap_lockmap) {
p1206mm/swap.cread_swap_page(SWP_ENTRY(type,0), (char *) p->swap_lockmap);
p1207mm/swap.cif (memcmp("SWAP-SPACE",p->swap_lockmap+PAGE_SIZE-10,10)) {
p1212mm/swap.cmemset(p->swap_lockmap+PAGE_SIZE-10,0,10);
p1214mm/swap.cp->lowest_bit = 0;
p1215mm/swap.cp->highest_bit = 0;
p1217mm/swap.cif (test_bit(i,p->swap_lockmap)) {
p1218mm/swap.cif (!p->lowest_bit)
p1219mm/swap.cp->lowest_bit = i;
p1220mm/swap.cp->highest_bit = i;
p1221mm/swap.cp->max = i+1;
p1230mm/swap.cp->swap_map = (unsigned char *) vmalloc(p->max);
p1231mm/swap.cif (!p->swap_map) {
p1235mm/swap.cfor (i = 1 ; i < p->max ; i++) {
p1236mm/swap.cif (test_bit(i,p->swap_lockmap))
p1237mm/swap.cp->swap_map[i] = 0;
p1239mm/swap.cp->swap_map[i] = 0x80;
p1241mm/swap.cp->swap_map[0] = 0x80;
p1242mm/swap.cmemset(p->swap_lockmap,0,PAGE_SIZE);
p1243mm/swap.cp->flags = SWP_WRITEOK;
p1244mm/swap.cp->pages = j;
p1251mm/swap.cif (p->prio >= swap_info[i].prio) {
p1256mm/swap.cp->next = i;
p1258mm/swap.cswap_list.head = swap_list.next = p - swap_info;
p1260mm/swap.cswap_info[prev].next = p - swap_info;
p1267mm/swap.cfree_page((long) p->swap_lockmap);
p1268mm/swap.cvfree(p->swap_map);
p1269mm/swap.ciput(p->swap_file);
p1270mm/swap.cp->swap_device = 0;
p1271mm/swap.cp->swap_file = NULL;
p1272mm/swap.cp->swap_map = NULL;
p1273mm/swap.cp->swap_lockmap = NULL;
p1274mm/swap.cp->flags = 0;
p1311mm/swap.cmem_map_t * p;
p1325mm/swap.cp = mem_map + MAP_NR(end_mem);
p1326mm/swap.cstart_mem = LONG_ALIGN((unsigned long) p);
p1327mm/swap.cwhile (p > mem_map) {
p1328mm/swap.c--p;
p1329mm/swap.cp->count = 0;
p1330mm/swap.cp->dirty = 0;
p1331mm/swap.cp->reserved = 1;
p32mm/vmalloc.cstruct task_struct * p;
p34mm/vmalloc.cfor_each_task(p) {
p35mm/vmalloc.cif (!p->mm)
p37mm/vmalloc.c*pgd_offset(p->mm,address) = entry;
p237mm/vmalloc.cstruct vm_struct **p, *tmp, *area;
p245mm/vmalloc.cfor (p = &vmlist; (tmp = *p) ; p = &tmp->next) {
p251mm/vmalloc.carea->next = *p;
p252mm/vmalloc.c*p = area;
p258mm/vmalloc.cstruct vm_struct **p, *tmp;
p266mm/vmalloc.cfor (p = &vmlist ; (tmp = *p) ; p = &tmp->next) {
p268mm/vmalloc.c*p = tmp->next;
p326mm/vmalloc.cstruct vm_struct **p, *tmp;
p330mm/vmalloc.cfor (p = &vmlist; (tmp = *p) ; p = &tmp->next) {
p59net/ax25/ax25_out.cunsigned char *p;
p92net/ax25/ax25_out.cp = skb_push(skbn, 2);
p94net/ax25/ax25_out.c*p++ = AX25_P_SEGMENT;
p96net/ax25/ax25_out.c*p = fragno--;
p98net/ax25/ax25_out.c*p |= SEG_FIRST;
p22net/core/firewall.cstruct firewall_ops **p;
p35net/core/firewall.cp=&firewall_chain[pf];
p37net/core/firewall.cwhile(*p)
p39net/core/firewall.cif(fw->fw_priority > (*p)->fw_priority)
p41net/core/firewall.cp=&((*p)->next);
p44net/core/firewall.cfw->next=*p;
p50net/core/firewall.cxchg(p,fw);
p247net/ipv4/af_inet.cstruct sock **p;
p263net/ipv4/af_inet.cp=&(sk1->prot->sock_array[sk1->num & (SOCK_ARRAY_SIZE -1)]);
p265net/ipv4/af_inet.cwhile(*p!=NULL)
p267net/ipv4/af_inet.cif(*p==sk1)
p270net/ipv4/af_inet.c*p=sk1->next;
p273net/ipv4/af_inet.cp=&((*p)->next);
p1458net/ipv4/af_inet.cstruct inet_protocol *p;
p1490net/ipv4/af_inet.cfor(p = inet_protocol_base; p != NULL;) 
p1492net/ipv4/af_inet.cstruct inet_protocol *tmp = (struct inet_protocol *) p->next;
p1493net/ipv4/af_inet.cinet_add_protocol(p);
p1494net/ipv4/af_inet.cprintk("%s%s",p->name,tmp?", ":"\n");
p1495net/ipv4/af_inet.cp = tmp;
p200net/ipv4/icmp.cstatic void icmp_glue_bits(const void *p, __u32 saddr, char *to, unsigned int offset, unsigned int fraglen)
p202net/ipv4/icmp.cstruct icmp_bxm *icmp_param = (struct icmp_bxm *)p;
p584net/ipv4/ip_fw.cchar *p, *data = (char *)&th[1];
p627net/ipv4/ip_fw.cp = data+5;
p684net/ipv4/ip_fw.cdiff = strlen(buf) - (data-p);
p695net/ipv4/ip_fw.cmemcpy(p,buf,strlen(buf));
p743net/ipv4/ip_fw.cmemcpy(skb2->data, skb->data, (p - (char *)skb->data));
p744net/ipv4/ip_fw.cmemcpy(&skb2->data[(p - (char *)skb->data)], buf, strlen(buf));
p745net/ipv4/ip_fw.cmemcpy(&skb2->data[(p - (char *)skb->data) + strlen(buf)], data,
p1525net/ipv4/ip_fw.cint len, p;
p1566net/ipv4/ip_fw.cfor (p = 0; p < IP_FW_MAX_PORTS; p++)
p1567net/ipv4/ip_fw.clen+=sprintf(buffer+len, " %u", i->fw_pts[p]);
p214net/ipv4/ipmr.cstruct mfc_cache **p;
p224net/ipv4/ipmr.cp=&cache_resolve_queue;
p225net/ipv4/ipmr.cwhile((*p)!=NULL)
p227net/ipv4/ipmr.cif((*p)==cache)
p229net/ipv4/ipmr.c*p=cache->next;
p232net/ipv4/ipmr.cp=&((*p)->next);
p248net/ipv4/packet.cstruct packet_type *p = (struct packet_type *) kmalloc(sizeof(*p), GFP_KERNEL);
p249net/ipv4/packet.cif (p == NULL) 
p252net/ipv4/packet.cp->func = packet_rcv;
p253net/ipv4/packet.cp->type = sk->num;
p254net/ipv4/packet.cp->data = (void *)sk;
p255net/ipv4/packet.cp->dev = NULL;
p256net/ipv4/packet.cdev_add_pack(p);
p262net/ipv4/packet.csk->protinfo.af_packet.prot_hook = p;
p137net/ipv4/protocol.cstruct inet_protocol *p;
p140net/ipv4/protocol.cfor (p = inet_protos[hash] ; p != NULL; p=p->next) 
p142net/ipv4/protocol.cif (p->protocol == prot) 
p143net/ipv4/protocol.creturn((struct inet_protocol *) p);
p184net/ipv4/protocol.cstruct inet_protocol *p;
p195net/ipv4/protocol.cp = (struct inet_protocol *) inet_protos[hash];
p196net/ipv4/protocol.cwhile(p != NULL) 
p203net/ipv4/protocol.cif (p->next != NULL && p->next == prot) 
p209net/ipv4/protocol.cif (p->copy == 0 && lp != NULL) 
p211net/ipv4/protocol.cp->next = prot->next;
p214net/ipv4/protocol.cif (p->next != NULL && p->next->protocol == prot->protocol) 
p215net/ipv4/protocol.clp = p;
p217net/ipv4/protocol.cp = (struct inet_protocol *) p->next;
p152net/ipv4/raw.cstatic void raw_getfrag(const void *p, __u32 saddr, char *to, unsigned int offset, unsigned int fraglen)
p154net/ipv4/raw.cmemcpy_fromfs(to, (const unsigned char *)p+offset, fraglen);
p161net/ipv4/raw.cstatic void raw_getrawfrag(const void *p, __u32 saddr, char *to, unsigned int offset, unsigned int fraglen)
p163net/ipv4/raw.cmemcpy_fromfs(to, (const unsigned char *)p+offset, fraglen);
p564net/ipv4/tcp.cstruct sk_buff *p=skb_peek(&s->receive_queue);
p565net/ipv4/tcp.cif(p==NULL)
p569net/ipv4/tcp.cif(p->sk->state == TCP_ESTABLISHED || p->sk->state >= TCP_FIN_WAIT1)
p570net/ipv4/tcp.creturn p;
p571net/ipv4/tcp.cp=p->next;
p573net/ipv4/tcp.cwhile(p!=(struct sk_buff *)&s->receive_queue);
p225net/ipv4/udp.cstatic void udp_getfrag(const void *p, __u32 saddr, char * to, unsigned int offset, unsigned int fraglen) 
p227net/ipv4/udp.cstruct udpfakehdr *ufh = (struct udpfakehdr *)p;
p265net/ipv4/udp.cstatic void udp_getfrag_nosum(const void *p, __u32 saddr, char * to, unsigned int offset, unsigned int fraglen) 
p267net/ipv4/udp.cstruct udpfakehdr *ufh = (struct udpfakehdr *)p;
p52net/ipv4/utils.cchar *p;
p54net/ipv4/utils.cp = (char *) &in;
p56net/ipv4/utils.c(p[0] & 255), (p[1] & 255), (p[2] & 255), (p[3] & 255));
p1647net/ipx/af_ipx.cchar *p, b[64];
p1649net/ipx/af_ipx.cp = b;
p1652net/ipx/af_ipx.c*(p++) = h2c[(d[i] >> 4) & 0x0f];
p1653net/ipx/af_ipx.c*(p++) = h2c[d[i] & 0x0f];
p1656net/ipx/af_ipx.c*(p++) = ' ';
p1657net/ipx/af_ipx.c*(p++) = ' ';
p1659net/ipx/af_ipx.c*(p++) = ' ';
p1661net/ipx/af_ipx.c*(p++) = '-';
p1662net/ipx/af_ipx.c*(p++) = ' ';
p1666net/ipx/af_ipx.c*(p++) = ' '<= d[i] && d[i]<'\177' ? d[i] : '.';
p1668net/ipx/af_ipx.c*(p++) = ' ';
p1669net/ipx/af_ipx.c*p = '\000';
p1675net/ipx/af_ipx.cvoid dump_addr(char *str,ipx_address *p) {
p1677net/ipx/af_ipx.cstr,ntohl(p->net),p->node[0],p->node[1],p->node[2],
p1678net/ipx/af_ipx.cp->node[3],p->node[4],p->node[5],ntohs(p->sock));
p1681net/ipx/af_ipx.cvoid dump_hdr(char *str,ipx_packet *p) {
p1683net/ipx/af_ipx.cstr,p->ipx_checksum,ntohs(p->ipx_pktsize),ntohs(p->ipx_pktsize),
p1684net/ipx/af_ipx.cp->ipx_tctrl,p->ipx_tctrl,p->ipx_type);
p1685net/ipx/af_ipx.cdump_addr("  IPX-DST",&p->ipx_dest);
p1686net/ipx/af_ipx.cdump_addr("  IPX-SRC",&p->ipx_source);
p1689net/ipx/af_ipx.cvoid dump_pkt(char *str,ipx_packet *p) {
p1690net/ipx/af_ipx.cint len = ntohs(p->ipx_pktsize);
p1691net/ipx/af_ipx.cdump_hdr(str,p);
p1693net/ipx/af_ipx.cdump_data(str,(unsigned char *)p + 30, len - 30);