taglinefilesource code
s120drivers/FPU-emu/fpu_proto.hextern void reg_load_bcd(char *s, FPU_REG *loaded_data);
s22drivers/FPU-emu/fpu_system.h#define LDT_DESCRIPTOR(s)       (current->ldt[(s) >> 3])
s27drivers/FPU-emu/fpu_system.h#define SEG_BASE_ADDR(s)        (((s).b & 0xff000000) \
s28drivers/FPU-emu/fpu_system.h| (((s).b & 0xff) << 16) | ((s).a >> 16))
s29drivers/FPU-emu/fpu_system.h#define SEG_LIMIT(s)            (((s).b & 0xff0000) | ((s).a & 0xffff))
s30drivers/FPU-emu/fpu_system.h#define SEG_EXECUTE_ONLY(s)     (((s).b & ((1 << 11) | (1 << 9))) == (1 << 11))
s31drivers/FPU-emu/fpu_system.h#define SEG_WRITE_PERM(s)       (((s).b & ((1 << 11) | (1 << 9))) == (1 << 9))
s32drivers/FPU-emu/fpu_system.h#define SEG_EXPAND_DOWN(s)      (((s).b & ((1 << 11) | (1 << 10))) \
s45drivers/FPU-emu/reg_ld_str.cint reg_load_extended(long double *s, FPU_REG *loaded_data)
s50drivers/FPU-emu/reg_ld_str.cFPU_verify_area(VERIFY_READ, s, 10);
s51drivers/FPU-emu/reg_ld_str.csigl = get_fs_long((unsigned long *) s);
s52drivers/FPU-emu/reg_ld_str.csigh = get_fs_long(1 + (unsigned long *) s);
s53drivers/FPU-emu/reg_ld_str.cexp = get_fs_word(4 + (unsigned short *) s);
s288drivers/FPU-emu/reg_ld_str.clong long s;
s292drivers/FPU-emu/reg_ld_str.c((unsigned long *)&s)[0] = get_fs_long((unsigned long *) _s);
s293drivers/FPU-emu/reg_ld_str.c((unsigned long *)&s)[1] = get_fs_long(1 + (unsigned long *) _s);
s296drivers/FPU-emu/reg_ld_str.cif (s == 0)
s299drivers/FPU-emu/reg_ld_str.cif (s > 0)
s303drivers/FPU-emu/reg_ld_str.cs = -s;
s308drivers/FPU-emu/reg_ld_str.csignificand(loaded_data) = s;
s318drivers/FPU-emu/reg_ld_str.clong s;
s323drivers/FPU-emu/reg_ld_str.cs = (long)get_fs_long((unsigned long *) _s);
s326drivers/FPU-emu/reg_ld_str.cif (s == 0)
s329drivers/FPU-emu/reg_ld_str.cif (s > 0)
s333drivers/FPU-emu/reg_ld_str.cs = -s;
s338drivers/FPU-emu/reg_ld_str.cloaded_data->sigh = s;
s349drivers/FPU-emu/reg_ld_str.cint s, e;
s354drivers/FPU-emu/reg_ld_str.cs = (short)get_fs_word((unsigned short *) _s);
s357drivers/FPU-emu/reg_ld_str.cif (s == 0)
s360drivers/FPU-emu/reg_ld_str.cif (s > 0)
s364drivers/FPU-emu/reg_ld_str.cs = -s;
s369drivers/FPU-emu/reg_ld_str.cloaded_data->sigh = s << 16;
s379drivers/FPU-emu/reg_ld_str.cvoid reg_load_bcd(char *s, FPU_REG *loaded_data)
s386drivers/FPU-emu/reg_ld_str.cFPU_verify_area(VERIFY_READ, s, 10);
s392drivers/FPU-emu/reg_ld_str.cbcd = (unsigned char)get_fs_byte((unsigned char *) s+pos);
s401drivers/FPU-emu/reg_ld_str.c((unsigned char)get_fs_byte((unsigned char *) s+9)) & 0x80 ?
s1149drivers/FPU-emu/reg_ld_str.cchar *fldenv(fpu_addr_modes addr_modes, char *s)
s1160drivers/FPU-emu/reg_ld_str.cFPU_verify_area(VERIFY_READ, s, 0x0e);
s1161drivers/FPU-emu/reg_ld_str.ccontrol_word = get_fs_word((unsigned short *) s);
s1162drivers/FPU-emu/reg_ld_str.cpartial_status = get_fs_word((unsigned short *) (s+2));
s1163drivers/FPU-emu/reg_ld_str.ctag_word = get_fs_word((unsigned short *) (s+4));
s1164drivers/FPU-emu/reg_ld_str.cinstruction_address.offset = get_fs_word((unsigned short *) (s+6));
s1165drivers/FPU-emu/reg_ld_str.cinstruction_address.selector = get_fs_word((unsigned short *) (s+8));
s1166drivers/FPU-emu/reg_ld_str.coperand_address.offset = get_fs_word((unsigned short *) (s+0x0a));
s1167drivers/FPU-emu/reg_ld_str.coperand_address.selector = get_fs_word((unsigned short *) (s+0x0c));
s1169drivers/FPU-emu/reg_ld_str.cs += 0x0e;
s1180drivers/FPU-emu/reg_ld_str.cFPU_verify_area(VERIFY_READ, s, 0x1c);
s1181drivers/FPU-emu/reg_ld_str.ccontrol_word = get_fs_word((unsigned short *) s);
s1182drivers/FPU-emu/reg_ld_str.cpartial_status = get_fs_word((unsigned short *) (s+4));
s1183drivers/FPU-emu/reg_ld_str.ctag_word = get_fs_word((unsigned short *) (s+8));
s1184drivers/FPU-emu/reg_ld_str.cinstruction_address.offset = get_fs_long((unsigned long *) (s+0x0c));
s1185drivers/FPU-emu/reg_ld_str.cinstruction_address.selector = get_fs_word((unsigned short *) (s+0x10));
s1186drivers/FPU-emu/reg_ld_str.cinstruction_address.opcode = get_fs_word((unsigned short *) (s+0x12));
s1187drivers/FPU-emu/reg_ld_str.coperand_address.offset = get_fs_long((unsigned long *) (s+0x14));
s1188drivers/FPU-emu/reg_ld_str.coperand_address.selector = get_fs_long((unsigned long *) (s+0x18));
s1190drivers/FPU-emu/reg_ld_str.cs += 0x1c;
s1237drivers/FPU-emu/reg_ld_str.creturn s;
s1245drivers/FPU-emu/reg_ld_str.cchar *s = fldenv(addr_modes, data_address);
s1252drivers/FPU-emu/reg_ld_str.creg_load_extended((long double *)(s+i*10), &regs[stnr]);
s64drivers/block/hd.c#define OK_STATUS(s)  (((s)&(STAT_OK|(BUSY_STAT|WRERR_STAT|ERR_STAT)))==STAT_OK)
s263drivers/block/hd.cstatic void fixstring (unsigned char *s, int bytecount)
s265drivers/block/hd.cunsigned char *p, *end = &s[bytecount &= ~1];  /* bytecount must be even */
s268drivers/block/hd.cfor (p = end ; p != s;) {
s274drivers/block/hd.cwhile (s != end && *s == ' ')
s275drivers/block/hd.c++s;
s278drivers/block/hd.cwhile (s != end && *s) {
s279drivers/block/hd.cif (*s++ != ' ' || (s != end && *s && *s != ' '))
s280drivers/block/hd.c*p++ = *(s-1);
s1330drivers/block/mcd.cint s;
s1342drivers/block/mcd.cs = inb(MCDPORT(0)) & 0xFF;
s1343drivers/block/mcd.c*result = (unsigned char) s;
s3514drivers/block/sbpcd.cvoid sbpcd_setup(char *s, int *p)
s3516drivers/block/sbpcd.cDPRINTF((DBG_INI,"SBPCD: sbpcd_setup called with %04X,%s\n",p[1], s));
s3518drivers/block/sbpcd.cif (!strcmp(s,str_sb)) sbpro_type=1;
s3519drivers/block/sbpcd.celse if (!strcmp(s,str_sp)) sbpro_type=2;
s446drivers/char/console.cstatic void * memsetw(void * s, unsigned short c, unsigned int count)
s452drivers/char/console.c:"a" (c),"D" (s),"c" (count/2)
s454drivers/char/console.creturn s;
s2376drivers/char/console.cstatic void highlight(const int currcons, const int s, const int e)
s2380drivers/char/console.cp1 = (unsigned char *)origin - hwscroll_offset + s + 1;
s425drivers/char/tpqic02.cstatic void tpqputs(unsigned long flags, char *s)
s428drivers/char/tpqic02.cprintk(TPQIC02_NAME ": %s\n", s);
s484drivers/char/tpqic02.cstatic int decode_exception_nr(unsigned s)
s489drivers/char/tpqic02.cif ((s & exception_list[i].mask)==exception_list[i].code)
s492drivers/char/tpqic02.cprintk(TPQIC02_NAME ": decode_exception_nr: exception(%x) not recognized\n", s);
s505drivers/char/tpqic02.cstatic void report_error(int s)
s509drivers/char/tpqic02.cif (s & TP_ST1) {
s510drivers/char/tpqic02.cif (s & TP_ILL)    /* 12: Illegal command. FATAL */
s512drivers/char/tpqic02.cif (s & TP_POR)    /* 13: Reset occurred. FATAL */
s515drivers/char/tpqic02.celse if (s & TP_ST0) {
s516drivers/char/tpqic02.cif (s & TP_EOR) {  /* extra: 15: End of Recorded Media. CONTINUABLE */
s520drivers/char/tpqic02.celse if (s & TP_EOM)    /* 4: End Of Media. CONTINUABLE */
s522drivers/char/tpqic02.celse if (s & TP_USL)    /* 2: Drive not online. FATAL */
s524drivers/char/tpqic02.celse if (s & TP_CNI) {  /* 1: Cartridge not in place. FATAL */
s530drivers/char/tpqic02.celse if (s & TP_UDA) {
s531drivers/char/tpqic02.cif (s & TP_BNL) {
s532drivers/char/tpqic02.cif (s & TP_NDT) {
s533drivers/char/tpqic02.cif (s & TP_BOM)    /* 9: Read error. No data detected & EOM. CONTINUABLE */
s535drivers/char/tpqic02.celse if (s & TP_EOM)  /* 10: Read error. No data detected & BOM. CONTINUABLE */
s545drivers/char/tpqic02.cif (s & TP_EOM)  /* 5: Read or Write error. Rewind tape. FATAL */
s557drivers/char/tpqic02.celse if (s & TP_FIL) {
s558drivers/char/tpqic02.cif (s & TP_MBD) {  /* 14: Marginal block detected. CONTINUABLE */
s564drivers/char/tpqic02.celse if (s & TP_WRP)    /* 3: Write protected cartridge. FATAL */
s845drivers/char/tpqic02.cint  s, n;
s879drivers/char/tpqic02.cdo s = inb_p(QIC02_STAT_PORT);
s880drivers/char/tpqic02.cwhile ((s & QIC02_STAT_MASK) == QIC02_STAT_MASK);  /* wait for ready or exception */
s882drivers/char/tpqic02.cif ((s & QIC02_STAT_EXCEPTION) == 0) {    /* if exception */
s2248drivers/char/tpqic02.cint s;
s2305drivers/char/tpqic02.cs = tp_sense(TP_WRP|TP_EOM|TP_BOM|TP_CNI|TP_EOR);
s2307drivers/char/tpqic02.cif (s == TE_OK)
s2310drivers/char/tpqic02.cs = tp_sense(TP_WRP|TP_EOM|TP_BOM|TP_CNI|TP_EOR);
s2312drivers/char/tpqic02.cif (s != TE_OK) {
s2348drivers/char/tpqic02.cs = do_qic_cmd(QCMD_REWIND, TIM_R);
s2349drivers/char/tpqic02.cif (s != 0) {
s2395drivers/char/tpqic02.cs = 0;
s2398drivers/char/tpqic02.cs = do_qic_cmd(QCMD_DENS_11, TIM_S);
s2401drivers/char/tpqic02.cs = do_qic_cmd(QCMD_DENS_24, TIM_S);
s2404drivers/char/tpqic02.cs = do_qic_cmd(QCMD_DENS_120, TIM_S);
s2407drivers/char/tpqic02.cs = do_qic_cmd(QCMD_DENS_150, TIM_S);
s2410drivers/char/tpqic02.cs = do_qic_cmd(QCMD_DENS_300, TIM_S);
s2413drivers/char/tpqic02.cs = do_qic_cmd(QCMD_DENS_600, TIM_S);
s2416drivers/char/tpqic02.cs = do_qic_cmd(QCMD_RETEN, TIM_R);
s2418drivers/char/tpqic02.cif (s != 0) {
s324drivers/char/vt.cu_char s;
s331drivers/char/vt.cif ((s = get_fs_byte((char *) &a->kb_table)) >= MAX_NR_KEYMAPS)
s333drivers/char/vt.ckey_map = key_maps[s];
s348drivers/char/vt.cu_char s;
s356drivers/char/vt.cif ((s = get_fs_byte((char *) &a->kb_table)) >= MAX_NR_KEYMAPS)
s361drivers/char/vt.ckey_map = key_maps[s];
s363drivers/char/vt.ckey_maps[s] = 0;
s383drivers/char/vt.cif (!(key_map = key_maps[s])) {
s391drivers/char/vt.ckey_maps[s] = key_map;
s393drivers/char/vt.cfor (s = 1; s < NR_KEYS; s++)
s394drivers/char/vt.ckey_map[s] = U(K_HOLE);
s476drivers/net/ni52.cunsigned long s;
s500drivers/net/ni52.cs = jiffies; /* warning: only active with interrupts on !! */
s502drivers/net/ni52.cif(jiffies-s > 30) break;
s526drivers/net/ni52.cs = jiffies;
s528drivers/net/ni52.cif(jiffies-s > 30) break;
s550drivers/net/ni52.cs = jiffies; 
s552drivers/net/ni52.cif(jiffies - s > 30) {
s343drivers/net/ni65.ctmdp->u.s.status = XMIT_START | XMIT_END;
s351drivers/net/ni65.crmdp->u.s.status = RCV_OWN;
s460drivers/net/ni65.ctmdstat = tmdp->u.s.status;
s506drivers/net/ni65.cwhile(!( (rmdstat = rmdp->u.s.status) & RCV_OWN))
s516drivers/net/ni65.crmdp->u.s.status = RCV_OWN; /* change owner */
s525drivers/net/ni65.crmdp->u.s.status = RCV_OWN;
s543drivers/net/ni65.crmdp->u.s.status = RCV_OWN;
s552drivers/net/ni65.crmdp->u.s.status = RCV_OWN;
s616drivers/net/ni65.ctmdp->u.s.status = XMIT_OWN | XMIT_START | XMIT_END;
s623drivers/net/ni65.cif( !((p->tmdhead + p->tmdnum)->u.s.status & XMIT_OWN) ) 
s109drivers/net/ni65.h} s;
s124drivers/net/ni65.h} s;
s286drivers/net/plip.cunsigned char *s;
s379drivers/net/plip.cs =  PLIP_STATE_STRING(snd->state);
s382drivers/net/plip.cdev->name, s, (unsigned int)c0);
s387drivers/net/plip.cs =  PLIP_STATE_STRING(rcv->state);
s390drivers/net/plip.cdev->name, s, (unsigned int)c0);
s1052drivers/net/sk_g16.ctmdp->u.s.status = TX_STP | TX_ENP;
s1072drivers/net/sk_g16.crmdp->u.s.status = RX_OWN;  
s1270drivers/net/sk_g16.ctmdp->u.s.status = TX_OWN | TX_STP | TX_ENP;
s1282drivers/net/sk_g16.cif (! ((p->tmdhead + p->tmdnum)->u.s.status & TX_OWN) )
s1405drivers/net/sk_g16.ctmdstat = tmdp->u.s.status & 0xff00; /* filter out status bits 15:08 */
s1524drivers/net/sk_g16.cwhile (!( (rmdstat = rmdp->u.s.status) & RX_OWN))
s1554drivers/net/sk_g16.crmdp->u.s.status = RX_OWN;      /* Relinquish ownership to LANCE */ 
s1566drivers/net/sk_g16.crmdp->u.s.status = RX_OWN;      /* Relinquish ownership to LANCE */
s1585drivers/net/sk_g16.crmdp->u.s.status = RX_OWN;  /* Relinquish ownership to LANCE */
s1623drivers/net/sk_g16.crmdp->u.s.status = RX_OWN;
s141drivers/net/sk_g16.h} s;
s159drivers/net/sk_g16.h} s;
s786drivers/net/slip.cslip_esc(unsigned char *s, unsigned char *d, int len)
s804drivers/net/slip.cswitch(*s) {
s814drivers/net/slip.cd[count++] = *s;
s816drivers/net/slip.c++s;
s823drivers/net/slip.cslip_unesc(struct slip *sl, unsigned char s)
s825drivers/net/slip.cswitch(s) {
s833drivers/net/slip.csl_enqueue(sl, s);
s840drivers/net/slip.csl_enqueue(sl, s);
s851drivers/net/slip.csl_enqueue(sl, s);
s864drivers/net/slip.cslip_esc6(unsigned char *s, unsigned char *d, int len)
s884drivers/net/slip.cv = (v << 8) | s[i];
s905drivers/net/slip.cslip_unesc6(struct slip *sl, unsigned char s)
s909drivers/net/slip.cif (s == 0x70) {
s925drivers/net/slip.c} else if (s >= 0x30 && s < 0x70) {
s926drivers/net/slip.csl->xdata = (sl->xdata << 6) | ((s - 0x30) & 0x3F);
s87drivers/net/slip.hextern int  slip_esc(unsigned char *s, unsigned char *d, int len);
s88drivers/net/slip.hextern int  slip_esc6(unsigned char *s, unsigned char *d, int len);
s89drivers/net/slip.hextern void  slip_unesc(struct slip *sl, unsigned char s);
s90drivers/net/slip.hextern void   slip_unesc6(struct slip *sl, unsigned char s);
s2038drivers/scsi/53c7,8xx.cTOKEN(ms,3), TOKEN(rp,2), TOKEN(rs,2), TOKEN(s,0), TOKEN(tb,0), TOKEN(te,0)
s2224drivers/scsi/aha152x.cint s;
s2231drivers/scsi/aha152x.cs=GETPORT(SCSISEQ);
s2233drivers/scsi/aha152x.cif( s & TEMODEO )     printk("TARGET MODE ");
s2234drivers/scsi/aha152x.cif( s & ENSELO )      printk("SELO ");
s2235drivers/scsi/aha152x.cif( s & ENSELI )      printk("SELI ");
s2236drivers/scsi/aha152x.cif( s & ENRESELI )    printk("RESELI ");
s2237drivers/scsi/aha152x.cif( s & ENAUTOATNO )  printk("AUTOATNO ");
s2238drivers/scsi/aha152x.cif( s & ENAUTOATNI )  printk("AUTOATNI ");
s2239drivers/scsi/aha152x.cif( s & ENAUTOATNP )  printk("AUTOATNP ");
s2240drivers/scsi/aha152x.cif( s & SCSIRSTO )    printk("SCSIRSTO ");
s2244drivers/scsi/aha152x.cs=GETPORT(SCSISIG);
s2245drivers/scsi/aha152x.cswitch(s & P_MASK)
s2275drivers/scsi/aha152x.cs=GETPORT(SSTAT0);
s2276drivers/scsi/aha152x.cif( s & TARGET )   printk("TARGET ");
s2277drivers/scsi/aha152x.cif( s & SELDO )    printk("SELDO ");
s2278drivers/scsi/aha152x.cif( s & SELDI )    printk("SELDI ");
s2279drivers/scsi/aha152x.cif( s & SELINGO )  printk("SELINGO ");
s2280drivers/scsi/aha152x.cif( s & SWRAP )    printk("SWRAP ");
s2281drivers/scsi/aha152x.cif( s & SDONE )    printk("SDONE ");
s2282drivers/scsi/aha152x.cif( s & SPIORDY )  printk("SPIORDY ");
s2283drivers/scsi/aha152x.cif( s & DMADONE )  printk("DMADONE ");
s2285drivers/scsi/aha152x.cs=GETPORT(SSTAT1);
s2286drivers/scsi/aha152x.cif( s & SELTO )     printk("SELTO ");
s2287drivers/scsi/aha152x.cif( s & ATNTARG )   printk("ATNTARG ");
s2288drivers/scsi/aha152x.cif( s & SCSIRSTI )  printk("SCSIRSTI ");
s2289drivers/scsi/aha152x.cif( s & PHASEMIS )  printk("PHASEMIS ");
s2290drivers/scsi/aha152x.cif( s & BUSFREE )   printk("BUSFREE ");
s2291drivers/scsi/aha152x.cif( s & SCSIPERR )  printk("SCSIPERR ");
s2292drivers/scsi/aha152x.cif( s & PHASECHG )  printk("PHASECHG ");
s2293drivers/scsi/aha152x.cif( s & REQINIT )   printk("REQINIT ");
s2299drivers/scsi/aha152x.cs=GETPORT(SSTAT0) & GETPORT(SIMODE0);
s2301drivers/scsi/aha152x.cif( s & TARGET )    printk("TARGET ");
s2302drivers/scsi/aha152x.cif( s & SELDO )     printk("SELDO ");
s2303drivers/scsi/aha152x.cif( s & SELDI )     printk("SELDI ");
s2304drivers/scsi/aha152x.cif( s & SELINGO )   printk("SELINGO ");
s2305drivers/scsi/aha152x.cif( s & SWRAP )     printk("SWRAP ");
s2306drivers/scsi/aha152x.cif( s & SDONE )     printk("SDONE ");
s2307drivers/scsi/aha152x.cif( s & SPIORDY )   printk("SPIORDY ");
s2308drivers/scsi/aha152x.cif( s & DMADONE )   printk("DMADONE ");
s2310drivers/scsi/aha152x.cs=GETPORT(SSTAT1) & GETPORT(SIMODE1);
s2312drivers/scsi/aha152x.cif( s & SELTO )     printk("SELTO ");
s2313drivers/scsi/aha152x.cif( s & ATNTARG )   printk("ATNTARG ");
s2314drivers/scsi/aha152x.cif( s & SCSIRSTI )  printk("SCSIRSTI ");
s2315drivers/scsi/aha152x.cif( s & PHASEMIS )  printk("PHASEMIS ");
s2316drivers/scsi/aha152x.cif( s & BUSFREE )   printk("BUSFREE ");
s2317drivers/scsi/aha152x.cif( s & SCSIPERR )  printk("SCSIPERR ");
s2318drivers/scsi/aha152x.cif( s & PHASECHG )  printk("PHASECHG ");
s2319drivers/scsi/aha152x.cif( s & REQINIT )   printk("REQINIT ");
s2324drivers/scsi/aha152x.cs=GETPORT(SXFRCTL0);
s2325drivers/scsi/aha152x.cif( s & SCSIEN )    printk("SCSIEN ");
s2326drivers/scsi/aha152x.cif( s & DMAEN )     printk("DMAEN ");
s2327drivers/scsi/aha152x.cif( s & CH1 )       printk("CH1 ");
s2328drivers/scsi/aha152x.cif( s & CLRSTCNT )  printk("CLRSTCNT ");
s2329drivers/scsi/aha152x.cif( s & SPIOEN )    printk("SPIOEN ");
s2330drivers/scsi/aha152x.cif( s & CLRCH1 )    printk("CLRCH1 ");
s2335drivers/scsi/aha152x.cs=GETPORT(SCSISIG);
s2336drivers/scsi/aha152x.cif( s & ATNI )  printk("ATNI ");
s2337drivers/scsi/aha152x.cif( s & SELI )  printk("SELI ");
s2338drivers/scsi/aha152x.cif( s & BSYI )  printk("BSYI ");
s2339drivers/scsi/aha152x.cif( s & REQI )  printk("REQI ");
s2340drivers/scsi/aha152x.cif( s & ACKI )  printk("ACKI ");
s2347drivers/scsi/aha152x.cs=GETPORT(SSTAT2);
s2348drivers/scsi/aha152x.cif( s & SOFFSET)  printk("SOFFSET ");
s2349drivers/scsi/aha152x.cif( s & SEMPTY)   printk("SEMPTY ");
s2350drivers/scsi/aha152x.cif( s & SFULL)    printk("SFULL ");
s2351drivers/scsi/aha152x.cprintk("); SFCNT ( %d ); ", s & (SFULL|SFCNT) );
s2355drivers/scsi/aha152x.cs=GETPORT(SSTAT4);
s2356drivers/scsi/aha152x.cif( s & SYNCERR)   printk("SYNCERR ");
s2357drivers/scsi/aha152x.cif( s & FWERR)     printk("FWERR ");
s2358drivers/scsi/aha152x.cif( s & FRERR)     printk("FRERR ");
s2365drivers/scsi/aha152x.cs=GETPORT(DMACNTRL0);
s2366drivers/scsi/aha152x.cprintk( "%s ", s & _8BIT      ? "8BIT"  : "16BIT" );
s2367drivers/scsi/aha152x.cprintk( "%s ", s & DMA        ? "DMA"   : "PIO"   );
s2368drivers/scsi/aha152x.cprintk( "%s ", s & WRITE_READ ? "WRITE" : "READ"  );
s2369drivers/scsi/aha152x.cif( s & ENDMA )    printk("ENDMA ");
s2370drivers/scsi/aha152x.cif( s & INTEN )    printk("INTEN ");
s2371drivers/scsi/aha152x.cif( s & RSTFIFO )  printk("RSTFIFO ");
s2372drivers/scsi/aha152x.cif( s & SWINT )    printk("SWINT ");
s2379drivers/scsi/aha152x.cs=GETPORT(DMACNTRL1);
s2380drivers/scsi/aha152x.cif( s & PWRDWN )    printk("PWRDN ");
s2384drivers/scsi/aha152x.cprintk("STK ( %d ); ", s & 0xf);
s2387drivers/scsi/aha152x.cs=GETPORT(DMASTAT);
s2388drivers/scsi/aha152x.cif( s & ATDONE )     printk("ATDONE ");
s2389drivers/scsi/aha152x.cif( s & WORDRDY )    printk("WORDRDY ");
s2390drivers/scsi/aha152x.cif( s & DFIFOFULL )  printk("DFIFOFULL ");
s2391drivers/scsi/aha152x.cif( s & DFIFOEMP )   printk("DFIFOEMP ");
s2405drivers/scsi/aha152x.cint s;
s2409drivers/scsi/aha152x.cs=GETPORT(SIMODE0);
s2410drivers/scsi/aha152x.cif( s & ENSELDO )    printk("ENSELDO ");
s2411drivers/scsi/aha152x.cif( s & ENSELDI )    printk("ENSELDI ");
s2412drivers/scsi/aha152x.cif( s & ENSELINGO )  printk("ENSELINGO ");
s2413drivers/scsi/aha152x.cif( s & ENSWRAP )    printk("ENSWRAP ");
s2414drivers/scsi/aha152x.cif( s & ENSDONE )    printk("ENSDONE ");
s2415drivers/scsi/aha152x.cif( s & ENSPIORDY )  printk("ENSPIORDY ");
s2416drivers/scsi/aha152x.cif( s & ENDMADONE )  printk("ENDMADONE ");
s2418drivers/scsi/aha152x.cs=GETPORT(SIMODE1);
s2419drivers/scsi/aha152x.cif( s & ENSELTIMO )    printk("ENSELTIMO ");
s2420drivers/scsi/aha152x.cif( s & ENATNTARG )    printk("ENATNTARG ");
s2421drivers/scsi/aha152x.cif( s & ENPHASEMIS )   printk("ENPHASEMIS ");
s2422drivers/scsi/aha152x.cif( s & ENBUSFREE )    printk("ENBUSFREE ");
s2423drivers/scsi/aha152x.cif( s & ENSCSIPERR )   printk("ENSCSIPERR ");
s2424drivers/scsi/aha152x.cif( s & ENPHASECHG )   printk("ENPHASECHG ");
s2425drivers/scsi/aha152x.cif( s & ENREQINIT )    printk("ENREQINIT ");
s316drivers/scsi/aha274x.cvoid aha274x_setup(char *s, int *dummy)
s329drivers/scsi/aha274x.cfor (p = strtok(s, ","); p; p = strtok(NULL, ",")) {
s63drivers/scsi/aic7770.cvoid error(char *s)
s65drivers/scsi/aic7770.cfprintf(stderr, "%s: %s at line %d\n", filename, s, lineno);
s85drivers/scsi/aic7770.cchar *Strdup(char *s)
s87drivers/scsi/aic7770.cchar *p = (char *)Malloc(strlen(s) + 1);
s88drivers/scsi/aic7770.cstrcpy(p, s);
s213drivers/scsi/buslogic.cint s = inb(STATUS(base)), i = inb(INTERRUPT(base));
s215drivers/scsi/buslogic.cbuslogic_printk("status=%02X intrflags=%02X\n", s, i);
s102drivers/scsi/constants.cint i,s;
s104drivers/scsi/constants.cfor ( i = 1, s = COMMAND_SIZE(command[0]); i < s; ++i) 
s366drivers/scsi/constants.cint i, s;
s377drivers/scsi/constants.cs = sense_buffer[7] + 8;
s378drivers/scsi/constants.cif(s > sizeof(SCpnt->sense_buffer)) s = sizeof(SCpnt->sense_buffer);
s437drivers/scsi/constants.cs = 4;
s443drivers/scsi/constants.cfor (i = 0; i < s; ++i) 
s511drivers/scsi/pas16.cregister unsigned char *s = src;
s517drivers/scsi/pas16.coutsb( reg, s, i );
s361drivers/scsi/t128.cT_DATA_REG_OFFSET), *s = src;
s371drivers/scsi/t128.c*reg = *s++;
s1001drivers/scsi/ultrastor.cunsigned int s = config.heads * config.sectors;
s1005drivers/scsi/ultrastor.cdkinfo[2] = size / s;  /* Ignore partial cylinders */
s55drivers/sound/os.h#define COPY_FROM_USER(d, s, o, c)  memcpy_fromfs((d), &((s)[o]), (c))
s56drivers/sound/os.h#define COPY_TO_USER(d, o, s, c)  memcpy_tofs(&((d)[o]), (s), (c))
s57drivers/sound/os.h#define IOCTL_FROM_USER(d, s, o, c)  memcpy_fromfs((d), &((s)[o]), (c))
s58drivers/sound/os.h#define IOCTL_TO_USER(d, o, s, c)  memcpy_tofs(&((d)[o]), (s), (c))
s57drivers/sound/sound_switch.cput_status (char *s)
s61drivers/sound/sound_switch.cfor (l = 0; l < 256, s[l]; l++);  /*
s68drivers/sound/sound_switch.cmemcpy (&status_buf[status_len], s, l);
s57fs/ext/inode.cstruct super_block *ext_read_super(struct super_block *s,void *data, 
s62fs/ext/inode.cint dev = s->s_dev,block;
s64fs/ext/inode.clock_super(s);
s67fs/ext/inode.cs->s_dev=0;
s68fs/ext/inode.cunlock_super(s);
s73fs/ext/inode.cs->s_blocksize = 1024;
s74fs/ext/inode.cs->s_blocksize_bits = 10;
s75fs/ext/inode.cs->u.ext_sb.s_ninodes = es->s_ninodes;
s76fs/ext/inode.cs->u.ext_sb.s_nzones = es->s_nzones;
s77fs/ext/inode.cs->u.ext_sb.s_firstdatazone = es->s_firstdatazone;
s78fs/ext/inode.cs->u.ext_sb.s_log_zone_size = es->s_log_zone_size;
s79fs/ext/inode.cs->u.ext_sb.s_max_size = es->s_max_size;
s80fs/ext/inode.cs->s_magic = es->s_magic;
s81fs/ext/inode.cs->u.ext_sb.s_firstfreeblocknumber = es->s_firstfreeblock;
s82fs/ext/inode.cs->u.ext_sb.s_freeblockscount = es->s_freeblockscount;
s83fs/ext/inode.cs->u.ext_sb.s_firstfreeinodenumber = es->s_firstfreeinode;
s84fs/ext/inode.cs->u.ext_sb.s_freeinodescount = es->s_freeinodescount;
s86fs/ext/inode.cif (s->s_magic != EXT_SUPER_MAGIC) {
s87fs/ext/inode.cs->s_dev = 0;
s88fs/ext/inode.cunlock_super(s);
s94fs/ext/inode.cif (!s->u.ext_sb.s_firstfreeblocknumber)
s95fs/ext/inode.cs->u.ext_sb.s_firstfreeblock = NULL;
s97fs/ext/inode.cif (!(s->u.ext_sb.s_firstfreeblock = bread(dev,
s98fs/ext/inode.cs->u.ext_sb.s_firstfreeblocknumber, BLOCK_SIZE))) {
s100fs/ext/inode.cs->s_dev = 0;
s101fs/ext/inode.cunlock_super(s);
s104fs/ext/inode.cif (!s->u.ext_sb.s_firstfreeinodenumber)
s105fs/ext/inode.cs->u.ext_sb.s_firstfreeinodeblock = NULL;
s107fs/ext/inode.cblock = 2 + (s->u.ext_sb.s_firstfreeinodenumber - 1) / EXT_INODES_PER_BLOCK;
s108fs/ext/inode.cif (!(s->u.ext_sb.s_firstfreeinodeblock = bread(dev, block, BLOCK_SIZE))) {
s110fs/ext/inode.cbrelse(s->u.ext_sb.s_firstfreeblock);
s111fs/ext/inode.cs->s_dev = 0;
s112fs/ext/inode.cunlock_super (s);
s116fs/ext/inode.cunlock_super(s);
s118fs/ext/inode.cs->s_dev = dev;
s119fs/ext/inode.cs->s_op = &ext_sops;
s120fs/ext/inode.cif (!(s->s_mounted = iget(s,EXT_ROOT_INO))) {
s121fs/ext/inode.cs->s_dev=0;
s125fs/ext/inode.creturn s;
s241fs/hpfs/hpfs_fs.cstatic unsigned count_bitmap(struct super_block *s);
s332fs/hpfs/hpfs_fs.cstruct super_block *hpfs_read_super(struct super_block *s,
s356fs/hpfs/hpfs_fs.cs->s_dev = 0;
s364fs/hpfs/hpfs_fs.clock_super(s);
s365fs/hpfs/hpfs_fs.cdev = s->s_dev;
s442fs/hpfs/hpfs_fs.cs->s_flags |= MS_RDONLY;
s448fs/hpfs/hpfs_fs.cs->s_magic = HPFS_SUPER_MAGIC;
s449fs/hpfs/hpfs_fs.cs->s_blocksize = 512;
s450fs/hpfs/hpfs_fs.cs->s_blocksize_bits = 9;
s451fs/hpfs/hpfs_fs.cs->s_op = (struct super_operations *) &hpfs_sops;
s457fs/hpfs/hpfs_fs.cs->s_hpfs_root = dir_ino(superblock->root);
s458fs/hpfs/hpfs_fs.cs->s_hpfs_fs_size = superblock->n_sectors;
s459fs/hpfs/hpfs_fs.cs->s_hpfs_dirband_size = superblock->n_dir_band / 4;
s460fs/hpfs/hpfs_fs.cs->s_hpfs_dmap = superblock->dir_band_bitmap;
s461fs/hpfs/hpfs_fs.cs->s_hpfs_bitmaps = superblock->bitmaps;
s462fs/hpfs/hpfs_fs.cs->s_hpfs_uid = uid;
s463fs/hpfs/hpfs_fs.cs->s_hpfs_gid = gid;
s464fs/hpfs/hpfs_fs.cs->s_hpfs_mode = 0777 & ~umask;
s465fs/hpfs/hpfs_fs.cs->s_hpfs_n_free = -1;
s466fs/hpfs/hpfs_fs.cs->s_hpfs_n_free_dnodes = -1;
s467fs/hpfs/hpfs_fs.cs->s_hpfs_lowercase = lowercase;
s468fs/hpfs/hpfs_fs.cs->s_hpfs_conv = conv;
s482fs/hpfs/hpfs_fs.cs->s_mounted = iget(s, s->s_hpfs_root);
s483fs/hpfs/hpfs_fs.cunlock_super(s);
s485fs/hpfs/hpfs_fs.cif (!s->s_mounted) {
s487fs/hpfs/hpfs_fs.cs->s_dev = 0;
s495fs/hpfs/hpfs_fs.croot_dno = fnode_dno(dev, s->s_hpfs_root);
s497fs/hpfs/hpfs_fs.cde = map_dirent(s->s_mounted, root_dno, "\001\001", 2, &qbh);
s501fs/hpfs/hpfs_fs.cs->s_dev = 0;
s505fs/hpfs/hpfs_fs.cs->s_mounted->i_atime = local_to_gmt(de->read_date);
s506fs/hpfs/hpfs_fs.cs->s_mounted->i_mtime = local_to_gmt(de->write_date);
s507fs/hpfs/hpfs_fs.cs->s_mounted->i_ctime = local_to_gmt(de->creation_date);
s510fs/hpfs/hpfs_fs.creturn s;
s519fs/hpfs/hpfs_fs.cs->s_dev = 0;
s520fs/hpfs/hpfs_fs.cunlock_super(s);
s623fs/hpfs/hpfs_fs.cstruct super_block *s = inode->i_sb;
s640fs/hpfs/hpfs_fs.cinode->i_uid = s->s_hpfs_uid;
s641fs/hpfs/hpfs_fs.cinode->i_gid = s->s_hpfs_gid;
s642fs/hpfs/hpfs_fs.cinode->i_mode = s->s_hpfs_mode;
s643fs/hpfs/hpfs_fs.cinode->i_hpfs_conv = s->s_hpfs_conv;
s717fs/hpfs/hpfs_fs.cstatic void hpfs_put_super(struct super_block *s)
s719fs/hpfs/hpfs_fs.clock_super(s);
s720fs/hpfs/hpfs_fs.cs->s_dev = 0;
s721fs/hpfs/hpfs_fs.cunlock_super(s);
s729fs/hpfs/hpfs_fs.cstatic void hpfs_statfs(struct super_block *s, struct statfs *buf)
s735fs/hpfs/hpfs_fs.cif (s->s_hpfs_n_free == -1) {
s736fs/hpfs/hpfs_fs.cs->s_hpfs_n_free = count_bitmap(s);
s737fs/hpfs/hpfs_fs.cs->s_hpfs_n_free_dnodes =
s738fs/hpfs/hpfs_fs.ccount_one_bitmap(s->s_dev, s->s_hpfs_dmap);
s745fs/hpfs/hpfs_fs.cput_fs_long(s->s_magic, &buf->f_type);
s747fs/hpfs/hpfs_fs.cput_fs_long(s->s_hpfs_fs_size, &buf->f_blocks);
s748fs/hpfs/hpfs_fs.cput_fs_long(s->s_hpfs_n_free, &buf->f_bfree);
s749fs/hpfs/hpfs_fs.cput_fs_long(s->s_hpfs_n_free, &buf->f_bavail);
s750fs/hpfs/hpfs_fs.cput_fs_long(s->s_hpfs_dirband_size, &buf->f_files);
s751fs/hpfs/hpfs_fs.cput_fs_long(s->s_hpfs_n_free_dnodes, &buf->f_ffree);
s759fs/hpfs/hpfs_fs.cstatic int hpfs_remount_fs(struct super_block *s, int *flags, char *data)
s803fs/hpfs/hpfs_fs.cstatic unsigned count_bitmap(struct super_block *s)
s812fs/hpfs/hpfs_fs.cn_bands = (s->s_hpfs_fs_size + 0x3fff) >> 14;
s818fs/hpfs/hpfs_fs.cbitmaps = map_4sectors(s->s_dev, s->s_hpfs_bitmaps, &qbh);
s831fs/hpfs/hpfs_fs.ccount += count_one_bitmap(s->s_dev, bitmaps[n]);
s140fs/isofs/inode.cstruct super_block *isofs_read_super(struct super_block *s,void *data,
s147fs/isofs/inode.cint dev=s->s_dev;
s159fs/isofs/inode.cs->s_dev = 0;
s183fs/isofs/inode.clock_super(s);
s185fs/isofs/inode.cs->u.isofs_sb.s_high_sierra = high_sierra = 0; /* default is iso9660 */
s189fs/isofs/inode.cs->s_dev=0;
s192fs/isofs/inode.cunlock_super(s);
s206fs/isofs/inode.cs->u.isofs_sb.s_high_sierra = 1;
s228fs/isofs/inode.cs->s_dev = 0;
s229fs/isofs/inode.cunlock_super(s);
s240fs/isofs/inode.cs->u.isofs_sb.s_nzones = isonum_733 (h_pri->volume_space_size);
s241fs/isofs/inode.cs->u.isofs_sb.s_log_zone_size = isonum_723 (h_pri->logical_block_size);
s242fs/isofs/inode.cs->u.isofs_sb.s_max_size = isonum_733(h_pri->volume_space_size);
s249fs/isofs/inode.cs->u.isofs_sb.s_nzones = isonum_733 (pri->volume_space_size);
s250fs/isofs/inode.cs->u.isofs_sb.s_log_zone_size = isonum_723 (pri->logical_block_size);
s251fs/isofs/inode.cs->u.isofs_sb.s_max_size = isonum_733(pri->volume_space_size);
s254fs/isofs/inode.cs->u.isofs_sb.s_ninodes = 0; /* No way to figure this out easily */
s258fs/isofs/inode.cswitch (s -> u.isofs_sb.s_log_zone_size)
s259fs/isofs/inode.c{ case  512: s -> u.isofs_sb.s_log_zone_size =  9; break;
s260fs/isofs/inode.ccase 1024: s -> u.isofs_sb.s_log_zone_size = 10; break;
s261fs/isofs/inode.ccase 2048: s -> u.isofs_sb.s_log_zone_size = 11; break;
s264fs/isofs/inode.cprintk("Bad logical zone size %ld\n", s -> u.isofs_sb.s_log_zone_size);
s270fs/isofs/inode.cs->u.isofs_sb.s_firstdatazone = (isonum_733( rootp->extent) 
s271fs/isofs/inode.c<< s -> u.isofs_sb.s_log_zone_size);
s272fs/isofs/inode.cs->s_magic = ISOFS_SUPER_MAGIC;
s279fs/isofs/inode.cs->s_flags |= MS_RDONLY /* | MS_NODEV | MS_NOSUID */;
s284fs/isofs/inode.cs->u.isofs_sb.s_max_size, 
s285fs/isofs/inode.c1UL << s->u.isofs_sb.s_log_zone_size);
s287fs/isofs/inode.cs->u.isofs_sb.s_firstdatazone >> s -> u.isofs_sb.s_log_zone_size,
s288fs/isofs/inode.cisonum_733 (rootp->extent) << s -> u.isofs_sb.s_log_zone_size);
s290fs/isofs/inode.cunlock_super(s);
s293fs/isofs/inode.cs->s_dev = dev;
s294fs/isofs/inode.cs->s_op = &isofs_sops;
s295fs/isofs/inode.cs->u.isofs_sb.s_mapping = opt.map;
s296fs/isofs/inode.cs->u.isofs_sb.s_rock = (opt.rock == 'y' ? 1 : 0);
s297fs/isofs/inode.cs->u.isofs_sb.s_conversion = opt.conversion;
s298fs/isofs/inode.cs->u.isofs_sb.s_cruft = opt.cruft;
s299fs/isofs/inode.cs->u.isofs_sb.s_uid = opt.uid;
s300fs/isofs/inode.cs->u.isofs_sb.s_gid = opt.gid;
s301fs/isofs/inode.cs->s_blocksize = opt.blocksize;
s302fs/isofs/inode.cs->s_blocksize_bits = blocksize_bits;
s303fs/isofs/inode.cs->s_mounted = iget(s, isonum_733 (rootp->extent) << s -> u.isofs_sb.s_log_zone_size);
s304fs/isofs/inode.cunlock_super(s);
s306fs/isofs/inode.cif (!(s->s_mounted)) {
s307fs/isofs/inode.cs->s_dev=0;
s312fs/isofs/inode.cif(!check_disk_change(s->s_dev)) {
s316fs/isofs/inode.creturn s;
s320fs/isofs/inode.cs->s_dev = 0;
s321fs/isofs/inode.cunlock_super(s);
s115fs/minix/inode.cstruct super_block *minix_read_super(struct super_block *s,void *data, 
s120fs/minix/inode.cint i,dev=s->s_dev,block;
s124fs/minix/inode.clock_super(s);
s127fs/minix/inode.cs->s_dev=0;
s128fs/minix/inode.cunlock_super(s);
s133fs/minix/inode.cs->u.minix_sb.s_ms = ms;
s134fs/minix/inode.cs->u.minix_sb.s_sbh = bh;
s135fs/minix/inode.cs->u.minix_sb.s_mount_state = ms->s_state;
s136fs/minix/inode.cs->s_blocksize = 1024;
s137fs/minix/inode.cs->s_blocksize_bits = 10;
s138fs/minix/inode.cs->u.minix_sb.s_ninodes = ms->s_ninodes;
s139fs/minix/inode.cs->u.minix_sb.s_nzones = ms->s_nzones;
s140fs/minix/inode.cs->u.minix_sb.s_imap_blocks = ms->s_imap_blocks;
s141fs/minix/inode.cs->u.minix_sb.s_zmap_blocks = ms->s_zmap_blocks;
s142fs/minix/inode.cs->u.minix_sb.s_firstdatazone = ms->s_firstdatazone;
s143fs/minix/inode.cs->u.minix_sb.s_log_zone_size = ms->s_log_zone_size;
s144fs/minix/inode.cs->u.minix_sb.s_max_size = ms->s_max_size;
s145fs/minix/inode.cs->s_magic = ms->s_magic;
s146fs/minix/inode.cif (s->s_magic == MINIX_SUPER_MAGIC) {
s147fs/minix/inode.cs->u.minix_sb.s_dirsize = 16;
s148fs/minix/inode.cs->u.minix_sb.s_namelen = 14;
s149fs/minix/inode.c} else if (s->s_magic == MINIX_SUPER_MAGIC2) {
s150fs/minix/inode.cs->u.minix_sb.s_dirsize = 32;
s151fs/minix/inode.cs->u.minix_sb.s_namelen = 30;
s153fs/minix/inode.cs->s_dev = 0;
s154fs/minix/inode.cunlock_super(s);
s161fs/minix/inode.cs->u.minix_sb.s_imap[i] = NULL;
s163fs/minix/inode.cs->u.minix_sb.s_zmap[i] = NULL;
s165fs/minix/inode.cfor (i=0 ; i < s->u.minix_sb.s_imap_blocks ; i++)
s166fs/minix/inode.cif ((s->u.minix_sb.s_imap[i]=bread(dev,block,BLOCK_SIZE)) != NULL)
s170fs/minix/inode.cfor (i=0 ; i < s->u.minix_sb.s_zmap_blocks ; i++)
s171fs/minix/inode.cif ((s->u.minix_sb.s_zmap[i]=bread(dev,block,BLOCK_SIZE)) != NULL)
s175fs/minix/inode.cif (block != 2+s->u.minix_sb.s_imap_blocks+s->u.minix_sb.s_zmap_blocks) {
s177fs/minix/inode.cbrelse(s->u.minix_sb.s_imap[i]);
s179fs/minix/inode.cbrelse(s->u.minix_sb.s_zmap[i]);
s180fs/minix/inode.cs->s_dev=0;
s181fs/minix/inode.cunlock_super(s);
s186fs/minix/inode.cset_bit(0,s->u.minix_sb.s_imap[0]->b_data);
s187fs/minix/inode.cset_bit(0,s->u.minix_sb.s_zmap[0]->b_data);
s188fs/minix/inode.cunlock_super(s);
s190fs/minix/inode.cs->s_dev = dev;
s191fs/minix/inode.cs->s_op = &minix_sops;
s192fs/minix/inode.cs->s_mounted = iget(s,MINIX_ROOT_INO);
s193fs/minix/inode.cif (!s->s_mounted) {
s194fs/minix/inode.cs->s_dev = 0;
s199fs/minix/inode.cif (!(s->s_flags & MS_RDONLY)) {
s202fs/minix/inode.cs->s_dirt = 1;
s204fs/minix/inode.cif (!(s->u.minix_sb.s_mount_state & MINIX_VALID_FS))
s207fs/minix/inode.celse if (s->u.minix_sb.s_mount_state & MINIX_ERROR_FS)
s210fs/minix/inode.creturn s;
s156fs/msdos/inode.cstruct super_block *msdos_read_super(struct super_block *s,void *data,
s170fs/msdos/inode.cs->s_dev = 0;
s174fs/msdos/inode.clock_super(s);
s175fs/msdos/inode.cset_blocksize(s->s_dev, SECTOR_SIZE);
s176fs/msdos/inode.cbh = bread(s->s_dev, 0, SECTOR_SIZE);
s177fs/msdos/inode.cunlock_super(s);
s179fs/msdos/inode.cs->s_dev = 0;
s184fs/msdos/inode.cs->s_blocksize = 512;  /* Using this small block size solve the */
s188fs/msdos/inode.cs->s_blocksize_bits = 9;  /* we cannot handle anything else yet */
s209fs/msdos/inode.cMSDOS_SB(s)->cluster_size = b->cluster_size*sector_mult;
s210fs/msdos/inode.cMSDOS_SB(s)->fats = b->fats;
s211fs/msdos/inode.cMSDOS_SB(s)->fat_start = CF_LE_W(b->reserved)*sector_mult;
s212fs/msdos/inode.cMSDOS_SB(s)->fat_length = CF_LE_W(b->fat_length)*sector_mult;
s213fs/msdos/inode.cMSDOS_SB(s)->dir_start = (CF_LE_W(b->reserved)+b->fats*CF_LE_W(
s215fs/msdos/inode.cMSDOS_SB(s)->dir_entries = CF_LE_W(*((unsigned short *) &b->dir_entries
s217fs/msdos/inode.cMSDOS_SB(s)->data_start = MSDOS_SB(s)->dir_start+ROUND_TO_MULTIPLE((
s218fs/msdos/inode.cMSDOS_SB(s)->dir_entries << MSDOS_DIR_BITS) >> SECTOR_BITS,
s222fs/msdos/inode.cCF_LE_L(b->total_sect))*sector_mult-MSDOS_SB(s)->data_start;
s225fs/msdos/inode.cMSDOS_SB(s)->clusters = b->cluster_size ? data_sectors/
s227fs/msdos/inode.cMSDOS_SB(s)->fat_bits = fat ? fat : MSDOS_SB(s)->clusters >
s229fs/msdos/inode.cerror = !MSDOS_SB(s)->fats || (MSDOS_SB(s)->dir_entries &
s230fs/msdos/inode.c(MSDOS_DPS-1)) || MSDOS_SB(s)->clusters+2 > MSDOS_SB(s)->
s231fs/msdos/inode.cfat_length*SECTOR_SIZE*8/MSDOS_SB(s)->fat_bits ||
s239fs/msdos/inode.c"uid=%d,gid=%d,umask=%03o%s]\n",MSDOS_SB(s)->fat_bits,check,
s240fs/msdos/inode.cconversion,uid,gid,umask,MSDOS_CAN_BMAP(MSDOS_SB(s)) ?
s243fs/msdos/inode.c"se=%d,ts=%ld,ls=%d]\n",b->media,MSDOS_SB(s)->cluster_size,
s244fs/msdos/inode.cMSDOS_SB(s)->fats,MSDOS_SB(s)->fat_start,MSDOS_SB(s)->
s245fs/msdos/inode.cfat_length,MSDOS_SB(s)->dir_start,MSDOS_SB(s)->dir_entries,
s246fs/msdos/inode.cMSDOS_SB(s)->data_start,CF_LE_W(*(unsigned short *) &b->
s252fs/msdos/inode.cs->s_dev);
s253fs/msdos/inode.cs->s_dev = 0;
s256fs/msdos/inode.cs->s_magic = MSDOS_SUPER_MAGIC;
s257fs/msdos/inode.cMSDOS_SB(s)->name_check = check;
s258fs/msdos/inode.cMSDOS_SB(s)->conversion = conversion;
s260fs/msdos/inode.cs->s_op = &msdos_sops;
s261fs/msdos/inode.cMSDOS_SB(s)->fs_uid = uid;
s262fs/msdos/inode.cMSDOS_SB(s)->fs_gid = gid;
s263fs/msdos/inode.cMSDOS_SB(s)->fs_umask = umask;
s264fs/msdos/inode.cMSDOS_SB(s)->quiet = quiet;
s265fs/msdos/inode.cMSDOS_SB(s)->free_clusters = -1; /* don't know yet */
s266fs/msdos/inode.cMSDOS_SB(s)->fat_wait = NULL;
s267fs/msdos/inode.cMSDOS_SB(s)->fat_lock = 0;
s268fs/msdos/inode.cMSDOS_SB(s)->prev_free = 0;
s269fs/msdos/inode.cif (!(s->s_mounted = iget(s,MSDOS_ROOT_INO))) {
s270fs/msdos/inode.cs->s_dev = 0;
s277fs/msdos/inode.creturn s;
s33fs/msdos/misc.cvoid fs_panic(struct super_block *s,char *msg)
s37fs/msdos/misc.cnot_ro = !(s->s_flags & MS_RDONLY);
s38fs/msdos/misc.cif (not_ro) s->s_flags |= MS_RDONLY;
s40fs/msdos/misc.cs->s_dev,s->s_covered->i_dev,s->s_covered->i_ino,msg);
s44fs/proc/inode.cstruct super_block *proc_read_super(struct super_block *s,void *data, 
s47fs/proc/inode.clock_super(s);
s48fs/proc/inode.cs->s_blocksize = 1024;
s49fs/proc/inode.cs->s_blocksize_bits = 10;
s50fs/proc/inode.cs->s_magic = PROC_SUPER_MAGIC;
s51fs/proc/inode.cs->s_op = &proc_sops;
s52fs/proc/inode.cunlock_super(s);
s53fs/proc/inode.cif (!(s->s_mounted = iget(s,PROC_ROOT_INO))) {
s54fs/proc/inode.cs->s_dev = 0;
s58fs/proc/inode.creturn s;
s220fs/super.cstruct super_block * s;
s224fs/super.cs = 0+super_blocks;
s225fs/super.cwhile (s < NR_SUPER+super_blocks)
s226fs/super.cif (s->s_dev == dev) {
s227fs/super.cwait_on_super(s);
s228fs/super.cif (s->s_dev == dev)
s229fs/super.creturn s;
s230fs/super.cs = 0+super_blocks;
s232fs/super.cs++;
s259fs/super.cstruct super_block * s;
s265fs/super.cs = get_super(dev);
s266fs/super.cif (s)
s267fs/super.creturn s;
s273fs/super.cfor (s = 0+super_blocks ;; s++) {
s274fs/super.cif (s >= NR_SUPER+super_blocks)
s276fs/super.cif (!s->s_dev)
s279fs/super.cs->s_dev = dev;
s280fs/super.cs->s_flags = flags;
s281fs/super.cif (!type->read_super(s,data, silent)) {
s282fs/super.cs->s_dev = 0;
s285fs/super.cs->s_dev = dev;
s286fs/super.cs->s_covered = NULL;
s287fs/super.cs->s_rd_only = 0;
s288fs/super.cs->s_dirt = 0;
s289fs/super.creturn s;
s394fs/umsdos/inode.cstruct super_block *s,
s411fs/umsdos/inode.cstruct super_block *sb = msdos_read_super(s,data,silent);
s419fs/umsdos/inode.cif (s == super_blocks){
s59fs/xiafs/inode.cstruct super_block *xiafs_read_super(struct super_block *s, void *data,
s66fs/xiafs/inode.cdev=s->s_dev;
s67fs/xiafs/inode.clock_super(s);
s72fs/xiafs/inode.cs->s_dev=0;
s73fs/xiafs/inode.cunlock_super(s);
s78fs/xiafs/inode.cs->s_magic = sp->s_magic;
s79fs/xiafs/inode.cif (s->s_magic != _XIAFS_SUPER_MAGIC) {
s80fs/xiafs/inode.cs->s_dev = 0;
s81fs/xiafs/inode.cunlock_super(s);
s88fs/xiafs/inode.cs->s_blocksize = sp->s_zone_size;
s89fs/xiafs/inode.cs->s_blocksize_bits = 10 + sp->s_zone_shift;
s90fs/xiafs/inode.cif (s->s_blocksize != BLOCK_SIZE && 
s91fs/xiafs/inode.c(s->s_blocksize == 1024 || s->s_blocksize == 2048 ||  
s92fs/xiafs/inode.cs->s_blocksize == 4096)) {
s94fs/xiafs/inode.cset_blocksize(dev, s->s_blocksize);
s95fs/xiafs/inode.cbh = bread (dev, 0,  s->s_blocksize);
s99fs/xiafs/inode.cs->u.xiafs_sb.s_nzones = sp->s_nzones;
s100fs/xiafs/inode.cs->u.xiafs_sb.s_ninodes = sp->s_ninodes;
s101fs/xiafs/inode.cs->u.xiafs_sb.s_ndatazones = sp->s_ndatazones;
s102fs/xiafs/inode.cs->u.xiafs_sb.s_imap_zones = sp->s_imap_zones;
s103fs/xiafs/inode.cs->u.xiafs_sb.s_zmap_zones = sp->s_zmap_zones;
s104fs/xiafs/inode.cs->u.xiafs_sb.s_firstdatazone = sp->s_firstdatazone;
s105fs/xiafs/inode.cs->u.xiafs_sb.s_zone_shift = sp->s_zone_shift;
s106fs/xiafs/inode.cs->u.xiafs_sb.s_max_size = sp->s_max_size;
s109fs/xiafs/inode.cs->u.xiafs_sb.s_imap_buf[i] = NULL;
s110fs/xiafs/inode.cs->u.xiafs_sb.s_imap_iznr[i] = -1;
s113fs/xiafs/inode.cs->u.xiafs_sb.s_zmap_buf[i] = NULL;
s114fs/xiafs/inode.cs->u.xiafs_sb.s_zmap_zznr[i] = -1;
s117fs/xiafs/inode.cif ( s->u.xiafs_sb.s_imap_zones > _XIAFS_IMAP_SLOTS )
s118fs/xiafs/inode.cs->u.xiafs_sb.s_imap_cached=1;
s120fs/xiafs/inode.cs->u.xiafs_sb.s_imap_cached=0;
s121fs/xiafs/inode.cfor (i=0 ; i < s->u.xiafs_sb.s_imap_zones ; i++) {
s122fs/xiafs/inode.cif (!(s->u.xiafs_sb.s_imap_buf[i]=bread(dev, z++, XIAFS_ZSIZE(s))))
s124fs/xiafs/inode.cs->u.xiafs_sb.s_imap_iznr[i]=i;
s127fs/xiafs/inode.cif ( s->u.xiafs_sb.s_zmap_zones > _XIAFS_ZMAP_SLOTS )
s128fs/xiafs/inode.cs->u.xiafs_sb.s_zmap_cached=1;
s130fs/xiafs/inode.cs->u.xiafs_sb.s_zmap_cached=0;
s131fs/xiafs/inode.cfor (i=0 ; i < s->u.xiafs_sb.s_zmap_zones ; i++) {
s132fs/xiafs/inode.cif (!(s->u.xiafs_sb.s_zmap_buf[i]=bread(dev, z++, XIAFS_ZSIZE(s))))
s134fs/xiafs/inode.cs->u.xiafs_sb.s_zmap_zznr[i]=i;
s138fs/xiafs/inode.cs->s_dev = dev;
s139fs/xiafs/inode.cs->s_op = &xiafs_sops;
s140fs/xiafs/inode.cs->s_mounted = iget(s, _XIAFS_ROOT_INO);
s141fs/xiafs/inode.cif (!s->s_mounted) 
s143fs/xiafs/inode.cunlock_super(s);
s145fs/xiafs/inode.creturn s;
s149fs/xiafs/inode.cbrelse(s->u.xiafs_sb.s_imap_buf[i]);
s151fs/xiafs/inode.cbrelse(s->u.xiafs_sb.s_zmap_buf[i]);
s152fs/xiafs/inode.cs->s_dev=0;
s153fs/xiafs/inode.cunlock_super(s);
s101include/asm-generic/string.hextern inline char * strchr(const char * s,char c)
s105include/asm-generic/string.hfor(; *s != ch; ++s)
s106include/asm-generic/string.hif (*s == '\0')
s108include/asm-generic/string.hreturn( (char *) s);
s113include/asm-generic/string.hextern inline size_t strlen(const char * s)
s116include/asm-generic/string.hfor (sc = s; *sc != '\0'; ++sc) ;
s117include/asm-generic/string.hreturn(sc - s);
s122include/asm-generic/string.hextern inline size_t strspn(const char *s, const char *accept)
s128include/asm-generic/string.hfor (p = s; *p != '\0'; ++p)
s157include/asm-generic/string.hextern inline char * strtok(char * s,const char * ct)
s162include/asm-generic/string.hsbegin  = s ? s : ssave;
s180include/asm-generic/string.hextern inline void * memset(void * s,char c,size_t count)
s182include/asm-generic/string.hvoid *xs = s;
s185include/asm-generic/string.h*s++ = c;
s44include/asm-i386/io.h#define __OUT1(s,x) \
s45include/asm-i386/io.hextern inline void __out##s(unsigned x value, unsigned short port) {
s47include/asm-i386/io.h#define __OUT2(s,s1,s2) \
s48include/asm-i386/io.h__asm__ __volatile__ ("out" #s " %" s1 "0,%" s2 "1"
s50include/asm-i386/io.h#define __OUT(s,s1,x) \
s51include/asm-i386/io.h__OUT1(s,x) __OUT2(s,s1,"w") : : "a" (value), "d" (port)); } \
s52include/asm-i386/io.h__OUT1(s##c,x) __OUT2(s,s1,"") : : "a" (value), "i" (port)); } \
s53include/asm-i386/io.h__OUT1(s##_p,x) __OUT2(s,s1,"w") : : "a" (value), "d" (port)); SLOW_DOWN_IO; } \
s54include/asm-i386/io.h__OUT1(s##c_p,x) __OUT2(s,s1,"") : : "a" (value), "i" (port)); SLOW_DOWN_IO; }
s56include/asm-i386/io.h#define __IN1(s) \
s57include/asm-i386/io.hextern inline unsigned int __in##s(unsigned short port) { unsigned int _v;
s59include/asm-i386/io.h#define __IN2(s,s1,s2) \
s60include/asm-i386/io.h__asm__ __volatile__ ("in" #s " %" s2 "1,%" s1 "0"
s62include/asm-i386/io.h#define __IN(s,s1,i...) \
s63include/asm-i386/io.h__IN1(s) __IN2(s,s1,"w") : "=a" (_v) : "d" (port) ,##i ); return _v; } \
s64include/asm-i386/io.h__IN1(s##c) __IN2(s,s1,"") : "=a" (_v) : "i" (port) ,##i ); return _v; } \
s65include/asm-i386/io.h__IN1(s##_p) __IN2(s,s1,"w") : "=a" (_v) : "d" (port) ,##i ); SLOW_DOWN_IO; return _v; } \
s66include/asm-i386/io.h__IN1(s##c_p) __IN2(s,s1,"") : "=a" (_v) : "i" (port) ,##i ); SLOW_DOWN_IO; return _v; }
s68include/asm-i386/io.h#define __INS(s) \
s69include/asm-i386/io.hextern inline void ins##s(unsigned short port, void * addr, unsigned long count) \
s70include/asm-i386/io.h{ __asm__ __volatile__ ("cld ; rep ; ins" #s \
s73include/asm-i386/io.h#define __OUTS(s) \
s74include/asm-i386/io.hextern inline void outs##s(unsigned short port, const void * addr, unsigned long count) \
s75include/asm-i386/io.h{ __asm__ __volatile__ ("cld ; rep ; outs" #s \
s125include/asm-i386/string.hextern inline char * strchr(const char * s,char c)
s139include/asm-i386/string.h:"=a" (__res):"S" (s),"0" (c):"si");
s143include/asm-i386/string.hextern inline char * strrchr(const char * s,char c)
s155include/asm-i386/string.h:"=d" (__res):"0" (0),"S" (s),"a" (c):"ax","si");
s265include/asm-i386/string.hextern inline size_t strlen(const char * s)
s274include/asm-i386/string.h:"=c" (__res):"D" (s),"a" (0),"0" (0xffffffff):"di");
s280include/asm-i386/string.hextern inline char * strtok(char * s,const char * ct)
s335include/asm-i386/string.h:"0" (___strtok),"1" (s),"g" (ct)
s417include/asm-i386/string.hextern inline void * __memset_generic(void * s,char c,size_t count)
s424include/asm-i386/string.h:"a" (c),"D" (s),"c" (count)
s426include/asm-i386/string.hreturn s;
s430include/asm-i386/string.h#define __constant_c_memset(s,c,count) __memset_generic((s),(c),(count))
s431include/asm-i386/string.h#define __constant_count_memset(s,c,count) __memset_generic((s),(c),(count))
s437include/asm-i386/string.hextern inline void * __constant_c_and_count_memset(void * s, unsigned long pattern, size_t count)
s441include/asm-i386/string.hreturn s;
s443include/asm-i386/string.h*(unsigned char *)s = pattern;
s444include/asm-i386/string.hreturn s;
s446include/asm-i386/string.h*(unsigned short *)s = pattern;
s447include/asm-i386/string.hreturn s;
s449include/asm-i386/string.h*(unsigned short *)s = pattern;
s450include/asm-i386/string.h*(2+(unsigned char *)s) = pattern;
s451include/asm-i386/string.hreturn s;
s453include/asm-i386/string.h*(unsigned long *)s = pattern;
s454include/asm-i386/string.hreturn s;
s461include/asm-i386/string.h: "a" (pattern),"c" (count/4),"D" ((long) s) \
s465include/asm-i386/string.hcase 0: COMMON(""); return s;
s466include/asm-i386/string.hcase 1: COMMON("\n\tstosb"); return s;
s467include/asm-i386/string.hcase 2: COMMON("\n\tstosw"); return s;
s468include/asm-i386/string.hcase 3: COMMON("\n\tstosw\n\tstosb"); return s;
s473include/asm-i386/string.h#define __constant_c_x_memset(s, c, count) \
s475include/asm-i386/string.h__constant_c_and_count_memset((s),(c),(count)) : \
s476include/asm-i386/string.h__constant_c_memset((s),(c),(count)))
s478include/asm-i386/string.h#define __memset(s, c, count) \
s480include/asm-i386/string.h__constant_count_memset((s),(c),(count)) : \
s481include/asm-i386/string.h__memset_generic((s),(c),(count)))
s483include/asm-i386/string.h#define memset(s, c, count) \
s485include/asm-i386/string.h__constant_c_x_memset((s),(0x01010101UL*(unsigned char)c),(count)) : \
s486include/asm-i386/string.h__memset((s),(c),(count)))
s124include/asm-mips/string.hextern inline void * memset(void * s,char c,size_t count)
s126include/asm-mips/string.hvoid *xs = s;
s137include/asm-mips/string.h: "=d" (s), "=d" (count)
s138include/asm-mips/string.h: "0" (s), "d" (c), "1" (count)
s95include/linux/ext2_fs.h# define EXT2_BLOCK_SIZE(s)    ((s)->s_blocksize)
s97include/linux/ext2_fs.h# define EXT2_BLOCK_SIZE(s)    (EXT2_MIN_BLOCK_SIZE << (s)->s_log_block_size)
s99include/linux/ext2_fs.h#define EXT2_ACLE_PER_BLOCK(s)    (EXT2_BLOCK_SIZE(s) / sizeof (struct ext2_acl_entry))
s100include/linux/ext2_fs.h#define  EXT2_ADDR_PER_BLOCK(s)    (EXT2_BLOCK_SIZE(s) / sizeof (unsigned long))
s102include/linux/ext2_fs.h# define EXT2_BLOCK_SIZE_BITS(s)  ((s)->u.ext2_sb.s_es->s_log_block_size + 10)
s104include/linux/ext2_fs.h# define EXT2_BLOCK_SIZE_BITS(s)  ((s)->s_log_block_size + 10)
s106include/linux/ext2_fs.h#define  EXT2_INODES_PER_BLOCK(s)  (EXT2_BLOCK_SIZE(s) / sizeof (struct ext2_inode))
s115include/linux/ext2_fs.h# define EXT2_FRAG_SIZE(s)    ((s)->u.ext2_sb.s_frag_size)
s116include/linux/ext2_fs.h# define EXT2_FRAGS_PER_BLOCK(s)  ((s)->u.ext2_sb.s_frags_per_block)
s118include/linux/ext2_fs.h# define EXT2_FRAG_SIZE(s)    (EXT2_MIN_FRAG_SIZE << (s)->s_log_frag_size)
s119include/linux/ext2_fs.h# define EXT2_FRAGS_PER_BLOCK(s)  (EXT2_BLOCK_SIZE(s) / EXT2_FRAG_SIZE(s))
s172include/linux/ext2_fs.h# define EXT2_BLOCKS_PER_GROUP(s)  ((s)->u.ext2_sb.s_blocks_per_group)
s173include/linux/ext2_fs.h# define EXT2_DESC_PER_BLOCK(s)    ((s)->u.ext2_sb.s_desc_per_block)
s174include/linux/ext2_fs.h# define EXT2_INODES_PER_GROUP(s)  ((s)->u.ext2_sb.s_inodes_per_group)
s176include/linux/ext2_fs.h# define EXT2_BLOCKS_PER_GROUP(s)  ((s)->s_blocks_per_group)
s177include/linux/ext2_fs.h# define EXT2_DESC_PER_BLOCK(s)    (EXT2_BLOCK_SIZE(s) / sizeof (struct ext2_group_desc))
s178include/linux/ext2_fs.h# define EXT2_INODES_PER_GROUP(s)  ((s)->s_inodes_per_group)
s42include/linux/msdos_fs.h#define MSDOS_SB(s) (&((s)->u.msdos_sb))
s121include/linux/msdos_fs.hextern void fs_panic(struct super_block *s,char *msg);
s167include/linux/msdos_fs.hextern struct super_block *msdos_read_super(struct super_block *s,
s609include/linux/tpqic02.h# define TPQDEB(s)  s
s610include/linux/tpqic02.h# define TPQPUTS(s)  tpqputs(s)
s612include/linux/tpqic02.h# define TPQDEB(s)
s613include/linux/tpqic02.h# define TPQPUTS(s)
s45kernel/vsprintf.cstatic int skip_atoi(const char **s)
s49kernel/vsprintf.cwhile (is_digit(**s))
s50kernel/vsprintf.ci = i*10 + *((*s)++) - '0';
s140kernel/vsprintf.cchar *s;
s217kernel/vsprintf.cs = va_arg(args, char *);
s218kernel/vsprintf.cif (!s)
s219kernel/vsprintf.cs = "<NULL>";
s220kernel/vsprintf.clen = strlen(s);
s230kernel/vsprintf.c*str++ = *s++;
s1297net/inet/af_inet.cstruct sock *s;
s1313net/inet/af_inet.cfor(s = prot->sock_array[hnum & (SOCK_ARRAY_SIZE - 1)];
s1314net/inet/af_inet.cs != NULL; s = s->next) 
s1318net/inet/af_inet.cif (s->num != hnum) 
s1321net/inet/af_inet.cif(s->dead && (s->state == TCP_CLOSE))
s1324net/inet/af_inet.cif (s->saddr) {
s1325net/inet/af_inet.cif (s->saddr != laddr)
s1330net/inet/af_inet.cif (s->daddr) {
s1331net/inet/af_inet.cif (s->daddr != raddr)
s1336net/inet/af_inet.cif (s->dummy_th.dest) {
s1337net/inet/af_inet.cif (s->dummy_th.dest != rnum)
s1343net/inet/af_inet.creturn s;
s1347net/inet/af_inet.cresult = s;
s1362net/inet/af_inet.cstruct sock *s;
s1364net/inet/af_inet.cs=sk;
s1366net/inet/af_inet.cfor(; s != NULL; s = s->next) 
s1368net/inet/af_inet.cif (s->num != num) 
s1370net/inet/af_inet.cif(s->dead && (s->state == TCP_CLOSE))
s1372net/inet/af_inet.cif(s->daddr && s->daddr!=raddr)
s1374net/inet/af_inet.cif(s->saddr  && s->saddr!=laddr)
s1376net/inet/af_inet.creturn(s);
s1391net/inet/af_inet.cstruct sock *s;
s1405net/inet/af_inet.cs=sk;
s1407net/inet/af_inet.cfor(; s != NULL; s = s->next) 
s1409net/inet/af_inet.cif (s->num != hnum) 
s1411net/inet/af_inet.cif(s->dead && (s->state == TCP_CLOSE))
s1413net/inet/af_inet.cif(s->daddr && s->daddr!=raddr)
s1415net/inet/af_inet.cif (s->dummy_th.dest != rnum && s->dummy_th.dest != 0) 
s1417net/inet/af_inet.cif(s->saddr  && s->saddr!=laddr)
s1419net/inet/af_inet.creturn(s);
s80net/inet/ipx.cipx_socket *s;
s83net/inet/ipx.cs=ipx_socket_list;
s84net/inet/ipx.cif(s==sk)
s86net/inet/ipx.cipx_socket_list=s->next;
s90net/inet/ipx.cwhile(s && s->next)
s92net/inet/ipx.cif(s->next==sk)
s94net/inet/ipx.cs->next=sk->next;
s98net/inet/ipx.cs=s->next;
s113net/inet/ipx.cipx_socket *s;
s114net/inet/ipx.cs=ipx_socket_list;
s115net/inet/ipx.cwhile(s)
s117net/inet/ipx.cif(s->ipx_source_addr.sock==port)
s119net/inet/ipx.creturn(s);
s121net/inet/ipx.cs=s->next;
s150net/inet/ipx.cipx_socket *s;
s158net/inet/ipx.cfor (s = ipx_socket_list; s != NULL; s = s->next)
s160net/inet/ipx.clen += sprintf (buffer+len,"%02X   ", s->ipx_type);
s161net/inet/ipx.clen += sprintf (buffer+len,"%08lX:%02X%02X%02X%02X%02X%02X:%04X ", htonl(s->ipx_source_addr.net),
s162net/inet/ipx.cs->ipx_source_addr.node[0], s->ipx_source_addr.node[1], s->ipx_source_addr.node[2],
s163net/inet/ipx.cs->ipx_source_addr.node[3], s->ipx_source_addr.node[4], s->ipx_source_addr.node[5],
s164net/inet/ipx.chtons(s->ipx_source_addr.sock));
s165net/inet/ipx.clen += sprintf (buffer+len,"%08lX:%02X%02X%02X%02X%02X%02X:%04X ", htonl(s->ipx_dest_addr.net),
s166net/inet/ipx.cs->ipx_dest_addr.node[0], s->ipx_dest_addr.node[1], s->ipx_dest_addr.node[2],
s167net/inet/ipx.cs->ipx_dest_addr.node[3], s->ipx_dest_addr.node[4], s->ipx_dest_addr.node[5],
s168net/inet/ipx.chtons(s->ipx_dest_addr.sock));
s169net/inet/ipx.clen += sprintf (buffer+len,"%08lX:%08lX ", s->wmem_alloc, s->rmem_alloc);
s170net/inet/ipx.clen += sprintf (buffer+len,"%02X %d\n", s->state, SOCK_INODE(s->socket)->i_uid);
s254net/inet/tcp.cstatic struct sk_buff *tcp_find_established(struct sock *s)
s256net/inet/tcp.cstruct sk_buff *p=skb_peek(&s->receive_queue);
s265net/inet/tcp.cwhile(p!=skb_peek(&s->receive_queue));
s305net/inet/tcp.cstatic struct sk_buff *tcp_dequeue_established(struct sock *s)
s311net/inet/tcp.cskb=tcp_find_established(s);
s52tools/build.cshort s[2];
s73tools/build.creturn t.s[0];
s22zBoot/gzip.h#  define memzero(s, n)     memset ((s), 0, (n))
s27zBoot/gzip.h#  define memcpy(d, s, n)   bcopy((s), (d), (n)) 
s29zBoot/gzip.h#  define memzero(s, n)     bzero((s), (n))
s268zBoot/gzip.hextern ulg  updcrc        OF((uch *s, unsigned n));
s273zBoot/gzip.hextern char *strlwr       OF((char *s));
s99zBoot/inflate.cint huft_build(b, n, s, d, e, t, m)
s102zBoot/inflate.cunsigned s;             /* number of simple-valued codes (0..s-1) */
s266zBoot/inflate.celse if (*p < s)
s273zBoot/inflate.cr.e = (uch)e[*p - s];   /* non-simple--look up in lists */
s274zBoot/inflate.cr.v.n = d[*p++ - s];
s128zBoot/misc.cstatic void puts(const char *s)
s136zBoot/misc.cwhile ( ( c = *s++ ) != '\0' ) {
s159zBoot/misc.c__ptr_t memset(__ptr_t s, int c, size_t n)
s162zBoot/misc.cchar *ss = (char*)s;
s171zBoot/misc.cchar *d = (char *)__dest, *s = (char *)__src;
s173zBoot/misc.cfor (i=0;i<__n;i++) d[i] = s[i];
s183zBoot/misc.culg updcrc(s, n)
s184zBoot/misc.cuch *s;                 /* pointer to bytes to pump through */
s191zBoot/misc.cif (s == NULL) {
s196zBoot/misc.cc = crc_32_tab[((int)c ^ (*s++)) & 0xff] ^ (c >> 8);