taglinefilesource code
s49drivers/FPU-emu/reg_ld_str.clong double *s = (long double *)FPU_data_address;
s55drivers/FPU-emu/reg_ld_str.csigl = get_fs_long((unsigned long *) s);
s56drivers/FPU-emu/reg_ld_str.csigh = get_fs_long(1 + (unsigned long *) s);
s57drivers/FPU-emu/reg_ld_str.cexp = get_fs_word(4 + (unsigned short *) s);
s296drivers/FPU-emu/reg_ld_str.clong long s;
s299drivers/FPU-emu/reg_ld_str.c((unsigned long *)&s)[0] = get_fs_long((unsigned long *) _s);
s300drivers/FPU-emu/reg_ld_str.c((unsigned long *)&s)[1] = get_fs_long(1 + (unsigned long *) _s);
s303drivers/FPU-emu/reg_ld_str.cif (s == 0)
s306drivers/FPU-emu/reg_ld_str.cif (s > 0)
s310drivers/FPU-emu/reg_ld_str.cs = -s;
s315drivers/FPU-emu/reg_ld_str.csignificand(&FPU_loaded_data) = s;
s326drivers/FPU-emu/reg_ld_str.clong s;
s330drivers/FPU-emu/reg_ld_str.cs = (long)get_fs_long((unsigned long *) _s);
s333drivers/FPU-emu/reg_ld_str.cif (s == 0)
s336drivers/FPU-emu/reg_ld_str.cif (s > 0)
s340drivers/FPU-emu/reg_ld_str.cs = -s;
s345drivers/FPU-emu/reg_ld_str.cFPU_loaded_data.sigh = s;
s357drivers/FPU-emu/reg_ld_str.cint s, e;
s361drivers/FPU-emu/reg_ld_str.cs = (short)get_fs_word((unsigned short *) _s);
s364drivers/FPU-emu/reg_ld_str.cif (s == 0)
s367drivers/FPU-emu/reg_ld_str.cif (s > 0)
s371drivers/FPU-emu/reg_ld_str.cs = -s;
s376drivers/FPU-emu/reg_ld_str.cFPU_loaded_data.sigh = s << 16;
s388drivers/FPU-emu/reg_ld_str.cchar *s = (char *)FPU_data_address;
s397drivers/FPU-emu/reg_ld_str.cbcd = (unsigned char)get_fs_byte((unsigned char *) s+pos);
s408drivers/FPU-emu/reg_ld_str.c((unsigned char)get_fs_byte((unsigned char *) s+9)) & 0x80 ?
s1155drivers/FPU-emu/reg_ld_str.cchar *s = (char *)FPU_data_address;
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+4));
s1163drivers/FPU-emu/reg_ld_str.ctag_word = get_fs_word((unsigned short *) (s+8));
s1164drivers/FPU-emu/reg_ld_str.cip_offset = get_fs_long((unsigned long *) (s+0x0c));
s1165drivers/FPU-emu/reg_ld_str.ccs_selector = get_fs_long((unsigned long *) (s+0x10));
s1166drivers/FPU-emu/reg_ld_str.cdata_operand_offset = get_fs_long((unsigned long *) (s+0x14));
s1167drivers/FPU-emu/reg_ld_str.coperand_selector = get_fs_long((unsigned long *) (s+0x18));
s1215drivers/FPU-emu/reg_ld_str.creturn s + 0x1c;
s1223drivers/FPU-emu/reg_ld_str.cchar *s = fldenv();
s1228drivers/FPU-emu/reg_ld_str.cFPU_data_address = (void *)(s+i*10);
s1021drivers/block/mcd.cint s;
s1033drivers/block/mcd.cs = inb(MCDPORT(0)) & 0xFF;
s1034drivers/block/mcd.c*result = (unsigned char) s;
s105drivers/block/ramdisk.cstruct minix_super_block s;
s136drivers/block/ramdisk.c*((struct minix_super_block *) &s) =
s139drivers/block/ramdisk.cnblocks = s.s_nzones << s.s_log_zone_size;
s140drivers/block/ramdisk.cif (s.s_magic != MINIX_SUPER_MAGIC &&
s141drivers/block/ramdisk.cs.s_magic != MINIX_SUPER_MAGIC2) {
s1294drivers/char/console.cvoid * memsetw(void * s,unsigned short c,int count)
s1300drivers/char/console.c:"a" (c),"D" (s),"c" (count)
s1302drivers/char/console.creturn s;
s1562drivers/char/console.cstatic void highlight(const int currcons, const int s, const int e)
s1566drivers/char/console.cp1 = (unsigned char *)origin - hwscroll_offset + s + 1;
s366drivers/char/tpqic02.cstatic void tpqputs(char *s)
s368drivers/char/tpqic02.cprintk(TPQIC_NAME ": %s\n", s);
s419drivers/char/tpqic02.cstatic int decode_exception_nr(short s)  /* s must be short, because of sign-extension */
s424drivers/char/tpqic02.cif ((s & exception_list[i].mask)==exception_list[i].code)
s440drivers/char/tpqic02.cstatic void report_error(int s)
s444drivers/char/tpqic02.cif (s & TP_ST1) {
s445drivers/char/tpqic02.cif (s & TP_ILL)    /* 12: Illegal command. FATAL */
s447drivers/char/tpqic02.cif (s & TP_POR)    /* 13: Reset occurred. FATAL */
s450drivers/char/tpqic02.celse if (s & TP_ST0) {
s451drivers/char/tpqic02.cif (s & TP_EOR) {  /* extra: 15: End of Recorded Media. CONTINUABLE */
s455drivers/char/tpqic02.celse if (s & TP_EOM)    /* 4: End Of Media. CONTINUABLE */
s457drivers/char/tpqic02.celse if (s & TP_USL)    /* 2: Drive not online. FATAL */
s459drivers/char/tpqic02.celse if (s & TP_CNI) {  /* 1: Cartridge not in place. FATAL */
s465drivers/char/tpqic02.celse if (s & TP_UDA) {
s466drivers/char/tpqic02.cif (s & TP_BNL) {
s467drivers/char/tpqic02.cif (s & TP_NDT) {
s468drivers/char/tpqic02.cif (s & TP_BOM)    /* 9: Read error. No data detected & EOM. CONTINUABLE */
s470drivers/char/tpqic02.celse if (s & TP_EOM)  /* 10: Read error. No data detected & BOM. CONTINUABLE */
s480drivers/char/tpqic02.cif (s & TP_EOM)  /* 5: Read or Write error. Rewind tape. FATAL */
s492drivers/char/tpqic02.celse if (s & TP_FIL) {
s493drivers/char/tpqic02.cif (s & TP_MBD) {  /* 14: Marginal block detected. CONTINUABLE */
s499drivers/char/tpqic02.celse if (s & TP_WRP)    /* 3: Write protected cartridge. FATAL */
s767drivers/char/tpqic02.cint  s, n;
s801drivers/char/tpqic02.cdo s = inb_p(QIC_STAT_PORT);
s802drivers/char/tpqic02.cwhile ((s & QIC_STAT_MASK) == QIC_STAT_MASK);  /* wait for ready or exception */
s804drivers/char/tpqic02.cif ((s & QIC_STAT_EXCEPTION) == 0) {    /* if exception */
s2132drivers/char/tpqic02.cint s;
s2177drivers/char/tpqic02.cs = tp_sense(TP_WRP|TP_EOM|TP_BOM|TP_CNI|TP_EOR);
s2178drivers/char/tpqic02.cif (s != TE_OK) {
s2202drivers/char/tpqic02.cs = do_qic_cmd(QCMD_REWIND, TIM_R);
s2203drivers/char/tpqic02.cif (s != 0) {
s2250drivers/char/tpqic02.cs = 0;
s2253drivers/char/tpqic02.cs = do_qic_cmd(QCMD_DENS_11, TIM_S);
s2256drivers/char/tpqic02.cs = do_qic_cmd(QCMD_DENS_24, TIM_S);
s2259drivers/char/tpqic02.cs = do_qic_cmd(QCMD_DENS_120, TIM_S);
s2262drivers/char/tpqic02.cs = do_qic_cmd(QCMD_DENS_150, TIM_S);
s2265drivers/char/tpqic02.cs = do_qic_cmd(QCMD_DENS_300, TIM_S);
s2268drivers/char/tpqic02.cs = do_qic_cmd(QCMD_DENS_600, TIM_S);
s2271drivers/char/tpqic02.cs = do_qic_cmd(QCMD_RETEN, TIM_R);
s2273drivers/char/tpqic02.cif (s != 0) {
s238drivers/char/vt.cu_char s;
s245drivers/char/vt.cif ((s = get_fs_byte((char *) &a->kb_table)) >= NR_KEYMAPS)
s247drivers/char/vt.cput_fs_word(key_map[s][i], (short *) &a->kb_value);
s254drivers/char/vt.cu_char s;
s262drivers/char/vt.cif ((s = get_fs_byte((char *) &a->kb_table)) >= NR_KEYMAPS)
s268drivers/char/vt.ckey_map[s][i] = v;
s882drivers/net/slip.cslip_esc(unsigned char *s, unsigned char *d, int len)
s900drivers/net/slip.cswitch(*s) {
s910drivers/net/slip.cd[count++] = *s;
s912drivers/net/slip.c++s;
s919drivers/net/slip.cslip_unesc(struct slip *sl, unsigned char *s, int count, int error)
s923drivers/net/slip.cfor (i = 0; i < count; ++i, ++s) {
s924drivers/net/slip.cswitch(*s) {
s932drivers/net/slip.csl_enqueue(sl, *s);
s939drivers/net/slip.csl_enqueue(sl, *s);
s950drivers/net/slip.csl_enqueue(sl, *s);
s965drivers/net/slip.cslip_esc6(unsigned char *s, unsigned char *d, int len)
s985drivers/net/slip.cv = (v << 8) | s[i];
s1006drivers/net/slip.cslip_unesc6(struct slip *sl, unsigned char *s, int count, int error)
s1011drivers/net/slip.cfor (i = 0; i < count; ++i, ++s) {
s1012drivers/net/slip.cif (*s == 0x70) {
s1028drivers/net/slip.c} else if (*s >= 0x30 && *s < 0x70) {
s1029drivers/net/slip.csl->xdata = (sl->xdata << 6) | ((*s - 0x30) & 0x3F);
s76drivers/net/slip.hextern int  slip_esc(unsigned char *s, unsigned char *d, int len);
s77drivers/net/slip.hextern int  slip_esc6(unsigned char *s, unsigned char *d, int len);
s78drivers/net/slip.hextern void  slip_unesc(struct slip *sl, unsigned char *s, int count, int error);
s79drivers/net/slip.hextern void   slip_unesc6(struct slip *sl, unsigned char *s, int count, int error);
s2067drivers/scsi/aha152x.cint s;
s2071drivers/scsi/aha152x.cs=GETPORT(SCSISEQ);
s2073drivers/scsi/aha152x.cif( s & TEMODEO )     printk("TARGET MODE ");
s2074drivers/scsi/aha152x.cif( s & ENSELO )      printk("SELO ");
s2075drivers/scsi/aha152x.cif( s & ENSELI )      printk("SELI ");
s2076drivers/scsi/aha152x.cif( s & ENRESELI )    printk("RESELI ");
s2077drivers/scsi/aha152x.cif( s & ENAUTOATNO )  printk("AUTOATNO ");
s2078drivers/scsi/aha152x.cif( s & ENAUTOATNI )  printk("AUTOATNI ");
s2079drivers/scsi/aha152x.cif( s & ENAUTOATNP )  printk("AUTOATNP ");
s2080drivers/scsi/aha152x.cif( s & SCSIRSTO )    printk("SCSIRSTO ");
s2084drivers/scsi/aha152x.cs=GETPORT(SCSISIG);
s2085drivers/scsi/aha152x.cswitch(s & P_MASK)
s2115drivers/scsi/aha152x.cs=GETPORT(SSTAT0);
s2116drivers/scsi/aha152x.cif( s & TARGET )   printk("TARGET ");
s2117drivers/scsi/aha152x.cif( s & SELDO )    printk("SELDO ");
s2118drivers/scsi/aha152x.cif( s & SELDI )    printk("SELDI ");
s2119drivers/scsi/aha152x.cif( s & SELINGO )  printk("SELINGO ");
s2120drivers/scsi/aha152x.cif( s & SWRAP )    printk("SWRAP ");
s2121drivers/scsi/aha152x.cif( s & SDONE )    printk("SDONE ");
s2122drivers/scsi/aha152x.cif( s & SPIORDY )  printk("SPIORDY ");
s2123drivers/scsi/aha152x.cif( s & DMADONE )  printk("DMADONE ");
s2125drivers/scsi/aha152x.cs=GETPORT(SSTAT1);
s2126drivers/scsi/aha152x.cif( s & SELTO )     printk("SELTO ");
s2127drivers/scsi/aha152x.cif( s & ATNTARG )   printk("ATNTARG ");
s2128drivers/scsi/aha152x.cif( s & SCSIRSTI )  printk("SCSIRSTI ");
s2129drivers/scsi/aha152x.cif( s & PHASEMIS )  printk("PHASEMIS ");
s2130drivers/scsi/aha152x.cif( s & BUSFREE )   printk("BUSFREE ");
s2131drivers/scsi/aha152x.cif( s & SCSIPERR )  printk("SCSIPERR ");
s2132drivers/scsi/aha152x.cif( s & PHASECHG )  printk("PHASECHG ");
s2133drivers/scsi/aha152x.cif( s & REQINIT )   printk("REQINIT ");
s2139drivers/scsi/aha152x.cs=GETPORT(SSTAT0) & GETPORT(SIMODE0);
s2141drivers/scsi/aha152x.cif( s & TARGET )    printk("TARGET ");
s2142drivers/scsi/aha152x.cif( s & SELDO )     printk("SELDO ");
s2143drivers/scsi/aha152x.cif( s & SELDI )     printk("SELDI ");
s2144drivers/scsi/aha152x.cif( s & SELINGO )   printk("SELINGO ");
s2145drivers/scsi/aha152x.cif( s & SWRAP )     printk("SWRAP ");
s2146drivers/scsi/aha152x.cif( s & SDONE )     printk("SDONE ");
s2147drivers/scsi/aha152x.cif( s & SPIORDY )   printk("SPIORDY ");
s2148drivers/scsi/aha152x.cif( s & DMADONE )   printk("DMADONE ");
s2150drivers/scsi/aha152x.cs=GETPORT(SSTAT1) & GETPORT(SIMODE1);
s2152drivers/scsi/aha152x.cif( s & SELTO )     printk("SELTO ");
s2153drivers/scsi/aha152x.cif( s & ATNTARG )   printk("ATNTARG ");
s2154drivers/scsi/aha152x.cif( s & SCSIRSTI )  printk("SCSIRSTI ");
s2155drivers/scsi/aha152x.cif( s & PHASEMIS )  printk("PHASEMIS ");
s2156drivers/scsi/aha152x.cif( s & BUSFREE )   printk("BUSFREE ");
s2157drivers/scsi/aha152x.cif( s & SCSIPERR )  printk("SCSIPERR ");
s2158drivers/scsi/aha152x.cif( s & PHASECHG )  printk("PHASECHG ");
s2159drivers/scsi/aha152x.cif( s & REQINIT )   printk("REQINIT ");
s2164drivers/scsi/aha152x.cs=GETPORT(SXFRCTL0);
s2165drivers/scsi/aha152x.cif( s & SCSIEN )    printk("SCSIEN ");
s2166drivers/scsi/aha152x.cif( s & DMAEN )     printk("DMAEN ");
s2167drivers/scsi/aha152x.cif( s & CH1 )       printk("CH1 ");
s2168drivers/scsi/aha152x.cif( s & CLRSTCNT )  printk("CLRSTCNT ");
s2169drivers/scsi/aha152x.cif( s & SPIOEN )    printk("SPIOEN ");
s2170drivers/scsi/aha152x.cif( s & CLRCH1 )    printk("CLRCH1 ");
s2175drivers/scsi/aha152x.cs=GETPORT(SCSISIG);
s2176drivers/scsi/aha152x.cif( s & ATNI )  printk("ATNI ");
s2177drivers/scsi/aha152x.cif( s & SELI )  printk("SELI ");
s2178drivers/scsi/aha152x.cif( s & BSYI )  printk("BSYI ");
s2179drivers/scsi/aha152x.cif( s & REQI )  printk("REQI ");
s2180drivers/scsi/aha152x.cif( s & ACKI )  printk("ACKI ");
s2187drivers/scsi/aha152x.cs=GETPORT(SSTAT2);
s2188drivers/scsi/aha152x.cif( s & SOFFSET)  printk("SOFFSET ");
s2189drivers/scsi/aha152x.cif( s & SEMPTY)   printk("SEMPTY ");
s2190drivers/scsi/aha152x.cif( s & SFULL)    printk("SFULL ");
s2191drivers/scsi/aha152x.cprintk("); SFCNT ( %d ); ", s & (SFULL|SFCNT) );
s2195drivers/scsi/aha152x.cs=GETPORT(SSTAT4);
s2196drivers/scsi/aha152x.cif( s & SYNCERR)   printk("SYNCERR ");
s2197drivers/scsi/aha152x.cif( s & FWERR)     printk("FWERR ");
s2198drivers/scsi/aha152x.cif( s & FRERR)     printk("FRERR ");
s2205drivers/scsi/aha152x.cs=GETPORT(DMACNTRL0);
s2206drivers/scsi/aha152x.cprintk( "%s ", s & _8BIT      ? "8BIT"  : "16BIT" );
s2207drivers/scsi/aha152x.cprintk( "%s ", s & DMA        ? "DMA"   : "PIO"   );
s2208drivers/scsi/aha152x.cprintk( "%s ", s & WRITE_READ ? "WRITE" : "READ"  );
s2209drivers/scsi/aha152x.cif( s & ENDMA )    printk("ENDMA ");
s2210drivers/scsi/aha152x.cif( s & INTEN )    printk("INTEN ");
s2211drivers/scsi/aha152x.cif( s & RSTFIFO )  printk("RSTFIFO ");
s2212drivers/scsi/aha152x.cif( s & SWINT )    printk("SWINT ");
s2219drivers/scsi/aha152x.cs=GETPORT(DMACNTRL1);
s2220drivers/scsi/aha152x.cif( s & PWRDWN )    printk("PWRDN ");
s2224drivers/scsi/aha152x.cprintk("STK ( %d ); ", s & 0xf);
s2227drivers/scsi/aha152x.cs=GETPORT(DMASTAT);
s2228drivers/scsi/aha152x.cif( s & ATDONE )     printk("ATDONE ");
s2229drivers/scsi/aha152x.cif( s & WORDRDY )    printk("WORDRDY ");
s2230drivers/scsi/aha152x.cif( s & DFIFOFULL )  printk("DFIFOFULL ");
s2231drivers/scsi/aha152x.cif( s & DFIFOEMP )   printk("DFIFOEMP ");
s2245drivers/scsi/aha152x.cint s;
s2249drivers/scsi/aha152x.cs=GETPORT(SIMODE0);
s2250drivers/scsi/aha152x.cif( s & ENSELDO )    printk("ENSELDO ");
s2251drivers/scsi/aha152x.cif( s & ENSELDI )    printk("ENSELDI ");
s2252drivers/scsi/aha152x.cif( s & ENSELINGO )  printk("ENSELINGO ");
s2253drivers/scsi/aha152x.cif( s & ENSWRAP )    printk("ENSWRAP ");
s2254drivers/scsi/aha152x.cif( s & ENSDONE )    printk("ENSDONE ");
s2255drivers/scsi/aha152x.cif( s & ENSPIORDY )  printk("ENSPIORDY ");
s2256drivers/scsi/aha152x.cif( s & ENDMADONE )  printk("ENDMADONE ");
s2258drivers/scsi/aha152x.cs=GETPORT(SIMODE1);
s2259drivers/scsi/aha152x.cif( s & ENSELTIMO )    printk("ENSELTIMO ");
s2260drivers/scsi/aha152x.cif( s & ENATNTARG )    printk("ENATNTARG ");
s2261drivers/scsi/aha152x.cif( s & ENPHASEMIS )   printk("ENPHASEMIS ");
s2262drivers/scsi/aha152x.cif( s & ENBUSFREE )    printk("ENBUSFREE ");
s2263drivers/scsi/aha152x.cif( s & ENSCSIPERR )   printk("ENSCSIPERR ");
s2264drivers/scsi/aha152x.cif( s & ENPHASECHG )   printk("ENPHASECHG ");
s2265drivers/scsi/aha152x.cif( s & ENREQINIT )    printk("ENREQINIT ");
s98drivers/scsi/constants.cint i,s;
s100drivers/scsi/constants.cfor ( i = 1, s = COMMAND_SIZE(command[0]); i < s; ++i) 
s362drivers/scsi/constants.cint i, s;
s373drivers/scsi/constants.cs = sense_buffer[7] + 8;
s374drivers/scsi/constants.cif(s > sizeof(SCpnt->sense_buffer)) s = sizeof(SCpnt->sense_buffer);
s436drivers/scsi/constants.cs = 4;
s440drivers/scsi/constants.cfor (i = 0; i < s; ++i) 
s453drivers/scsi/pas16.cregister unsigned char *s = src;
s459drivers/scsi/pas16.coutb( *s++, reg );
s357drivers/scsi/t128.cT_DATA_REG_OFFSET), *s = src;
s362drivers/scsi/t128.c*reg = *s++;
s989drivers/scsi/ultrastor.cunsigned int s = config.heads * config.sectors;
s993drivers/scsi/ultrastor.cdkinfo[2] = size / s;  /* Ignore partial cylinders */
s54drivers/sound/os.h#define COPY_FROM_USER(d, s, o, c)  memcpy_fromfs((d), &((s)[o]), (c))
s55drivers/sound/os.h#define COPY_TO_USER(d, o, s, c)  memcpy_tofs(&((d)[o]), (s), (c))
s56drivers/sound/os.h#define IOCTL_FROM_USER(d, s, o, c)  memcpy_fromfs((d), &((s)[o]), (c))
s57drivers/sound/os.h#define IOCTL_TO_USER(d, o, s, c)  memcpy_tofs(&((d)[o]), (s), (c))
s65drivers/sound/soundcard.cput_status (char *s)
s67drivers/sound/soundcard.cint             l = strlen (s);
s72drivers/sound/soundcard.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;
s201fs/ext2/super.cstruct super_block * ext2_read_super (struct super_block * s, void * data,
s208fs/ext2/super.cint dev = s->s_dev;
s215fs/ext2/super.cs->u.ext2_sb.s_mount_opt = 0;
s217fs/ext2/super.c&s->u.ext2_sb.s_mount_opt)) {
s218fs/ext2/super.cs->s_dev = 0;
s222fs/ext2/super.clock_super (s);
s225fs/ext2/super.cs->s_dev = 0;
s226fs/ext2/super.cunlock_super (s);
s233fs/ext2/super.cs->u.ext2_sb.s_es = es;
s234fs/ext2/super.cs->s_magic = es->s_magic;
s235fs/ext2/super.cif (s->s_magic != EXT2_SUPER_MAGIC
s237fs/ext2/super.c&& s->s_magic != EXT2_PRE_02B_MAGIC
s240fs/ext2/super.cs->s_dev = 0;
s241fs/ext2/super.cunlock_super (s);
s248fs/ext2/super.cs->s_blocksize = EXT2_MIN_BLOCK_SIZE << es->s_log_block_size;
s249fs/ext2/super.cs->s_blocksize_bits = EXT2_BLOCK_SIZE_BITS(s);
s250fs/ext2/super.cif (s->s_blocksize != BLOCK_SIZE && 
s251fs/ext2/super.c(s->s_blocksize == 1024 || s->s_blocksize == 2048 ||  
s252fs/ext2/super.cs->s_blocksize == 4096)) {
s256fs/ext2/super.cset_blocksize (dev, s->s_blocksize);
s257fs/ext2/super.clogic_sb_block = sb_block / s->s_blocksize;
s258fs/ext2/super.coffset = sb_block % s->s_blocksize;
s259fs/ext2/super.cbh = bread (dev, logic_sb_block, s->s_blocksize);
s263fs/ext2/super.cs->u.ext2_sb.s_es = es;
s265fs/ext2/super.cs->s_dev = 0;
s266fs/ext2/super.cunlock_super (s);
s272fs/ext2/super.cs->u.ext2_sb.s_frag_size = EXT2_MIN_FRAG_SIZE <<
s274fs/ext2/super.cif (s->u.ext2_sb.s_frag_size)
s275fs/ext2/super.cs->u.ext2_sb.s_frags_per_block = s->s_blocksize /
s276fs/ext2/super.cs->u.ext2_sb.s_frag_size;
s278fs/ext2/super.cs->s_magic = 0;
s279fs/ext2/super.cs->u.ext2_sb.s_blocks_per_group = es->s_blocks_per_group;
s280fs/ext2/super.cs->u.ext2_sb.s_frags_per_group = es->s_frags_per_group;
s281fs/ext2/super.cs->u.ext2_sb.s_inodes_per_group = es->s_inodes_per_group;
s282fs/ext2/super.cs->u.ext2_sb.s_inodes_per_block = s->s_blocksize /
s284fs/ext2/super.cs->u.ext2_sb.s_desc_per_block = s->s_blocksize /
s286fs/ext2/super.cs->u.ext2_sb.s_sbh = bh;
s287fs/ext2/super.cs->u.ext2_sb.s_es = es;
s288fs/ext2/super.cs->u.ext2_sb.s_mount_state = es->s_state;
s289fs/ext2/super.cs->u.ext2_sb.s_rename_lock = 0;
s290fs/ext2/super.cs->u.ext2_sb.s_rename_wait = NULL;
s292fs/ext2/super.cif (s->s_magic == EXT2_PRE_02B_MAGIC) {
s295fs/ext2/super.cs->s_dev = 0;
s296fs/ext2/super.cunlock_super (s);
s304fs/ext2/super.cif (!(s->s_flags & MS_RDONLY)) {
s305fs/ext2/super.cs->s_dev = 0;
s306fs/ext2/super.cunlock_super (s);
s311fs/ext2/super.cif (!convert_pre_02b_fs (s, bh)) {
s312fs/ext2/super.cs->s_dev = 0;
s313fs/ext2/super.cunlock_super (s);
s322fs/ext2/super.cif (s->s_magic != EXT2_SUPER_MAGIC) {
s323fs/ext2/super.cs->s_dev = 0;
s324fs/ext2/super.cunlock_super (s);
s331fs/ext2/super.cif (s->s_blocksize != bh->b_size) {
s332fs/ext2/super.cs->s_dev = 0;
s333fs/ext2/super.cunlock_super (s);
s341fs/ext2/super.cif (s->s_blocksize != s->u.ext2_sb.s_frag_size) {
s342fs/ext2/super.cs->s_dev = 0;
s343fs/ext2/super.cunlock_super (s);
s346fs/ext2/super.cs->u.ext2_sb.s_frag_size, s->s_blocksize);
s350fs/ext2/super.cs->u.ext2_sb.s_groups_count = (es->s_blocks_count -
s352fs/ext2/super.cEXT2_BLOCKS_PER_GROUP(s) - 1) /
s353fs/ext2/super.cEXT2_BLOCKS_PER_GROUP(s);
s355fs/ext2/super.cs->u.ext2_sb.s_group_desc[i] = NULL;
s356fs/ext2/super.cbh_count = (s->u.ext2_sb.s_groups_count + EXT2_DESC_PER_BLOCK(s) - 1) /
s357fs/ext2/super.cEXT2_DESC_PER_BLOCK(s);
s359fs/ext2/super.cs->s_dev = 0;
s360fs/ext2/super.cunlock_super (s);
s366fs/ext2/super.cs->u.ext2_sb.s_group_desc[i] = bread (dev, logic_sb_block + i + 1,
s367fs/ext2/super.cs->s_blocksize);
s368fs/ext2/super.cif (!s->u.ext2_sb.s_group_desc[i]) {
s369fs/ext2/super.cs->s_dev = 0;
s370fs/ext2/super.cunlock_super (s);
s372fs/ext2/super.cbrelse (s->u.ext2_sb.s_group_desc[i]);
s379fs/ext2/super.cs->u.ext2_sb.s_inode_bitmap_number[i] = 0;
s380fs/ext2/super.cs->u.ext2_sb.s_inode_bitmap[i] = NULL;
s381fs/ext2/super.cs->u.ext2_sb.s_block_bitmap_number[i] = 0;
s382fs/ext2/super.cs->u.ext2_sb.s_block_bitmap[i] = NULL;
s384fs/ext2/super.cs->u.ext2_sb.s_loaded_inode_bitmaps = 0;
s385fs/ext2/super.cs->u.ext2_sb.s_loaded_block_bitmaps = 0;
s386fs/ext2/super.cunlock_super (s);
s388fs/ext2/super.cs->s_dev = dev;
s389fs/ext2/super.cs->s_op = &ext2_sops;
s390fs/ext2/super.cif (!(s->s_mounted = iget (s, EXT2_ROOT_INO))) {
s391fs/ext2/super.cs->s_dev = 0;
s393fs/ext2/super.cif (s->u.ext2_sb.s_group_desc[i])
s394fs/ext2/super.cbrelse (s->u.ext2_sb.s_group_desc[i]);
s399fs/ext2/super.cif (!(s->s_flags & MS_RDONLY)) {
s406fs/ext2/super.cs->s_dirt = 1;
s411fs/ext2/super.cs->u.ext2_sb.s_group_desc[i]->b_dirt = 1;
s412fs/ext2/super.cs->s_dirt = 1;
s415fs/ext2/super.cif (!(s->u.ext2_sb.s_mount_state & EXT2_VALID_FS))
s418fs/ext2/super.celse if (s->u.ext2_sb.s_mount_state & EXT2_ERROR_FS)
s424fs/ext2/super.cif (s->u.ext2_sb.s_mount_opt & EXT2_MOUNT_CHECK) {
s426fs/ext2/super.cEXT2FS_VERSION, EXT2FS_DATE, s->s_blocksize,
s427fs/ext2/super.cs->u.ext2_sb.s_frag_size, s->u.ext2_sb.s_groups_count,
s428fs/ext2/super.cEXT2_BLOCKS_PER_GROUP(s), EXT2_INODES_PER_GROUP(s));
s429fs/ext2/super.cext2_check_blocks_bitmap (s);
s430fs/ext2/super.cext2_check_inodes_bitmap (s);
s432fs/ext2/super.creturn s;
s237fs/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)
s731fs/hpfs/hpfs_fs.cif (s->s_hpfs_n_free == -1) {
s732fs/hpfs/hpfs_fs.cs->s_hpfs_n_free = count_bitmap(s);
s733fs/hpfs/hpfs_fs.cs->s_hpfs_n_free_dnodes =
s734fs/hpfs/hpfs_fs.ccount_one_bitmap(s->s_dev, s->s_hpfs_dmap);
s741fs/hpfs/hpfs_fs.cput_fs_long(s->s_magic, &buf->f_type);
s743fs/hpfs/hpfs_fs.cput_fs_long(s->s_hpfs_fs_size, &buf->f_blocks);
s744fs/hpfs/hpfs_fs.cput_fs_long(s->s_hpfs_n_free, &buf->f_bfree);
s745fs/hpfs/hpfs_fs.cput_fs_long(s->s_hpfs_n_free, &buf->f_bavail);
s746fs/hpfs/hpfs_fs.cput_fs_long(s->s_hpfs_dirband_size, &buf->f_files);
s747fs/hpfs/hpfs_fs.cput_fs_long(s->s_hpfs_n_free_dnodes, &buf->f_ffree);
s755fs/hpfs/hpfs_fs.cstatic int hpfs_remount_fs(struct super_block *s, int *flags)
s799fs/hpfs/hpfs_fs.cstatic unsigned count_bitmap(struct super_block *s)
s808fs/hpfs/hpfs_fs.cn_bands = (s->s_hpfs_fs_size + 0x3fff) >> 14;
s814fs/hpfs/hpfs_fs.cbitmaps = map_4sectors(s->s_dev, s->s_hpfs_bitmaps, &qbh);
s827fs/hpfs/hpfs_fs.ccount += count_one_bitmap(s->s_dev, bitmaps[n]);
s120fs/isofs/inode.cstruct super_block *isofs_read_super(struct super_block *s,void *data,
s127fs/isofs/inode.cint dev=s->s_dev;
s139fs/isofs/inode.cs->s_dev = 0;
s153fs/isofs/inode.clock_super(s);
s155fs/isofs/inode.cs->u.isofs_sb.s_high_sierra = high_sierra = 0; /* default is iso9660 */
s159fs/isofs/inode.cs->s_dev=0;
s162fs/isofs/inode.cunlock_super(s);
s176fs/isofs/inode.cs->u.isofs_sb.s_high_sierra = 1;
s198fs/isofs/inode.cs->s_dev = 0;
s199fs/isofs/inode.cunlock_super(s);
s210fs/isofs/inode.cs->u.isofs_sb.s_nzones = isonum_733 (h_pri->volume_space_size);
s211fs/isofs/inode.cs->u.isofs_sb.s_log_zone_size = isonum_723 (h_pri->logical_block_size);
s212fs/isofs/inode.cs->u.isofs_sb.s_max_size = isonum_733(h_pri->volume_space_size);
s219fs/isofs/inode.cs->u.isofs_sb.s_nzones = isonum_733 (pri->volume_space_size);
s220fs/isofs/inode.cs->u.isofs_sb.s_log_zone_size = isonum_723 (pri->logical_block_size);
s221fs/isofs/inode.cs->u.isofs_sb.s_max_size = isonum_733(pri->volume_space_size);
s224fs/isofs/inode.cs->u.isofs_sb.s_ninodes = 0; /* No way to figure this out easily */
s226fs/isofs/inode.cs->u.isofs_sb.s_firstdatazone = isonum_733( rootp->extent) << 
s228fs/isofs/inode.cs->s_magic = ISOFS_SUPER_MAGIC;
s235fs/isofs/inode.cs->s_flags = MS_RDONLY /* | MS_NODEV | MS_NOSUID */;
s237fs/isofs/inode.cif(s->u.isofs_sb.s_log_zone_size != (1 << ISOFS_BLOCK_BITS)) {
s245fs/isofs/inode.cs->u.isofs_sb.s_max_size, 
s246fs/isofs/inode.cs->u.isofs_sb.s_log_zone_size);
s248fs/isofs/inode.cs->u.isofs_sb.s_firstdatazone,
s251fs/isofs/inode.cunlock_super(s);
s254fs/isofs/inode.cs->s_dev = dev;
s255fs/isofs/inode.cs->s_op = &isofs_sops;
s256fs/isofs/inode.cs->u.isofs_sb.s_mapping = map;
s257fs/isofs/inode.cs->u.isofs_sb.s_rock = (rock == 'y' ? 1 : 0);
s258fs/isofs/inode.cs->u.isofs_sb.s_conversion = conversion;
s259fs/isofs/inode.cs->u.isofs_sb.s_cruft = cruft;
s260fs/isofs/inode.cs->s_blocksize = blocksize;
s261fs/isofs/inode.cs->s_blocksize_bits = blocksize_bits;
s262fs/isofs/inode.cs->s_mounted = iget(s, isonum_733 (rootp->extent) << ISOFS_BLOCK_BITS);
s263fs/isofs/inode.cunlock_super(s);
s265fs/isofs/inode.cif (!(s->s_mounted)) {
s266fs/isofs/inode.cs->s_dev=0;
s271fs/isofs/inode.cif (MAJOR(s->s_dev) == SCSI_CDROM_MAJOR) {
s273fs/isofs/inode.cif(check_cdrom_media_change(s->s_dev, 0))
s278fs/isofs/inode.cif (MAJOR(s->s_dev) == CDU31A_CDROM_MAJOR) {
s280fs/isofs/inode.cif(check_cdu31a_media_change(s->s_dev, 0))
s285fs/isofs/inode.cif (MAJOR(s->s_dev) == MITSUMI_CDROM_MAJOR) {
s287fs/isofs/inode.cif(check_mcd_media_change(s->s_dev, 0))
s291fs/isofs/inode.creturn s;
s294fs/isofs/inode.cs->s_dev = 0;
s295fs/isofs/inode.cunlock_super(s);
s53fs/minix/inode.cstruct super_block *minix_read_super(struct super_block *s,void *data, 
s58fs/minix/inode.cint i,dev=s->s_dev,block;
s62fs/minix/inode.clock_super(s);
s64fs/minix/inode.cs->s_dev=0;
s65fs/minix/inode.cunlock_super(s);
s70fs/minix/inode.cs->s_blocksize = 1024;
s71fs/minix/inode.cs->s_blocksize_bits = 10;
s72fs/minix/inode.cs->u.minix_sb.s_ninodes = ms->s_ninodes;
s73fs/minix/inode.cs->u.minix_sb.s_nzones = ms->s_nzones;
s74fs/minix/inode.cs->u.minix_sb.s_imap_blocks = ms->s_imap_blocks;
s75fs/minix/inode.cs->u.minix_sb.s_zmap_blocks = ms->s_zmap_blocks;
s76fs/minix/inode.cs->u.minix_sb.s_firstdatazone = ms->s_firstdatazone;
s77fs/minix/inode.cs->u.minix_sb.s_log_zone_size = ms->s_log_zone_size;
s78fs/minix/inode.cs->u.minix_sb.s_max_size = ms->s_max_size;
s79fs/minix/inode.cs->s_magic = ms->s_magic;
s81fs/minix/inode.cif (s->s_magic == MINIX_SUPER_MAGIC) {
s82fs/minix/inode.cs->u.minix_sb.s_dirsize = 16;
s83fs/minix/inode.cs->u.minix_sb.s_namelen = 14;
s84fs/minix/inode.c} else if (s->s_magic == MINIX_SUPER_MAGIC2) {
s85fs/minix/inode.cs->u.minix_sb.s_dirsize = 32;
s86fs/minix/inode.cs->u.minix_sb.s_namelen = 30;
s88fs/minix/inode.cs->s_dev = 0;
s89fs/minix/inode.cunlock_super(s);
s96fs/minix/inode.cs->u.minix_sb.s_imap[i] = NULL;
s98fs/minix/inode.cs->u.minix_sb.s_zmap[i] = NULL;
s100fs/minix/inode.cfor (i=0 ; i < s->u.minix_sb.s_imap_blocks ; i++)
s101fs/minix/inode.cif ((s->u.minix_sb.s_imap[i]=bread(dev,block,BLOCK_SIZE)) != NULL)
s105fs/minix/inode.cfor (i=0 ; i < s->u.minix_sb.s_zmap_blocks ; i++)
s106fs/minix/inode.cif ((s->u.minix_sb.s_zmap[i]=bread(dev,block,BLOCK_SIZE)) != NULL)
s110fs/minix/inode.cif (block != 2+s->u.minix_sb.s_imap_blocks+s->u.minix_sb.s_zmap_blocks) {
s112fs/minix/inode.cbrelse(s->u.minix_sb.s_imap[i]);
s114fs/minix/inode.cbrelse(s->u.minix_sb.s_zmap[i]);
s115fs/minix/inode.cs->s_dev=0;
s116fs/minix/inode.cunlock_super(s);
s120fs/minix/inode.cset_bit(0,s->u.minix_sb.s_imap[0]->b_data);
s121fs/minix/inode.cset_bit(0,s->u.minix_sb.s_zmap[0]->b_data);
s123fs/minix/inode.cs->s_dev = dev;
s124fs/minix/inode.cs->s_op = &minix_sops;
s125fs/minix/inode.cs->s_mounted = iget(s,MINIX_ROOT_INO);
s126fs/minix/inode.cunlock_super(s);
s127fs/minix/inode.cif (!s->s_mounted) {
s128fs/minix/inode.cs->s_dev = 0;
s132fs/minix/inode.creturn s;
s144fs/msdos/inode.cstruct super_block *msdos_read_super(struct super_block *s,void *data,
s158fs/msdos/inode.cs->s_dev = 0;
s162fs/msdos/inode.clock_super(s);
s163fs/msdos/inode.cbh = bread(s->s_dev, 0, BLOCK_SIZE);
s164fs/msdos/inode.cunlock_super(s);
s166fs/msdos/inode.cs->s_dev = 0;
s171fs/msdos/inode.cs->s_blocksize = 1024;  /* we cannot handle anything else yet */
s172fs/msdos/inode.cs->s_blocksize_bits = 10;  /* we cannot handle anything else yet */
s194fs/msdos/inode.cMSDOS_SB(s)->cluster_size = b->cluster_size*sector_mult;
s195fs/msdos/inode.cMSDOS_SB(s)->fats = b->fats;
s196fs/msdos/inode.cMSDOS_SB(s)->fat_start = CF_LE_W(b->reserved)*sector_mult;
s197fs/msdos/inode.cMSDOS_SB(s)->fat_length = CF_LE_W(b->fat_length)*sector_mult;
s198fs/msdos/inode.cMSDOS_SB(s)->dir_start = (CF_LE_W(b->reserved)+b->fats*CF_LE_W(
s200fs/msdos/inode.cMSDOS_SB(s)->dir_entries = CF_LE_W(*((unsigned short *) &b->dir_entries
s202fs/msdos/inode.cMSDOS_SB(s)->data_start = MSDOS_SB(s)->dir_start+ROUND_TO_MULTIPLE((
s203fs/msdos/inode.cMSDOS_SB(s)->dir_entries << MSDOS_DIR_BITS) >> SECTOR_BITS,
s207fs/msdos/inode.cCF_LE_L(b->total_sect))*sector_mult-MSDOS_SB(s)->data_start;
s210fs/msdos/inode.cMSDOS_SB(s)->clusters = b->cluster_size ? data_sectors/
s212fs/msdos/inode.cMSDOS_SB(s)->fat_bits = fat ? fat : MSDOS_SB(s)->clusters >
s214fs/msdos/inode.cerror = !MSDOS_SB(s)->fats || (MSDOS_SB(s)->dir_entries &
s215fs/msdos/inode.c(MSDOS_DPS-1)) || MSDOS_SB(s)->clusters+2 > MSDOS_SB(s)->
s216fs/msdos/inode.cfat_length*SECTOR_SIZE*8/MSDOS_SB(s)->fat_bits ||
s223fs/msdos/inode.c"uid=%d,gid=%d,umask=%03o%s]\n",MSDOS_SB(s)->fat_bits,check,
s224fs/msdos/inode.cconversion,uid,gid,umask,MSDOS_CAN_BMAP(MSDOS_SB(s)) ?
s227fs/msdos/inode.c"se=%d,ts=%ld,ls=%d]\n",b->media,MSDOS_SB(s)->cluster_size,
s228fs/msdos/inode.cMSDOS_SB(s)->fats,MSDOS_SB(s)->fat_start,MSDOS_SB(s)->
s229fs/msdos/inode.cfat_length,MSDOS_SB(s)->dir_start,MSDOS_SB(s)->dir_entries,
s230fs/msdos/inode.cMSDOS_SB(s)->data_start,CF_LE_W(*(unsigned short *) &b->
s236fs/msdos/inode.cs->s_dev);
s237fs/msdos/inode.cs->s_dev = 0;
s240fs/msdos/inode.cs->s_magic = MSDOS_SUPER_MAGIC;
s241fs/msdos/inode.cMSDOS_SB(s)->name_check = check;
s242fs/msdos/inode.cMSDOS_SB(s)->conversion = conversion;
s244fs/msdos/inode.cs->s_op = &msdos_sops;
s245fs/msdos/inode.cMSDOS_SB(s)->fs_uid = uid;
s246fs/msdos/inode.cMSDOS_SB(s)->fs_gid = gid;
s247fs/msdos/inode.cMSDOS_SB(s)->fs_umask = umask;
s248fs/msdos/inode.cMSDOS_SB(s)->quiet = quiet;
s249fs/msdos/inode.cMSDOS_SB(s)->free_clusters = -1; /* don't know yet */
s250fs/msdos/inode.cMSDOS_SB(s)->fat_wait = NULL;
s251fs/msdos/inode.cMSDOS_SB(s)->fat_lock = 0;
s252fs/msdos/inode.cMSDOS_SB(s)->prev_free = 0;
s253fs/msdos/inode.cif (!(s->s_mounted = iget(s,MSDOS_ROOT_INO))) {
s254fs/msdos/inode.cs->s_dev = 0;
s258fs/msdos/inode.creturn s;
s30fs/msdos/misc.cvoid fs_panic(struct super_block *s,char *msg)
s34fs/msdos/misc.cnot_ro = !(s->s_flags & MS_RDONLY);
s35fs/msdos/misc.cif (not_ro) s->s_flags |= MS_RDONLY;
s37fs/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;
s92fs/super.cstruct super_block * s;
s96fs/super.cs = 0+super_blocks;
s97fs/super.cwhile (s < NR_SUPER+super_blocks)
s98fs/super.cif (s->s_dev == dev) {
s99fs/super.cwait_on_super(s);
s100fs/super.cif (s->s_dev == dev)
s101fs/super.creturn s;
s102fs/super.cs = 0+super_blocks;
s104fs/super.cs++;
s131fs/super.cstruct super_block * s;
s137fs/super.cs = get_super(dev);
s138fs/super.cif (s)
s139fs/super.creturn s;
s145fs/super.cfor (s = 0+super_blocks ;; s++) {
s146fs/super.cif (s >= NR_SUPER+super_blocks)
s148fs/super.cif (!s->s_dev)
s151fs/super.cs->s_dev = dev;
s152fs/super.cs->s_flags = flags;
s153fs/super.cif (!type->read_super(s,data, silent)) {
s154fs/super.cs->s_dev = 0;
s157fs/super.cs->s_dev = dev;
s158fs/super.cs->s_covered = NULL;
s159fs/super.cs->s_rd_only = 0;
s160fs/super.cs->s_dirt = 0;
s161fs/super.creturn s;
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);
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 (unsigned long))
s105include/linux/ext2_fs.h# define EXT2_BLOCK_SIZE_BITS(s)  ((s)->u.ext2_sb.s_es->s_log_block_size + 10)
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))
s118include/linux/ext2_fs.h# define EXT2_FRAG_SIZE(s)    ((s)->u.ext2_sb.s_frag_size)
s119include/linux/ext2_fs.h# define EXT2_FRAGS_PER_BLOCK(s)  ((s)->u.ext2_sb.s_frags_per_block)
s121include/linux/ext2_fs.h# define EXT2_FRAG_SIZE(s)    (EXT2_MIN_FRAG_SIZE << (s)->s_log_frag_size)
s122include/linux/ext2_fs.h# define EXT2_FRAGS_PER_BLOCK(s)  (EXT2_BLOCK_SIZE(s) / EXT2_FRAG_SIZE(s))
s175include/linux/ext2_fs.h# define EXT2_BLOCKS_PER_GROUP(s)  ((s)->u.ext2_sb.s_blocks_per_group)
s176include/linux/ext2_fs.h# define EXT2_DESC_PER_BLOCK(s)    ((s)->u.ext2_sb.s_desc_per_block)
s177include/linux/ext2_fs.h# define EXT2_INODES_PER_GROUP(s)  ((s)->u.ext2_sb.s_inodes_per_group)
s179include/linux/ext2_fs.h# define EXT2_BLOCKS_PER_GROUP(s)  ((s)->s_blocks_per_group)
s180include/linux/ext2_fs.h# define EXT2_DESC_PER_BLOCK(s)    (EXT2_BLOCK_SIZE(s) / sizeof (struct ext2_group_desc))
s181include/linux/ext2_fs.h# define EXT2_INODES_PER_GROUP(s)  ((s)->s_inodes_per_group)
s43include/linux/msdos_fs.h#define MSDOS_SB(s) (&((s)->u.msdos_sb))
s126include/linux/msdos_fs.hextern void fs_panic(struct super_block *s,char *msg);
s171include/linux/msdos_fs.hextern struct super_block *msdos_read_super(struct super_block *s,
s127include/linux/string.hextern inline char * strchr(const char * s,char c)
s140include/linux/string.h:"=a" (__res):"S" (s),"0" (c):"si");
s144include/linux/string.hextern inline char * strrchr(const char * s,char c)
s156include/linux/string.h:"=d" (__res):"0" (0),"S" (s),"a" (c):"ax","si");
s262include/linux/string.hextern inline size_t strlen(const char * s)
s270include/linux/string.h:"=c" (__res):"D" (s),"a" (0),"0" (0xffffffff):"di");
s276include/linux/string.hextern inline char * strtok(char * s,const char * ct)
s330include/linux/string.h:"0" (___strtok),"1" (s),"g" (ct)
s408include/linux/string.hextern inline void * memset(void * s,char c,size_t count)
s414include/linux/string.h:"a" (c),"D" (s),"c" (count)
s416include/linux/string.hreturn s;
s360include/linux/tpqic02.h# define TPQDEB(s)  s
s361include/linux/tpqic02.h# define TPQPUTS(s)  tpqputs(s)
s363include/linux/tpqic02.h# define TPQDEB(s)
s364include/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';
s124kernel/vsprintf.cchar *s;
s197kernel/vsprintf.cs = va_arg(args, char *);
s198kernel/vsprintf.cif (!s)
s199kernel/vsprintf.cs = "<NULL>";
s200kernel/vsprintf.clen = strlen(s);
s210kernel/vsprintf.c*str++ = *s++;
s1616net/inet/sock.cstruct sock *s;
s1631net/inet/sock.cfor(s = prot->sock_array[hnum & (SOCK_ARRAY_SIZE - 1)];
s1632net/inet/sock.cs != NULL; s = s->next) 
s1634net/inet/sock.cif (s->num != hnum) 
s1636net/inet/sock.cif(s->dead && (s->state == TCP_CLOSE))
s1639net/inet/sock.creturn s;
s1640net/inet/sock.cif(ip_addr_match(s->daddr,raddr)==0)
s1642net/inet/sock.cif (s->dummy_th.dest != rnum && s->dummy_th.dest != 0) 
s1644net/inet/sock.cif(ip_addr_match(s->saddr,laddr) == 0)
s1646net/inet/sock.creturn(s);
s50tools/build.cshort s[2];
s71tools/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) */
s274zBoot/inflate.celse if (*p < s)
s281zBoot/inflate.cr.e = (uch)e[*p - s];   /* non-simple--look up in lists */
s282zBoot/inflate.cr.v.n = d[*p++ - s];
s113zBoot/misc.cstatic void puts(char *s)
s121zBoot/misc.cwhile ( ( c = *s++ ) != '\0' ) {
s144zBoot/misc.c__ptr_t memset(__ptr_t s, int c, size_t n)
s147zBoot/misc.cchar *ss = (char*)s;
s156zBoot/misc.cchar *d = (char *)__dest, *s = (char *)__src;
s158zBoot/misc.cfor (i=0;i<__n;i++) d[i] = s[i];
s168zBoot/misc.culg updcrc(s, n)
s169zBoot/misc.cuch *s;                 /* pointer to bytes to pump through */
s176zBoot/misc.cif (s == NULL) {
s181zBoot/misc.cc = crc_32_tab[((int)c ^ (*s++)) & 0xff] ^ (c >> 8);