taglinefilesource code
s24arch/alpha/lib/memcpy.c#define ALIGN_DEST_TO8(d,s,n) \
s28arch/alpha/lib/memcpy.c*(char *) d = *(char *) s; \
s29arch/alpha/lib/memcpy.cd++; s++; \
s36arch/alpha/lib/memcpy.c#define DO_REST(d,s,n) \
s39arch/alpha/lib/memcpy.c*(char *) d = *(char *) s; \
s40arch/alpha/lib/memcpy.cd++; s++; \
s47arch/alpha/lib/memcpy.c#define DO_REST_ALIGNED(d,s,n) DO_REST(d,s,n)
s56arch/alpha/lib/memcpy.cstatic inline void __memcpy_unaligned(unsigned long d, unsigned long s, long n)
s58arch/alpha/lib/memcpy.cALIGN_DEST_TO8(d,s,n);
s62arch/alpha/lib/memcpy.c__asm__("ldq_u %0,%1":"=r" (low_word):"m" (*(unsigned long *) s));
s65arch/alpha/lib/memcpy.c__asm__("ldq_u %0,%1":"=r" (high_word):"m" (*(unsigned long *)(s+8)));
s69arch/alpha/lib/memcpy.c:"r" (low_word), "r" (s));
s72arch/alpha/lib/memcpy.c:"r" (high_word), "r" (s));
s73arch/alpha/lib/memcpy.cs += 8;
s80arch/alpha/lib/memcpy.cDO_REST(d,s,n);
s91arch/alpha/lib/memcpy.cstatic inline void __memcpy_aligned(unsigned long d, unsigned long s, long n)
s93arch/alpha/lib/memcpy.cALIGN_DEST_TO8(d,s,n);
s97arch/alpha/lib/memcpy.c__asm__("ldq %0,%1":"=r" (tmp):"m" (*(unsigned long *) s));
s99arch/alpha/lib/memcpy.cs += 8;
s104arch/alpha/lib/memcpy.cDO_REST_ALIGNED(d,s,n);
s13arch/alpha/lib/memset.cinline void * __constant_c_memset(void * s, unsigned long c, long count)
s15arch/alpha/lib/memset.cunsigned long xs = (unsigned long) s;
s33arch/alpha/lib/memset.creturn s;
s36arch/alpha/lib/memset.cvoid * __memset(void * s,char c,size_t count)
s38arch/alpha/lib/memset.c__constant_c_memset(s,0x0101010101010101UL * (unsigned char) c, count);
s39arch/alpha/lib/memset.creturn s;
s22arch/i386/boot/compressed/gzip.h#  define memzero(s, n)     memset ((s), 0, (n))
s27arch/i386/boot/compressed/gzip.h#  define memcpy(d, s, n)   bcopy((s), (d), (n)) 
s29arch/i386/boot/compressed/gzip.h#  define memzero(s, n)     bzero((s), (n))
s268arch/i386/boot/compressed/gzip.hextern ulg  updcrc        OF((uch *s, unsigned n));
s273arch/i386/boot/compressed/gzip.hextern char *strlwr       OF((char *s));
s99arch/i386/boot/compressed/inflate.cint huft_build(b, n, s, d, e, t, m)
s102arch/i386/boot/compressed/inflate.cunsigned s;             /* number of simple-valued codes (0..s-1) */
s266arch/i386/boot/compressed/inflate.celse if (*p < s)
s273arch/i386/boot/compressed/inflate.cr.e = (uch)e[*p - s];   /* non-simple--look up in lists */
s274arch/i386/boot/compressed/inflate.cr.v.n = d[*p++ - s];
s129arch/i386/boot/compressed/misc.cstatic void puts(const char *s)
s137arch/i386/boot/compressed/misc.cwhile ( ( c = *s++ ) != '\0' ) {
s160arch/i386/boot/compressed/misc.c__ptr_t memset(__ptr_t s, int c, size_t n)
s163arch/i386/boot/compressed/misc.cchar *ss = (char*)s;
s172arch/i386/boot/compressed/misc.cchar *d = (char *)__dest, *s = (char *)__src;
s174arch/i386/boot/compressed/misc.cfor (i=0;i<__n;i++) d[i] = s[i];
s184arch/i386/boot/compressed/misc.culg updcrc(s, n)
s185arch/i386/boot/compressed/misc.cuch *s;                 /* pointer to bytes to pump through */
s192arch/i386/boot/compressed/misc.cif (s == NULL) {
s197arch/i386/boot/compressed/misc.cc = crc_32_tab[((int)c ^ (*s++)) & 0xff] ^ (c >> 8);
s55arch/i386/boot/tools/build.cshort s[2];
s76arch/i386/boot/tools/build.creturn t.s[0];
s120arch/i386/math-emu/fpu_proto.hextern void reg_load_bcd(char *s, FPU_REG *loaded_data);
s23arch/i386/math-emu/fpu_system.h#define LDT_DESCRIPTOR(s)       (current->ldt[(s) >> 3])
s28arch/i386/math-emu/fpu_system.h#define SEG_BASE_ADDR(s)        (((s).b & 0xff000000) \
s29arch/i386/math-emu/fpu_system.h| (((s).b & 0xff) << 16) | ((s).a >> 16))
s30arch/i386/math-emu/fpu_system.h#define SEG_LIMIT(s)            (((s).b & 0xff0000) | ((s).a & 0xffff))
s31arch/i386/math-emu/fpu_system.h#define SEG_EXECUTE_ONLY(s)     (((s).b & ((1 << 11) | (1 << 9))) == (1 << 11))
s32arch/i386/math-emu/fpu_system.h#define SEG_WRITE_PERM(s)       (((s).b & ((1 << 11) | (1 << 9))) == (1 << 9))
s33arch/i386/math-emu/fpu_system.h#define SEG_EXPAND_DOWN(s)      (((s).b & ((1 << 11) | (1 << 10))) \
s45arch/i386/math-emu/reg_ld_str.cint reg_load_extended(long double *s, FPU_REG *loaded_data)
s50arch/i386/math-emu/reg_ld_str.cFPU_verify_area(VERIFY_READ, s, 10);
s51arch/i386/math-emu/reg_ld_str.csigl = get_fs_long((unsigned long *) s);
s52arch/i386/math-emu/reg_ld_str.csigh = get_fs_long(1 + (unsigned long *) s);
s53arch/i386/math-emu/reg_ld_str.cexp = get_fs_word(4 + (unsigned short *) s);
s288arch/i386/math-emu/reg_ld_str.clong long s;
s292arch/i386/math-emu/reg_ld_str.c((unsigned long *)&s)[0] = get_fs_long((unsigned long *) _s);
s293arch/i386/math-emu/reg_ld_str.c((unsigned long *)&s)[1] = get_fs_long(1 + (unsigned long *) _s);
s296arch/i386/math-emu/reg_ld_str.cif (s == 0)
s299arch/i386/math-emu/reg_ld_str.cif (s > 0)
s303arch/i386/math-emu/reg_ld_str.cs = -s;
s308arch/i386/math-emu/reg_ld_str.csignificand(loaded_data) = s;
s318arch/i386/math-emu/reg_ld_str.clong s;
s323arch/i386/math-emu/reg_ld_str.cs = (long)get_fs_long((unsigned long *) _s);
s326arch/i386/math-emu/reg_ld_str.cif (s == 0)
s329arch/i386/math-emu/reg_ld_str.cif (s > 0)
s333arch/i386/math-emu/reg_ld_str.cs = -s;
s338arch/i386/math-emu/reg_ld_str.cloaded_data->sigh = s;
s349arch/i386/math-emu/reg_ld_str.cint s, e;
s354arch/i386/math-emu/reg_ld_str.cs = (short)get_fs_word((unsigned short *) _s);
s357arch/i386/math-emu/reg_ld_str.cif (s == 0)
s360arch/i386/math-emu/reg_ld_str.cif (s > 0)
s364arch/i386/math-emu/reg_ld_str.cs = -s;
s369arch/i386/math-emu/reg_ld_str.cloaded_data->sigh = s << 16;
s379arch/i386/math-emu/reg_ld_str.cvoid reg_load_bcd(char *s, FPU_REG *loaded_data)
s386arch/i386/math-emu/reg_ld_str.cFPU_verify_area(VERIFY_READ, s, 10);
s392arch/i386/math-emu/reg_ld_str.cbcd = (unsigned char)get_fs_byte((unsigned char *) s+pos);
s401arch/i386/math-emu/reg_ld_str.c((unsigned char)get_fs_byte((unsigned char *) s+9)) & 0x80 ?
s1149arch/i386/math-emu/reg_ld_str.cchar *fldenv(fpu_addr_modes addr_modes, char *s)
s1160arch/i386/math-emu/reg_ld_str.cFPU_verify_area(VERIFY_READ, s, 0x0e);
s1161arch/i386/math-emu/reg_ld_str.ccontrol_word = get_fs_word((unsigned short *) s);
s1162arch/i386/math-emu/reg_ld_str.cpartial_status = get_fs_word((unsigned short *) (s+2));
s1163arch/i386/math-emu/reg_ld_str.ctag_word = get_fs_word((unsigned short *) (s+4));
s1164arch/i386/math-emu/reg_ld_str.cinstruction_address.offset = get_fs_word((unsigned short *) (s+6));
s1165arch/i386/math-emu/reg_ld_str.cinstruction_address.selector = get_fs_word((unsigned short *) (s+8));
s1166arch/i386/math-emu/reg_ld_str.coperand_address.offset = get_fs_word((unsigned short *) (s+0x0a));
s1167arch/i386/math-emu/reg_ld_str.coperand_address.selector = get_fs_word((unsigned short *) (s+0x0c));
s1169arch/i386/math-emu/reg_ld_str.cs += 0x0e;
s1180arch/i386/math-emu/reg_ld_str.cFPU_verify_area(VERIFY_READ, s, 0x1c);
s1181arch/i386/math-emu/reg_ld_str.ccontrol_word = get_fs_word((unsigned short *) s);
s1182arch/i386/math-emu/reg_ld_str.cpartial_status = get_fs_word((unsigned short *) (s+4));
s1183arch/i386/math-emu/reg_ld_str.ctag_word = get_fs_word((unsigned short *) (s+8));
s1184arch/i386/math-emu/reg_ld_str.cinstruction_address.offset = get_fs_long((unsigned long *) (s+0x0c));
s1185arch/i386/math-emu/reg_ld_str.cinstruction_address.selector = get_fs_word((unsigned short *) (s+0x10));
s1186arch/i386/math-emu/reg_ld_str.cinstruction_address.opcode = get_fs_word((unsigned short *) (s+0x12));
s1187arch/i386/math-emu/reg_ld_str.coperand_address.offset = get_fs_long((unsigned long *) (s+0x14));
s1188arch/i386/math-emu/reg_ld_str.coperand_address.selector = get_fs_long((unsigned long *) (s+0x18));
s1190arch/i386/math-emu/reg_ld_str.cs += 0x1c;
s1237arch/i386/math-emu/reg_ld_str.creturn s;
s1245arch/i386/math-emu/reg_ld_str.cchar *s = fldenv(addr_modes, data_address);
s1252arch/i386/math-emu/reg_ld_str.creg_load_extended((long double *)(s+i*10), &regs[stnr]);
s1601drivers/block/aztcd.c{       int s;
s1608drivers/block/aztcd.cs = inb(DATA_PORT) & 0xFF;
s1609drivers/block/aztcd.c*result = (unsigned char) s;
s412drivers/block/cm206.cinline int f_s_m2lba(uch f, uch s, uch m)
s414drivers/block/cm206.creturn f + 75*(s-2 + 60*m);
s1249drivers/block/cm206.cvoid cm206_setup(char *s, int *p)
s1252drivers/block/cm206.cif (!strcmp(s, "auto")) auto_probe=1;
s285drivers/block/floppy.c# define CROSS_64KB(a,s)  (0)
s287drivers/block/floppy.c# define CROSS_64KB(a,s) \
s288drivers/block/floppy.c((unsigned long)(a)/K_64 != ((unsigned long)(a) + (s) - 1) / K_64)
s59drivers/block/hd.c#define OK_STATUS(s)  (((s)&(STAT_OK|(BUSY_STAT|WRERR_STAT|ERR_STAT)))==STAT_OK)
s258drivers/block/hd.cstatic void fixstring (unsigned char *s, int bytecount)
s260drivers/block/hd.cunsigned char *p, *end = &s[bytecount &= ~1];  /* bytecount must be even */
s263drivers/block/hd.cfor (p = end ; p != s;) {
s269drivers/block/hd.cwhile (s != end && *s == ' ')
s270drivers/block/hd.c++s;
s273drivers/block/hd.cwhile (s != end && *s) {
s274drivers/block/hd.cif (*s++ != ' ' || (s != end && *s && *s != ' '))
s275drivers/block/hd.c*p++ = *(s-1);
s377drivers/block/ide-cd.cchar *s;
s386drivers/block/ide-cd.cs = sense_key_texts[reqbuf->sense_key];
s388drivers/block/ide-cd.cs = "(bad sense key)";
s390drivers/block/ide-cd.cprintk ("  Sense key: %x - %s\n", reqbuf->sense_key, s);
s394drivers/block/ide-cd.cs = buf;
s405drivers/block/ide-cd.cs = NULL;
s410drivers/block/ide-cd.cs = sense_data_texts[mid].text;
s420drivers/block/ide-cd.cif (s == NULL) {
s422drivers/block/ide-cd.cs = "(vendor-specific error)";
s424drivers/block/ide-cd.cs = "(reserved error code)";
s428drivers/block/ide-cd.creqbuf->asc, reqbuf->ascq, s);
s1417drivers/block/ide-cd.cvoid lba_to_msf (int lba, byte *m, byte *s, byte *f)
s1423drivers/block/ide-cd.c*s = lba / CD_FRAMES;
s1429drivers/block/ide-cd.cint msf_to_lba (byte m, byte s, byte f)
s1431drivers/block/ide-cd.creturn (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_BLOCK_OFFSET;
s964drivers/block/ide.cspecial_t *s = &dev->special;
s966drivers/block/ide.cprintk("%s: do_special: 0x%02x\n", dev->name, s->all);
s968drivers/block/ide.cif (s->b.set_geometry) {
s969drivers/block/ide.cs->b.set_geometry = 0;
s977drivers/block/ide.c} else if (s->b.recalibrate) {
s978drivers/block/ide.cs->b.recalibrate = 0;
s981drivers/block/ide.c} else if (s->b.set_multmode) {
s990drivers/block/ide.cs->b.set_multmode = 0;
s992drivers/block/ide.cif (s->all) {
s993drivers/block/ide.cprintk("%s: bad special flag: 0x%02x\n", dev->name, s->all);
s994drivers/block/ide.cs->all = 0;
s1663drivers/block/ide.cstatic void fixstring (byte *s, int bytecount, int byteswap)
s1665drivers/block/ide.cbyte *p, *end = &s[bytecount &= ~1];  /* bytecount must be even */
s1669drivers/block/ide.cfor (p = end ; p != s;) {
s1674drivers/block/ide.cp = s;
s1677drivers/block/ide.cwhile (s != end && *s == ' ')
s1678drivers/block/ide.c++s;
s1681drivers/block/ide.cwhile (s != end && *s) {
s1682drivers/block/ide.cif (*s++ != ' ' || (s != end && *s && *s != ' '))
s1683drivers/block/ide.c*p++ = *(s-1);
s1449drivers/block/mcd.cint s;
s1461drivers/block/mcd.cs = inb(MCDPORT(0)) & 0xFF;
s1462drivers/block/mcd.c*result = (unsigned char) s;
s913drivers/block/mcdx.cchar s[255];
s917drivers/block/mcdx.cif (sizeof(s) < vsprintf(s, fmt, args))
s919drivers/block/mcdx.celse printk(MCD ":: %s", s);
s927drivers/block/mcdx.cchar s[255];
s930drivers/block/mcdx.cif (sizeof(s) < vsprintf(s, fmt, args))
s932drivers/block/mcdx.celse printk(MCD ": %s", s);
s4986drivers/block/sbpcd.cvoid sbpcd_setup(char *s, int *p)
s4989drivers/block/sbpcd.cmsg(DBG_INI,"sbpcd_setup called with %04X,%s\n",p[1], s);
s4991drivers/block/sbpcd.cif (!strcmp(s,str_sb)) sbpro_type=1;
s4992drivers/block/sbpcd.celse if (!strcmp(s,str_sb_l)) sbpro_type=1;
s4993drivers/block/sbpcd.celse if (!strcmp(s,str_sp)) sbpro_type=2;
s4994drivers/block/sbpcd.celse if (!strcmp(s,str_sp_l)) sbpro_type=2;
s588drivers/block/sjcd.cint s;
s593drivers/block/sjcd.cs = sjcd_receive_status();
s594drivers/block/sjcd.cif( s < 0 || sjcd_command_failed || !sjcd_status_valid ){
s596drivers/block/sjcd.cs = sjcd_receive_status();
s597drivers/block/sjcd.cif( s < 0 || sjcd_command_failed || !sjcd_status_valid ) return( -1 );
s599drivers/block/sjcd.cs = sjcd_receive_status();
s600drivers/block/sjcd.cif( s < 0 || sjcd_command_failed || !sjcd_status_valid ) return( -1 );
s704drivers/block/sjcd.cstruct cdrom_ti ti; int s;
s708drivers/block/sjcd.cif( ( s = verify_area( VERIFY_READ, (void *) arg, sizeof( ti ) ) ) == 0 ){
s726drivers/block/sjcd.creturn( s );
s730drivers/block/sjcd.cstruct cdrom_msf sjcd_msf; int s;
s734drivers/block/sjcd.cif( ( s = verify_area( VERIFY_READ, (void *) arg, sizeof( sjcd_msf ) ) ) == 0 ){
s755drivers/block/sjcd.creturn( s );
s759drivers/block/sjcd.cstruct cdrom_tochdr toc_header; int s;
s763drivers/block/sjcd.cif( ( s = verify_area( VERIFY_WRITE, (void *) arg, sizeof( toc_header ) ) ) == 0 ){
s768drivers/block/sjcd.creturn( s );
s772drivers/block/sjcd.cstruct cdrom_tocentry toc_entry; int s;
s776drivers/block/sjcd.cif( ( s = verify_area( VERIFY_WRITE, (void *) arg, sizeof( toc_entry ) ) ) == 0 ){
s803drivers/block/sjcd.creturn( s );
s807drivers/block/sjcd.cstruct cdrom_subchnl subchnl; int s;
s811drivers/block/sjcd.cif( ( s = verify_area( VERIFY_WRITE, (void *) arg, sizeof( subchnl ) ) ) == 0 ){
s840drivers/block/sjcd.creturn( s );
s844drivers/block/sjcd.cstruct cdrom_volctrl vol_ctrl; int s;
s848drivers/block/sjcd.cif( ( s = verify_area( VERIFY_READ, (void *) arg, sizeof( vol_ctrl ) ) ) == 0 ){
s857drivers/block/sjcd.creturn( s );
s872drivers/block/sjcd.cint s;
s876drivers/block/sjcd.cif( ( s = verify_area( VERIFY_WRITE, (void *) arg, sizeof( statistic ) ) ) == 0 )
s878drivers/block/sjcd.creturn( s );
s317drivers/char/console.cstatic void memsetw(void * s, unsigned short c, unsigned int count)
s319drivers/char/console.cunsigned short * addr = (unsigned short *) s;
s586drivers/char/console.cunsigned short * s = (unsigned short *) last_origin;
s594drivers/char/console.cscr_writew(scr_readw(d++),s++);
s684drivers/char/console.cunsigned short * s = (unsigned short *) origin;
s690drivers/char/console.cscr_writew(scr_readw(s++),d++);
s719drivers/char/console.cunsigned short * s = (unsigned short *) (origin+video_size_row*(t+1));
s724drivers/char/console.cscr_writew(scr_readw(s++), d++);
s736drivers/char/console.cunsigned short *d, *s;
s742drivers/char/console.cs = (unsigned short *) (origin+video_size_row*(b-1));
s746drivers/char/console.cscr_writew(scr_readw(--s), --d);
s48drivers/char/selection.chighlight(const int s, const int e) {
s49drivers/char/selection.cinvert_screen(sel_cons, s, e-s+2, 1);
s427drivers/char/tpqic02.cstatic void tpqputs(unsigned long flags, char *s)
s430drivers/char/tpqic02.cprintk(TPQIC02_NAME ": %s\n", s);
s486drivers/char/tpqic02.cstatic int decode_exception_nr(unsigned s)
s491drivers/char/tpqic02.cif ((s & exception_list[i].mask)==exception_list[i].code)
s494drivers/char/tpqic02.cprintk(TPQIC02_NAME ": decode_exception_nr: exception(%x) not recognized\n", s);
s507drivers/char/tpqic02.cstatic void report_error(int s)
s511drivers/char/tpqic02.cif (s & TP_ST1) {
s512drivers/char/tpqic02.cif (s & TP_ILL)    /* 12: Illegal command. FATAL */
s514drivers/char/tpqic02.cif (s & TP_POR)    /* 13: Reset occurred. FATAL */
s517drivers/char/tpqic02.celse if (s & TP_ST0) {
s518drivers/char/tpqic02.cif (s & TP_EOR) {  /* extra: 15: End of Recorded Media. CONTINUABLE */
s522drivers/char/tpqic02.celse if (s & TP_EOM)    /* 4: End Of Media. CONTINUABLE */
s524drivers/char/tpqic02.celse if (s & TP_USL)    /* 2: Drive not online. FATAL */
s526drivers/char/tpqic02.celse if (s & TP_CNI) {  /* 1: Cartridge not in place. FATAL */
s532drivers/char/tpqic02.celse if (s & TP_UDA) {
s533drivers/char/tpqic02.cif (s & TP_BNL) {
s534drivers/char/tpqic02.cif (s & TP_NDT) {
s535drivers/char/tpqic02.cif (s & TP_BOM)    /* 9: Read error. No data detected & EOM. CONTINUABLE */
s537drivers/char/tpqic02.celse if (s & TP_EOM)  /* 10: Read error. No data detected & BOM. CONTINUABLE */
s547drivers/char/tpqic02.cif (s & TP_EOM)  /* 5: Read or Write error. Rewind tape. FATAL */
s559drivers/char/tpqic02.celse if (s & TP_FIL) {
s560drivers/char/tpqic02.cif (s & TP_MBD) {  /* 14: Marginal block detected. CONTINUABLE */
s566drivers/char/tpqic02.celse if (s & TP_WRP)    /* 3: Write protected cartridge. FATAL */
s847drivers/char/tpqic02.cint  s, n;
s881drivers/char/tpqic02.cdo s = inb_p(QIC02_STAT_PORT);
s882drivers/char/tpqic02.cwhile ((s & QIC02_STAT_MASK) == QIC02_STAT_MASK);  /* wait for ready or exception */
s884drivers/char/tpqic02.cif ((s & QIC02_STAT_EXCEPTION) == 0) {    /* if exception */
s2250drivers/char/tpqic02.cint s;
s2307drivers/char/tpqic02.cs = tp_sense(TP_WRP|TP_EOM|TP_BOM|TP_CNI|TP_EOR);
s2309drivers/char/tpqic02.cif (s == TE_OK)
s2312drivers/char/tpqic02.cs = tp_sense(TP_WRP|TP_EOM|TP_BOM|TP_CNI|TP_EOR);
s2314drivers/char/tpqic02.cif (s != TE_OK) {
s2350drivers/char/tpqic02.cs = do_qic_cmd(QCMD_REWIND, TIM_R);
s2351drivers/char/tpqic02.cif (s != 0) {
s2397drivers/char/tpqic02.cs = 0;
s2400drivers/char/tpqic02.cs = do_qic_cmd(QCMD_DENS_11, TIM_S);
s2403drivers/char/tpqic02.cs = do_qic_cmd(QCMD_DENS_24, TIM_S);
s2406drivers/char/tpqic02.cs = do_qic_cmd(QCMD_DENS_120, TIM_S);
s2409drivers/char/tpqic02.cs = do_qic_cmd(QCMD_DENS_150, TIM_S);
s2412drivers/char/tpqic02.cs = do_qic_cmd(QCMD_DENS_300, TIM_S);
s2415drivers/char/tpqic02.cs = do_qic_cmd(QCMD_DENS_600, TIM_S);
s2418drivers/char/tpqic02.cs = do_qic_cmd(QCMD_RETEN, TIM_R);
s2420drivers/char/tpqic02.cif (s != 0) {
s398drivers/char/vt.cu_char s;
s405drivers/char/vt.cif ((s = get_user(&a->kb_table)) >= MAX_NR_KEYMAPS)
s407drivers/char/vt.ckey_map = key_maps[s];
s422drivers/char/vt.cu_char s;
s432drivers/char/vt.cif ((s = get_user(&a->kb_table)) >= MAX_NR_KEYMAPS)
s437drivers/char/vt.ckey_map = key_maps[s];
s438drivers/char/vt.cif (s && key_map) {
s439drivers/char/vt.ckey_maps[s] = 0;
s459drivers/char/vt.cif (!(key_map = key_maps[s])) {
s469drivers/char/vt.ckey_maps[s] = key_map;
s485drivers/char/vt.cif (!s && (KTYP(ov) == KT_SHIFT || KTYP(v) == KT_SHIFT))
s448drivers/net/eql.cslave_t *s = eql_new_slave ();
s451drivers/net/eql.cs->dev = slave_dev;
s452drivers/net/eql.cs->priority = srq.priority;
s453drivers/net/eql.cs->priority_bps = srq.priority;
s454drivers/net/eql.cs->priority_Bps = srq.priority / 8;
s458drivers/net/eql.ceql_insert_slave (eql->queue, s);
s453drivers/net/ni52.cunsigned long s;
s484drivers/net/ni52.cs = jiffies; /* warning: only active with interrupts on !! */
s486drivers/net/ni52.cif(jiffies-s > 30) break;
s510drivers/net/ni52.cs = jiffies;
s512drivers/net/ni52.cif(jiffies-s > 30) break;
s534drivers/net/ni52.cs = jiffies; 
s536drivers/net/ni52.cif(jiffies - s > 30) {
s626drivers/net/ni52.cs = jiffies;
s628drivers/net/ni52.cif(jiffies - s > 30)
s342drivers/net/ni65.ctmdp->u.s.status = XMIT_START | XMIT_END;
s350drivers/net/ni65.crmdp->u.s.status = RCV_OWN;
s458drivers/net/ni65.ctmdstat = tmdp->u.s.status;
s504drivers/net/ni65.cwhile(!( (rmdstat = rmdp->u.s.status) & RCV_OWN))
s514drivers/net/ni65.crmdp->u.s.status = RCV_OWN; /* change owner */
s523drivers/net/ni65.crmdp->u.s.status = RCV_OWN;
s541drivers/net/ni65.crmdp->u.s.status = RCV_OWN;
s550drivers/net/ni65.crmdp->u.s.status = RCV_OWN;
s614drivers/net/ni65.ctmdp->u.s.status = XMIT_OWN | XMIT_START | XMIT_END;
s621drivers/net/ni65.cif( !((p->tmdhead + p->tmdnum)->u.s.status & XMIT_OWN) ) 
s109drivers/net/ni65.h} s;
s124drivers/net/ni65.h} s;
s1051drivers/net/sk_g16.ctmdp->u.s.status = TX_STP | TX_ENP;
s1071drivers/net/sk_g16.crmdp->u.s.status = RX_OWN;  
s1269drivers/net/sk_g16.ctmdp->u.s.status = TX_OWN | TX_STP | TX_ENP;
s1281drivers/net/sk_g16.cif (! ((p->tmdhead + p->tmdnum)->u.s.status & TX_OWN) )
s1403drivers/net/sk_g16.ctmdstat = tmdp->u.s.status & 0xff00; /* filter out status bits 15:08 */
s1522drivers/net/sk_g16.cwhile (!( (rmdstat = rmdp->u.s.status) & RX_OWN))
s1552drivers/net/sk_g16.crmdp->u.s.status = RX_OWN;      /* Relinquish ownership to LANCE */ 
s1564drivers/net/sk_g16.crmdp->u.s.status = RX_OWN;      /* Relinquish ownership to LANCE */
s1583drivers/net/sk_g16.crmdp->u.s.status = RX_OWN;  /* Relinquish ownership to LANCE */
s1622drivers/net/sk_g16.crmdp->u.s.status = RX_OWN;
s141drivers/net/sk_g16.h} s;
s159drivers/net/sk_g16.h} s;
s777drivers/net/slip.cslip_esc(unsigned char *s, unsigned char *d, int len)
s796drivers/net/slip.cswitch(c = *s++) {
s815drivers/net/slip.cslip_unesc(struct slip *sl, unsigned char s)
s818drivers/net/slip.cswitch(s) {
s832drivers/net/slip.cs = ESC;
s837drivers/net/slip.cs = END;
s843drivers/net/slip.csl->rbuff[sl->rcount++] = s;
s858drivers/net/slip.cslip_esc6(unsigned char *s, unsigned char *d, int len)
s879drivers/net/slip.cv = (v << 8) | s[i];
s896drivers/net/slip.cslip_unesc6(struct slip *sl, unsigned char s)
s900drivers/net/slip.cif (s == 0x70) {
s907drivers/net/slip.c} else if (s >= 0x30 && s < 0x70) {
s908drivers/net/slip.csl->xdata = (sl->xdata << 6) | ((s - 0x30) & 0x3F);
s755drivers/net/wavelan.c#define  SC(t,s,n)  if (sizeof(t) != s) return n
s2133drivers/scsi/53c7,8xx.cTOKEN(ms,3), TOKEN(rp,2), TOKEN(rs,2), TOKEN(s,0), TOKEN(tb,0), TOKEN(te,0)
s2290drivers/scsi/aha152x.cint s;
s2299drivers/scsi/aha152x.cs=GETPORT(SCSISEQ);
s2301drivers/scsi/aha152x.cif( s & TEMODEO )     printk("TARGET MODE ");
s2302drivers/scsi/aha152x.cif( s & ENSELO )      printk("SELO ");
s2303drivers/scsi/aha152x.cif( s & ENSELI )      printk("SELI ");
s2304drivers/scsi/aha152x.cif( s & ENRESELI )    printk("RESELI ");
s2305drivers/scsi/aha152x.cif( s & ENAUTOATNO )  printk("AUTOATNO ");
s2306drivers/scsi/aha152x.cif( s & ENAUTOATNI )  printk("AUTOATNI ");
s2307drivers/scsi/aha152x.cif( s & ENAUTOATNP )  printk("AUTOATNP ");
s2308drivers/scsi/aha152x.cif( s & SCSIRSTO )    printk("SCSIRSTO ");
s2312drivers/scsi/aha152x.cs=GETPORT(SCSISIG);
s2313drivers/scsi/aha152x.cswitch(s & P_MASK)
s2343drivers/scsi/aha152x.cs=GETPORT(SSTAT0);
s2344drivers/scsi/aha152x.cif( s & TARGET )   printk("TARGET ");
s2345drivers/scsi/aha152x.cif( s & SELDO )    printk("SELDO ");
s2346drivers/scsi/aha152x.cif( s & SELDI )    printk("SELDI ");
s2347drivers/scsi/aha152x.cif( s & SELINGO )  printk("SELINGO ");
s2348drivers/scsi/aha152x.cif( s & SWRAP )    printk("SWRAP ");
s2349drivers/scsi/aha152x.cif( s & SDONE )    printk("SDONE ");
s2350drivers/scsi/aha152x.cif( s & SPIORDY )  printk("SPIORDY ");
s2351drivers/scsi/aha152x.cif( s & DMADONE )  printk("DMADONE ");
s2353drivers/scsi/aha152x.cs=GETPORT(SSTAT1);
s2354drivers/scsi/aha152x.cif( s & SELTO )     printk("SELTO ");
s2355drivers/scsi/aha152x.cif( s & ATNTARG )   printk("ATNTARG ");
s2356drivers/scsi/aha152x.cif( s & SCSIRSTI )  printk("SCSIRSTI ");
s2357drivers/scsi/aha152x.cif( s & PHASEMIS )  printk("PHASEMIS ");
s2358drivers/scsi/aha152x.cif( s & BUSFREE )   printk("BUSFREE ");
s2359drivers/scsi/aha152x.cif( s & SCSIPERR )  printk("SCSIPERR ");
s2360drivers/scsi/aha152x.cif( s & PHASECHG )  printk("PHASECHG ");
s2361drivers/scsi/aha152x.cif( s & REQINIT )   printk("REQINIT ");
s2367drivers/scsi/aha152x.cs=GETPORT(SSTAT0) & GETPORT(SIMODE0);
s2369drivers/scsi/aha152x.cif( s & TARGET )    printk("TARGET ");
s2370drivers/scsi/aha152x.cif( s & SELDO )     printk("SELDO ");
s2371drivers/scsi/aha152x.cif( s & SELDI )     printk("SELDI ");
s2372drivers/scsi/aha152x.cif( s & SELINGO )   printk("SELINGO ");
s2373drivers/scsi/aha152x.cif( s & SWRAP )     printk("SWRAP ");
s2374drivers/scsi/aha152x.cif( s & SDONE )     printk("SDONE ");
s2375drivers/scsi/aha152x.cif( s & SPIORDY )   printk("SPIORDY ");
s2376drivers/scsi/aha152x.cif( s & DMADONE )   printk("DMADONE ");
s2378drivers/scsi/aha152x.cs=GETPORT(SSTAT1) & GETPORT(SIMODE1);
s2380drivers/scsi/aha152x.cif( s & SELTO )     printk("SELTO ");
s2381drivers/scsi/aha152x.cif( s & ATNTARG )   printk("ATNTARG ");
s2382drivers/scsi/aha152x.cif( s & SCSIRSTI )  printk("SCSIRSTI ");
s2383drivers/scsi/aha152x.cif( s & PHASEMIS )  printk("PHASEMIS ");
s2384drivers/scsi/aha152x.cif( s & BUSFREE )   printk("BUSFREE ");
s2385drivers/scsi/aha152x.cif( s & SCSIPERR )  printk("SCSIPERR ");
s2386drivers/scsi/aha152x.cif( s & PHASECHG )  printk("PHASECHG ");
s2387drivers/scsi/aha152x.cif( s & REQINIT )   printk("REQINIT ");
s2392drivers/scsi/aha152x.cs=GETPORT(SXFRCTL0);
s2393drivers/scsi/aha152x.cif( s & SCSIEN )    printk("SCSIEN ");
s2394drivers/scsi/aha152x.cif( s & DMAEN )     printk("DMAEN ");
s2395drivers/scsi/aha152x.cif( s & CH1 )       printk("CH1 ");
s2396drivers/scsi/aha152x.cif( s & CLRSTCNT )  printk("CLRSTCNT ");
s2397drivers/scsi/aha152x.cif( s & SPIOEN )    printk("SPIOEN ");
s2398drivers/scsi/aha152x.cif( s & CLRCH1 )    printk("CLRCH1 ");
s2403drivers/scsi/aha152x.cs=GETPORT(SCSISIG);
s2404drivers/scsi/aha152x.cif( s & ATNI )  printk("ATNI ");
s2405drivers/scsi/aha152x.cif( s & SELI )  printk("SELI ");
s2406drivers/scsi/aha152x.cif( s & BSYI )  printk("BSYI ");
s2407drivers/scsi/aha152x.cif( s & REQI )  printk("REQI ");
s2408drivers/scsi/aha152x.cif( s & ACKI )  printk("ACKI ");
s2415drivers/scsi/aha152x.cs=GETPORT(SSTAT2);
s2416drivers/scsi/aha152x.cif( s & SOFFSET)  printk("SOFFSET ");
s2417drivers/scsi/aha152x.cif( s & SEMPTY)   printk("SEMPTY ");
s2418drivers/scsi/aha152x.cif( s & SFULL)    printk("SFULL ");
s2419drivers/scsi/aha152x.cprintk("); SFCNT ( %d ); ", s & (SFULL|SFCNT) );
s2423drivers/scsi/aha152x.cs=GETPORT(SSTAT4);
s2424drivers/scsi/aha152x.cif( s & SYNCERR)   printk("SYNCERR ");
s2425drivers/scsi/aha152x.cif( s & FWERR)     printk("FWERR ");
s2426drivers/scsi/aha152x.cif( s & FRERR)     printk("FRERR ");
s2433drivers/scsi/aha152x.cs=GETPORT(DMACNTRL0);
s2434drivers/scsi/aha152x.cprintk( "%s ", s & _8BIT      ? "8BIT"  : "16BIT" );
s2435drivers/scsi/aha152x.cprintk( "%s ", s & DMA        ? "DMA"   : "PIO"   );
s2436drivers/scsi/aha152x.cprintk( "%s ", s & WRITE_READ ? "WRITE" : "READ"  );
s2437drivers/scsi/aha152x.cif( s & ENDMA )    printk("ENDMA ");
s2438drivers/scsi/aha152x.cif( s & INTEN )    printk("INTEN ");
s2439drivers/scsi/aha152x.cif( s & RSTFIFO )  printk("RSTFIFO ");
s2440drivers/scsi/aha152x.cif( s & SWINT )    printk("SWINT ");
s2447drivers/scsi/aha152x.cs=GETPORT(DMACNTRL1);
s2448drivers/scsi/aha152x.cif( s & PWRDWN )    printk("PWRDN ");
s2452drivers/scsi/aha152x.cprintk("STK ( %d ); ", s & 0xf);
s2455drivers/scsi/aha152x.cs=GETPORT(DMASTAT);
s2456drivers/scsi/aha152x.cif( s & ATDONE )     printk("ATDONE ");
s2457drivers/scsi/aha152x.cif( s & WORDRDY )    printk("WORDRDY ");
s2458drivers/scsi/aha152x.cif( s & DFIFOFULL )  printk("DFIFOFULL ");
s2459drivers/scsi/aha152x.cif( s & DFIFOEMP )   printk("DFIFOEMP ");
s2473drivers/scsi/aha152x.cint s;
s2477drivers/scsi/aha152x.cs=GETPORT(SIMODE0);
s2478drivers/scsi/aha152x.cif( s & ENSELDO )    printk("ENSELDO ");
s2479drivers/scsi/aha152x.cif( s & ENSELDI )    printk("ENSELDI ");
s2480drivers/scsi/aha152x.cif( s & ENSELINGO )  printk("ENSELINGO ");
s2481drivers/scsi/aha152x.cif( s & ENSWRAP )    printk("ENSWRAP ");
s2482drivers/scsi/aha152x.cif( s & ENSDONE )    printk("ENSDONE ");
s2483drivers/scsi/aha152x.cif( s & ENSPIORDY )  printk("ENSPIORDY ");
s2484drivers/scsi/aha152x.cif( s & ENDMADONE )  printk("ENDMADONE ");
s2486drivers/scsi/aha152x.cs=GETPORT(SIMODE1);
s2487drivers/scsi/aha152x.cif( s & ENSELTIMO )    printk("ENSELTIMO ");
s2488drivers/scsi/aha152x.cif( s & ENATNTARG )    printk("ENATNTARG ");
s2489drivers/scsi/aha152x.cif( s & ENPHASEMIS )   printk("ENPHASEMIS ");
s2490drivers/scsi/aha152x.cif( s & ENBUSFREE )    printk("ENBUSFREE ");
s2491drivers/scsi/aha152x.cif( s & ENSCSIPERR )   printk("ENSCSIPERR ");
s2492drivers/scsi/aha152x.cif( s & ENPHASECHG )   printk("ENPHASECHG ");
s2493drivers/scsi/aha152x.cif( s & ENREQINIT )    printk("ENREQINIT ");
s1028drivers/scsi/aic7xxx.caic7xxx_setup(char *s, int *dummy)
s1042drivers/scsi/aic7xxx.cfor (p = strtok(s, ","); p; p = strtok(NULL, ","))
s59drivers/scsi/aic7xxx_asm.cerror(char *s)
s61drivers/scsi/aic7xxx_asm.cfprintf(stderr, "%s: %s at line %d\n", filename, s, lineno);
s84drivers/scsi/aic7xxx_asm.cStrdup(char *s)
s86drivers/scsi/aic7xxx_asm.cchar *p = (char *)Malloc(strlen(s) + 1);
s87drivers/scsi/aic7xxx_asm.cstrcpy(p, s);
s240drivers/scsi/buslogic.cint s = inb(STATUS(base)), i = inb(INTERRUPT(base));
s242drivers/scsi/buslogic.cbuslogic_printk("status=%02X intrflags=%02X\n", s, i);
s117drivers/scsi/constants.cint i,s;
s119drivers/scsi/constants.cfor ( i = 1, s = COMMAND_SIZE(command[0]); i < s; ++i) 
s381drivers/scsi/constants.cint i, s;
s392drivers/scsi/constants.cs = sense_buffer[7] + 8;
s393drivers/scsi/constants.cif(s > sizeof(SCpnt->sense_buffer)) s = sizeof(SCpnt->sense_buffer);
s452drivers/scsi/constants.cs = 4;
s458drivers/scsi/constants.cfor (i = 0; i < s; ++i) 
s516drivers/scsi/pas16.cregister unsigned char *s = src;
s522drivers/scsi/pas16.coutsb( reg, s, i );
s361drivers/scsi/t128.cT_DATA_REG_OFFSET), *s = src;
s371drivers/scsi/t128.c*reg = *s++;
s1009drivers/scsi/ultrastor.cunsigned int s = config.heads * config.sectors;
s1013drivers/scsi/ultrastor.cdkinfo[2] = size / s;  /* Ignore partial cylinders */
s62drivers/sound/os.h#define COPY_FROM_USER(d, s, o, c)  memcpy_fromfs((d), &((s)[o]), (c))
s63drivers/sound/os.h#define COPY_TO_USER(d, o, s, c)  memcpy_tofs(&((d)[o]), (s), (c))
s64drivers/sound/os.h#define IOCTL_FROM_USER(d, s, o, c)  memcpy_fromfs((d), &((s)[o]), (c))
s65drivers/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;
s239fs/hpfs/hpfs_fs.cstatic unsigned count_bitmap(struct super_block *s);
s328fs/hpfs/hpfs_fs.cstruct super_block *hpfs_read_super(struct super_block *s,
s352fs/hpfs/hpfs_fs.cs->s_dev = 0;
s360fs/hpfs/hpfs_fs.clock_super(s);
s361fs/hpfs/hpfs_fs.cdev = s->s_dev;
s438fs/hpfs/hpfs_fs.cs->s_flags |= MS_RDONLY;
s444fs/hpfs/hpfs_fs.cs->s_magic = HPFS_SUPER_MAGIC;
s445fs/hpfs/hpfs_fs.cs->s_blocksize = 512;
s446fs/hpfs/hpfs_fs.cs->s_blocksize_bits = 9;
s447fs/hpfs/hpfs_fs.cs->s_op = (struct super_operations *) &hpfs_sops;
s453fs/hpfs/hpfs_fs.cs->s_hpfs_root = dir_ino(superblock->root);
s454fs/hpfs/hpfs_fs.cs->s_hpfs_fs_size = superblock->n_sectors;
s455fs/hpfs/hpfs_fs.cs->s_hpfs_dirband_size = superblock->n_dir_band / 4;
s456fs/hpfs/hpfs_fs.cs->s_hpfs_dmap = superblock->dir_band_bitmap;
s457fs/hpfs/hpfs_fs.cs->s_hpfs_bitmaps = superblock->bitmaps;
s458fs/hpfs/hpfs_fs.cs->s_hpfs_uid = uid;
s459fs/hpfs/hpfs_fs.cs->s_hpfs_gid = gid;
s460fs/hpfs/hpfs_fs.cs->s_hpfs_mode = 0777 & ~umask;
s461fs/hpfs/hpfs_fs.cs->s_hpfs_n_free = -1;
s462fs/hpfs/hpfs_fs.cs->s_hpfs_n_free_dnodes = -1;
s463fs/hpfs/hpfs_fs.cs->s_hpfs_lowercase = lowercase;
s464fs/hpfs/hpfs_fs.cs->s_hpfs_conv = conv;
s478fs/hpfs/hpfs_fs.cs->s_mounted = iget(s, s->s_hpfs_root);
s479fs/hpfs/hpfs_fs.cunlock_super(s);
s481fs/hpfs/hpfs_fs.cif (!s->s_mounted) {
s483fs/hpfs/hpfs_fs.cs->s_dev = 0;
s491fs/hpfs/hpfs_fs.croot_dno = fnode_dno(dev, s->s_hpfs_root);
s493fs/hpfs/hpfs_fs.cde = map_dirent(s->s_mounted, root_dno, "\001\001", 2, &qbh);
s497fs/hpfs/hpfs_fs.cs->s_dev = 0;
s501fs/hpfs/hpfs_fs.cs->s_mounted->i_atime = local_to_gmt(de->read_date);
s502fs/hpfs/hpfs_fs.cs->s_mounted->i_mtime = local_to_gmt(de->write_date);
s503fs/hpfs/hpfs_fs.cs->s_mounted->i_ctime = local_to_gmt(de->creation_date);
s506fs/hpfs/hpfs_fs.creturn s;
s515fs/hpfs/hpfs_fs.cs->s_dev = 0;
s516fs/hpfs/hpfs_fs.cunlock_super(s);
s619fs/hpfs/hpfs_fs.cstruct super_block *s = inode->i_sb;
s636fs/hpfs/hpfs_fs.cinode->i_uid = s->s_hpfs_uid;
s637fs/hpfs/hpfs_fs.cinode->i_gid = s->s_hpfs_gid;
s638fs/hpfs/hpfs_fs.cinode->i_mode = s->s_hpfs_mode;
s639fs/hpfs/hpfs_fs.cinode->i_hpfs_conv = s->s_hpfs_conv;
s713fs/hpfs/hpfs_fs.cstatic void hpfs_put_super(struct super_block *s)
s715fs/hpfs/hpfs_fs.clock_super(s);
s716fs/hpfs/hpfs_fs.cs->s_dev = 0;
s717fs/hpfs/hpfs_fs.cunlock_super(s);
s725fs/hpfs/hpfs_fs.cstatic void hpfs_statfs(struct super_block *s, struct statfs *buf, int bufsiz)
s732fs/hpfs/hpfs_fs.cif (s->s_hpfs_n_free == -1) {
s733fs/hpfs/hpfs_fs.cs->s_hpfs_n_free = count_bitmap(s);
s734fs/hpfs/hpfs_fs.cs->s_hpfs_n_free_dnodes =
s735fs/hpfs/hpfs_fs.ccount_one_bitmap(s->s_dev, s->s_hpfs_dmap);
s741fs/hpfs/hpfs_fs.ctmp.f_type = s->s_magic;
s743fs/hpfs/hpfs_fs.ctmp.f_blocks = s->s_hpfs_fs_size;
s744fs/hpfs/hpfs_fs.ctmp.f_bfree = s->s_hpfs_n_free;
s745fs/hpfs/hpfs_fs.ctmp.f_bavail = s->s_hpfs_n_free;
s746fs/hpfs/hpfs_fs.ctmp.f_files = s->s_hpfs_dirband_size;
s747fs/hpfs/hpfs_fs.ctmp.f_ffree = s->s_hpfs_n_free_dnodes;
s756fs/hpfs/hpfs_fs.cstatic int hpfs_remount_fs(struct super_block *s, int *flags, char *data)
s800fs/hpfs/hpfs_fs.cstatic unsigned count_bitmap(struct super_block *s)
s809fs/hpfs/hpfs_fs.cn_bands = (s->s_hpfs_fs_size + 0x3fff) >> 14;
s815fs/hpfs/hpfs_fs.cbitmaps = map_4sectors(s->s_dev, s->s_hpfs_bitmaps, &qbh);
s828fs/hpfs/hpfs_fs.ccount += count_one_bitmap(s->s_dev, bitmaps[n]);
s192fs/isofs/inode.cstruct super_block *isofs_read_super(struct super_block *s,void *data,
s199fs/isofs/inode.cint dev=s->s_dev;
s215fs/isofs/inode.cs->s_dev = 0;
s241fs/isofs/inode.clock_super(s);
s243fs/isofs/inode.cs->u.isofs_sb.s_high_sierra = high_sierra = 0; /* default is iso9660 */
s252fs/isofs/inode.cs->s_dev=0;
s255fs/isofs/inode.cunlock_super(s);
s270fs/isofs/inode.cs->u.isofs_sb.s_high_sierra = 1;
s292fs/isofs/inode.cs->s_dev = 0;
s293fs/isofs/inode.cunlock_super(s);
s305fs/isofs/inode.cs->u.isofs_sb.s_nzones = isonum_733 (h_pri->volume_space_size);
s306fs/isofs/inode.cs->u.isofs_sb.s_log_zone_size = isonum_723 (h_pri->logical_block_size);
s307fs/isofs/inode.cs->u.isofs_sb.s_max_size = isonum_733(h_pri->volume_space_size);
s314fs/isofs/inode.cs->u.isofs_sb.s_nzones = isonum_733 (pri->volume_space_size);
s315fs/isofs/inode.cs->u.isofs_sb.s_log_zone_size = isonum_723 (pri->logical_block_size);
s316fs/isofs/inode.cs->u.isofs_sb.s_max_size = isonum_733(pri->volume_space_size);
s319fs/isofs/inode.cs->u.isofs_sb.s_ninodes = 0; /* No way to figure this out easily */
s323fs/isofs/inode.cswitch (s -> u.isofs_sb.s_log_zone_size)
s324fs/isofs/inode.c{ case  512: s -> u.isofs_sb.s_log_zone_size =  9; break;
s325fs/isofs/inode.ccase 1024: s -> u.isofs_sb.s_log_zone_size = 10; break;
s326fs/isofs/inode.ccase 2048: s -> u.isofs_sb.s_log_zone_size = 11; break;
s329fs/isofs/inode.cprintk("Bad logical zone size %ld\n", s -> u.isofs_sb.s_log_zone_size);
s335fs/isofs/inode.cs->u.isofs_sb.s_firstdatazone = (isonum_733( rootp->extent) 
s336fs/isofs/inode.c<< s -> u.isofs_sb.s_log_zone_size);
s337fs/isofs/inode.cs->s_magic = ISOFS_SUPER_MAGIC;
s344fs/isofs/inode.cs->s_flags |= MS_RDONLY /* | MS_NODEV | MS_NOSUID */;
s349fs/isofs/inode.cs->u.isofs_sb.s_max_size, 
s350fs/isofs/inode.c1UL << s->u.isofs_sb.s_log_zone_size);
s352fs/isofs/inode.cs->u.isofs_sb.s_firstdatazone >> s -> u.isofs_sb.s_log_zone_size,
s353fs/isofs/inode.cisonum_733 (rootp->extent) << s -> u.isofs_sb.s_log_zone_size);
s355fs/isofs/inode.cunlock_super(s);
s358fs/isofs/inode.cs->s_dev = dev;
s359fs/isofs/inode.cs->s_op = &isofs_sops;
s360fs/isofs/inode.cs->u.isofs_sb.s_mapping = opt.map;
s361fs/isofs/inode.cs->u.isofs_sb.s_rock = (opt.rock == 'y' ? 1 : 0);
s362fs/isofs/inode.cs->u.isofs_sb.s_conversion = opt.conversion;
s363fs/isofs/inode.cs->u.isofs_sb.s_cruft = opt.cruft;
s364fs/isofs/inode.cs->u.isofs_sb.s_unhide = opt.unhide;
s365fs/isofs/inode.cs->u.isofs_sb.s_uid = opt.uid;
s366fs/isofs/inode.cs->u.isofs_sb.s_gid = opt.gid;
s371fs/isofs/inode.cs->u.isofs_sb.s_mode = opt.mode & 0777;
s372fs/isofs/inode.cs->s_blocksize = opt.blocksize;
s373fs/isofs/inode.cs->s_blocksize_bits = blocksize_bits;
s374fs/isofs/inode.cs->s_mounted = iget(s, isonum_733 (rootp->extent) << s -> u.isofs_sb.s_log_zone_size);
s375fs/isofs/inode.cunlock_super(s);
s377fs/isofs/inode.cif (!(s->s_mounted)) {
s378fs/isofs/inode.cs->s_dev=0;
s384fs/isofs/inode.cif(!check_disk_change(s->s_dev)) {
s385fs/isofs/inode.creturn s;
s389fs/isofs/inode.cs->s_dev = 0;
s390fs/isofs/inode.cunlock_super(s);
s124fs/minix/inode.cstruct super_block *minix_read_super(struct super_block *s,void *data, 
s129fs/minix/inode.cint i,dev=s->s_dev,block;
s134fs/minix/inode.clock_super(s);
s137fs/minix/inode.cs->s_dev=0;
s138fs/minix/inode.cunlock_super(s);
s144fs/minix/inode.cs->u.minix_sb.s_ms = ms;
s145fs/minix/inode.cs->u.minix_sb.s_sbh = bh;
s146fs/minix/inode.cs->u.minix_sb.s_mount_state = ms->s_state;
s147fs/minix/inode.cs->s_blocksize = 1024;
s148fs/minix/inode.cs->s_blocksize_bits = 10;
s149fs/minix/inode.cs->u.minix_sb.s_ninodes = ms->s_ninodes;
s150fs/minix/inode.cs->u.minix_sb.s_nzones = ms->s_nzones;
s151fs/minix/inode.cs->u.minix_sb.s_imap_blocks = ms->s_imap_blocks;
s152fs/minix/inode.cs->u.minix_sb.s_zmap_blocks = ms->s_zmap_blocks;
s153fs/minix/inode.cs->u.minix_sb.s_firstdatazone = ms->s_firstdatazone;
s154fs/minix/inode.cs->u.minix_sb.s_log_zone_size = ms->s_log_zone_size;
s155fs/minix/inode.cs->u.minix_sb.s_max_size = ms->s_max_size;
s156fs/minix/inode.cs->s_magic = ms->s_magic;
s157fs/minix/inode.cif (s->s_magic == MINIX_SUPER_MAGIC) {
s158fs/minix/inode.cs->u.minix_sb.s_dirsize = 16;
s159fs/minix/inode.cs->u.minix_sb.s_namelen = 14;
s160fs/minix/inode.c} else if (s->s_magic == MINIX_SUPER_MAGIC2) {
s161fs/minix/inode.cs->u.minix_sb.s_dirsize = 32;
s162fs/minix/inode.cs->u.minix_sb.s_namelen = 30;
s164fs/minix/inode.cs->s_dev = 0;
s165fs/minix/inode.cunlock_super(s);
s173fs/minix/inode.cs->u.minix_sb.s_imap[i] = NULL;
s175fs/minix/inode.cs->u.minix_sb.s_zmap[i] = NULL;
s177fs/minix/inode.cfor (i=0 ; i < s->u.minix_sb.s_imap_blocks ; i++)
s178fs/minix/inode.cif ((s->u.minix_sb.s_imap[i]=bread(dev,block,BLOCK_SIZE)) != NULL)
s182fs/minix/inode.cfor (i=0 ; i < s->u.minix_sb.s_zmap_blocks ; i++)
s183fs/minix/inode.cif ((s->u.minix_sb.s_zmap[i]=bread(dev,block,BLOCK_SIZE)) != NULL)
s187fs/minix/inode.cif (block != 2+s->u.minix_sb.s_imap_blocks+s->u.minix_sb.s_zmap_blocks) {
s189fs/minix/inode.cbrelse(s->u.minix_sb.s_imap[i]);
s191fs/minix/inode.cbrelse(s->u.minix_sb.s_zmap[i]);
s192fs/minix/inode.cs->s_dev=0;
s193fs/minix/inode.cunlock_super(s);
s199fs/minix/inode.cset_bit(0,s->u.minix_sb.s_imap[0]->b_data);
s200fs/minix/inode.cset_bit(0,s->u.minix_sb.s_zmap[0]->b_data);
s201fs/minix/inode.cunlock_super(s);
s203fs/minix/inode.cs->s_dev = dev;
s204fs/minix/inode.cs->s_op = &minix_sops;
s205fs/minix/inode.cs->s_mounted = iget(s,MINIX_ROOT_INO);
s206fs/minix/inode.cif (!s->s_mounted) {
s207fs/minix/inode.cs->s_dev = 0;
s213fs/minix/inode.cif (!(s->s_flags & MS_RDONLY)) {
s216fs/minix/inode.cs->s_dirt = 1;
s218fs/minix/inode.cif (!(s->u.minix_sb.s_mount_state & MINIX_VALID_FS))
s221fs/minix/inode.celse if (s->u.minix_sb.s_mount_state & MINIX_ERROR_FS)
s224fs/minix/inode.creturn s;
s39fs/msdos/misc.cvoid fs_panic(struct super_block *s,char *msg)
s43fs/msdos/misc.cnot_ro = !(s->s_flags & MS_RDONLY);
s44fs/msdos/misc.cif (not_ro) s->s_flags |= MS_RDONLY;
s46fs/msdos/misc.cs->s_dev,s->s_covered->i_dev,s->s_covered->i_ino,msg);
s31fs/msdos/msbuffer.h#define bread(d,b,s)      msdos_bread(sb,b)
s32fs/msdos/msbuffer.h#define getblk(d,b,s)      msdos_getblk(sb,b)
s78fs/proc/inode.cstruct super_block *proc_read_super(struct super_block *s,void *data, 
s81fs/proc/inode.clock_super(s);
s82fs/proc/inode.cs->s_blocksize = 1024;
s83fs/proc/inode.cs->s_blocksize_bits = 10;
s84fs/proc/inode.cs->s_magic = PROC_SUPER_MAGIC;
s85fs/proc/inode.cs->s_op = &proc_sops;
s86fs/proc/inode.cunlock_super(s);
s87fs/proc/inode.cif (!(s->s_mounted = iget(s,PROC_ROOT_INO))) {
s88fs/proc/inode.cs->s_dev = 0;
s92fs/proc/inode.cparse_options(data, &s->s_mounted->i_uid, &s->s_mounted->i_gid);
s93fs/proc/inode.creturn s;
s41fs/smbfs/proc.cstatic int smb_request_ok(struct smb_server *s, int command, int wct, int bcc);
s423fs/smbfs/proc.csmb_request_ok(struct smb_server *s, int command, int wct, int bcc)
s426fs/smbfs/proc.cs->rcls = 0;
s427fs/smbfs/proc.cs->err  = 0;
s429fs/smbfs/proc.cif (smb_request(s) < 0) {
s433fs/smbfs/proc.celse if (smb_valid_packet(s->packet) != 0) {
s437fs/smbfs/proc.celse if (s->rcls != 0) {
s438fs/smbfs/proc.cresult =  -smb_errno(s->rcls, s->err);
s440fs/smbfs/proc.celse if (smb_verify(s->packet, command, wct, bcc) != 0) {
s477fs/smbfs/proc.csmb_request_ok_unlock(struct smb_server *s, int command, int wct, int bcc)
s479fs/smbfs/proc.cint result = smb_request_ok(s, command, wct, bcc);
s481fs/smbfs/proc.csmb_unlock_server(s);
s221fs/super.cstruct super_block * s;
s225fs/super.cs = 0+super_blocks;
s226fs/super.cwhile (s < NR_SUPER+super_blocks)
s227fs/super.cif (s->s_dev == dev) {
s228fs/super.cwait_on_super(s);
s229fs/super.cif (s->s_dev == dev)
s230fs/super.creturn s;
s231fs/super.cs = 0+super_blocks;
s233fs/super.cs++;
s260fs/super.cstruct super_block * s;
s266fs/super.cs = get_super(dev);
s267fs/super.cif (s)
s268fs/super.creturn s;
s274fs/super.cfor (s = 0+super_blocks ;; s++) {
s275fs/super.cif (s >= NR_SUPER+super_blocks)
s277fs/super.cif (!s->s_dev)
s280fs/super.cs->s_dev = dev;
s281fs/super.cs->s_flags = flags;
s282fs/super.cif (!type->read_super(s,data, silent)) {
s283fs/super.cs->s_dev = 0;
s286fs/super.cs->s_dev = dev;
s287fs/super.cs->s_covered = NULL;
s288fs/super.cs->s_rd_only = 0;
s289fs/super.cs->s_dirt = 0;
s290fs/super.cs->s_type = type;
s291fs/super.creturn s;
s390fs/umsdos/inode.cstruct super_block *s,
s409fs/umsdos/inode.csb = msdos_read_super(s,data,silent);
s417fs/umsdos/inode.cif (s == super_blocks){
s68fs/xiafs/inode.cstruct super_block *xiafs_read_super(struct super_block *s, void *data,
s76fs/xiafs/inode.cdev=s->s_dev;
s77fs/xiafs/inode.clock_super(s);
s82fs/xiafs/inode.cs->s_dev=0;
s83fs/xiafs/inode.cunlock_super(s);
s89fs/xiafs/inode.cs->s_magic = sp->s_magic;
s90fs/xiafs/inode.cif (s->s_magic != _XIAFS_SUPER_MAGIC) {
s91fs/xiafs/inode.cs->s_dev = 0;
s92fs/xiafs/inode.cunlock_super(s);
s100fs/xiafs/inode.cs->s_blocksize = sp->s_zone_size;
s101fs/xiafs/inode.cs->s_blocksize_bits = 10 + sp->s_zone_shift;
s102fs/xiafs/inode.cif (s->s_blocksize != BLOCK_SIZE && 
s103fs/xiafs/inode.c(s->s_blocksize == 1024 || s->s_blocksize == 2048 ||  
s104fs/xiafs/inode.cs->s_blocksize == 4096)) {
s106fs/xiafs/inode.cset_blocksize(dev, s->s_blocksize);
s107fs/xiafs/inode.cbh = bread (dev, 0,  s->s_blocksize);
s114fs/xiafs/inode.cs->u.xiafs_sb.s_nzones = sp->s_nzones;
s115fs/xiafs/inode.cs->u.xiafs_sb.s_ninodes = sp->s_ninodes;
s116fs/xiafs/inode.cs->u.xiafs_sb.s_ndatazones = sp->s_ndatazones;
s117fs/xiafs/inode.cs->u.xiafs_sb.s_imap_zones = sp->s_imap_zones;
s118fs/xiafs/inode.cs->u.xiafs_sb.s_zmap_zones = sp->s_zmap_zones;
s119fs/xiafs/inode.cs->u.xiafs_sb.s_firstdatazone = sp->s_firstdatazone;
s120fs/xiafs/inode.cs->u.xiafs_sb.s_zone_shift = sp->s_zone_shift;
s121fs/xiafs/inode.cs->u.xiafs_sb.s_max_size = sp->s_max_size;
s124fs/xiafs/inode.cs->u.xiafs_sb.s_imap_buf[i] = NULL;
s125fs/xiafs/inode.cs->u.xiafs_sb.s_imap_iznr[i] = -1;
s128fs/xiafs/inode.cs->u.xiafs_sb.s_zmap_buf[i] = NULL;
s129fs/xiafs/inode.cs->u.xiafs_sb.s_zmap_zznr[i] = -1;
s132fs/xiafs/inode.cif ( s->u.xiafs_sb.s_imap_zones > _XIAFS_IMAP_SLOTS )
s133fs/xiafs/inode.cs->u.xiafs_sb.s_imap_cached=1;
s135fs/xiafs/inode.cs->u.xiafs_sb.s_imap_cached=0;
s136fs/xiafs/inode.cfor (i=0 ; i < s->u.xiafs_sb.s_imap_zones ; i++) {
s137fs/xiafs/inode.cif (!(s->u.xiafs_sb.s_imap_buf[i]=bread(dev, z++, XIAFS_ZSIZE(s))))
s139fs/xiafs/inode.cs->u.xiafs_sb.s_imap_iznr[i]=i;
s142fs/xiafs/inode.cif ( s->u.xiafs_sb.s_zmap_zones > _XIAFS_ZMAP_SLOTS )
s143fs/xiafs/inode.cs->u.xiafs_sb.s_zmap_cached=1;
s145fs/xiafs/inode.cs->u.xiafs_sb.s_zmap_cached=0;
s146fs/xiafs/inode.cfor (i=0 ; i < s->u.xiafs_sb.s_zmap_zones ; i++) {
s147fs/xiafs/inode.cif (!(s->u.xiafs_sb.s_zmap_buf[i]=bread(dev, z++, XIAFS_ZSIZE(s))))
s149fs/xiafs/inode.cs->u.xiafs_sb.s_zmap_zznr[i]=i;
s153fs/xiafs/inode.cs->s_dev = dev;
s154fs/xiafs/inode.cs->s_op = &xiafs_sops;
s155fs/xiafs/inode.cs->s_mounted = iget(s, _XIAFS_ROOT_INO);
s156fs/xiafs/inode.cif (!s->s_mounted) 
s158fs/xiafs/inode.cunlock_super(s);
s160fs/xiafs/inode.creturn s;
s164fs/xiafs/inode.cbrelse(s->u.xiafs_sb.s_imap_buf[i]);
s166fs/xiafs/inode.cbrelse(s->u.xiafs_sb.s_zmap_buf[i]);
s167fs/xiafs/inode.cs->s_dev=0;
s168fs/xiafs/inode.cunlock_super(s);
s9include/asm-alpha/string.h#define memset(s, c, count) \
s11include/asm-alpha/string.h__constant_c_memset((s),(0x0101010101010101UL*(unsigned char)c),(count)) : \
s12include/asm-alpha/string.h__memset((s),(c),(count)))
s16include/asm-i386/bugs.hstatic void no_halt(char *s, int *ints)
s21include/asm-i386/bugs.hstatic void no_387(char *s, int *ints)
s84include/asm-i386/io.h#define __OUT1(s,x) \
s85include/asm-i386/io.hextern inline void __out##s(unsigned x value, unsigned short port) {
s87include/asm-i386/io.h#define __OUT2(s,s1,s2) \
s88include/asm-i386/io.h__asm__ __volatile__ ("out" #s " %" s1 "0,%" s2 "1"
s90include/asm-i386/io.h#define __OUT(s,s1,x) \
s91include/asm-i386/io.h__OUT1(s,x) __OUT2(s,s1,"w") : : "a" (value), "d" (port)); } \
s92include/asm-i386/io.h__OUT1(s##c,x) __OUT2(s,s1,"") : : "a" (value), "i" (port)); } \
s93include/asm-i386/io.h__OUT1(s##_p,x) __OUT2(s,s1,"w") : : "a" (value), "d" (port)); SLOW_DOWN_IO; } \
s94include/asm-i386/io.h__OUT1(s##c_p,x) __OUT2(s,s1,"") : : "a" (value), "i" (port)); SLOW_DOWN_IO; }
s96include/asm-i386/io.h#define __IN1(s) \
s97include/asm-i386/io.hextern inline unsigned int __in##s(unsigned short port) { unsigned int _v;
s99include/asm-i386/io.h#define __IN2(s,s1,s2) \
s100include/asm-i386/io.h__asm__ __volatile__ ("in" #s " %" s2 "1,%" s1 "0"
s102include/asm-i386/io.h#define __IN(s,s1,i...) \
s103include/asm-i386/io.h__IN1(s) __IN2(s,s1,"w") : "=a" (_v) : "d" (port) ,##i ); return _v; } \
s104include/asm-i386/io.h__IN1(s##c) __IN2(s,s1,"") : "=a" (_v) : "i" (port) ,##i ); return _v; } \
s105include/asm-i386/io.h__IN1(s##_p) __IN2(s,s1,"w") : "=a" (_v) : "d" (port) ,##i ); SLOW_DOWN_IO; return _v; } \
s106include/asm-i386/io.h__IN1(s##c_p) __IN2(s,s1,"") : "=a" (_v) : "i" (port) ,##i ); SLOW_DOWN_IO; return _v; }
s108include/asm-i386/io.h#define __INS(s) \
s109include/asm-i386/io.hextern inline void ins##s(unsigned short port, void * addr, unsigned long count) \
s110include/asm-i386/io.h{ __asm__ __volatile__ ("cld ; rep ; ins" #s \
s113include/asm-i386/io.h#define __OUTS(s) \
s114include/asm-i386/io.hextern inline void outs##s(unsigned short port, const void * addr, unsigned long count) \
s115include/asm-i386/io.h{ __asm__ __volatile__ ("cld ; rep ; outs" #s \
s132include/asm-i386/string.hextern inline char * strchr(const char * s, int c)
s146include/asm-i386/string.h:"=a" (__res):"S" (s),"0" (c):"si");
s151include/asm-i386/string.hextern inline char * strrchr(const char * s, int c)
s163include/asm-i386/string.h:"=d" (__res):"0" (0),"S" (s),"a" (c):"ax","si");
s278include/asm-i386/string.hextern inline size_t strlen(const char * s)
s287include/asm-i386/string.h:"=c" (__res):"D" (s),"a" (0),"0" (0xffffffff):"di");
s294include/asm-i386/string.hextern inline char * strtok(char * s,const char * ct)
s349include/asm-i386/string.h:"0" (___strtok),"1" (s),"g" (ct)
s463include/asm-i386/string.hextern inline void * __memset_generic(void * s, char c,size_t count)
s470include/asm-i386/string.h:"a" (c),"D" (s),"c" (count)
s472include/asm-i386/string.hreturn s;
s476include/asm-i386/string.h#define __constant_count_memset(s,c,count) __memset_generic((s),(c),(count))
s483include/asm-i386/string.hextern inline void * __constant_c_memset(void * s, unsigned long c, size_t count)
s496include/asm-i386/string.h:"a" (c), "q" (count), "c" (count/4), "D" ((long) s)
s498include/asm-i386/string.hreturn (s);  
s506include/asm-i386/string.hextern inline void * __constant_c_and_count_memset(void * s, unsigned long pattern, size_t count)
s510include/asm-i386/string.hreturn s;
s512include/asm-i386/string.h*(unsigned char *)s = pattern;
s513include/asm-i386/string.hreturn s;
s515include/asm-i386/string.h*(unsigned short *)s = pattern;
s516include/asm-i386/string.hreturn s;
s518include/asm-i386/string.h*(unsigned short *)s = pattern;
s519include/asm-i386/string.h*(2+(unsigned char *)s) = pattern;
s520include/asm-i386/string.hreturn s;
s522include/asm-i386/string.h*(unsigned long *)s = pattern;
s523include/asm-i386/string.hreturn s;
s530include/asm-i386/string.h: "a" (pattern),"c" (count/4),"D" ((long) s) \
s534include/asm-i386/string.hcase 0: COMMON(""); return s;
s535include/asm-i386/string.hcase 1: COMMON("\n\tstosb"); return s;
s536include/asm-i386/string.hcase 2: COMMON("\n\tstosw"); return s;
s537include/asm-i386/string.hcase 3: COMMON("\n\tstosw\n\tstosb"); return s;
s542include/asm-i386/string.h#define __constant_c_x_memset(s, c, count) \
s544include/asm-i386/string.h__constant_c_and_count_memset((s),(c),(count)) : \
s545include/asm-i386/string.h__constant_c_memset((s),(c),(count)))
s547include/asm-i386/string.h#define __memset(s, c, count) \
s549include/asm-i386/string.h__constant_count_memset((s),(c),(count)) : \
s550include/asm-i386/string.h__memset_generic((s),(c),(count)))
s553include/asm-i386/string.h#define memset(s, c, count) \
s555include/asm-i386/string.h__constant_c_x_memset((s),(0x01010101UL*(unsigned char)c),(count)) : \
s556include/asm-i386/string.h__memset((s),(c),(count)))
s92include/asm-m68k/string.hextern inline void * memset(void * s,char c,size_t count)
s94include/asm-m68k/string.hvoid *xs = s;
s102include/asm-m68k/string.h: "=a" (s), "=d" (count)
s103include/asm-m68k/string.h: "0" (s), "d" (c), "1" (count)
s53include/asm-mips/io.h#define __OUT1(s) \
s54include/asm-mips/io.hextern inline void __out##s(unsigned int value, unsigned int port) {
s59include/asm-mips/io.h#define __OUT(m,s) \
s60include/asm-mips/io.h__OUT1(s) __OUT2(m) : : "r" (value), "i" (0), "r" (PORT_BASE+port)); } \
s61include/asm-mips/io.h__OUT1(s##c) __OUT2(m) : : "r" (value), "i" (port), "r" (PORT_BASE)); } \
s62include/asm-mips/io.h__OUT1(s##_p) __OUT2(m) : : "r" (value), "i" (0), "r" (PORT_BASE+port)); \
s64include/asm-mips/io.h__OUT1(s##c_p) __OUT2(m) : : "r" (value), "i" (port), "r" (PORT_BASE)); \
s67include/asm-mips/io.h#define __IN1(s) \
s68include/asm-mips/io.hextern inline unsigned int __in##s(unsigned int port) { unsigned int _v;
s73include/asm-mips/io.h#define __IN(m,s) \
s74include/asm-mips/io.h__IN1(s) __IN2(m) STR(FILL_LDS) : "=r" (_v) : "i" (0), "r" (PORT_BASE+port)); return _v; } \
s75include/asm-mips/io.h__IN1(s##c) __IN2(m) STR(FILL_LDS) : "=r" (_v) : "i" (port), "r" (PORT_BASE)); return _v; } \
s76include/asm-mips/io.h__IN1(s##_p) __IN2(m) : "=r" (_v) : "i" (0), "r" (PORT_BASE+port)); SLOW_DOWN_IO; return _v; } \
s77include/asm-mips/io.h__IN1(s##c_p) __IN2(m) : "=r" (_v) : "i" (port), "r" (PORT_BASE)); SLOW_DOWN_IO; return _v; }
s79include/asm-mips/io.h#define __INS1(s) \
s80include/asm-mips/io.hextern inline void __ins##s(unsigned int port, void * addr, unsigned long count) {
s94include/asm-mips/io.h#define __INS(m,s,i) \
s95include/asm-mips/io.h__INS1(s) __INS2(m) \
s99include/asm-mips/io.h__INS1(s##c) __INS2(m) \
s104include/asm-mips/io.h#define __OUTS1(s) \
s105include/asm-mips/io.hextern inline void __outs##s(unsigned int port, const void * addr, unsigned long count) {
s119include/asm-mips/io.h#define __OUTS(m,s,i) \
s120include/asm-mips/io.h__OUTS1(s) __OUTS2(m) \
s124include/asm-mips/io.h__OUTS1(s##c) __OUTS2(m) \
s117include/asm-mips/string.hextern __inline__ void * memset(void * s, int c, size_t count)
s119include/asm-mips/string.hvoid *xs = s;
s129include/asm-mips/string.h: "=r" (s), "=r" (count)
s130include/asm-mips/string.h: "0" (s), "r" (c), "1" (s + count - 1)
s114include/asm-sparc/string.hextern __inline__ size_t strspn(const char *s, const char *accept)
s120include/asm-sparc/string.hfor (p = s; *p != '\0'; ++p) {
s133include/asm-sparc/string.hextern __inline__ char *strtok(char *s, const char *ct)
s137include/asm-sparc/string.hsbegin  = s ? s : ___strtok;
s166include/asm-sparc/string.hchar *tmp = (char *) dest, *s = (char *) src;
s169include/asm-sparc/string.h*tmp++ = *s++;
s176include/asm-sparc/string.hchar *tmp, *s;
s180include/asm-sparc/string.hs = (char *) src;
s182include/asm-sparc/string.h*tmp++ = *s++;
s186include/asm-sparc/string.hs = (char *) src + count;
s188include/asm-sparc/string.h*--tmp = *--s;
s98include/linux/ext2_fs.h# define EXT2_BLOCK_SIZE(s)    ((s)->s_blocksize)
s100include/linux/ext2_fs.h# define EXT2_BLOCK_SIZE(s)    (EXT2_MIN_BLOCK_SIZE << (s)->s_log_block_size)
s102include/linux/ext2_fs.h#define EXT2_ACLE_PER_BLOCK(s)    (EXT2_BLOCK_SIZE(s) / sizeof (struct ext2_acl_entry))
s103include/linux/ext2_fs.h#define  EXT2_ADDR_PER_BLOCK(s)    (EXT2_BLOCK_SIZE(s) / sizeof (__u32))
s105include/linux/ext2_fs.h# define EXT2_BLOCK_SIZE_BITS(s)  ((s)->s_blocksize_bits)
s107include/linux/ext2_fs.h# define EXT2_BLOCK_SIZE_BITS(s)  ((s)->s_log_block_size + 10)
s109include/linux/ext2_fs.h#define  EXT2_INODES_PER_BLOCK(s)  (EXT2_BLOCK_SIZE(s) / sizeof (struct ext2_inode))
s111include/linux/ext2_fs.h#define  EXT2_ADDR_PER_BLOCK_BITS(s)  ((s)->u.ext2_sb.s_addr_per_block_bits)
s112include/linux/ext2_fs.h#define  EXT2_INODES_PER_BLOCK_BITS(s)  ((s)->u.ext2_sb.s_inodes_per_block_bits)
s122include/linux/ext2_fs.h# define EXT2_FRAG_SIZE(s)    ((s)->u.ext2_sb.s_frag_size)
s123include/linux/ext2_fs.h# define EXT2_FRAGS_PER_BLOCK(s)  ((s)->u.ext2_sb.s_frags_per_block)
s125include/linux/ext2_fs.h# define EXT2_FRAG_SIZE(s)    (EXT2_MIN_FRAG_SIZE << (s)->s_log_frag_size)
s126include/linux/ext2_fs.h# define EXT2_FRAGS_PER_BLOCK(s)  (EXT2_BLOCK_SIZE(s) / EXT2_FRAG_SIZE(s))
s179include/linux/ext2_fs.h# define EXT2_BLOCKS_PER_GROUP(s)  ((s)->u.ext2_sb.s_blocks_per_group)
s180include/linux/ext2_fs.h# define EXT2_DESC_PER_BLOCK(s)    ((s)->u.ext2_sb.s_desc_per_block)
s181include/linux/ext2_fs.h# define EXT2_INODES_PER_GROUP(s)  ((s)->u.ext2_sb.s_inodes_per_group)
s182include/linux/ext2_fs.h# define EXT2_DESC_PER_BLOCK_BITS(s)  ((s)->u.ext2_sb.s_desc_per_block_bits)
s184include/linux/ext2_fs.h# define EXT2_BLOCKS_PER_GROUP(s)  ((s)->s_blocks_per_group)
s185include/linux/ext2_fs.h# define EXT2_DESC_PER_BLOCK(s)    (EXT2_BLOCK_SIZE(s) / sizeof (struct ext2_group_desc))
s186include/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))
s115include/linux/msdos_fs.hextern void fs_panic(struct super_block *s,char *msg);
s160include/linux/msdos_fs.hextern struct super_block *msdos_read_super(struct super_block *s,
s81include/linux/smb_fs.h#define smb_kmalloc(s,p) kmalloc(s,p)
s82include/linux/smb_fs.h#define smb_kfree_s(o,s) kfree_s(o,s)
s95include/linux/sonycd535.h#define SONY_BLOCK_NUMBER(m,s,f) (((m)*60L+(s))*75L+(f))
s610include/linux/tpqic02.h# define TPQDEB(s)  s
s611include/linux/tpqic02.h# define TPQPUTS(s)  tpqputs(s)
s613include/linux/tpqic02.h# define TPQDEB(s)
s614include/linux/tpqic02.h# define TPQPUTS(s)
s104lib/string.cchar * strchr(const char * s,char c)
s106lib/string.cfor(; *s != c; ++s)
s107lib/string.cif (*s == '\0')
s109lib/string.creturn (char *) s;
s114lib/string.csize_t strlen(const char * s)
s118lib/string.cfor (sc = s; *sc != '\0'; ++sc)
s120lib/string.creturn sc - s;
s125lib/string.csize_t strnlen(const char * s, size_t count)
s129lib/string.cfor (sc = s; count-- && *sc != '\0'; ++sc)
s131lib/string.creturn sc - s;
s136lib/string.csize_t strspn(const char *s, const char *accept)
s142lib/string.cfor (p = s; *p != '\0'; ++p) {
s172lib/string.cchar * strtok(char * s,const char * ct)
s176lib/string.csbegin  = s ? s : ___strtok;
s194lib/string.cvoid * memset(void * s,char c,size_t count)
s196lib/string.cchar *xs = (char *) s;
s201lib/string.creturn s;
s220lib/string.cchar *tmp = (char *) dest, *s = (char *) src;
s223lib/string.c*tmp++ = *s++;
s232lib/string.cchar *tmp, *s;
s236lib/string.cs = (char *) src;
s238lib/string.c*tmp++ = *s++;
s242lib/string.cs = (char *) src + count;
s244lib/string.c*--tmp = *--s;
s45lib/vsprintf.cstatic int skip_atoi(const char **s)
s49lib/vsprintf.cwhile (is_digit(**s))
s50lib/vsprintf.ci = i*10 + *((*s)++) - '0';
s140lib/vsprintf.cchar *s;
s217lib/vsprintf.cs = va_arg(args, char *);
s218lib/vsprintf.cif (!s)
s219lib/vsprintf.cs = "<NULL>";
s221lib/vsprintf.clen = strnlen(s, precision);
s227lib/vsprintf.c*str++ = *s++;
s83net/appletalk/ddp.catalk_socket *s;
s88net/appletalk/ddp.cs=atalk_socket_list;
s89net/appletalk/ddp.cif(s==sk)
s91net/appletalk/ddp.catalk_socket_list=s->next;
s95net/appletalk/ddp.cwhile(s && s->next)
s97net/appletalk/ddp.cif(s->next==sk)
s99net/appletalk/ddp.cs->next=sk->next;
s103net/appletalk/ddp.cs=s->next;
s120net/appletalk/ddp.catalk_socket *s;
s122net/appletalk/ddp.cfor( s = atalk_socket_list; s != NULL; s = s->next ) {
s123net/appletalk/ddp.cif ( to->sat_port != s->at.src_port ) {
s129net/appletalk/ddp.cs->at.src_net == atif->address.s_net ) {
s133net/appletalk/ddp.cif ( to->sat_addr.s_net == s->at.src_net &&
s134net/appletalk/ddp.cto->sat_addr.s_node == s->at.src_node ) {
s140net/appletalk/ddp.creturn( s );
s149net/appletalk/ddp.catalk_socket *s;
s151net/appletalk/ddp.cfor ( s = atalk_socket_list; s != NULL; s = s->next ) {
s152net/appletalk/ddp.cif ( s->at.src_net != sat->sat_addr.s_net ) {
s155net/appletalk/ddp.cif ( s->at.src_node != sat->sat_addr.s_node ) {
s158net/appletalk/ddp.cif ( s->at.src_port != sat->sat_port ) {
s163net/appletalk/ddp.creturn( s );
s213net/appletalk/ddp.catalk_socket *s;
s225net/appletalk/ddp.cfor (s = atalk_socket_list; s != NULL; s = s->next)
s227net/appletalk/ddp.clen += sprintf (buffer+len,"%02X   ", s->type);
s229net/appletalk/ddp.cs->at.src_net,s->at.src_node,s->at.src_port);
s231net/appletalk/ddp.cs->at.dest_net,s->at.dest_node,s->at.dest_port);
s232net/appletalk/ddp.clen += sprintf (buffer+len,"%08lX:%08lX ", s->wmem_alloc, s->rmem_alloc);
s233net/appletalk/ddp.clen += sprintf (buffer+len,"%02X %d\n", s->state, SOCK_INODE(s->socket)->i_uid);
s117net/ax25/af_ax25.cchar c, *s;
s120net/ax25/af_ax25.cfor (n = 0, s = buf; n < 6; n++)
s124net/ax25/af_ax25.cif (c != ' ') *s++ = c;
s127net/ax25/af_ax25.c*s++ = '-';
s131net/ax25/af_ax25.c*s++ = '1';
s135net/ax25/af_ax25.c*s++ = n + '0';
s136net/ax25/af_ax25.c*s++ = '\0';
s166net/ax25/af_ax25.cax25_cb *s;
s172net/ax25/af_ax25.cif ((s = ax25_list) == ax25) {
s173net/ax25/af_ax25.cax25_list = s->next;
s178net/ax25/af_ax25.cwhile (s != NULL && s->next != NULL) {
s179net/ax25/af_ax25.cif (s->next == ax25) {
s180net/ax25/af_ax25.cs->next = ax25->next;
s185net/ax25/af_ax25.cs = s->next;
s196net/ax25/af_ax25.cax25_cb *s;
s198net/ax25/af_ax25.cfor (s = ax25_list; s != NULL; s = s->next) {
s199net/ax25/af_ax25.cif (s->device == dev) {
s200net/ax25/af_ax25.cs->device = NULL;
s201net/ax25/af_ax25.cif (s->sk != NULL) {
s202net/ax25/af_ax25.cs->sk->state = TCP_CLOSE;
s203net/ax25/af_ax25.cs->sk->err   = ENETUNREACH;
s204net/ax25/af_ax25.cif (!s->sk->dead)
s205net/ax25/af_ax25.cs->sk->state_change(s->sk);
s206net/ax25/af_ax25.cs->sk->dead  = 1;
s250net/ax25/af_ax25.cax25_cb *s;
s255net/ax25/af_ax25.cfor (s = ax25_list; s != NULL; s = s->next) {
s256net/ax25/af_ax25.cif (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 && s->sk->type == type && s->sk->state == TCP_LISTEN) {
s258net/ax25/af_ax25.cif (s->device == NULL || s->device == dev) {
s260net/ax25/af_ax25.creturn s->sk;
s274net/ax25/af_ax25.cax25_cb *s;
s280net/ax25/af_ax25.cfor (s = ax25_list; s != NULL; s = s->next) {
s281net/ax25/af_ax25.cif (s->sk != NULL && ax25cmp(&s->source_addr, my_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->sk->type == type) {
s283net/ax25/af_ax25.creturn s->sk;
s298net/ax25/af_ax25.cax25_cb *s;
s304net/ax25/af_ax25.cfor (s = ax25_list; s != NULL; s = s->next) {
s305net/ax25/af_ax25.cif (s->sk != NULL && s->sk->type != SOCK_SEQPACKET)
s307net/ax25/af_ax25.cif (ax25cmp(&s->source_addr, my_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->device == dev) {
s309net/ax25/af_ax25.creturn s;
s324net/ax25/af_ax25.cax25_cb *s;
s329net/ax25/af_ax25.cfor (s = ax25_list; s != NULL; s = s->next) {
s330net/ax25/af_ax25.cif (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 && s->sk->type == SOCK_RAW) {
s332net/ax25/af_ax25.creturn s->sk;
s116net/ax25/ax25_route.cstruct ax25_route *s, *t, *ax25_rt = ax25_route;
s119net/ax25/ax25_route.cs       = ax25_rt;
s122net/ax25/ax25_route.cif (s->dev == dev) {
s123net/ax25/ax25_route.cif (ax25_route == s) {
s124net/ax25/ax25_route.cax25_route = s->next;
s125net/ax25/ax25_route.ckfree_s((void *)s, (sizeof *s));
s128net/ax25/ax25_route.cif (t->next == s) {
s129net/ax25/ax25_route.ct->next = s->next;
s130net/ax25/ax25_route.ckfree_s((void *)s, sizeof(*s));
s384net/core/sock.cint s=skb->truesize;
s394net/core/sock.csk->wmem_alloc -= s;
s405net/core/sock.cint s=skb->truesize;
s415net/core/sock.csk->rmem_alloc -= s;
s1386net/ipv4/af_inet.cstruct sock *s;
s1402net/ipv4/af_inet.cfor(s = prot->sock_array[hnum & (SOCK_ARRAY_SIZE - 1)];
s1403net/ipv4/af_inet.cs != NULL; s = s->next) 
s1407net/ipv4/af_inet.cif (s->num != hnum) 
s1410net/ipv4/af_inet.cif(s->dead && (s->state == TCP_CLOSE))
s1413net/ipv4/af_inet.cif (s->saddr) {
s1414net/ipv4/af_inet.cif (s->saddr != laddr)
s1419net/ipv4/af_inet.cif (s->daddr) {
s1420net/ipv4/af_inet.cif (s->daddr != raddr)
s1425net/ipv4/af_inet.cif (s->dummy_th.dest) {
s1426net/ipv4/af_inet.cif (s->dummy_th.dest != rnum)
s1432net/ipv4/af_inet.creturn s;
s1436net/ipv4/af_inet.cresult = s;
s1451net/ipv4/af_inet.cstruct sock *s;
s1453net/ipv4/af_inet.cs=sk;
s1455net/ipv4/af_inet.cfor(; s != NULL; s = s->next) 
s1457net/ipv4/af_inet.cif (s->num != num) 
s1459net/ipv4/af_inet.cif(s->dead && (s->state == TCP_CLOSE))
s1461net/ipv4/af_inet.cif(s->daddr && s->daddr!=raddr)
s1463net/ipv4/af_inet.cif(s->saddr  && s->saddr!=laddr)
s1465net/ipv4/af_inet.creturn(s);
s1480net/ipv4/af_inet.cstruct sock *s;
s1494net/ipv4/af_inet.cs=sk;
s1496net/ipv4/af_inet.cfor(; s != NULL; s = s->next) 
s1498net/ipv4/af_inet.cif (s->num != hnum) 
s1500net/ipv4/af_inet.cif(s->dead && (s->state == TCP_CLOSE))
s1502net/ipv4/af_inet.cif(s->daddr && s->daddr!=raddr)
s1504net/ipv4/af_inet.cif (s->dummy_th.dest != rnum && s->dummy_th.dest != 0) 
s1506net/ipv4/af_inet.cif(s->saddr  && s->saddr!=laddr)
s1508net/ipv4/af_inet.creturn(s);
s371net/ipv4/tcp.cstatic struct sk_buff *tcp_find_established(struct sock *s)
s373net/ipv4/tcp.cstruct sk_buff *p=skb_peek(&s->receive_queue);
s382net/ipv4/tcp.cwhile(p!=(struct sk_buff *)&s->receive_queue);
s391net/ipv4/tcp.cstatic struct sk_buff *tcp_dequeue_established(struct sock *s)
s397net/ipv4/tcp.cskb=tcp_find_established(s);
s134net/ipx/af_ipx.cipx_socket  *s;
s148net/ipx/af_ipx.cs=intrfc->if_sklist;
s149net/ipx/af_ipx.cif(s==sk) {
s150net/ipx/af_ipx.cintrfc->if_sklist=s->next;
s155net/ipx/af_ipx.cwhile(s && s->next) {
s156net/ipx/af_ipx.cif(s->next==sk) {
s157net/ipx/af_ipx.cs->next=sk->next;
s161net/ipx/af_ipx.cs=s->next;
s231net/ipx/af_ipx.cipx_socket  *s;
s238net/ipx/af_ipx.cfor (s = intrfc->if_sklist; s->next != NULL; s = s->next)
s240net/ipx/af_ipx.cs->next = sk;
s247net/ipx/af_ipx.cipx_socket  *s;
s249net/ipx/af_ipx.cfor (s=intrfc->if_sklist; 
s250net/ipx/af_ipx.c(s != NULL) && (s->ipx_port != port); 
s251net/ipx/af_ipx.cs=s->next)
s254net/ipx/af_ipx.creturn s;
s263net/ipx/af_ipx.cipx_socket  *s, *t;
s269net/ipx/af_ipx.cfor (s = intrfc->if_sklist; s != NULL; ) {
s270net/ipx/af_ipx.cs->err = ENOLINK;
s271net/ipx/af_ipx.cs->error_report(s);
s272net/ipx/af_ipx.cs->ipx_intrfc = NULL;
s273net/ipx/af_ipx.cs->ipx_port = 0;
s274net/ipx/af_ipx.cs->zapped=1;  /* Indicates it is no longer bound */
s275net/ipx/af_ipx.ct = s;
s276net/ipx/af_ipx.cs = s->next;
s1166net/ipx/af_ipx.cipx_socket *s;
s1178net/ipx/af_ipx.cfor (s = i->if_sklist; s != NULL; s = s->next) {
s1181net/ipx/af_ipx.chtons(s->ipx_port));
s1182net/ipx/af_ipx.cif (s->state!=TCP_ESTABLISHED) {
s1187net/ipx/af_ipx.chtonl(s->ipx_dest_addr.net),
s1188net/ipx/af_ipx.cs->ipx_dest_addr.node[0], s->ipx_dest_addr.node[1], 
s1189net/ipx/af_ipx.cs->ipx_dest_addr.node[2], s->ipx_dest_addr.node[3], 
s1190net/ipx/af_ipx.cs->ipx_dest_addr.node[4], s->ipx_dest_addr.node[5],
s1191net/ipx/af_ipx.chtons(s->ipx_dest_addr.sock));
s1194net/ipx/af_ipx.cs->wmem_alloc, s->rmem_alloc);
s1196net/ipx/af_ipx.cs->state, SOCK_INODE(s->socket)->i_uid);
s73net/netrom/af_netrom.cstruct sock *s;
s79net/netrom/af_netrom.cif ((s = nr_list) == sk) {
s80net/netrom/af_netrom.cnr_list = s->next;
s85net/netrom/af_netrom.cwhile (s != NULL && s->next != NULL) {
s86net/netrom/af_netrom.cif (s->next == sk) {
s87net/netrom/af_netrom.cs->next = sk->next;
s92net/netrom/af_netrom.cs = s->next;
s134net/netrom/af_netrom.cstruct sock *s;
s139net/netrom/af_netrom.cfor (s = nr_list; s != NULL; s = s->next) {
s140net/netrom/af_netrom.cif (ax25cmp(&s->nr->source_addr, addr) == 0 && s->type == type && s->state == TCP_LISTEN) {
s142net/netrom/af_netrom.creturn s;
s155net/netrom/af_netrom.cstruct sock *s;
s161net/netrom/af_netrom.cfor (s = nr_list; s != NULL; s = s->next) {
s162net/netrom/af_netrom.cif (s->nr->my_index == index && s->nr->my_id == id && s->type == type) {
s164net/netrom/af_netrom.creturn s;
s178net/netrom/af_netrom.cstruct sock *s;
s184net/netrom/af_netrom.cfor (s = nr_list; s != NULL; s = s->next) {
s185net/netrom/af_netrom.cif (s->nr->your_index == index && s->nr->your_id == id && s->type == type) {
s187net/netrom/af_netrom.creturn s;
s1256net/netrom/af_netrom.cstruct sock *s;
s1265net/netrom/af_netrom.cfor (s = nr_list; s != NULL; s = s->next) {
s1267net/netrom/af_netrom.cax2asc(&s->nr->user_addr));
s1269net/netrom/af_netrom.cax2asc(&s->nr->dest_addr));
s1271net/netrom/af_netrom.cax2asc(&s->nr->source_addr),
s1272net/netrom/af_netrom.cs->nr->my_index, s->nr->my_id,
s1273net/netrom/af_netrom.cs->nr->your_index, s->nr->your_id,
s1274net/netrom/af_netrom.cs->nr->state,
s1275net/netrom/af_netrom.cs->nr->vs, s->nr->vr, s->nr->va,
s1276net/netrom/af_netrom.cs->nr->t1timer / PR_SLOWHZ,
s1277net/netrom/af_netrom.cs->nr->t1      / PR_SLOWHZ,
s1278net/netrom/af_netrom.cs->nr->t2timer / PR_SLOWHZ,
s1279net/netrom/af_netrom.cs->nr->t2      / PR_SLOWHZ,
s1280net/netrom/af_netrom.cs->nr->n2count, s->nr->n2,
s1281net/netrom/af_netrom.cs->nr->rtt     / PR_SLOWHZ,
s1282net/netrom/af_netrom.cs->window,
s1283net/netrom/af_netrom.cs->wmem_alloc, s->rmem_alloc);
s225net/netrom/nr_route.cstruct nr_node *s;
s231net/netrom/nr_route.cif ((s = nr_node_list) == nr_node) {
s238net/netrom/nr_route.cwhile (s != NULL && s->next != NULL) {
s239net/netrom/nr_route.cif (s->next == nr_node) {
s240net/netrom/nr_route.cs->next = nr_node->next;
s246net/netrom/nr_route.cs = s->next;
s254net/netrom/nr_route.cstruct nr_neigh *s;
s260net/netrom/nr_route.cif ((s = nr_neigh_list) == nr_neigh) {
s269net/netrom/nr_route.cwhile (s != NULL && s->next != NULL) {
s270net/netrom/nr_route.cif (s->next == nr_neigh) {
s271net/netrom/nr_route.cs->next = nr_neigh->next;
s279net/netrom/nr_route.cs = s->next;
s406net/netrom/nr_route.cstruct nr_node  *s, *nr_node;
s412net/netrom/nr_route.cs       = nr_node;
s415net/netrom/nr_route.cfor (i = 0; i < s->count; i++) {
s416net/netrom/nr_route.cswitch (s->routes[i].obs_count) {
s428net/netrom/nr_route.cif (t->number == s->routes[i].neighbour) {
s438net/netrom/nr_route.cs->count--;
s442net/netrom/nr_route.cs->routes[0] = s->routes[1];
s444net/netrom/nr_route.cs->routes[1] = s->routes[2];
s451net/netrom/nr_route.cs->routes[i].obs_count--;
s457net/netrom/nr_route.cif (s->count <= 0)
s458net/netrom/nr_route.cnr_remove_node(s);
s469net/netrom/nr_route.cstruct nr_neigh *s, *nr_neigh = nr_neigh_list;
s474net/netrom/nr_route.cs        = nr_neigh;
s477net/netrom/nr_route.cif (s->dev == dev) {
s485net/netrom/nr_route.cif (t->routes[i].neighbour == s->number) {
s503net/netrom/nr_route.cnr_remove_neigh(s);