taglinefilesource code
sb42arch/i386/boot/compressed/xtract.cstruct stat sb;
sb104arch/i386/boot/tools/build.cstruct stat sb;
sb111arch/i386/boot/tools/build.cif (stat("/", &sb)) {
sb115arch/i386/boot/tools/build.cmajor_root = major(sb.st_dev);
sb116arch/i386/boot/tools/build.cminor_root = minor(sb.st_dev);
sb118arch/i386/boot/tools/build.cif (stat(argv[4], &sb)) {
sb122arch/i386/boot/tools/build.cmajor_root = major(sb.st_rdev);
sb123arch/i386/boot/tools/build.cminor_root = minor(sb.st_rdev);
sb232arch/i386/boot/tools/build.cif (fstat (id, &sb)) {
sb236arch/i386/boot/tools/build.csz = sb.st_size;
sb780drivers/char/tpqic02.cstatic int send_qic02_data(char sb[], unsigned size, int ignore_ex)
sb790drivers/char/tpqic02.cstat = notify_cmd(sb[i], ignore_ex);
sb82drivers/scsi/eata_dma_proc.cscbu   *sb;
sb112drivers/scsi/eata_dma_proc.csb = (scbu *)     (buff + 0x178);
sb220drivers/scsi/eata_dma_proc.c(sb->wide == TRUE)?" WIDE":"", 
sb221drivers/scsi/eata_dma_proc.c(sb->dif == TRUE)?" DIFFERENTIAL":"",
sb222drivers/scsi/eata_dma_proc.c(sb->speed == 0)?"5":(sb->speed == 1)?"10":"20",
sb223drivers/scsi/eata_dma_proc.c(sb->ext == TRUE)?"With external cable detection":"");
sb40fs/ext/freelists.cvoid ext_free_block(struct super_block * sb, int block)
sb45fs/ext/freelists.cif (!sb) {
sb49fs/ext/freelists.clock_super (sb);
sb50fs/ext/freelists.cif (block < sb->u.ext_sb.s_firstdatazone ||
sb51fs/ext/freelists.cblock >= sb->u.ext_sb.s_nzones) {
sb55fs/ext/freelists.cbh = get_hash_table(sb->s_dev, block, sb->s_blocksize);
sb59fs/ext/freelists.cif (sb->u.ext_sb.s_firstfreeblock)
sb60fs/ext/freelists.cefb = (struct ext_free_block *) sb->u.ext_sb.s_firstfreeblock->b_data;
sb61fs/ext/freelists.cif (!sb->u.ext_sb.s_firstfreeblock || efb->count == 254) {
sb65fs/ext/freelists.cif (sb->u.ext_sb.s_firstfreeblock)
sb66fs/ext/freelists.cbrelse (sb->u.ext_sb.s_firstfreeblock);
sb67fs/ext/freelists.cif (!(sb->u.ext_sb.s_firstfreeblock = bread (sb->s_dev,
sb68fs/ext/freelists.cblock, sb->s_blocksize)))
sb70fs/ext/freelists.cefb = (struct ext_free_block *) sb->u.ext_sb.s_firstfreeblock->b_data;
sb71fs/ext/freelists.cefb->next = sb->u.ext_sb.s_firstfreeblocknumber;
sb73fs/ext/freelists.csb->u.ext_sb.s_firstfreeblocknumber = block;
sb77fs/ext/freelists.csb->u.ext_sb.s_freeblockscount ++;
sb78fs/ext/freelists.csb->s_dirt = 1;
sb79fs/ext/freelists.cmark_buffer_dirty(sb->u.ext_sb.s_firstfreeblock, 1);
sb80fs/ext/freelists.cunlock_super (sb);
sb84fs/ext/freelists.cint ext_new_block(struct super_block * sb)
sb90fs/ext/freelists.cif (!sb) {
sb94fs/ext/freelists.cif (!sb->u.ext_sb.s_firstfreeblock)
sb96fs/ext/freelists.clock_super (sb);
sb97fs/ext/freelists.cefb = (struct ext_free_block *) sb->u.ext_sb.s_firstfreeblock->b_data;
sb100fs/ext/freelists.cmark_buffer_dirty(sb->u.ext_sb.s_firstfreeblock, 1);
sb105fs/ext/freelists.cj = sb->u.ext_sb.s_firstfreeblocknumber;
sb106fs/ext/freelists.csb->u.ext_sb.s_firstfreeblocknumber = efb->next;
sb107fs/ext/freelists.cbrelse (sb->u.ext_sb.s_firstfreeblock);
sb108fs/ext/freelists.cif (!sb->u.ext_sb.s_firstfreeblocknumber) {
sb109fs/ext/freelists.csb->u.ext_sb.s_firstfreeblock = NULL;
sb111fs/ext/freelists.cif (!(sb->u.ext_sb.s_firstfreeblock = bread (sb->s_dev,
sb112fs/ext/freelists.csb->u.ext_sb.s_firstfreeblocknumber,
sb113fs/ext/freelists.csb->s_blocksize)))
sb117fs/ext/freelists.cif (j < sb->u.ext_sb.s_firstdatazone || j > sb->u.ext_sb.s_nzones) {
sb122fs/ext/freelists.csb->u.ext_sb.s_freeblockscount --;
sb123fs/ext/freelists.csb->s_dirt = 1;
sb125fs/ext/freelists.cif (!(bh=getblk(sb->s_dev, j, sb->s_blocksize))) {
sb136fs/ext/freelists.cunlock_super (sb);
sb140fs/ext/freelists.cunsigned long ext_count_free_blocks(struct super_block *sb)
sb147fs/ext/freelists.clock_super (sb);
sb148fs/ext/freelists.cif (!sb->u.ext_sb.s_firstfreeblock)
sb151fs/ext/freelists.cefb = (struct ext_free_block *) sb->u.ext_sb.s_firstfreeblock->b_data;
sb155fs/ext/freelists.cif (!(bh = bread (sb->s_dev, block, sb->s_blocksize))) {
sb167fs/ext/freelists.csb->u.ext_sb.s_freeblockscount, count);
sb168fs/ext/freelists.cunlock_super (sb);
sb171fs/ext/freelists.creturn sb->u.ext_sb.s_freeblockscount;
sb179fs/ext/freelists.cstruct super_block * sb;
sb202fs/ext/freelists.csb = inode->i_sb;
sb206fs/ext/freelists.clock_super (sb);
sb207fs/ext/freelists.cif (ino < 1 || ino > sb->u.ext_sb.s_ninodes) {
sb209fs/ext/freelists.cunlock_super (sb);
sb212fs/ext/freelists.cif (sb->u.ext_sb.s_firstfreeinodeblock)
sb213fs/ext/freelists.cefi = ((struct ext_free_inode *) sb->u.ext_sb.s_firstfreeinodeblock->b_data) +
sb214fs/ext/freelists.c(sb->u.ext_sb.s_firstfreeinodenumber-1)%EXT_INODES_PER_BLOCK;
sb215fs/ext/freelists.cif (!sb->u.ext_sb.s_firstfreeinodeblock || efi->count == 14) {
sb219fs/ext/freelists.cif (sb->u.ext_sb.s_firstfreeinodeblock)
sb220fs/ext/freelists.cbrelse (sb->u.ext_sb.s_firstfreeinodeblock);
sb222fs/ext/freelists.cif (!(bh = bread(dev, block, sb->s_blocksize)))
sb226fs/ext/freelists.cefi->next = sb->u.ext_sb.s_firstfreeinodenumber;
sb228fs/ext/freelists.csb->u.ext_sb.s_firstfreeinodenumber = ino;
sb229fs/ext/freelists.csb->u.ext_sb.s_firstfreeinodeblock = bh;
sb233fs/ext/freelists.csb->u.ext_sb.s_freeinodescount ++;
sb234fs/ext/freelists.csb->s_dirt = 1;
sb235fs/ext/freelists.cmark_buffer_dirty(sb->u.ext_sb.s_firstfreeinodeblock, 1);
sb236fs/ext/freelists.cunlock_super (sb);
sb241fs/ext/freelists.cstruct super_block * sb;
sb249fs/ext/freelists.csb = dir->i_sb;
sb250fs/ext/freelists.cinode->i_sb = sb;
sb251fs/ext/freelists.cinode->i_flags = sb->s_flags;
sb252fs/ext/freelists.cif (!sb->u.ext_sb.s_firstfreeinodeblock)
sb254fs/ext/freelists.clock_super (sb);
sb255fs/ext/freelists.cefi = ((struct ext_free_inode *) sb->u.ext_sb.s_firstfreeinodeblock->b_data) +
sb256fs/ext/freelists.c(sb->u.ext_sb.s_firstfreeinodenumber-1)%EXT_INODES_PER_BLOCK;
sb259fs/ext/freelists.cmark_buffer_dirty(sb->u.ext_sb.s_firstfreeinodeblock, 1);
sb264fs/ext/freelists.cj = sb->u.ext_sb.s_firstfreeinodenumber;
sb265fs/ext/freelists.cif (efi->next > sb->u.ext_sb.s_ninodes) {
sb269fs/ext/freelists.csb->u.ext_sb.s_firstfreeinodenumber = efi->next;
sb271fs/ext/freelists.cbrelse (sb->u.ext_sb.s_firstfreeinodeblock);
sb272fs/ext/freelists.cif (!sb->u.ext_sb.s_firstfreeinodenumber) {
sb273fs/ext/freelists.csb->u.ext_sb.s_firstfreeinodeblock = NULL;
sb275fs/ext/freelists.cif (!(sb->u.ext_sb.s_firstfreeinodeblock =
sb276fs/ext/freelists.cbread(sb->s_dev, block, sb->s_blocksize)))
sb280fs/ext/freelists.csb->u.ext_sb.s_freeinodescount --;
sb281fs/ext/freelists.csb->s_dirt = 1;
sb284fs/ext/freelists.cinode->i_dev = sb->s_dev;
sb296fs/ext/freelists.cunlock_super (sb);
sb300fs/ext/freelists.cunsigned long ext_count_free_inodes(struct super_block *sb)
sb307fs/ext/freelists.clock_super (sb);
sb308fs/ext/freelists.cif (!sb->u.ext_sb.s_firstfreeinodeblock)
sb311fs/ext/freelists.cefi = ((struct ext_free_inode *) sb->u.ext_sb.s_firstfreeinodeblock->b_data) +
sb312fs/ext/freelists.c((sb->u.ext_sb.s_firstfreeinodenumber-1)%EXT_INODES_PER_BLOCK);
sb316fs/ext/freelists.cif (ino < 1 || ino > sb->u.ext_sb.s_ninodes) {
sb318fs/ext/freelists.c(int) sb->u.ext_sb.s_firstfreeinodenumber,ino);
sb322fs/ext/freelists.cif (!(bh = bread (sb->s_dev, block, sb->s_blocksize))) {
sb335fs/ext/freelists.csb->u.ext_sb.s_freeinodescount, count);
sb336fs/ext/freelists.cunlock_super (sb);
sb339fs/ext/freelists.creturn sb->u.ext_sb.s_freeinodescount;
sb35fs/ext/inode.cvoid ext_put_super(struct super_block *sb)
sb38fs/ext/inode.clock_super(sb);
sb39fs/ext/inode.csb->s_dev = 0;
sb40fs/ext/inode.cif (sb->u.ext_sb.s_firstfreeinodeblock)
sb41fs/ext/inode.cbrelse (sb->u.ext_sb.s_firstfreeinodeblock);
sb42fs/ext/inode.cif (sb->u.ext_sb.s_firstfreeblock)
sb43fs/ext/inode.cbrelse (sb->u.ext_sb.s_firstfreeblock);
sb44fs/ext/inode.cunlock_super(sb);
sb138fs/ext/inode.cvoid ext_write_super (struct super_block *sb)
sb143fs/ext/inode.cif (!(bh = bread(sb->s_dev, 1, BLOCK_SIZE))) {
sb148fs/ext/inode.ces->s_firstfreeblock = sb->u.ext_sb.s_firstfreeblocknumber;
sb149fs/ext/inode.ces->s_freeblockscount = sb->u.ext_sb.s_freeblockscount;
sb150fs/ext/inode.ces->s_firstfreeinode = sb->u.ext_sb.s_firstfreeinodenumber;
sb151fs/ext/inode.ces->s_freeinodescount = sb->u.ext_sb.s_freeinodescount;
sb154fs/ext/inode.csb->s_dirt = 0;
sb157fs/ext/inode.cvoid ext_statfs (struct super_block *sb, struct statfs *buf, int bufsiz)
sb163fs/ext/inode.ctmp.f_blocks = sb->u.ext_sb.s_nzones << sb->u.ext_sb.s_log_zone_size;
sb164fs/ext/inode.ctmp.f_bfree = ext_count_free_blocks(sb);
sb166fs/ext/inode.ctmp.f_files = sb->u.ext_sb.s_ninodes;
sb167fs/ext/inode.ctmp.f_ffree = ext_count_free_inodes(sb);
sb38fs/ext2/balloc.cstatic struct ext2_group_desc * get_group_desc (struct super_block * sb,
sb46fs/ext2/balloc.cif (block_group >= sb->u.ext2_sb.s_groups_count)
sb47fs/ext2/balloc.cext2_panic (sb, "get_group_desc",
sb50fs/ext2/balloc.cblock_group, sb->u.ext2_sb.s_groups_count);
sb52fs/ext2/balloc.cgroup_desc = block_group / EXT2_DESC_PER_BLOCK(sb);
sb53fs/ext2/balloc.cdesc = block_group % EXT2_DESC_PER_BLOCK(sb);
sb54fs/ext2/balloc.cif (!sb->u.ext2_sb.s_group_desc[group_desc])
sb55fs/ext2/balloc.cext2_panic (sb, "get_group_desc",
sb60fs/ext2/balloc.csb->u.ext2_sb.s_group_desc[group_desc]->b_data;
sb62fs/ext2/balloc.c*bh = sb->u.ext2_sb.s_group_desc[group_desc];
sb66fs/ext2/balloc.cstatic void read_block_bitmap (struct super_block * sb,
sb73fs/ext2/balloc.cgdp = get_group_desc (sb, block_group, NULL);
sb74fs/ext2/balloc.cbh = bread (sb->s_dev, gdp->bg_block_bitmap, sb->s_blocksize);
sb76fs/ext2/balloc.cext2_panic (sb, "read_block_bitmap",
sb80fs/ext2/balloc.csb->u.ext2_sb.s_block_bitmap_number[bitmap_nr] = block_group;
sb81fs/ext2/balloc.csb->u.ext2_sb.s_block_bitmap[bitmap_nr] = bh;
sb95fs/ext2/balloc.cstatic int load__block_bitmap (struct super_block * sb,
sb102fs/ext2/balloc.cif (block_group >= sb->u.ext2_sb.s_groups_count)
sb103fs/ext2/balloc.cext2_panic (sb, "load_block_bitmap",
sb106fs/ext2/balloc.cblock_group, sb->u.ext2_sb.s_groups_count);
sb108fs/ext2/balloc.cif (sb->u.ext2_sb.s_groups_count <= EXT2_MAX_GROUP_LOADED) {
sb109fs/ext2/balloc.cif (sb->u.ext2_sb.s_block_bitmap[block_group]) {
sb110fs/ext2/balloc.cif (sb->u.ext2_sb.s_block_bitmap_number[block_group] !=
sb112fs/ext2/balloc.cext2_panic (sb, "load_block_bitmap",
sb117fs/ext2/balloc.cread_block_bitmap (sb, block_group, block_group);
sb122fs/ext2/balloc.cfor (i = 0; i < sb->u.ext2_sb.s_loaded_block_bitmaps &&
sb123fs/ext2/balloc.csb->u.ext2_sb.s_block_bitmap_number[i] != block_group; i++)
sb125fs/ext2/balloc.cif (i < sb->u.ext2_sb.s_loaded_block_bitmaps &&
sb126fs/ext2/balloc.csb->u.ext2_sb.s_block_bitmap_number[i] == block_group) {
sb127fs/ext2/balloc.cblock_bitmap_number = sb->u.ext2_sb.s_block_bitmap_number[i];
sb128fs/ext2/balloc.cblock_bitmap = sb->u.ext2_sb.s_block_bitmap[i];
sb130fs/ext2/balloc.csb->u.ext2_sb.s_block_bitmap_number[j] =
sb131fs/ext2/balloc.csb->u.ext2_sb.s_block_bitmap_number[j - 1];
sb132fs/ext2/balloc.csb->u.ext2_sb.s_block_bitmap[j] =
sb133fs/ext2/balloc.csb->u.ext2_sb.s_block_bitmap[j - 1];
sb135fs/ext2/balloc.csb->u.ext2_sb.s_block_bitmap_number[0] = block_bitmap_number;
sb136fs/ext2/balloc.csb->u.ext2_sb.s_block_bitmap[0] = block_bitmap;
sb138fs/ext2/balloc.cif (sb->u.ext2_sb.s_loaded_block_bitmaps < EXT2_MAX_GROUP_LOADED)
sb139fs/ext2/balloc.csb->u.ext2_sb.s_loaded_block_bitmaps++;
sb141fs/ext2/balloc.cbrelse (sb->u.ext2_sb.s_block_bitmap[EXT2_MAX_GROUP_LOADED - 1]);
sb142fs/ext2/balloc.cfor (j = sb->u.ext2_sb.s_loaded_block_bitmaps - 1; j > 0;  j--) {
sb143fs/ext2/balloc.csb->u.ext2_sb.s_block_bitmap_number[j] =
sb144fs/ext2/balloc.csb->u.ext2_sb.s_block_bitmap_number[j - 1];
sb145fs/ext2/balloc.csb->u.ext2_sb.s_block_bitmap[j] =
sb146fs/ext2/balloc.csb->u.ext2_sb.s_block_bitmap[j - 1];
sb148fs/ext2/balloc.cread_block_bitmap (sb, block_group, 0);
sb153fs/ext2/balloc.cstatic inline int load_block_bitmap (struct super_block * sb,
sb156fs/ext2/balloc.cif (sb->u.ext2_sb.s_loaded_block_bitmaps > 0 &&
sb157fs/ext2/balloc.csb->u.ext2_sb.s_block_bitmap_number[0] == block_group)
sb160fs/ext2/balloc.cif (sb->u.ext2_sb.s_groups_count <= EXT2_MAX_GROUP_LOADED && 
sb161fs/ext2/balloc.csb->u.ext2_sb.s_block_bitmap_number[block_group] == block_group &&
sb162fs/ext2/balloc.csb->u.ext2_sb.s_block_bitmap[block_group]) 
sb165fs/ext2/balloc.creturn load__block_bitmap (sb, block_group);
sb177fs/ext2/balloc.cstruct super_block * sb;
sb181fs/ext2/balloc.csb = inode->i_sb;
sb182fs/ext2/balloc.cif (!sb) {
sb186fs/ext2/balloc.clock_super (sb);
sb187fs/ext2/balloc.ces = sb->u.ext2_sb.s_es;
sb190fs/ext2/balloc.cext2_error (sb, "ext2_free_blocks",
sb193fs/ext2/balloc.cunlock_super (sb);
sb200fs/ext2/balloc.cEXT2_BLOCKS_PER_GROUP(sb);
sb201fs/ext2/balloc.cbit = (block - es->s_first_data_block) % EXT2_BLOCKS_PER_GROUP(sb);
sb202fs/ext2/balloc.cif (bit + count > EXT2_BLOCKS_PER_GROUP(sb))
sb203fs/ext2/balloc.cext2_panic (sb, "ext2_free_blocks",
sb207fs/ext2/balloc.cbitmap_nr = load_block_bitmap (sb, block_group);
sb208fs/ext2/balloc.cbh = sb->u.ext2_sb.s_block_bitmap[bitmap_nr];
sb209fs/ext2/balloc.cgdp = get_group_desc (sb, block_group, &bh2);
sb211fs/ext2/balloc.cif (test_opt (sb, CHECK_STRICT) &&
sb215fs/ext2/balloc.csb->u.ext2_sb.s_itb_per_group) ||
sb217fs/ext2/balloc.csb->u.ext2_sb.s_itb_per_group)))
sb218fs/ext2/balloc.cext2_panic (sb, "ext2_free_blocks",
sb225fs/ext2/balloc.cext2_warning (sb, "ext2_free_blocks",
sb229fs/ext2/balloc.cif (sb->dq_op)
sb230fs/ext2/balloc.csb->dq_op->free_block(inode, fs_to_dq_blocks(1, sb->s_blocksize));
sb237fs/ext2/balloc.cmark_buffer_dirty(sb->u.ext2_sb.s_sbh, 1);
sb240fs/ext2/balloc.cif (sb->s_flags & MS_SYNCHRONOUS) {
sb244fs/ext2/balloc.csb->s_dirt = 1;
sb245fs/ext2/balloc.cunlock_super (sb);
sb264fs/ext2/balloc.cstruct super_block * sb;
sb272fs/ext2/balloc.csb = inode->i_sb;
sb273fs/ext2/balloc.cif (!sb) {
sb277fs/ext2/balloc.clock_super (sb);
sb278fs/ext2/balloc.ces = sb->u.ext2_sb.s_es;
sb280fs/ext2/balloc.c(!fsuser() && (sb->u.ext2_sb.s_resuid != current->fsuid) &&
sb281fs/ext2/balloc.c(sb->u.ext2_sb.s_resgid == 0 ||
sb282fs/ext2/balloc.c!in_group_p (sb->u.ext2_sb.s_resgid)))) {
sb283fs/ext2/balloc.cunlock_super (sb);
sb295fs/ext2/balloc.ci = (goal - es->s_first_data_block) / EXT2_BLOCKS_PER_GROUP(sb);
sb296fs/ext2/balloc.cgdp = get_group_desc (sb, i, &bh2);
sb298fs/ext2/balloc.cj = ((goal - es->s_first_data_block) % EXT2_BLOCKS_PER_GROUP(sb));
sb303fs/ext2/balloc.cbitmap_nr = load_block_bitmap (sb, i);
sb304fs/ext2/balloc.cbh = sb->u.ext2_sb.s_block_bitmap[bitmap_nr];
sb342fs/ext2/balloc.cr = memscan(p, 0, (EXT2_BLOCKS_PER_GROUP(sb) - j + 7) >> 3);
sb344fs/ext2/balloc.cif (k < EXT2_BLOCKS_PER_GROUP(sb)) {
sb349fs/ext2/balloc.cEXT2_BLOCKS_PER_GROUP(sb),
sb351fs/ext2/balloc.cif (k < EXT2_BLOCKS_PER_GROUP(sb)) {
sb363fs/ext2/balloc.cfor (k = 0; k < sb->u.ext2_sb.s_groups_count; k++) {
sb365fs/ext2/balloc.cif (i >= sb->u.ext2_sb.s_groups_count)
sb367fs/ext2/balloc.cgdp = get_group_desc (sb, i, &bh2);
sb371fs/ext2/balloc.cif (k >= sb->u.ext2_sb.s_groups_count) {
sb372fs/ext2/balloc.cunlock_super (sb);
sb375fs/ext2/balloc.cbitmap_nr = load_block_bitmap (sb, i);
sb376fs/ext2/balloc.cbh = sb->u.ext2_sb.s_block_bitmap[bitmap_nr];
sb377fs/ext2/balloc.cr = memscan(bh->b_data, 0, EXT2_BLOCKS_PER_GROUP(sb) >> 3);
sb379fs/ext2/balloc.cif (j < EXT2_BLOCKS_PER_GROUP(sb))
sb383fs/ext2/balloc.cEXT2_BLOCKS_PER_GROUP(sb));
sb384fs/ext2/balloc.cif (j >= EXT2_BLOCKS_PER_GROUP(sb)) {
sb385fs/ext2/balloc.cext2_error (sb, "ext2_new_block",
sb387fs/ext2/balloc.cunlock_super (sb);
sb406fs/ext2/balloc.cif (sb->dq_op)
sb407fs/ext2/balloc.cif (sb->dq_op->alloc_block (inode, fs_to_dq_blocks(1, sb->s_blocksize))) {
sb408fs/ext2/balloc.cunlock_super (sb);
sb413fs/ext2/balloc.ctmp = j + i * EXT2_BLOCKS_PER_GROUP(sb) + es->s_first_data_block;
sb415fs/ext2/balloc.cif (test_opt (sb, CHECK_STRICT) &&
sb418fs/ext2/balloc.cin_range (tmp, gdp->bg_inode_table, sb->u.ext2_sb.s_itb_per_group)))
sb419fs/ext2/balloc.cext2_panic (sb, "ext2_new_block",
sb424fs/ext2/balloc.cext2_warning (sb, "ext2_new_block",
sb426fs/ext2/balloc.cif (sb->dq_op)
sb427fs/ext2/balloc.csb->dq_op->free_block(inode, fs_to_dq_blocks(1, sb->s_blocksize));
sb441fs/ext2/balloc.ck < 8 && (j + k) < EXT2_BLOCKS_PER_GROUP(sb); k++) {
sb442fs/ext2/balloc.cif (sb->dq_op)
sb443fs/ext2/balloc.cif (sb->dq_op->alloc_block(inode, fs_to_dq_blocks(1, sb->s_blocksize)))
sb446fs/ext2/balloc.cif (sb->dq_op)
sb447fs/ext2/balloc.csb->dq_op->free_block(inode, fs_to_dq_blocks(1, sb->s_blocksize));
sb462fs/ext2/balloc.cif (sb->s_flags & MS_SYNCHRONOUS) {
sb468fs/ext2/balloc.cext2_error (sb, "ext2_new_block",
sb471fs/ext2/balloc.cunlock_super (sb);
sb474fs/ext2/balloc.cif (!(bh = getblk (sb->s_dev, j, sb->s_blocksize))) {
sb475fs/ext2/balloc.cext2_error (sb, "ext2_new_block", "cannot get block %d", j);
sb476fs/ext2/balloc.cunlock_super (sb);
sb479fs/ext2/balloc.cmemset(bh->b_data, 0, sb->s_blocksize);
sb490fs/ext2/balloc.cmark_buffer_dirty(sb->u.ext2_sb.s_sbh, 1);
sb491fs/ext2/balloc.csb->s_dirt = 1;
sb492fs/ext2/balloc.cunlock_super (sb);
sb497fs/ext2/balloc.cunsigned long ext2_count_free_blocks (struct super_block * sb)
sb506fs/ext2/balloc.clock_super (sb);
sb507fs/ext2/balloc.ces = sb->u.ext2_sb.s_es;
sb511fs/ext2/balloc.cfor (i = 0; i < sb->u.ext2_sb.s_groups_count; i++) {
sb512fs/ext2/balloc.cgdp = get_group_desc (sb, i, NULL);
sb514fs/ext2/balloc.cbitmap_nr = load_block_bitmap (sb, i);
sb515fs/ext2/balloc.cx = ext2_count_free (sb->u.ext2_sb.s_block_bitmap[bitmap_nr],
sb516fs/ext2/balloc.csb->s_blocksize);
sb523fs/ext2/balloc.cunlock_super (sb);
sb526fs/ext2/balloc.creturn sb->u.ext2_sb.s_es->s_free_blocks_count;
sb531fs/ext2/balloc.cstruct super_block * sb,
sb534fs/ext2/balloc.creturn test_bit ((block - sb->u.ext2_sb.s_es->s_first_data_block) %
sb535fs/ext2/balloc.cEXT2_BLOCKS_PER_GROUP(sb), map);
sb538fs/ext2/balloc.cvoid ext2_check_blocks_bitmap (struct super_block * sb)
sb548fs/ext2/balloc.clock_super (sb);
sb549fs/ext2/balloc.ces = sb->u.ext2_sb.s_es;
sb553fs/ext2/balloc.cdesc_blocks = (sb->u.ext2_sb.s_groups_count + EXT2_DESC_PER_BLOCK(sb) - 1) /
sb554fs/ext2/balloc.cEXT2_DESC_PER_BLOCK(sb);
sb555fs/ext2/balloc.cfor (i = 0; i < sb->u.ext2_sb.s_groups_count; i++) {
sb556fs/ext2/balloc.cgdp = get_group_desc (sb, i, NULL);
sb558fs/ext2/balloc.cbitmap_nr = load_block_bitmap (sb, i);
sb559fs/ext2/balloc.cbh = sb->u.ext2_sb.s_block_bitmap[bitmap_nr];
sb562fs/ext2/balloc.cext2_error (sb, "ext2_check_blocks_bitmap",
sb567fs/ext2/balloc.cext2_error (sb, "ext2_check_blocks_bitmap",
sb571fs/ext2/balloc.cif (!block_in_use (gdp->bg_block_bitmap, sb, bh->b_data))
sb572fs/ext2/balloc.cext2_error (sb, "ext2_check_blocks_bitmap",
sb576fs/ext2/balloc.cif (!block_in_use (gdp->bg_inode_bitmap, sb, bh->b_data))
sb577fs/ext2/balloc.cext2_error (sb, "ext2_check_blocks_bitmap",
sb581fs/ext2/balloc.cfor (j = 0; j < sb->u.ext2_sb.s_itb_per_group; j++)
sb582fs/ext2/balloc.cif (!block_in_use (gdp->bg_inode_table + j, sb, bh->b_data))
sb583fs/ext2/balloc.cext2_error (sb, "ext2_check_blocks_bitmap",
sb587fs/ext2/balloc.cx = ext2_count_free (bh, sb->s_blocksize);
sb589fs/ext2/balloc.cext2_error (sb, "ext2_check_blocks_bitmap",
sb596fs/ext2/balloc.cext2_error (sb, "ext2_check_blocks_bitmap",
sb600fs/ext2/balloc.cunlock_super (sb);
sb108fs/ext2/dir.cstruct super_block * sb;
sb113fs/ext2/dir.csb = inode->i_sb;
sb117fs/ext2/dir.coffset = filp->f_pos & (sb->s_blocksize - 1);
sb120fs/ext2/dir.cblk = (filp->f_pos) >> EXT2_BLOCK_SIZE_BITS(sb);
sb123fs/ext2/dir.cext2_error (sb, "ext2_readdir",
sb126fs/ext2/dir.cfilp->f_pos += sb->s_blocksize - offset;
sb134fs/ext2/dir.cfor (i = 16 >> (EXT2_BLOCK_SIZE_BITS(sb) - 9), num = 0;
sb155fs/ext2/dir.cfor (i = 0; i < sb->s_blocksize && i < offset; ) {
sb169fs/ext2/dir.cfilp->f_pos = (filp->f_pos & ~(sb->s_blocksize - 1))
sb175fs/ext2/dir.c&& offset < sb->s_blocksize) {
sb181fs/ext2/dir.cfilp->f_pos = (filp->f_pos & (sb->s_blocksize - 1))
sb182fs/ext2/dir.c+ sb->s_blocksize;
sb93fs/ext2/file.cstruct super_block * sb;
sb102fs/ext2/file.csb = inode->i_sb;
sb103fs/ext2/file.cif (sb->s_flags & MS_RDONLY)
sb110fs/ext2/file.cext2_warning (sb, "ext2_file_write", "mode = %07o",
sb127fs/ext2/file.cblock = pos2 >> EXT2_BLOCK_SIZE_BITS(sb);
sb128fs/ext2/file.coffset = pos2 & (sb->s_blocksize - 1);
sb129fs/ext2/file.cc = sb->s_blocksize - offset;
sb146fs/ext2/file.cif (c != sb->s_blocksize && !buffer_uptodate(bh)) {
sb182fs/ext2/file.cc = sb->s_blocksize;
sb37fs/ext2/ialloc.cstatic struct ext2_group_desc * get_group_desc (struct super_block * sb,
sb45fs/ext2/ialloc.cif (block_group >= sb->u.ext2_sb.s_groups_count)
sb46fs/ext2/ialloc.cext2_panic (sb, "get_group_desc",
sb49fs/ext2/ialloc.cblock_group, sb->u.ext2_sb.s_groups_count);
sb51fs/ext2/ialloc.cgroup_desc = block_group / EXT2_DESC_PER_BLOCK(sb);
sb52fs/ext2/ialloc.cdesc = block_group % EXT2_DESC_PER_BLOCK(sb);
sb53fs/ext2/ialloc.cif (!sb->u.ext2_sb.s_group_desc[group_desc])
sb54fs/ext2/ialloc.cext2_panic (sb, "get_group_desc",
sb59fs/ext2/ialloc.csb->u.ext2_sb.s_group_desc[group_desc]->b_data;
sb61fs/ext2/ialloc.c*bh = sb->u.ext2_sb.s_group_desc[group_desc];
sb65fs/ext2/ialloc.cstatic void read_inode_bitmap (struct super_block * sb,
sb72fs/ext2/ialloc.cgdp = get_group_desc (sb, block_group, NULL);
sb73fs/ext2/ialloc.cbh = bread (sb->s_dev, gdp->bg_inode_bitmap, sb->s_blocksize);
sb75fs/ext2/ialloc.cext2_panic (sb, "read_inode_bitmap",
sb79fs/ext2/ialloc.csb->u.ext2_sb.s_inode_bitmap_number[bitmap_nr] = block_group;
sb80fs/ext2/ialloc.csb->u.ext2_sb.s_inode_bitmap[bitmap_nr] = bh;
sb94fs/ext2/ialloc.cstatic int load_inode_bitmap (struct super_block * sb,
sb101fs/ext2/ialloc.cif (block_group >= sb->u.ext2_sb.s_groups_count)
sb102fs/ext2/ialloc.cext2_panic (sb, "load_inode_bitmap",
sb105fs/ext2/ialloc.cblock_group, sb->u.ext2_sb.s_groups_count);
sb106fs/ext2/ialloc.cif (sb->u.ext2_sb.s_loaded_inode_bitmaps > 0 &&
sb107fs/ext2/ialloc.csb->u.ext2_sb.s_inode_bitmap_number[0] == block_group)
sb109fs/ext2/ialloc.cif (sb->u.ext2_sb.s_groups_count <= EXT2_MAX_GROUP_LOADED) {
sb110fs/ext2/ialloc.cif (sb->u.ext2_sb.s_inode_bitmap[block_group]) {
sb111fs/ext2/ialloc.cif (sb->u.ext2_sb.s_inode_bitmap_number[block_group] != block_group)
sb112fs/ext2/ialloc.cext2_panic (sb, "load_inode_bitmap",
sb117fs/ext2/ialloc.cread_inode_bitmap (sb, block_group, block_group);
sb122fs/ext2/ialloc.cfor (i = 0; i < sb->u.ext2_sb.s_loaded_inode_bitmaps &&
sb123fs/ext2/ialloc.csb->u.ext2_sb.s_inode_bitmap_number[i] != block_group;
sb126fs/ext2/ialloc.cif (i < sb->u.ext2_sb.s_loaded_inode_bitmaps &&
sb127fs/ext2/ialloc.csb->u.ext2_sb.s_inode_bitmap_number[i] == block_group) {
sb128fs/ext2/ialloc.cinode_bitmap_number = sb->u.ext2_sb.s_inode_bitmap_number[i];
sb129fs/ext2/ialloc.cinode_bitmap = sb->u.ext2_sb.s_inode_bitmap[i];
sb131fs/ext2/ialloc.csb->u.ext2_sb.s_inode_bitmap_number[j] =
sb132fs/ext2/ialloc.csb->u.ext2_sb.s_inode_bitmap_number[j - 1];
sb133fs/ext2/ialloc.csb->u.ext2_sb.s_inode_bitmap[j] =
sb134fs/ext2/ialloc.csb->u.ext2_sb.s_inode_bitmap[j - 1];
sb136fs/ext2/ialloc.csb->u.ext2_sb.s_inode_bitmap_number[0] = inode_bitmap_number;
sb137fs/ext2/ialloc.csb->u.ext2_sb.s_inode_bitmap[0] = inode_bitmap;
sb139fs/ext2/ialloc.cif (sb->u.ext2_sb.s_loaded_inode_bitmaps < EXT2_MAX_GROUP_LOADED)
sb140fs/ext2/ialloc.csb->u.ext2_sb.s_loaded_inode_bitmaps++;
sb142fs/ext2/ialloc.cbrelse (sb->u.ext2_sb.s_inode_bitmap[EXT2_MAX_GROUP_LOADED - 1]);
sb143fs/ext2/ialloc.cfor (j = sb->u.ext2_sb.s_loaded_inode_bitmaps - 1; j > 0; j--) {
sb144fs/ext2/ialloc.csb->u.ext2_sb.s_inode_bitmap_number[j] =
sb145fs/ext2/ialloc.csb->u.ext2_sb.s_inode_bitmap_number[j - 1];
sb146fs/ext2/ialloc.csb->u.ext2_sb.s_inode_bitmap[j] =
sb147fs/ext2/ialloc.csb->u.ext2_sb.s_inode_bitmap[j - 1];
sb149fs/ext2/ialloc.cread_inode_bitmap (sb, block_group, 0);
sb191fs/ext2/ialloc.cstruct super_block * sb;
sb223fs/ext2/ialloc.csb = inode->i_sb;
sb224fs/ext2/ialloc.clock_super (sb);
sb226fs/ext2/ialloc.cinode->i_ino > sb->u.ext2_sb.s_es->s_inodes_count) {
sb227fs/ext2/ialloc.cext2_error (sb, "free_inode",
sb229fs/ext2/ialloc.cunlock_super (sb);
sb232fs/ext2/ialloc.ces = sb->u.ext2_sb.s_es;
sb233fs/ext2/ialloc.cblock_group = (inode->i_ino - 1) / EXT2_INODES_PER_GROUP(sb);
sb234fs/ext2/ialloc.cbit = (inode->i_ino - 1) % EXT2_INODES_PER_GROUP(sb);
sb235fs/ext2/ialloc.cbitmap_nr = load_inode_bitmap (sb, block_group);
sb236fs/ext2/ialloc.cbh = sb->u.ext2_sb.s_inode_bitmap[bitmap_nr];
sb238fs/ext2/ialloc.cext2_warning (sb, "ext2_free_inode",
sb241fs/ext2/ialloc.cgdp = get_group_desc (sb, block_group, &bh2);
sb247fs/ext2/ialloc.cmark_buffer_dirty(sb->u.ext2_sb.s_sbh, 1);
sb252fs/ext2/ialloc.cif (sb->s_flags & MS_SYNCHRONOUS) {
sb256fs/ext2/ialloc.cif (sb->dq_op)
sb257fs/ext2/ialloc.csb->dq_op->free_inode (inode, 1);
sb258fs/ext2/ialloc.csb->s_dirt = 1;
sb260fs/ext2/ialloc.cunlock_super (sb);
sb310fs/ext2/ialloc.cstruct super_block * sb;
sb322fs/ext2/ialloc.csb = dir->i_sb;
sb323fs/ext2/ialloc.cinode->i_sb = sb;
sb324fs/ext2/ialloc.cinode->i_flags = sb->s_flags;
sb325fs/ext2/ialloc.clock_super (sb);
sb326fs/ext2/ialloc.ces = sb->u.ext2_sb.s_es;
sb333fs/ext2/ialloc.csb->u.ext2_sb.s_groups_count;
sb348fs/ext2/ialloc.cfor (j = 0; j < sb->u.ext2_sb.s_groups_count; j++) {
sb349fs/ext2/ialloc.ctmp = get_group_desc (sb, j, &bh2);
sb368fs/ext2/ialloc.ctmp = get_group_desc (sb, i, &bh2);
sb377fs/ext2/ialloc.cfor (j = 1; j < sb->u.ext2_sb.s_groups_count; j <<= 1) {
sb379fs/ext2/ialloc.cif (i >= sb->u.ext2_sb.s_groups_count)
sb380fs/ext2/ialloc.ci -= sb->u.ext2_sb.s_groups_count;
sb381fs/ext2/ialloc.ctmp = get_group_desc (sb, i, &bh2);
sb393fs/ext2/ialloc.cfor (j = 2; j < sb->u.ext2_sb.s_groups_count; j++) {
sb394fs/ext2/ialloc.cif (++i >= sb->u.ext2_sb.s_groups_count)
sb396fs/ext2/ialloc.ctmp = get_group_desc (sb, i, &bh2);
sb406fs/ext2/ialloc.cunlock_super (sb);
sb410fs/ext2/ialloc.cbitmap_nr = load_inode_bitmap (sb, i);
sb411fs/ext2/ialloc.cbh = sb->u.ext2_sb.s_inode_bitmap[bitmap_nr];
sb413fs/ext2/ialloc.cEXT2_INODES_PER_GROUP(sb))) <
sb414fs/ext2/ialloc.cEXT2_INODES_PER_GROUP(sb)) {
sb416fs/ext2/ialloc.cext2_warning (sb, "ext2_new_inode",
sb421fs/ext2/ialloc.cif (sb->s_flags & MS_SYNCHRONOUS) {
sb427fs/ext2/ialloc.cext2_error (sb, "ext2_new_inode",
sb430fs/ext2/ialloc.cunlock_super (sb);
sb436fs/ext2/ialloc.cj += i * EXT2_INODES_PER_GROUP(sb) + 1;
sb438fs/ext2/ialloc.cext2_error (sb, "ext2_new_inode",
sb441fs/ext2/ialloc.cunlock_super (sb);
sb450fs/ext2/ialloc.cmark_buffer_dirty(sb->u.ext2_sb.s_sbh, 1);
sb451fs/ext2/ialloc.csb->s_dirt = 1;
sb453fs/ext2/ialloc.cinode->i_sb = sb;
sb456fs/ext2/ialloc.cinode->i_dev = sb->s_dev;
sb458fs/ext2/ialloc.cif (test_opt (sb, GRPID))
sb487fs/ext2/ialloc.cunlock_super (sb);
sb488fs/ext2/ialloc.cif (sb->dq_op) {
sb489fs/ext2/ialloc.csb->dq_op->initialize (inode, -1);
sb490fs/ext2/ialloc.cif (sb->dq_op->alloc_inode (inode, 1)) {
sb491fs/ext2/ialloc.csb->dq_op->drop (inode);
sb505fs/ext2/ialloc.cunsigned long ext2_count_free_inodes (struct super_block * sb)
sb514fs/ext2/ialloc.clock_super (sb);
sb515fs/ext2/ialloc.ces = sb->u.ext2_sb.s_es;
sb519fs/ext2/ialloc.cfor (i = 0; i < sb->u.ext2_sb.s_groups_count; i++) {
sb520fs/ext2/ialloc.cgdp = get_group_desc (sb, i, NULL);
sb522fs/ext2/ialloc.cbitmap_nr = load_inode_bitmap (sb, i);
sb523fs/ext2/ialloc.cx = ext2_count_free (sb->u.ext2_sb.s_inode_bitmap[bitmap_nr],
sb524fs/ext2/ialloc.cEXT2_INODES_PER_GROUP(sb) / 8);
sb531fs/ext2/ialloc.cunlock_super (sb);
sb534fs/ext2/ialloc.creturn sb->u.ext2_sb.s_es->s_free_inodes_count;
sb538fs/ext2/ialloc.cvoid ext2_check_inodes_bitmap (struct super_block * sb)
sb546fs/ext2/ialloc.clock_super (sb);
sb547fs/ext2/ialloc.ces = sb->u.ext2_sb.s_es;
sb551fs/ext2/ialloc.cfor (i = 0; i < sb->u.ext2_sb.s_groups_count; i++) {
sb552fs/ext2/ialloc.cgdp = get_group_desc (sb, i, NULL);
sb554fs/ext2/ialloc.cbitmap_nr = load_inode_bitmap (sb, i);
sb555fs/ext2/ialloc.cx = ext2_count_free (sb->u.ext2_sb.s_inode_bitmap[bitmap_nr],
sb556fs/ext2/ialloc.cEXT2_INODES_PER_GROUP(sb) / 8);
sb558fs/ext2/ialloc.cext2_error (sb, "ext2_check_inodes_bitmap",
sb565fs/ext2/ialloc.cext2_error (sb, "ext2_check_inodes_bitmap",
sb569fs/ext2/ialloc.cunlock_super (sb);
sb72fs/ext2/namei.cstruct super_block * sb;
sb81fs/ext2/namei.csb = dir->i_sb;
sb96fs/ext2/namei.cif ((block << EXT2_BLOCK_SIZE_BITS (sb)) >= dir->i_size)
sb115fs/ext2/namei.cext2_error (sb, "ext2_find_entry",
sb118fs/ext2/namei.coffset += sb->s_blocksize;
sb130fs/ext2/namei.cdlimit = bh->b_data + sb->s_blocksize;
sb149fs/ext2/namei.cif (((block + NAMEI_RA_SIZE) << EXT2_BLOCK_SIZE_BITS (sb)) >=
sb228fs/ext2/namei.cstruct super_block * sb;
sb234fs/ext2/namei.csb = dir->i_sb;
sb260fs/ext2/namei.cif ((char *)de >= sb->s_blocksize + bh->b_data) {
sb263fs/ext2/namei.cbh = ext2_bread (dir, offset >> EXT2_BLOCK_SIZE_BITS(sb), 1, err);
sb276fs/ext2/namei.cde->rec_len = sb->s_blocksize;
sb277fs/ext2/namei.cdir->i_size = offset + sb->s_blocksize;
sb556fs/ext2/namei.cstruct super_block * sb;
sb559fs/ext2/namei.csb = inode->i_sb;
sb579fs/ext2/namei.cif ((void *) de >= (void *) (bh->b_data + sb->s_blocksize)) {
sb581fs/ext2/namei.cbh = ext2_bread (inode, offset >> EXT2_BLOCK_SIZE_BITS(sb), 1, &err);
sb583fs/ext2/namei.cext2_error (sb, "empty_dir",
sb586fs/ext2/namei.coffset += sb->s_blocksize;
sb35fs/ext2/super.cvoid ext2_error (struct super_block * sb, const char * function,
sb40fs/ext2/super.cif (!(sb->s_flags & MS_RDONLY)) {
sb41fs/ext2/super.csb->u.ext2_sb.s_mount_state |= EXT2_ERROR_FS;
sb42fs/ext2/super.csb->u.ext2_sb.s_es->s_state |= EXT2_ERROR_FS;
sb43fs/ext2/super.cmark_buffer_dirty(sb->u.ext2_sb.s_sbh, 1);
sb44fs/ext2/super.csb->s_dirt = 1;
sb49fs/ext2/super.cif (test_opt (sb, ERRORS_PANIC) ||
sb50fs/ext2/super.c(sb->u.ext2_sb.s_es->s_errors == EXT2_ERRORS_PANIC &&
sb51fs/ext2/super.c!test_opt (sb, ERRORS_CONT) && !test_opt (sb, ERRORS_RO)))
sb53fs/ext2/super.ckdevname(sb->s_dev), function, error_buf);
sb55fs/ext2/super.ckdevname(sb->s_dev), function, error_buf);
sb56fs/ext2/super.cif (test_opt (sb, ERRORS_RO) ||
sb57fs/ext2/super.c(sb->u.ext2_sb.s_es->s_errors == EXT2_ERRORS_RO &&
sb58fs/ext2/super.c!test_opt (sb, ERRORS_CONT) && !test_opt (sb, ERRORS_PANIC))) {
sb60fs/ext2/super.csb->s_flags |= MS_RDONLY;
sb64fs/ext2/super.cNORET_TYPE void ext2_panic (struct super_block * sb, const char * function,
sb69fs/ext2/super.cif (!(sb->s_flags & MS_RDONLY)) {
sb70fs/ext2/super.csb->u.ext2_sb.s_mount_state |= EXT2_ERROR_FS;
sb71fs/ext2/super.csb->u.ext2_sb.s_es->s_state |= EXT2_ERROR_FS;
sb72fs/ext2/super.cmark_buffer_dirty(sb->u.ext2_sb.s_sbh, 1);
sb73fs/ext2/super.csb->s_dirt = 1;
sb79fs/ext2/super.cif (sb->s_lock)
sb80fs/ext2/super.csb->s_lock=0;
sb81fs/ext2/super.csb->s_flags |= MS_RDONLY;
sb83fs/ext2/super.ckdevname(sb->s_dev), function, error_buf);
sb86fs/ext2/super.cvoid ext2_warning (struct super_block * sb, const char * function,
sb95fs/ext2/super.ckdevname(sb->s_dev), function, error_buf);
sb98fs/ext2/super.cvoid ext2_put_super (struct super_block * sb)
sb103fs/ext2/super.clock_super (sb);
sb104fs/ext2/super.cif (!(sb->s_flags & MS_RDONLY)) {
sb105fs/ext2/super.csb->u.ext2_sb.s_es->s_state = sb->u.ext2_sb.s_mount_state;
sb106fs/ext2/super.cmark_buffer_dirty(sb->u.ext2_sb.s_sbh, 1);
sb108fs/ext2/super.csb->s_dev = 0;
sb109fs/ext2/super.cdb_count = sb->u.ext2_sb.s_db_per_group;
sb111fs/ext2/super.cif (sb->u.ext2_sb.s_group_desc[i])
sb112fs/ext2/super.cbrelse (sb->u.ext2_sb.s_group_desc[i]);
sb113fs/ext2/super.ckfree_s (sb->u.ext2_sb.s_group_desc,
sb116fs/ext2/super.cif (sb->u.ext2_sb.s_inode_bitmap[i])
sb117fs/ext2/super.cbrelse (sb->u.ext2_sb.s_inode_bitmap[i]);
sb119fs/ext2/super.cif (sb->u.ext2_sb.s_block_bitmap[i])
sb120fs/ext2/super.cbrelse (sb->u.ext2_sb.s_block_bitmap[i]);
sb121fs/ext2/super.cbrelse (sb->u.ext2_sb.s_sbh);
sb122fs/ext2/super.cunlock_super (sb);
sb270fs/ext2/super.cstatic void ext2_setup_super (struct super_block * sb,
sb276fs/ext2/super.csb->s_flags |= MS_RDONLY;
sb278fs/ext2/super.cif (!(sb->s_flags & MS_RDONLY)) {
sb279fs/ext2/super.cif (!(sb->u.ext2_sb.s_mount_state & EXT2_VALID_FS))
sb282fs/ext2/super.celse if ((sb->u.ext2_sb.s_mount_state & EXT2_ERROR_FS))
sb298fs/ext2/super.cmark_buffer_dirty(sb->u.ext2_sb.s_sbh, 1);
sb299fs/ext2/super.csb->s_dirt = 1;
sb300fs/ext2/super.cif (test_opt (sb, DEBUG))
sb303fs/ext2/super.cEXT2FS_VERSION, EXT2FS_DATE, sb->s_blocksize,
sb304fs/ext2/super.csb->u.ext2_sb.s_frag_size,
sb305fs/ext2/super.csb->u.ext2_sb.s_groups_count,
sb306fs/ext2/super.cEXT2_BLOCKS_PER_GROUP(sb),
sb307fs/ext2/super.cEXT2_INODES_PER_GROUP(sb),
sb308fs/ext2/super.csb->u.ext2_sb.s_mount_opt);
sb309fs/ext2/super.cif (test_opt (sb, CHECK)) {
sb310fs/ext2/super.cext2_check_blocks_bitmap (sb);
sb311fs/ext2/super.cext2_check_inodes_bitmap (sb);
sb316fs/ext2/super.cstatic int ext2_check_descriptors (struct super_block * sb)
sb320fs/ext2/super.cunsigned long block = sb->u.ext2_sb.s_es->s_first_data_block;
sb325fs/ext2/super.cfor (i = 0; i < sb->u.ext2_sb.s_groups_count; i++)
sb327fs/ext2/super.cif ((i % EXT2_DESC_PER_BLOCK(sb)) == 0)
sb328fs/ext2/super.cgdp = (struct ext2_group_desc *) sb->u.ext2_sb.s_group_desc[desc_block++]->b_data;
sb330fs/ext2/super.cgdp->bg_block_bitmap >= block + EXT2_BLOCKS_PER_GROUP(sb))
sb332fs/ext2/super.cext2_error (sb, "ext2_check_descriptors",
sb339fs/ext2/super.cgdp->bg_inode_bitmap >= block + EXT2_BLOCKS_PER_GROUP(sb))
sb341fs/ext2/super.cext2_error (sb, "ext2_check_descriptors",
sb348fs/ext2/super.cgdp->bg_inode_table + sb->u.ext2_sb.s_itb_per_group >=
sb349fs/ext2/super.cblock + EXT2_BLOCKS_PER_GROUP(sb))
sb351fs/ext2/super.cext2_error (sb, "ext2_check_descriptors",
sb357fs/ext2/super.cblock += EXT2_BLOCKS_PER_GROUP(sb);
sb365fs/ext2/super.cstruct super_block * ext2_read_super (struct super_block * sb, void * data,
sb374fs/ext2/super.ckdev_t dev = sb->s_dev;
sb378fs/ext2/super.cset_opt (sb->u.ext2_sb.s_mount_opt, CHECK_NORMAL);
sb380fs/ext2/super.c&sb->u.ext2_sb.s_mount_opt)) {
sb381fs/ext2/super.csb->s_dev = 0;
sb386fs/ext2/super.clock_super (sb);
sb389fs/ext2/super.csb->s_dev = 0;
sb390fs/ext2/super.cunlock_super (sb);
sb400fs/ext2/super.csb->u.ext2_sb.s_es = es;
sb401fs/ext2/super.csb->s_magic = es->s_magic;
sb402fs/ext2/super.cif (sb->s_magic != EXT2_SUPER_MAGIC) {
sb403fs/ext2/super.csb->s_dev = 0;
sb404fs/ext2/super.cunlock_super (sb);
sb411fs/ext2/super.csb->s_blocksize_bits = sb->u.ext2_sb.s_es->s_log_block_size + 10;
sb412fs/ext2/super.csb->s_blocksize = 1 << sb->s_blocksize_bits;
sb413fs/ext2/super.cif (sb->s_blocksize != BLOCK_SIZE && 
sb414fs/ext2/super.c(sb->s_blocksize == 1024 || sb->s_blocksize == 2048 ||  
sb415fs/ext2/super.csb->s_blocksize == 4096)) {
sb419fs/ext2/super.cset_blocksize (dev, sb->s_blocksize);
sb420fs/ext2/super.clogic_sb_block = (sb_block*BLOCK_SIZE) / sb->s_blocksize;
sb421fs/ext2/super.coffset = (sb_block*BLOCK_SIZE) % sb->s_blocksize;
sb422fs/ext2/super.cbh = bread (dev, logic_sb_block, sb->s_blocksize);
sb428fs/ext2/super.csb->u.ext2_sb.s_es = es;
sb430fs/ext2/super.csb->s_dev = 0;
sb431fs/ext2/super.cunlock_super (sb);
sb438fs/ext2/super.csb->u.ext2_sb.s_frag_size = EXT2_MIN_FRAG_SIZE <<
sb440fs/ext2/super.cif (sb->u.ext2_sb.s_frag_size)
sb441fs/ext2/super.csb->u.ext2_sb.s_frags_per_block = sb->s_blocksize /
sb442fs/ext2/super.csb->u.ext2_sb.s_frag_size;
sb444fs/ext2/super.csb->s_magic = 0;
sb445fs/ext2/super.csb->u.ext2_sb.s_blocks_per_group = es->s_blocks_per_group;
sb446fs/ext2/super.csb->u.ext2_sb.s_frags_per_group = es->s_frags_per_group;
sb447fs/ext2/super.csb->u.ext2_sb.s_inodes_per_group = es->s_inodes_per_group;
sb448fs/ext2/super.csb->u.ext2_sb.s_inodes_per_block = sb->s_blocksize /
sb450fs/ext2/super.csb->u.ext2_sb.s_itb_per_group = sb->u.ext2_sb.s_inodes_per_group /
sb451fs/ext2/super.csb->u.ext2_sb.s_inodes_per_block;
sb452fs/ext2/super.csb->u.ext2_sb.s_desc_per_block = sb->s_blocksize /
sb454fs/ext2/super.csb->u.ext2_sb.s_sbh = bh;
sb456fs/ext2/super.csb->u.ext2_sb.s_resuid = resuid;
sb458fs/ext2/super.csb->u.ext2_sb.s_resuid = es->s_def_resuid;
sb460fs/ext2/super.csb->u.ext2_sb.s_resgid = resgid;
sb462fs/ext2/super.csb->u.ext2_sb.s_resgid = es->s_def_resgid;
sb463fs/ext2/super.csb->u.ext2_sb.s_mount_state = es->s_state;
sb464fs/ext2/super.csb->u.ext2_sb.s_rename_lock = 0;
sb465fs/ext2/super.csb->u.ext2_sb.s_rename_wait = NULL;
sb466fs/ext2/super.csb->u.ext2_sb.s_addr_per_block_bits =
sb467fs/ext2/super.clog2 (EXT2_ADDR_PER_BLOCK(sb));
sb468fs/ext2/super.csb->u.ext2_sb.s_inodes_per_block_bits =
sb469fs/ext2/super.clog2 (EXT2_INODES_PER_BLOCK(sb));
sb470fs/ext2/super.csb->u.ext2_sb.s_desc_per_block_bits =
sb471fs/ext2/super.clog2 (EXT2_DESC_PER_BLOCK(sb));
sb472fs/ext2/super.cif (sb->s_magic != EXT2_SUPER_MAGIC) {
sb473fs/ext2/super.csb->s_dev = 0;
sb474fs/ext2/super.cunlock_super (sb);
sb483fs/ext2/super.cif (sb->s_blocksize != bh->b_size) {
sb484fs/ext2/super.csb->s_dev = 0;
sb485fs/ext2/super.cunlock_super (sb);
sb494fs/ext2/super.cif (sb->s_blocksize != sb->u.ext2_sb.s_frag_size) {
sb495fs/ext2/super.csb->s_dev = 0;
sb496fs/ext2/super.cunlock_super (sb);
sb499fs/ext2/super.csb->u.ext2_sb.s_frag_size, sb->s_blocksize);
sb504fs/ext2/super.cif (sb->u.ext2_sb.s_blocks_per_group > sb->s_blocksize * 8) {
sb505fs/ext2/super.csb->s_dev = 0;
sb506fs/ext2/super.cunlock_super (sb);
sb509fs/ext2/super.csb->u.ext2_sb.s_blocks_per_group);
sb513fs/ext2/super.cif (sb->u.ext2_sb.s_frags_per_group > sb->s_blocksize * 8) {
sb514fs/ext2/super.csb->s_dev = 0;
sb515fs/ext2/super.cunlock_super (sb);
sb518fs/ext2/super.csb->u.ext2_sb.s_frags_per_group);
sb522fs/ext2/super.cif (sb->u.ext2_sb.s_inodes_per_group > sb->s_blocksize * 8) {
sb523fs/ext2/super.csb->s_dev = 0;
sb524fs/ext2/super.cunlock_super (sb);
sb527fs/ext2/super.csb->u.ext2_sb.s_inodes_per_group);
sb532fs/ext2/super.csb->u.ext2_sb.s_groups_count = (es->s_blocks_count -
sb534fs/ext2/super.cEXT2_BLOCKS_PER_GROUP(sb) - 1) /
sb535fs/ext2/super.cEXT2_BLOCKS_PER_GROUP(sb);
sb536fs/ext2/super.cdb_count = (sb->u.ext2_sb.s_groups_count + EXT2_DESC_PER_BLOCK(sb) - 1) /
sb537fs/ext2/super.cEXT2_DESC_PER_BLOCK(sb);
sb538fs/ext2/super.csb->u.ext2_sb.s_group_desc = kmalloc (db_count * sizeof (struct buffer_head *), GFP_KERNEL);
sb539fs/ext2/super.cif (sb->u.ext2_sb.s_group_desc == NULL) {
sb540fs/ext2/super.csb->s_dev = 0;
sb541fs/ext2/super.cunlock_super (sb);
sb548fs/ext2/super.csb->u.ext2_sb.s_group_desc[i] = bread (dev, logic_sb_block + i + 1,
sb549fs/ext2/super.csb->s_blocksize);
sb550fs/ext2/super.cif (!sb->u.ext2_sb.s_group_desc[i]) {
sb551fs/ext2/super.csb->s_dev = 0;
sb552fs/ext2/super.cunlock_super (sb);
sb554fs/ext2/super.cbrelse (sb->u.ext2_sb.s_group_desc[j]);
sb555fs/ext2/super.ckfree_s (sb->u.ext2_sb.s_group_desc,
sb563fs/ext2/super.cif (!ext2_check_descriptors (sb)) {
sb564fs/ext2/super.csb->s_dev = 0;
sb565fs/ext2/super.cunlock_super (sb);
sb567fs/ext2/super.cbrelse (sb->u.ext2_sb.s_group_desc[j]);
sb568fs/ext2/super.ckfree_s (sb->u.ext2_sb.s_group_desc,
sb576fs/ext2/super.csb->u.ext2_sb.s_inode_bitmap_number[i] = 0;
sb577fs/ext2/super.csb->u.ext2_sb.s_inode_bitmap[i] = NULL;
sb578fs/ext2/super.csb->u.ext2_sb.s_block_bitmap_number[i] = 0;
sb579fs/ext2/super.csb->u.ext2_sb.s_block_bitmap[i] = NULL;
sb581fs/ext2/super.csb->u.ext2_sb.s_loaded_inode_bitmaps = 0;
sb582fs/ext2/super.csb->u.ext2_sb.s_loaded_block_bitmaps = 0;
sb583fs/ext2/super.csb->u.ext2_sb.s_db_per_group = db_count;
sb584fs/ext2/super.cunlock_super (sb);
sb588fs/ext2/super.csb->s_dev = dev;
sb589fs/ext2/super.csb->s_op = &ext2_sops;
sb590fs/ext2/super.cif (!(sb->s_mounted = iget (sb, EXT2_ROOT_INO))) {
sb591fs/ext2/super.csb->s_dev = 0;
sb593fs/ext2/super.cif (sb->u.ext2_sb.s_group_desc[i])
sb594fs/ext2/super.cbrelse (sb->u.ext2_sb.s_group_desc[i]);
sb595fs/ext2/super.ckfree_s (sb->u.ext2_sb.s_group_desc,
sb602fs/ext2/super.cext2_setup_super (sb, es);
sb603fs/ext2/super.creturn sb;
sb606fs/ext2/super.cstatic void ext2_commit_super (struct super_block * sb,
sb610fs/ext2/super.cmark_buffer_dirty(sb->u.ext2_sb.s_sbh, 1);
sb611fs/ext2/super.csb->s_dirt = 0;
sb625fs/ext2/super.cvoid ext2_write_super (struct super_block * sb)
sb629fs/ext2/super.cif (!(sb->s_flags & MS_RDONLY)) {
sb630fs/ext2/super.ces = sb->u.ext2_sb.s_es;
sb638fs/ext2/super.cext2_commit_super (sb, es);
sb640fs/ext2/super.csb->s_dirt = 0;
sb643fs/ext2/super.cint ext2_remount (struct super_block * sb, int * flags, char * data)
sb646fs/ext2/super.cunsigned short resuid = sb->u.ext2_sb.s_resuid;
sb647fs/ext2/super.cunsigned short resgid = sb->u.ext2_sb.s_resgid;
sb659fs/ext2/super.csb->u.ext2_sb.s_mount_opt = new_mount_opt;
sb660fs/ext2/super.csb->u.ext2_sb.s_resuid = resuid;
sb661fs/ext2/super.csb->u.ext2_sb.s_resgid = resgid;
sb662fs/ext2/super.ces = sb->u.ext2_sb.s_es;
sb663fs/ext2/super.cif ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
sb667fs/ext2/super.c!(sb->u.ext2_sb.s_mount_state & EXT2_VALID_FS))
sb673fs/ext2/super.ces->s_state = sb->u.ext2_sb.s_mount_state;
sb675fs/ext2/super.cmark_buffer_dirty(sb->u.ext2_sb.s_sbh, 1);
sb676fs/ext2/super.csb->s_dirt = 1;
sb677fs/ext2/super.cext2_commit_super (sb, es);
sb685fs/ext2/super.csb->u.ext2_sb.s_mount_state = es->s_state;
sb686fs/ext2/super.csb->s_flags &= ~MS_RDONLY;
sb687fs/ext2/super.cext2_setup_super (sb, es);
sb718fs/ext2/super.cvoid ext2_statfs (struct super_block * sb, struct statfs * buf, int bufsiz)
sb724fs/ext2/super.cif (test_opt (sb, MINIX_DF))
sb731fs/ext2/super.csb->u.ext2_sb.s_db_per_group /* descriptors */ +
sb734fs/ext2/super.csb->u.ext2_sb.s_itb_per_group /* inode table */;
sb735fs/ext2/super.coverhead = sb->u.ext2_sb.s_es->s_first_data_block +
sb736fs/ext2/super.csb->u.ext2_sb.s_groups_count * overhead_per_group;
sb740fs/ext2/super.ctmp.f_bsize = sb->s_blocksize;
sb741fs/ext2/super.ctmp.f_blocks = sb->u.ext2_sb.s_es->s_blocks_count - overhead;
sb742fs/ext2/super.ctmp.f_bfree = ext2_count_free_blocks (sb);
sb743fs/ext2/super.ctmp.f_bavail = tmp.f_bfree - sb->u.ext2_sb.s_es->s_r_blocks_count;
sb744fs/ext2/super.cif (tmp.f_bfree < sb->u.ext2_sb.s_es->s_r_blocks_count)
sb746fs/ext2/super.ctmp.f_files = sb->u.ext2_sb.s_es->s_inodes_count;
sb747fs/ext2/super.ctmp.f_ffree = ext2_count_free_inodes (sb);
sb14fs/fat/buffer.cstruct super_block *sb,
sb18fs/fat/buffer.cif (sb->s_blocksize == 512){
sb19fs/fat/buffer.cret = bread (sb->s_dev,block,512);
sb21fs/fat/buffer.cstruct buffer_head *real = bread (sb->s_dev,block>>1,1024);
sb67fs/fat/buffer.cstruct super_block *sb,
sb71fs/fat/buffer.cif (sb->s_blocksize == 512){
sb72fs/fat/buffer.cret = getblk (sb->s_dev,block,512);
sb80fs/fat/buffer.cret = fat_bread (sb,block);
sb86fs/fat/buffer.cstruct super_block *sb,
sb90fs/fat/buffer.cif (sb->s_blocksize == 512){
sb103fs/fat/buffer.cstruct super_block *sb,
sb107fs/fat/buffer.cif (sb->s_blocksize != 512){
sb114fs/fat/buffer.cstruct super_block *sb,
sb118fs/fat/buffer.cif (sb->s_blocksize != 512){
sb124fs/fat/buffer.cstruct super_block *sb,
sb127fs/fat/buffer.cif (sb->s_blocksize != 512){
sb134fs/fat/buffer.cstruct super_block *sb,
sb139fs/fat/buffer.cif (sb->s_blocksize == 512){
sb20fs/fat/cache.cint fat_access(struct super_block *sb,int nr,int new_value)
sb26fs/fat/cache.cif ((unsigned) (nr-2) >= MSDOS_SB(sb)->clusters) return 0;
sb27fs/fat/cache.cif (MSDOS_SB(sb)->fat_bits == 16) first = last = nr*2;
sb32fs/fat/cache.cif (!(bh = bread(sb->s_dev,MSDOS_SB(sb)->fat_start+(first >>
sb40fs/fat/cache.cif (!(bh2 = bread(sb->s_dev,MSDOS_SB(sb)->fat_start+(last
sb47fs/fat/cache.cif (MSDOS_SB(sb)->fat_bits == 16) {
sb62fs/fat/cache.cif (MSDOS_SB(sb)->fat_bits == 16)
sb77fs/fat/cache.cfor (copy = 1; copy < MSDOS_SB(sb)->fats; copy++) {
sb78fs/fat/cache.cif (!(c_bh = bread(sb->s_dev,MSDOS_SB(sb)->
sb79fs/fat/cache.cfat_start+(first >> SECTOR_BITS)+MSDOS_SB(sb)->
sb84fs/fat/cache.cif (!(c_bh2 = bread(sb->s_dev,
sb85fs/fat/cache.cMSDOS_SB(sb)->fat_start+(first >>
sb86fs/fat/cache.cSECTOR_BITS)+MSDOS_SB(sb)->fat_length*copy
sb244fs/fat/cache.cstruct msdos_sb_info *sb;
sb247fs/fat/cache.csb = MSDOS_SB(inode->i_sb);
sb250fs/fat/cache.cif (sector >= sb->dir_entries >> MSDOS_DPS_BITS) return 0;
sb251fs/fat/cache.creturn sector+sb->dir_start;
sb253fs/fat/cache.ccluster = sector/sb->cluster_size;
sb254fs/fat/cache.coffset = sector % sb->cluster_size;
sb256fs/fat/cache.creturn (cluster-2)*sb->cluster_size+sb->data_start+offset;
sb104fs/fat/dir.cstruct super_block *sb = inode->i_sb;
sb116fs/fat/dir.cint uni_xlate = MSDOS_SB(sb)->options.unicode_xlate;
sb141fs/fat/dir.cif (MSDOS_SB(sb)->options.isvfat && (de->name[0] == (__s8) DELETED_FLAG)) {
sb144fs/fat/dir.c} else if (MSDOS_SB(sb)->options.isvfat && de->attr ==  ATTR_EXT) {
sb230fs/fat/dir.cif ((de->attr & ATTR_HIDDEN) && MSDOS_SB(sb)->options.dotsOK) {
sb128fs/fat/file.cstruct super_block *sb = inode->i_sb;
sb142fs/fat/file.cif (!fat_is_uptodate(sb,bh)) bhreq[nbreq++] = bh;
sb147fs/fat/file.cif (nbreq > 0) fat_ll_rw_block (sb,READ,nbreq,bhreq);
sb160fs/fat/file.cstruct super_block *sb = inode->i_sb;
sb230fs/fat/file.cif (!fat_is_uptodate(sb,bh)){
sb274fs/fat/file.cstruct super_block *sb = inode->i_sb;
sb355fs/fat/file.cfat_set_uptodate(sb,bh,1);
sb32fs/fat/inode.cstruct super_block *sb;
sb41fs/fat/inode.csb = inode->i_sb;
sb47fs/fat/inode.cfat_fs_panic(sb,"...");
sb56fs/fat/inode.cvoid fat_put_super(struct super_block *sb)
sb58fs/fat/inode.cfat_cache_inval_dev(sb->s_dev);
sb59fs/fat/inode.cset_blocksize (sb->s_dev,BLOCK_SIZE);
sb60fs/fat/inode.clock_super(sb);
sb61fs/fat/inode.csb->s_dev = 0;
sb62fs/fat/inode.cunlock_super(sb);
sb171fs/fat/inode.cstruct super_block *fat_read_super(struct super_block *sb,void *data, int silent)
sb181fs/fat/inode.cif (hardsect_size[MAJOR(sb->s_dev)] != NULL){
sb182fs/fat/inode.cblksize = hardsect_size[MAJOR(sb->s_dev)][MINOR(sb->s_dev)];
sb189fs/fat/inode.csb->s_dev = 0;
sb194fs/fat/inode.clock_super(sb);
sb196fs/fat/inode.csb->s_blocksize = 1024;
sb197fs/fat/inode.cset_blocksize(sb->s_dev, 1024);
sb198fs/fat/inode.cbh = bread(sb->s_dev, 0, 1024);
sb199fs/fat/inode.cunlock_super(sb);
sb200fs/fat/inode.cif (bh == NULL || !fat_is_uptodate(sb,bh)) {
sb202fs/fat/inode.csb->s_dev = 0;
sb208fs/fat/inode.cset_blocksize(sb->s_dev, blksize);
sb229fs/fat/inode.cMSDOS_SB(sb)->cluster_size = b->cluster_size*sector_mult;
sb230fs/fat/inode.cMSDOS_SB(sb)->fats = b->fats;
sb231fs/fat/inode.cMSDOS_SB(sb)->fat_start = CF_LE_W(b->reserved)*sector_mult;
sb232fs/fat/inode.cMSDOS_SB(sb)->fat_length = CF_LE_W(b->fat_length)*sector_mult;
sb233fs/fat/inode.cMSDOS_SB(sb)->dir_start = (CF_LE_W(b->reserved)+b->fats*CF_LE_W(
sb235fs/fat/inode.cMSDOS_SB(sb)->dir_entries = CF_LE_W(*((unsigned short *) &b->dir_entries
sb237fs/fat/inode.cMSDOS_SB(sb)->data_start = MSDOS_SB(sb)->dir_start+ROUND_TO_MULTIPLE((
sb238fs/fat/inode.cMSDOS_SB(sb)->dir_entries << MSDOS_DIR_BITS) >> SECTOR_BITS,
sb242fs/fat/inode.cCF_LE_L(b->total_sect))*sector_mult-MSDOS_SB(sb)->data_start;
sb245fs/fat/inode.cMSDOS_SB(sb)->clusters = b->cluster_size ? data_sectors/
sb247fs/fat/inode.cMSDOS_SB(sb)->fat_bits = fat ? fat : MSDOS_SB(sb)->clusters >
sb249fs/fat/inode.cfat_clusters = MSDOS_SB(sb)->fat_length*SECTOR_SIZE*8/
sb250fs/fat/inode.cMSDOS_SB(sb)->fat_bits;
sb251fs/fat/inode.cerror = !MSDOS_SB(sb)->fats || (MSDOS_SB(sb)->dir_entries &
sb252fs/fat/inode.c(MSDOS_DPS-1)) || MSDOS_SB(sb)->clusters+2 > fat_clusters+
sb261fs/fat/inode.csb->s_blocksize = blksize;  /* Using this small block size solve the */
sb265fs/fat/inode.csb->s_blocksize_bits = blksize == 512 ? 9 : 10;
sb270fs/fat/inode.cMSDOS_SB(sb)->fat_bits,opts.name_check,
sb272fs/fat/inode.cMSDOS_CAN_BMAP(MSDOS_SB(sb)) ? ",bmap" : "");
sb274fs/fat/inode.c"se=%d,ts=%ld,ls=%d]\n",b->media,MSDOS_SB(sb)->cluster_size,
sb275fs/fat/inode.cMSDOS_SB(sb)->fats,MSDOS_SB(sb)->fat_start,MSDOS_SB(sb)->fat_length,
sb276fs/fat/inode.cMSDOS_SB(sb)->dir_start,MSDOS_SB(sb)->dir_entries,
sb277fs/fat/inode.cMSDOS_SB(sb)->data_start,
sb282fs/fat/inode.cif (MSDOS_SB(sb)->clusters+2 > fat_clusters)
sb283fs/fat/inode.cMSDOS_SB(sb)->clusters = fat_clusters-2;
sb287fs/fat/inode.c"%s.\n", kdevname(sb->s_dev));
sb288fs/fat/inode.csb->s_dev = 0;
sb292fs/fat/inode.csb->s_magic = MSDOS_SUPER_MAGIC;
sb294fs/fat/inode.cMSDOS_SB(sb)->free_clusters = -1; /* don't know yet */
sb295fs/fat/inode.cMSDOS_SB(sb)->fat_wait = NULL;
sb296fs/fat/inode.cMSDOS_SB(sb)->fat_lock = 0;
sb297fs/fat/inode.cMSDOS_SB(sb)->prev_free = 0;
sb298fs/fat/inode.cmemcpy(&(MSDOS_SB(sb)->options), &opts, sizeof(struct fat_mount_options));
sb299fs/fat/inode.cif (!(sb->s_mounted = iget(sb,MSDOS_ROOT_INO))) {
sb300fs/fat/inode.csb->s_dev = 0;
sb305fs/fat/inode.creturn sb;
sb309fs/fat/inode.cvoid fat_statfs(struct super_block *sb,struct statfs *buf, int bufsiz)
sb314fs/fat/inode.clock_fat(sb);
sb315fs/fat/inode.cif (MSDOS_SB(sb)->free_clusters != -1)
sb316fs/fat/inode.cfree = MSDOS_SB(sb)->free_clusters;
sb319fs/fat/inode.cfor (nr = 2; nr < MSDOS_SB(sb)->clusters+2; nr++)
sb320fs/fat/inode.cif (!fat_access(sb,nr,-1)) free++;
sb321fs/fat/inode.cMSDOS_SB(sb)->free_clusters = free;
sb323fs/fat/inode.cunlock_fat(sb);
sb324fs/fat/inode.ctmp.f_type = sb->s_magic;
sb325fs/fat/inode.ctmp.f_bsize = MSDOS_SB(sb)->cluster_size*SECTOR_SIZE;
sb326fs/fat/inode.ctmp.f_blocks = MSDOS_SB(sb)->clusters;
sb338fs/fat/inode.cstruct msdos_sb_info *sb;
sb341fs/fat/inode.csb = MSDOS_SB(inode->i_sb);
sb343fs/fat/inode.creturn sb->dir_start + block;
sb345fs/fat/inode.ccluster = block/sb->cluster_size;
sb346fs/fat/inode.coffset = block % sb->cluster_size;
sb348fs/fat/inode.creturn (cluster-2)*sb->cluster_size+sb->data_start+offset;
sb363fs/fat/inode.cstruct super_block *sb = inode->i_sb;
sb432fs/fat/inode.cinode->i_op = (sb->s_blocksize == 1024)
sb461fs/fat/inode.cstruct super_block *sb = inode->i_sb;
sb489fs/fat/inode.cif (MSDOS_SB(sb)->options.isvfat) {
sb97fs/fat/misc.cvoid lock_fat(struct super_block *sb)
sb99fs/fat/misc.cwhile (MSDOS_SB(sb)->fat_lock) sleep_on(&MSDOS_SB(sb)->fat_wait);
sb100fs/fat/misc.cMSDOS_SB(sb)->fat_lock = 1;
sb104fs/fat/misc.cvoid unlock_fat(struct super_block *sb)
sb106fs/fat/misc.cMSDOS_SB(sb)->fat_lock = 0;
sb107fs/fat/misc.cwake_up(&MSDOS_SB(sb)->fat_wait);
sb118fs/fat/misc.cstruct super_block *sb = inode->i_sb;
sb198fs/fat/misc.cfat_set_uptodate(sb,bh,1);
sb286fs/fat/misc.cstruct super_block *sb = dir->i_sb;
sb350fs/fat/misc.cinode = iget(sb,sector*MSDOS_DPS+entry); \
sb366fs/fat/misc.cstatic int raw_scan_sector(struct super_block *sb,int sector,const char *name,
sb375fs/fat/misc.cif (!(bh = bread(sb->s_dev,sector,SECTOR_SIZE))) return -EIO;
sb414fs/fat/misc.cstatic int raw_scan_root(struct super_block *sb,const char *name,int *number,int *ino,
sb419fs/fat/misc.cfor (count = 0; count < MSDOS_SB(sb)->dir_entries/MSDOS_DPS; count++) {
sb420fs/fat/misc.cif ((cluster = raw_scan_sector(sb,MSDOS_SB(sb)->dir_start+count,
sb432fs/fat/misc.cstatic int raw_scan_nonroot(struct super_block *sb,int start,const char *name,
sb442fs/fat/misc.cfor (count = 0; count < MSDOS_SB(sb)->cluster_size; count++) {
sb443fs/fat/misc.cif ((cluster = raw_scan_sector(sb,(start-2)*
sb444fs/fat/misc.cMSDOS_SB(sb)->cluster_size+MSDOS_SB(sb)->data_start+
sb448fs/fat/misc.cif (!(start = fat_access(sb,start,-1))) {
sb449fs/fat/misc.cfat_fs_panic(sb,"FAT error");
sb468fs/fat/misc.cstatic int raw_scan(struct super_block *sb, int start, const char *name,
sb473fs/fat/misc.c(sb,start,name,number,ino,res_bh,res_de,scantype);
sb475fs/fat/misc.c(sb,name,number,ino,res_bh,res_de,scantype);
sb2fs/fat/msbuffer.hstruct buffer_head *fat_bread (struct super_block *sb, int block);
sb3fs/fat/msbuffer.hstruct buffer_head *fat_getblk (struct super_block *sb, int block);
sb4fs/fat/msbuffer.hvoid fat_brelse (struct super_block *sb, struct buffer_head *bh);
sb5fs/fat/msbuffer.hvoid fat_mark_buffer_dirty (struct super_block *sb,
sb8fs/fat/msbuffer.hvoid fat_set_uptodate (struct super_block *sb,
sb11fs/fat/msbuffer.hint fat_is_uptodate (struct super_block *sb, struct buffer_head *bh);
sb12fs/fat/msbuffer.hvoid fat_ll_rw_block (struct super_block *sb, int opr,
sb30fs/fat/msbuffer.h#define brelse(b)      fat_brelse(sb,b)
sb31fs/fat/msbuffer.h#define bread(d,b,s)      fat_bread(sb,b)
sb32fs/fat/msbuffer.h#define getblk(d,b,s)      fat_getblk(sb,b)
sb33fs/fat/msbuffer.h#define mark_buffer_dirty(b,v)    fat_mark_buffer_dirty(sb,b,v)
sb551fs/inode.cstruct inode *__iget(struct super_block * sb, int nr, int crossmntp)
sb558fs/inode.cif (!sb)
sb560fs/inode.ch = hash(sb->s_dev, nr);
sb563fs/inode.cif (inode->i_dev == sb->s_dev && inode->i_ino == nr)
sb575fs/inode.cinode->i_sb = sb;
sb576fs/inode.cinode->i_dev = sb->s_dev;
sb578fs/inode.cinode->i_flags = sb->s_flags;
sb589fs/inode.cif (inode->i_dev != sb->s_dev || inode->i_ino != nr) {
sb33fs/isofs/inode.cvoid isofs_put_super(struct super_block *sb)
sb35fs/isofs/inode.clock_super(sb);
sb41fs/isofs/inode.csb->s_dev = 0;
sb42fs/isofs/inode.cunlock_super(sb);
sb400fs/isofs/inode.cvoid isofs_statfs (struct super_block *sb, struct statfs *buf, int bufsiz)
sb406fs/isofs/inode.ctmp.f_blocks = sb->u.isofs_sb.s_nzones;
sb409fs/isofs/inode.ctmp.f_files = sb->u.isofs_sb.s_ninodes;
sb34fs/minix/bitmap.cvoid minix_free_block(struct super_block * sb, int block)
sb39fs/minix/bitmap.cif (!sb) {
sb43fs/minix/bitmap.cif (block < sb->u.minix_sb.s_firstdatazone ||
sb44fs/minix/bitmap.cblock >= sb->u.minix_sb.s_nzones) {
sb48fs/minix/bitmap.cbh = get_hash_table(sb->s_dev,block,BLOCK_SIZE);
sb52fs/minix/bitmap.czone = block - sb->u.minix_sb.s_firstdatazone + 1;
sb55fs/minix/bitmap.cbh = sb->u.minix_sb.s_zmap[zone];
sb62fs/minix/bitmap.ckdevname(sb->s_dev), block);
sb67fs/minix/bitmap.cint minix_new_block(struct super_block * sb)
sb72fs/minix/bitmap.cif (!sb) {
sb79fs/minix/bitmap.cif ((bh=sb->u.minix_sb.s_zmap[i]) != NULL)
sb89fs/minix/bitmap.cj += i*8192 + sb->u.minix_sb.s_firstdatazone-1;
sb90fs/minix/bitmap.cif (j < sb->u.minix_sb.s_firstdatazone ||
sb91fs/minix/bitmap.cj >= sb->u.minix_sb.s_nzones)
sb93fs/minix/bitmap.cif (!(bh = getblk(sb->s_dev,j,BLOCK_SIZE))) {
sb104fs/minix/bitmap.cunsigned long minix_count_free_blocks(struct super_block *sb)
sb106fs/minix/bitmap.creturn (count_free(sb->u.minix_sb.s_zmap,sb->u.minix_sb.s_zmap_blocks)
sb107fs/minix/bitmap.c<< sb->u.minix_sb.s_log_zone_size);
sb219fs/minix/bitmap.cstruct super_block * sb;
sb226fs/minix/bitmap.csb = dir->i_sb;
sb227fs/minix/bitmap.cinode->i_sb = sb;
sb251fs/minix/bitmap.cinode->i_dev = sb->s_dev;
sb263fs/minix/bitmap.cunsigned long minix_count_free_inodes(struct super_block *sb)
sb265fs/minix/bitmap.creturn count_free(sb->u.minix_sb.s_imap,sb->u.minix_sb.s_imap_blocks);
sb33fs/minix/inode.cstatic void minix_commit_super (struct super_block * sb,
sb36fs/minix/inode.cmark_buffer_dirty(sb->u.minix_sb.s_sbh, 1);
sb37fs/minix/inode.csb->s_dirt = 0;
sb40fs/minix/inode.cvoid minix_write_super (struct super_block * sb)
sb44fs/minix/inode.cif (!(sb->s_flags & MS_RDONLY)) {
sb45fs/minix/inode.cms = sb->u.minix_sb.s_ms;
sb49fs/minix/inode.cminix_commit_super (sb, ms);
sb51fs/minix/inode.csb->s_dirt = 0;
sb55fs/minix/inode.cvoid minix_put_super(struct super_block *sb)
sb59fs/minix/inode.clock_super(sb);
sb60fs/minix/inode.cif (!(sb->s_flags & MS_RDONLY)) {
sb61fs/minix/inode.csb->u.minix_sb.s_ms->s_state = sb->u.minix_sb.s_mount_state;
sb62fs/minix/inode.cmark_buffer_dirty(sb->u.minix_sb.s_sbh, 1);
sb64fs/minix/inode.csb->s_dev = 0;
sb66fs/minix/inode.cbrelse(sb->u.minix_sb.s_imap[i]);
sb68fs/minix/inode.cbrelse(sb->u.minix_sb.s_zmap[i]);
sb69fs/minix/inode.cbrelse (sb->u.minix_sb.s_sbh);
sb70fs/minix/inode.cunlock_super(sb);
sb86fs/minix/inode.cint minix_remount (struct super_block * sb, int * flags, char * data)
sb90fs/minix/inode.cms = sb->u.minix_sb.s_ms;
sb91fs/minix/inode.cif ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
sb95fs/minix/inode.c!(sb->u.minix_sb.s_mount_state & MINIX_VALID_FS))
sb98fs/minix/inode.cms->s_state = sb->u.minix_sb.s_mount_state;
sb99fs/minix/inode.cmark_buffer_dirty(sb->u.minix_sb.s_sbh, 1);
sb100fs/minix/inode.csb->s_dirt = 1;
sb101fs/minix/inode.cminix_commit_super (sb, ms);
sb105fs/minix/inode.csb->u.minix_sb.s_mount_state = ms->s_state;
sb107fs/minix/inode.cmark_buffer_dirty(sb->u.minix_sb.s_sbh, 1);
sb108fs/minix/inode.csb->s_dirt = 1;
sb110fs/minix/inode.cif (!(sb->u.minix_sb.s_mount_state & MINIX_VALID_FS))
sb113fs/minix/inode.celse if ((sb->u.minix_sb.s_mount_state & MINIX_ERROR_FS))
sb240fs/minix/inode.cvoid minix_statfs(struct super_block *sb, struct statfs *buf, int bufsiz)
sb244fs/minix/inode.ctmp.f_type = sb->s_magic;
sb245fs/minix/inode.ctmp.f_bsize = sb->s_blocksize;
sb246fs/minix/inode.ctmp.f_blocks = (sb->u.minix_sb.s_nzones - sb->u.minix_sb.s_firstdatazone) << sb->u.minix_sb.s_log_zone_size;
sb247fs/minix/inode.ctmp.f_bfree = minix_count_free_blocks(sb);
sb249fs/minix/inode.ctmp.f_files = sb->u.minix_sb.s_ninodes;
sb250fs/minix/inode.ctmp.f_ffree = minix_count_free_inodes(sb);
sb251fs/minix/inode.ctmp.f_namelen = sb->u.minix_sb.s_namelen;
sb40fs/msdos/namei.cvoid msdos_put_super(struct super_block *sb)
sb42fs/msdos/namei.cfat_put_super(sb);
sb57fs/msdos/namei.cstruct super_block *msdos_read_super(struct super_block *sb,void *data, int silent)
sb63fs/msdos/namei.csb->s_op = &msdos_sops;
sb64fs/msdos/namei.cres =  fat_read_super(sb, data, silent);
sb179fs/msdos/namei.cstruct super_block *sb = dir->i_sb;
sb259fs/msdos/namei.cstruct super_block *sb = dir->i_sb;
sb298fs/msdos/namei.cstruct super_block *sb = dir->i_sb;
sb339fs/msdos/namei.cstatic void dump_fat(struct super_block *sb,int start)
sb344fs/msdos/namei.cstart = fat_access(sb,start,-1);
sb359fs/msdos/namei.cstruct super_block *sb = dir->i_sb;
sb385fs/msdos/namei.cstruct super_block *sb = dir->i_sb;
sb424fs/msdos/namei.cstruct super_block *sb = dir->i_sb;
sb489fs/msdos/namei.cstruct super_block *sb = dir->i_sb;
sb542fs/msdos/namei.cstruct super_block *sb = old_dir->i_sb;
sb608fs/msdos/namei.cstruct super_block *sb = old_dir->i_sb;
sb738fs/msdos/namei.cstruct super_block *sb = old_dir->i_sb;
sb156fs/namei.cstruct super_block * sb;
sb168fs/namei.c} else if ((sb = dir->i_sb) && (dir == sb->s_mounted)) {
sb170fs/namei.cdir = sb->s_covered;
sb34fs/ncpfs/inode.cstatic void ncp_statfs(struct super_block *sb, struct statfs *buf, int bufsiz);
sb158fs/ncpfs/inode.cncp_read_super(struct super_block *sb, void *raw_data, int silent)
sb165fs/ncpfs/inode.ckdev_t dev = sb->s_dev;
sb171fs/ncpfs/inode.csb->s_dev = 0;
sb180fs/ncpfs/inode.csb->s_dev = 0;
sb189fs/ncpfs/inode.csb->s_dev = 0;
sb198fs/ncpfs/inode.csb->s_dev = 0;
sb207fs/ncpfs/inode.csb->s_dev = 0;
sb225fs/ncpfs/inode.clock_super(sb);
sb227fs/ncpfs/inode.cNCP_SBP(sb) = server;
sb229fs/ncpfs/inode.csb->s_blocksize = 1024; /* Eh...  Is this correct? */
sb230fs/ncpfs/inode.csb->s_blocksize_bits = 10;
sb231fs/ncpfs/inode.csb->s_magic = NCP_SUPER_MAGIC;
sb232fs/ncpfs/inode.csb->s_dev = dev;
sb233fs/ncpfs/inode.csb->s_op = &ncp_sops;
sb260fs/ncpfs/inode.cunlock_super(sb);
sb272fs/ncpfs/inode.cunlock_super(sb);
sb281fs/ncpfs/inode.cunlock_super(sb);
sb288fs/ncpfs/inode.cunlock_super(sb);
sb292fs/ncpfs/inode.csb->s_dev = 0;
sb300fs/ncpfs/inode.cDPRINTK("ncp_read_super: NCP_SBP(sb) = %x\n", (int)NCP_SBP(sb));
sb304fs/ncpfs/inode.cif (!(sb->s_mounted = iget(sb, ncp_info_ino(server, &(server->root)))))
sb306fs/ncpfs/inode.csb->s_dev = 0;
sb314fs/ncpfs/inode.csb->s_dev = 0;
sb322fs/ncpfs/inode.creturn sb;
sb334fs/ncpfs/inode.cncp_kfree_s(NCP_SBP(sb), sizeof(struct ncp_server));
sb339fs/ncpfs/inode.cncp_put_super(struct super_block *sb)
sb341fs/ncpfs/inode.cstruct ncp_server *server = NCP_SBP(sb);
sb343fs/ncpfs/inode.clock_super(sb);
sb359fs/ncpfs/inode.csb->s_dev = 0;
sb360fs/ncpfs/inode.cncp_kfree_s(NCP_SBP(sb), sizeof(struct ncp_server));
sb361fs/ncpfs/inode.cNCP_SBP(sb) = NULL;
sb363fs/ncpfs/inode.cunlock_super(sb);
sb395fs/ncpfs/inode.cncp_statfs(struct super_block *sb, struct statfs *buf, int bufsiz)
sb69fs/nfs/inode.cvoid nfs_put_super(struct super_block *sb)
sb71fs/nfs/inode.cclose_fp(sb->u.nfs_sb.s_server.file);
sb72fs/nfs/inode.crpc_closesock(sb->u.nfs_sb.s_server.rsock);
sb73fs/nfs/inode.clock_super(sb);
sb74fs/nfs/inode.csb->s_dev = 0;
sb75fs/nfs/inode.cunlock_super(sb);
sb87fs/nfs/inode.cstruct super_block *nfs_read_super(struct super_block *sb, void *raw_data,
sb95fs/nfs/inode.ckdev_t dev = sb->s_dev;
sb100fs/nfs/inode.csb->s_dev = 0;
sb111fs/nfs/inode.csb->s_dev = 0;
sb117fs/nfs/inode.csb->s_dev = 0;
sb122fs/nfs/inode.clock_super(sb);
sb124fs/nfs/inode.csb->s_blocksize = 1024; /* XXX */
sb125fs/nfs/inode.csb->s_blocksize_bits = 10;
sb126fs/nfs/inode.csb->s_magic = NFS_SUPER_MAGIC;
sb127fs/nfs/inode.csb->s_dev = dev;
sb128fs/nfs/inode.csb->s_op = &nfs_sops;
sb129fs/nfs/inode.cserver = &sb->u.nfs_sb.s_server;
sb183fs/nfs/inode.csb->u.nfs_sb.s_root = data->root;
sb184fs/nfs/inode.cunlock_super(sb);
sb185fs/nfs/inode.cif (!(sb->s_mounted = nfs_fhget(sb, &data->root, NULL))) {
sb186fs/nfs/inode.csb->s_dev = 0;
sb191fs/nfs/inode.creturn sb;
sb194fs/nfs/inode.cvoid nfs_statfs(struct super_block *sb, struct statfs *buf, int bufsiz)
sb200fs/nfs/inode.cerror = nfs_proc_statfs(&sb->u.nfs_sb.s_server, &sb->u.nfs_sb.s_root,
sb226fs/nfs/inode.cstruct inode *nfs_fhget(struct super_block *sb, struct nfs_fh *fhandle,
sb233fs/nfs/inode.cif (!sb) {
sb238fs/nfs/inode.cerror = nfs_proc_getattr(&sb->u.nfs_sb.s_server, fhandle,
sb246fs/nfs/inode.cif (!(inode = iget(sb, fattr->fileid))) {
sb250fs/nfs/inode.cif (inode->i_dev == sb->s_dev) {
sb954fs/nfs/nfsroot.cstatic int root_nfs_do_mount(struct super_block *sb)
sb968fs/nfs/nfsroot.cif (nfs_read_super(sb, &nfs_data, 1) == NULL) {
sb980fs/nfs/nfsroot.cint nfs_root_mount(struct super_block *sb)
sb990fs/nfs/nfsroot.cif (root_nfs_do_mount(sb) < 0)
sb60fs/proc/fd.cstruct super_block * sb;
sb69fs/proc/fd.csb = dir->i_sb;
sb80fs/proc/fd.cif (!(*result = proc_get_inode(sb, (pid << 16)+PROC_PID_INO, &proc_pid))) {
sb114fs/proc/fd.cif (!(*result = proc_get_inode(sb, ino, NULL)))
sb26fs/proc/inode.cstatic void proc_put_super(struct super_block *sb)
sb28fs/proc/inode.clock_super(sb);
sb29fs/proc/inode.csb->s_dev = 0;
sb30fs/proc/inode.cunlock_super(sb);
sb117fs/proc/inode.cvoid proc_statfs(struct super_block *sb, struct statfs *buf, int bufsiz)
sb149fs/smbfs/inode.csmb_put_super(struct super_block *sb)
sb151fs/smbfs/inode.cstruct smb_server *server = &(SMB_SBP(sb)->s_server);
sb156fs/smbfs/inode.clock_super(sb);
sb162fs/smbfs/inode.csb->s_dev = 0;
sb163fs/smbfs/inode.csmb_kfree_s(SMB_SBP(sb), sizeof(struct smb_sb_info));
sb165fs/smbfs/inode.cunlock_super(sb);
sb173fs/smbfs/inode.csmb_read_super(struct super_block *sb, void *raw_data, int silent)
sb180fs/smbfs/inode.ckdev_t dev = sb->s_dev;
sb185fs/smbfs/inode.csb->s_dev = 0;
sb196fs/smbfs/inode.csb->s_dev = 0;
sb201fs/smbfs/inode.csb->s_dev = 0;
sb216fs/smbfs/inode.clock_super(sb);
sb218fs/smbfs/inode.cSMB_SBP(sb) = smb_sb;
sb220fs/smbfs/inode.csb->s_blocksize = 1024; /* Eh...  Is this correct? */
sb221fs/smbfs/inode.csb->s_blocksize_bits = 10;
sb222fs/smbfs/inode.csb->s_magic = SMB_SUPER_MAGIC;
sb223fs/smbfs/inode.csb->s_dev = dev;
sb224fs/smbfs/inode.csb->s_op = &smb_sops;
sb226fs/smbfs/inode.cserver = &(SMB_SBP(sb)->s_server);
sb253fs/smbfs/inode.cunlock_super(sb);
sb256fs/smbfs/inode.csb->s_dev = 0;
sb267fs/smbfs/inode.cif ((error = smb_proc_dskattr(sb, &(SMB_SBP(sb)->s_attr))) < 0) {
sb268fs/smbfs/inode.csb->s_dev = 0;
sb276fs/smbfs/inode.csb->s_dev = 0;
sb283fs/smbfs/inode.cSMB_SBP(sb)->s_attr.total,
sb284fs/smbfs/inode.cSMB_SBP(sb)->s_attr.blocksize,
sb285fs/smbfs/inode.cSMB_SBP(sb)->s_attr.allocblocks,
sb286fs/smbfs/inode.cSMB_SBP(sb)->s_attr.free);
sb288fs/smbfs/inode.cDPRINTK("smb_read_super: SMB_SBP(sb) = %x\n", (int)SMB_SBP(sb));
sb290fs/smbfs/inode.cif (!(sb->s_mounted = iget(sb, (int)&(server->root)))) {
sb291fs/smbfs/inode.csb->s_dev = 0;
sb298fs/smbfs/inode.creturn sb;
sb302fs/smbfs/inode.csmb_kfree_s(SMB_SBP(sb), sizeof(struct smb_sb_info));
sb307fs/smbfs/inode.csmb_statfs(struct super_block *sb, struct statfs *buf, int bufsiz)
sb313fs/smbfs/inode.cerror = smb_proc_dskattr(sb, &attr);
sb49fs/super.cstatic int do_remount_sb(struct super_block *sb, int flags, char * data);
sb316fs/super.cvoid __wait_on_super(struct super_block * sb)
sb320fs/super.cadd_wait_queue(&sb->s_wait, &wait);
sb323fs/super.cif (sb->s_lock) {
sb327fs/super.cremove_wait_queue(&sb->s_wait, &wait);
sb333fs/super.cstruct super_block * sb;
sb335fs/super.cfor (sb = super_blocks + 0 ; sb < super_blocks + NR_SUPER ; sb++) {
sb336fs/super.cif (!sb->s_dev)
sb338fs/super.cif (dev && sb->s_dev != dev)
sb340fs/super.cwait_on_super(sb);
sb341fs/super.cif (!sb->s_dev || !sb->s_dirt)
sb343fs/super.cif (dev && (dev != sb->s_dev))
sb345fs/super.cif (sb->s_op && sb->s_op->write_super)
sb346fs/super.csb->s_op->write_super(sb);
sb370fs/super.cstruct super_block * sb;
sb377fs/super.cif (!(sb = get_super(dev)))
sb379fs/super.cif (sb->s_covered) {
sb384fs/super.cif (sb->s_op && sb->s_op->put_super)
sb385fs/super.csb->s_op->put_super(sb);
sb488fs/super.cstruct super_block * sb;
sb496fs/super.cif (!(sb=get_super(dev)))
sb498fs/super.cif (!(sb->s_flags & MS_RDONLY)) {
sb507fs/super.cretval = do_remount_sb(sb, MS_RDONLY, 0);
sb513fs/super.cif (!(sb=get_super(dev)) || !(sb->s_covered))
sb515fs/super.cif (!sb->s_covered->i_mount)
sb524fs/super.cif (!fs_may_umount(dev, sb->s_mounted))
sb526fs/super.csb->s_covered->i_mount = NULL;
sb527fs/super.ciput(sb->s_covered);
sb528fs/super.csb->s_covered = NULL;
sb529fs/super.ciput(sb->s_mounted);
sb530fs/super.csb->s_mounted = NULL;
sb531fs/super.cif (sb->s_op && sb->s_op->write_super && sb->s_dirt)
sb532fs/super.csb->s_op->write_super(sb);
sb611fs/super.cstruct super_block * sb;
sb630fs/super.csb = read_super(dev,type,flags,data,0);
sb631fs/super.cif (!sb) {
sb635fs/super.cif (sb->s_covered) {
sb641fs/super.cvfsmnt->mnt_sb = sb;
sb644fs/super.csb->s_covered = dir_i;
sb645fs/super.cdir_i->i_mount = sb->s_mounted;
sb656fs/super.cstatic int do_remount_sb(struct super_block *sb, int flags, char *data)
sb660fs/super.cif (!(flags & MS_RDONLY) && sb->s_dev && is_read_only(sb->s_dev))
sb664fs/super.cif ((flags & MS_RDONLY) && !(sb->s_flags & MS_RDONLY))
sb665fs/super.cif (!fs_may_remount_ro(sb->s_dev))
sb667fs/super.cif (sb->s_op && sb->s_op->remount_fs) {
sb668fs/super.cretval = sb->s_op->remount_fs(sb, &flags, data);
sb672fs/super.csb->s_flags = (sb->s_flags & ~MS_RMT_MASK) |
sb825fs/super.cstruct super_block * sb;
sb841fs/super.csb = &super_blocks[0];
sb842fs/super.cwhile (sb->s_dev) sb++;
sb843fs/super.csb->s_dev = get_unnamed_dev();
sb844fs/super.csb->s_flags = root_mountflags & ~MS_RDONLY;
sb845fs/super.cif (nfs_root_mount(sb) >= 0) {
sb846fs/super.cinode = sb->s_mounted;
sb848fs/super.csb->s_covered = inode;
sb849fs/super.csb->s_rd_only = 0;
sb850fs/super.csb->s_dirt = 0;
sb851fs/super.csb->s_type = fs_type;
sb854fs/super.cROOT_DEV = sb->s_dev;
sb858fs/super.csb->s_dev = 0;
sb898fs/super.csb = read_super(ROOT_DEV,fs_type->name,root_mountflags,NULL,1);
sb899fs/super.cif (sb) {
sb900fs/super.cinode = sb->s_mounted;
sb902fs/super.csb->s_covered = inode;
sb903fs/super.csb->s_flags = root_mountflags;
sb908fs/super.c(sb->s_flags & MS_RDONLY) ? " readonly" : "");
sb912fs/super.cvfsmnt->mnt_sb = sb;
sb32fs/sysv/balloc.cvoid sysv_free_block(struct super_block * sb, unsigned int block)
sb37fs/sysv/balloc.cif (!sb) {
sb41fs/sysv/balloc.cif (block < sb->sv_firstdatazone || block >= sb->sv_nzones) {
sb45fs/sysv/balloc.clock_super(sb);
sb46fs/sysv/balloc.cif (*sb->sv_sb_flc_count > sb->sv_flc_size) {
sb48fs/sysv/balloc.cunlock_super(sb);
sb54fs/sysv/balloc.cif (*sb->sv_sb_flc_count == sb->sv_flc_size) {
sb58fs/sysv/balloc.cbh = sv_getblk(sb, sb->s_dev, block);
sb61fs/sysv/balloc.cunlock_super(sb);
sb65fs/sysv/balloc.cswitch (sb->sv_type) {
sb84fs/sysv/balloc.c*flc_count = *sb->sv_sb_flc_count; /* = sb->sv_flc_size */
sb85fs/sysv/balloc.cmemcpy(flc_blocks, sb->sv_sb_flc_blocks, *flc_count * sizeof(sysv_zone_t));
sb89fs/sysv/balloc.c*sb->sv_sb_flc_count = 0;
sb94fs/sysv/balloc.cif (*sb->sv_sb_flc_count == 0) { /* Applies only to Coherent FS */
sb95fs/sysv/balloc.cbh = sv_getblk(sb, sb->s_dev, block);
sb98fs/sysv/balloc.cunlock_super(sb);
sb101fs/sysv/balloc.cmemset(bh->b_data, 0, sb->sv_block_size);
sb109fs/sysv/balloc.cbh = sv_get_hash_table(sb, sb->s_dev, block);
sb114fs/sysv/balloc.cif (sb->sv_convert)
sb116fs/sysv/balloc.csb->sv_sb_flc_blocks[(*sb->sv_sb_flc_count)++] = block;
sb117fs/sysv/balloc.cif (sb->sv_convert)
sb118fs/sysv/balloc.c*sb->sv_sb_total_free_blocks =
sb119fs/sysv/balloc.cto_coh_ulong(from_coh_ulong(*sb->sv_sb_total_free_blocks) + 1);
sb121fs/sysv/balloc.c*sb->sv_sb_total_free_blocks = *sb->sv_sb_total_free_blocks + 1;
sb122fs/sysv/balloc.cmark_buffer_dirty(sb->sv_bh1, 1); /* super-block has been modified */
sb123fs/sysv/balloc.cif (sb->sv_bh1 != sb->sv_bh2) mark_buffer_dirty(sb->sv_bh2, 1);
sb124fs/sysv/balloc.csb->s_dirt = 1; /* and needs time stamp */
sb125fs/sysv/balloc.cunlock_super(sb);
sb128fs/sysv/balloc.cint sysv_new_block(struct super_block * sb)
sb134fs/sysv/balloc.cif (!sb) {
sb138fs/sysv/balloc.clock_super(sb);
sb139fs/sysv/balloc.cif (*sb->sv_sb_flc_count == 0) { /* Applies only to Coherent FS */
sb140fs/sysv/balloc.cunlock_super(sb);
sb143fs/sysv/balloc.cblock = sb->sv_sb_flc_blocks[(*sb->sv_sb_flc_count)-1];
sb144fs/sysv/balloc.cif (sb->sv_convert)
sb147fs/sysv/balloc.cunlock_super(sb);
sb150fs/sysv/balloc.c(*sb->sv_sb_flc_count)--;
sb151fs/sysv/balloc.cif (block < sb->sv_firstdatazone || block >= sb->sv_nzones) {
sb153fs/sysv/balloc.cunlock_super(sb);
sb156fs/sysv/balloc.cif (*sb->sv_sb_flc_count == 0) { /* the last block continues the free list */
sb160fs/sysv/balloc.cif (!(bh = sv_bread(sb, sb->s_dev, block))) {
sb163fs/sysv/balloc.c(*sb->sv_sb_flc_count)++;
sb164fs/sysv/balloc.cunlock_super(sb);
sb168fs/sysv/balloc.cswitch (sb->sv_type) {
sb187fs/sysv/balloc.cif (*flc_count > sb->sv_flc_size) {
sb190fs/sysv/balloc.cunlock_super(sb);
sb193fs/sysv/balloc.c*sb->sv_sb_flc_count = *flc_count;
sb194fs/sysv/balloc.cmemcpy(sb->sv_sb_flc_blocks, flc_blocks, *flc_count * sizeof(sysv_zone_t));
sb198fs/sysv/balloc.cbh = sv_getblk(sb, sb->s_dev, block);
sb201fs/sysv/balloc.cunlock_super(sb);
sb206fs/sysv/balloc.cunlock_super(sb);
sb209fs/sysv/balloc.cmemset(bh->b_data, 0, sb->sv_block_size);
sb213fs/sysv/balloc.cif (sb->sv_convert)
sb214fs/sysv/balloc.c*sb->sv_sb_total_free_blocks =
sb215fs/sysv/balloc.cto_coh_ulong(from_coh_ulong(*sb->sv_sb_total_free_blocks) - 1);
sb217fs/sysv/balloc.c*sb->sv_sb_total_free_blocks = *sb->sv_sb_total_free_blocks - 1;
sb218fs/sysv/balloc.cmark_buffer_dirty(sb->sv_bh1, 1); /* super-block has been modified */
sb219fs/sysv/balloc.cif (sb->sv_bh1 != sb->sv_bh2) mark_buffer_dirty(sb->sv_bh2, 1);
sb220fs/sysv/balloc.csb->s_dirt = 1; /* and needs time stamp */
sb221fs/sysv/balloc.cunlock_super(sb);
sb225fs/sysv/balloc.cunsigned long sysv_count_free_blocks(struct super_block * sb)
sb236fs/sysv/balloc.clock_super(sb);
sb237fs/sysv/balloc.cif (*sb->sv_sb_flc_count > 0) {
sb238fs/sysv/balloc.cfor (i = *sb->sv_sb_flc_count ; /* i > 0 */ ; ) {
sb239fs/sysv/balloc.cblock = sb->sv_sb_flc_blocks[--i];
sb240fs/sysv/balloc.cif (sb->sv_convert)
sb253fs/sysv/balloc.cif (block < sb->sv_firstdatazone || block >= sb->sv_nzones) {
sb257fs/sysv/balloc.cif (!(bh = sv_bread(sb, sb->s_dev, block))) {
sb262fs/sysv/balloc.cswitch (sb->sv_type) {
sb281fs/sysv/balloc.cif (*flc_count > sb->sv_flc_size) {
sb292fs/sysv/balloc.cif (sb->sv_convert)
sb307fs/sysv/balloc.cold_count = *sb->sv_sb_total_free_blocks;
sb308fs/sysv/balloc.cif (sb->sv_convert)
sb312fs/sysv/balloc.cif (!(sb->s_flags & MS_RDONLY)) {
sb313fs/sysv/balloc.c*sb->sv_sb_total_free_blocks = (sb->sv_convert ? to_coh_ulong(count) : count);
sb314fs/sysv/balloc.cmark_buffer_dirty(sb->sv_bh2, 1); /* super-block has been modified */
sb315fs/sysv/balloc.csb->s_dirt = 1; /* and needs time stamp */
sb318fs/sysv/balloc.cunlock_super(sb);
sb323fs/sysv/balloc.ccount = *sb->sv_sb_total_free_blocks;
sb324fs/sysv/balloc.cif (sb->sv_convert)
sb70fs/sysv/dir.cstruct super_block * sb;
sb76fs/sysv/dir.cif (!inode || !(sb = inode->i_sb) || !S_ISDIR(inode->i_mode))
sb81fs/sysv/dir.coffset = filp->f_pos & sb->sv_block_size_1;
sb82fs/sysv/dir.cbh = sysv_file_bread(inode, filp->f_pos >> sb->sv_block_size_bits, 0);
sb84fs/sysv/dir.cfilp->f_pos += sb->sv_block_size - offset;
sb88fs/sysv/dir.cwhile (offset < sb->sv_block_size && filp->f_pos < inode->i_size) {
sb77fs/sysv/file.cstruct super_block * sb = inode->i_sb;
sb106fs/sysv/file.cblock = offset >> sb->sv_block_size_bits;
sb107fs/sysv/file.coffset &= sb->sv_block_size_1;
sb108fs/sysv/file.csize = (size + sb->sv_block_size_1) >> sb->sv_block_size_bits;
sb109fs/sysv/file.cblocks = (left + offset + sb->sv_block_size_1) >> sb->sv_block_size_bits;
sb112fs/sysv/file.cblocks += read_ahead[MAJOR(inode->i_dev)] >> (sb->sv_block_size_bits - 9);
sb165fs/sysv/file.cif (left < sb->sv_block_size - offset)
sb168fs/sysv/file.cchars = sb->sv_block_size - offset;
sb204fs/sysv/file.cstruct super_block * sb = inode->i_sb;
sb231fs/sysv/file.cbh = sysv_getblk (inode, pos >> sb->sv_block_size_bits, 1);
sb237fs/sysv/file.cc = sb->sv_block_size - (pos & sb->sv_block_size_1);
sb240fs/sysv/file.cif (c != sb->sv_block_size && !buffer_uptodate(bh)) {
sb251fs/sysv/file.cp = (pos & sb->sv_block_size_1) + bh->b_data;
sb33fs/sysv/fsync.cstruct super_block * sb;
sb40fs/sysv/fsync.csb = inode->i_sb;
sb41fs/sysv/fsync.cbh = sv_get_hash_table(sb, inode->i_dev, block);
sb109fs/sysv/fsync.cstruct super_block * sb;
sb115fs/sysv/fsync.csb = inode->i_sb;
sb116fs/sysv/fsync.cfor (i = 0; i < sb->sv_ind_per_block; i++) {
sb118fs/sysv/fsync.c((unsigned long *) ind_bh->b_data) + i, sb->sv_convert,
sb135fs/sysv/fsync.cstruct super_block * sb;
sb141fs/sysv/fsync.csb = inode->i_sb;
sb142fs/sysv/fsync.cfor (i = 0; i < sb->sv_ind_per_block; i++) {
sb144fs/sysv/fsync.c((unsigned long *) dind_bh->b_data) + i, sb->sv_convert,
sb161fs/sysv/fsync.cstruct super_block * sb;
sb167fs/sysv/fsync.csb = inode->i_sb;
sb168fs/sysv/fsync.cfor (i = 0; i < sb->sv_ind_per_block; i++) {
sb170fs/sysv/fsync.c((unsigned long *) tind_bh->b_data) + i, sb->sv_convert,
sb38fs/sysv/ialloc.cstatic inline sysv_ino_t * sv_sb_fic_inode (struct super_block * sb, unsigned int i)
sb40fs/sysv/ialloc.cif (sb->sv_bh1 == sb->sv_bh2)
sb41fs/sysv/ialloc.creturn &sb->sv_sb_fic_inodes[i];
sb46fs/sysv/ialloc.creturn (sysv_ino_t*)(sb->sv_sbd1 + offset);
sb48fs/sysv/ialloc.creturn (sysv_ino_t*)(sb->sv_sbd2 + offset);
sb54fs/sysv/ialloc.cstruct super_block * sb;
sb73fs/sysv/ialloc.cif (!(sb = inode->i_sb)) {
sb78fs/sysv/ialloc.cif (ino <= SYSV_ROOT_INO || ino > sb->sv_ninodes) {
sb82fs/sysv/ialloc.cif (!(bh = sv_bread(sb, inode->i_dev, sb->sv_firstinodezone + ((ino-1) >> sb->sv_inodes_per_block_bits)))) {
sb88fs/sysv/ialloc.craw_inode = (struct sysv_inode *) bh->b_data + ((ino-1) & sb->sv_inodes_per_block_1);
sb89fs/sysv/ialloc.clock_super(sb);
sb90fs/sysv/ialloc.cif (*sb->sv_sb_fic_count < sb->sv_fic_size)
sb91fs/sysv/ialloc.c*sv_sb_fic_inode(sb,(*sb->sv_sb_fic_count)++) = ino;
sb92fs/sysv/ialloc.c(*sb->sv_sb_total_free_inodes)++;
sb93fs/sysv/ialloc.cmark_buffer_dirty(sb->sv_bh1, 1); /* super-block has been modified */
sb94fs/sysv/ialloc.cif (sb->sv_bh1 != sb->sv_bh2) mark_buffer_dirty(sb->sv_bh2, 1);
sb95fs/sysv/ialloc.csb->s_dirt = 1; /* and needs time stamp */
sb98fs/sysv/ialloc.cunlock_super(sb);
sb106fs/sysv/ialloc.cstruct super_block * sb;
sb113fs/sysv/ialloc.csb = dir->i_sb;
sb114fs/sysv/ialloc.cinode->i_sb = sb;
sb116fs/sysv/ialloc.clock_super(sb);    /* protect against task switches */
sb117fs/sysv/ialloc.cif ((*sb->sv_sb_fic_count == 0)
sb118fs/sysv/ialloc.c|| (*sv_sb_fic_inode(sb,(*sb->sv_sb_fic_count)-1) == 0) /* Applies only to SystemV2 FS */
sb127fs/sysv/ialloc.cfor (i = 0, ino = SYSV_ROOT_INO+1, block = sb->sv_firstinodezone, j = SYSV_ROOT_INO ; i < sb->sv_fic_size && block < sb->sv_firstdatazone ; block++, j = 0) {
sb128fs/sysv/ialloc.cif (!(bh = sv_bread(sb, sb->s_dev, block))) {
sb134fs/sysv/ialloc.cfor (; j < sb->sv_inodes_per_block && i < sb->sv_fic_size; ino++, j++, raw_inode++) {
sb136fs/sysv/ialloc.c*sv_sb_fic_inode(sb,i++) = ino;
sb142fs/sysv/ialloc.cunlock_super(sb);
sb145fs/sysv/ialloc.c*sb->sv_sb_fic_count = i;
sb148fs/sysv/ialloc.cino = *sv_sb_fic_inode(sb,--(*sb->sv_sb_fic_count));
sb149fs/sysv/ialloc.cmark_buffer_dirty(sb->sv_bh1, 1); /* super-block has been modified */
sb150fs/sysv/ialloc.cif (sb->sv_bh1 != sb->sv_bh2) mark_buffer_dirty(sb->sv_bh2, 1);
sb151fs/sysv/ialloc.csb->s_dirt = 1; /* and needs time stamp */
sb154fs/sysv/ialloc.cinode->i_dev = sb->s_dev;
sb170fs/sysv/ialloc.c(*sb->sv_sb_total_free_inodes)--;
sb171fs/sysv/ialloc.cmark_buffer_dirty(sb->sv_bh2, 1); /* super-block has been modified again */
sb172fs/sysv/ialloc.csb->s_dirt = 1; /* and needs time stamp again */
sb173fs/sysv/ialloc.cunlock_super(sb);
sb177fs/sysv/ialloc.cunsigned long sysv_count_free_inodes(struct super_block * sb)
sb186fs/sysv/ialloc.clock_super(sb);
sb193fs/sysv/ialloc.cfor (block = sb->sv_firstinodezone, j = SYSV_ROOT_INO ; block < sb->sv_firstdatazone ; block++, j = 0) {
sb194fs/sysv/ialloc.cif (!(bh = sv_bread(sb, sb->s_dev, block))) {
sb200fs/sysv/ialloc.cfor (; j < sb->sv_inodes_per_block ; j++, raw_inode++)
sb205fs/sysv/ialloc.cif (count != *sb->sv_sb_total_free_inodes) {
sb206fs/sysv/ialloc.cprintk("sysv_count_free_inodes: free inode count was %d, correcting to %d\n",(short)(*sb->sv_sb_total_free_inodes),count);
sb207fs/sysv/ialloc.cif (!(sb->s_flags & MS_RDONLY)) {
sb208fs/sysv/ialloc.c*sb->sv_sb_total_free_inodes = count;
sb209fs/sysv/ialloc.cmark_buffer_dirty(sb->sv_bh2, 1); /* super-block has been modified */
sb210fs/sysv/ialloc.csb->s_dirt = 1; /* and needs time stamp */
sb213fs/sysv/ialloc.cunlock_super(sb);
sb216fs/sysv/ialloc.creturn *sb->sv_sb_total_free_inodes;
sb65fs/sysv/inode.cstatic void detected_bs512 (struct super_block *sb)
sb67fs/sysv/inode.csb->sv_block_size = 512;
sb68fs/sysv/inode.csb->sv_block_size_1 = 512-1;
sb69fs/sysv/inode.csb->sv_block_size_bits = 9;
sb70fs/sysv/inode.csb->sv_block_size_ratio = 2;
sb71fs/sysv/inode.csb->sv_block_size_ratio_bits = 1;
sb72fs/sysv/inode.csb->sv_inodes_per_block = 512/64;
sb73fs/sysv/inode.csb->sv_inodes_per_block_1 = 512/64-1;
sb74fs/sysv/inode.csb->sv_inodes_per_block_bits = 9-6;
sb75fs/sysv/inode.csb->sv_toobig_block = 10 + 
sb76fs/sysv/inode.c(sb->sv_ind_per_block = 512/4) +
sb77fs/sysv/inode.c(sb->sv_ind_per_block_2 = (512/4)*(512/4)) +
sb78fs/sysv/inode.c(sb->sv_ind_per_block_3 = (512/4)*(512/4)*(512/4));
sb79fs/sysv/inode.csb->sv_ind_per_block_1 = 512/4-1;
sb80fs/sysv/inode.csb->sv_ind_per_block_2_1 = (512/4)*(512/4)-1;
sb81fs/sysv/inode.csb->sv_ind_per_block_2_bits = 2 *
sb82fs/sysv/inode.c(sb->sv_ind_per_block_bits = 9-2);
sb83fs/sysv/inode.csb->sv_ind_per_block_block_size_1 = (512/4)*512-1;
sb84fs/sysv/inode.csb->sv_ind_per_block_block_size_bits = (9-2)+9;
sb85fs/sysv/inode.csb->sv_ind_per_block_2_block_size_1 = (512/4)*(512/4)*512-1;
sb86fs/sysv/inode.csb->sv_ind_per_block_2_block_size_bits = (9-2)+(9-2)+9;
sb87fs/sysv/inode.csb->sv_ind0_size = 10 * 512;
sb88fs/sysv/inode.csb->sv_ind1_size = (10 + (512/4))* 512;
sb89fs/sysv/inode.csb->sv_ind2_size = (10 + (512/4) + (512/4)*(512/4)) * 512;
sb92fs/sysv/inode.cstatic void detected_bs1024 (struct super_block *sb)
sb94fs/sysv/inode.csb->sv_block_size = 1024;
sb95fs/sysv/inode.csb->sv_block_size_1 = 1024-1;
sb96fs/sysv/inode.csb->sv_block_size_bits = 10;
sb97fs/sysv/inode.csb->sv_block_size_ratio = 1;
sb98fs/sysv/inode.csb->sv_block_size_ratio_bits = 0;
sb99fs/sysv/inode.csb->sv_inodes_per_block = 1024/64;
sb100fs/sysv/inode.csb->sv_inodes_per_block_1 = 1024/64-1;
sb101fs/sysv/inode.csb->sv_inodes_per_block_bits = 10-6;
sb102fs/sysv/inode.csb->sv_toobig_block = 10 + 
sb103fs/sysv/inode.c(sb->sv_ind_per_block = 1024/4) +
sb104fs/sysv/inode.c(sb->sv_ind_per_block_2 = (1024/4)*(1024/4)) +
sb105fs/sysv/inode.c(sb->sv_ind_per_block_3 = (1024/4)*(1024/4)*(1024/4));
sb106fs/sysv/inode.csb->sv_ind_per_block_1 = 1024/4-1;
sb107fs/sysv/inode.csb->sv_ind_per_block_2_1 = (1024/4)*(1024/4)-1;
sb108fs/sysv/inode.csb->sv_ind_per_block_2_bits = 2 *
sb109fs/sysv/inode.c(sb->sv_ind_per_block_bits = 10-2);
sb110fs/sysv/inode.csb->sv_ind_per_block_block_size_1 = (1024/4)*1024-1;
sb111fs/sysv/inode.csb->sv_ind_per_block_block_size_bits = (10-2)+10;
sb112fs/sysv/inode.csb->sv_ind_per_block_2_block_size_1 = (1024/4)*(1024/4)*1024-1;
sb113fs/sysv/inode.csb->sv_ind_per_block_2_block_size_bits = (10-2)+(10-2)+10;
sb114fs/sysv/inode.csb->sv_ind0_size = 10 * 1024;
sb115fs/sysv/inode.csb->sv_ind1_size = (10 + (1024/4))* 1024;
sb116fs/sysv/inode.csb->sv_ind2_size = (10 + (1024/4) + (1024/4)*(1024/4)) * 1024;
sb119fs/sysv/inode.cstatic const char* detect_xenix (struct super_block *sb, struct buffer_head *bh)
sb127fs/sysv/inode.ccase 1: detected_bs512(sb); break;
sb128fs/sysv/inode.ccase 2: detected_bs1024(sb); break;
sb131fs/sysv/inode.csb->sv_type = FSTYPE_XENIX;
sb134fs/sysv/inode.cstatic struct super_block * detected_xenix (struct super_block *sb, struct buffer_head *bh1, struct buffer_head *bh2)
sb139fs/sysv/inode.cif (sb->sv_block_size == BLOCK_SIZE)
sb151fs/sysv/inode.csb->sv_convert = 0;
sb152fs/sysv/inode.csb->sv_kludge_symlinks = 1;
sb153fs/sysv/inode.csb->sv_truncate = 1;
sb154fs/sysv/inode.csb->sv_link_max = XENIX_LINK_MAX;
sb155fs/sysv/inode.csb->sv_fic_size = XENIX_NICINOD;
sb156fs/sysv/inode.csb->sv_flc_size = XENIX_NICFREE;
sb157fs/sysv/inode.csb->sv_bh1 = bh1;
sb158fs/sysv/inode.csb->sv_bh2 = bh2;
sb159fs/sysv/inode.csb->sv_sbd1 = (char *) sbd1;
sb160fs/sysv/inode.csb->sv_sbd2 = (char *) sbd2;
sb161fs/sysv/inode.csb->sv_sb_fic_count = &sbd1->s_ninode;
sb162fs/sysv/inode.csb->sv_sb_fic_inodes = &sbd1->s_inode[0];
sb163fs/sysv/inode.csb->sv_sb_total_free_inodes = &sbd2->s_tinode;
sb164fs/sysv/inode.csb->sv_sb_flc_count = &sbd1->s_nfree;
sb165fs/sysv/inode.csb->sv_sb_flc_blocks = &sbd1->s_free[0];
sb166fs/sysv/inode.csb->sv_sb_total_free_blocks = &sbd2->s_tfree;
sb167fs/sysv/inode.csb->sv_sb_time = &sbd2->s_time;
sb168fs/sysv/inode.csb->sv_block_base = 0;
sb169fs/sysv/inode.csb->sv_firstinodezone = 2;
sb170fs/sysv/inode.csb->sv_firstdatazone = sbd1->s_isize;
sb171fs/sysv/inode.csb->sv_nzones = sbd1->s_fsize;
sb172fs/sysv/inode.csb->sv_ndatazones = sb->sv_nzones - sb->sv_firstdatazone;
sb173fs/sysv/inode.creturn sb;
sb176fs/sysv/inode.cstatic const char* detect_sysv4 (struct super_block *sb, struct buffer_head *bh)
sb186fs/sysv/inode.ccase 1: detected_bs512(sb); break;
sb187fs/sysv/inode.ccase 2: detected_bs1024(sb); break;
sb190fs/sysv/inode.csb->sv_type = FSTYPE_SYSV4;
sb193fs/sysv/inode.cstatic struct super_block * detected_sysv4 (struct super_block *sb, struct buffer_head *bh)
sb197fs/sysv/inode.cif (sb->sv_block_size == BLOCK_SIZE)
sb208fs/sysv/inode.csb->sv_convert = 0;
sb209fs/sysv/inode.csb->sv_kludge_symlinks = 0; /* ?? */
sb210fs/sysv/inode.csb->sv_truncate = 1;
sb211fs/sysv/inode.csb->sv_link_max = SYSV_LINK_MAX;
sb212fs/sysv/inode.csb->sv_fic_size = SYSV_NICINOD;
sb213fs/sysv/inode.csb->sv_flc_size = SYSV_NICFREE;
sb214fs/sysv/inode.csb->sv_bh1 = bh;
sb215fs/sysv/inode.csb->sv_bh2 = bh;
sb216fs/sysv/inode.csb->sv_sbd1 = (char *) sbd;
sb217fs/sysv/inode.csb->sv_sbd2 = (char *) sbd;
sb218fs/sysv/inode.csb->sv_sb_fic_count = &sbd->s_ninode;
sb219fs/sysv/inode.csb->sv_sb_fic_inodes = &sbd->s_inode[0];
sb220fs/sysv/inode.csb->sv_sb_total_free_inodes = &sbd->s_tinode;
sb221fs/sysv/inode.csb->sv_sb_flc_count = &sbd->s_nfree;
sb222fs/sysv/inode.csb->sv_sb_flc_blocks = &sbd->s_free[0];
sb223fs/sysv/inode.csb->sv_sb_total_free_blocks = &sbd->s_tfree;
sb224fs/sysv/inode.csb->sv_sb_time = &sbd->s_time;
sb225fs/sysv/inode.csb->sv_sb_state = &sbd->s_state;
sb226fs/sysv/inode.csb->sv_block_base = 0;
sb227fs/sysv/inode.csb->sv_firstinodezone = 2;
sb228fs/sysv/inode.csb->sv_firstdatazone = sbd->s_isize;
sb229fs/sysv/inode.csb->sv_nzones = sbd->s_fsize;
sb230fs/sysv/inode.csb->sv_ndatazones = sb->sv_nzones - sb->sv_firstdatazone;
sb231fs/sysv/inode.creturn sb;
sb234fs/sysv/inode.cstatic const char* detect_sysv2 (struct super_block *sb, struct buffer_head *bh)
sb244fs/sysv/inode.ccase 1: detected_bs512(sb); break;
sb245fs/sysv/inode.ccase 2: detected_bs1024(sb); break;
sb248fs/sysv/inode.csb->sv_type = FSTYPE_SYSV2;
sb251fs/sysv/inode.cstatic struct super_block * detected_sysv2 (struct super_block *sb, struct buffer_head *bh)
sb255fs/sysv/inode.cif (sb->sv_block_size == BLOCK_SIZE)
sb266fs/sysv/inode.csb->sv_convert = 0;
sb267fs/sysv/inode.csb->sv_kludge_symlinks = 0; /* ?? */
sb268fs/sysv/inode.csb->sv_truncate = 1;
sb269fs/sysv/inode.csb->sv_link_max = SYSV_LINK_MAX;
sb270fs/sysv/inode.csb->sv_fic_size = SYSV_NICINOD;
sb271fs/sysv/inode.csb->sv_flc_size = SYSV_NICFREE;
sb272fs/sysv/inode.csb->sv_bh1 = bh;
sb273fs/sysv/inode.csb->sv_bh2 = bh;
sb274fs/sysv/inode.csb->sv_sbd1 = (char *) sbd;
sb275fs/sysv/inode.csb->sv_sbd2 = (char *) sbd;
sb276fs/sysv/inode.csb->sv_sb_fic_count = &sbd->s_ninode;
sb277fs/sysv/inode.csb->sv_sb_fic_inodes = &sbd->s_inode[0];
sb278fs/sysv/inode.csb->sv_sb_total_free_inodes = &sbd->s_tinode;
sb279fs/sysv/inode.csb->sv_sb_flc_count = &sbd->s_nfree;
sb280fs/sysv/inode.csb->sv_sb_flc_blocks = &sbd->s_free[0];
sb281fs/sysv/inode.csb->sv_sb_total_free_blocks = &sbd->s_tfree;
sb282fs/sysv/inode.csb->sv_sb_time = &sbd->s_time;
sb283fs/sysv/inode.csb->sv_sb_state = &sbd->s_state;
sb284fs/sysv/inode.csb->sv_block_base = 0;
sb285fs/sysv/inode.csb->sv_firstinodezone = 2;
sb286fs/sysv/inode.csb->sv_firstdatazone = sbd->s_isize;
sb287fs/sysv/inode.csb->sv_nzones = sbd->s_fsize;
sb288fs/sysv/inode.csb->sv_ndatazones = sb->sv_nzones - sb->sv_firstdatazone;
sb289fs/sysv/inode.creturn sb;
sb292fs/sysv/inode.cstatic const char* detect_coherent (struct super_block *sb, struct buffer_head *bh)
sb300fs/sysv/inode.cdetected_bs512(sb);
sb301fs/sysv/inode.csb->sv_type = FSTYPE_COH;
sb304fs/sysv/inode.cstatic struct super_block * detected_coherent (struct super_block *sb, struct buffer_head *bh)
sb314fs/sysv/inode.csb->sv_convert = 1;
sb315fs/sysv/inode.csb->sv_kludge_symlinks = 1;
sb316fs/sysv/inode.csb->sv_truncate = 1;
sb317fs/sysv/inode.csb->sv_link_max = COH_LINK_MAX;
sb318fs/sysv/inode.csb->sv_fic_size = COH_NICINOD;
sb319fs/sysv/inode.csb->sv_flc_size = COH_NICFREE;
sb320fs/sysv/inode.csb->sv_bh1 = bh;
sb321fs/sysv/inode.csb->sv_bh2 = bh;
sb322fs/sysv/inode.csb->sv_sbd1 = (char *) sbd;
sb323fs/sysv/inode.csb->sv_sbd2 = (char *) sbd;
sb324fs/sysv/inode.csb->sv_sb_fic_count = &sbd->s_ninode;
sb325fs/sysv/inode.csb->sv_sb_fic_inodes = &sbd->s_inode[0];
sb326fs/sysv/inode.csb->sv_sb_total_free_inodes = &sbd->s_tinode;
sb327fs/sysv/inode.csb->sv_sb_flc_count = &sbd->s_nfree;
sb328fs/sysv/inode.csb->sv_sb_flc_blocks = &sbd->s_free[0];
sb329fs/sysv/inode.csb->sv_sb_total_free_blocks = &sbd->s_tfree;
sb330fs/sysv/inode.csb->sv_sb_time = &sbd->s_time;
sb331fs/sysv/inode.csb->sv_block_base = 0;
sb332fs/sysv/inode.csb->sv_firstinodezone = 2;
sb333fs/sysv/inode.csb->sv_firstdatazone = sbd->s_isize;
sb334fs/sysv/inode.csb->sv_nzones = from_coh_ulong(sbd->s_fsize);
sb335fs/sysv/inode.csb->sv_ndatazones = sb->sv_nzones - sb->sv_firstdatazone;
sb336fs/sysv/inode.creturn sb;
sb339fs/sysv/inode.cstruct super_block *sysv_read_super(struct super_block *sb,void *data, 
sb344fs/sysv/inode.ckdev_t dev = sb->s_dev;
sb356fs/sysv/inode.clock_super(sb);
sb361fs/sysv/inode.cif ((found = detect_xenix(sb,bh)) != NULL)
sb367fs/sysv/inode.cif ((found = detect_sysv4(sb,bh)) != NULL)
sb369fs/sysv/inode.cif ((found = detect_sysv2(sb,bh)) != NULL)
sb372fs/sysv/inode.cif ((found = detect_coherent(sb,bh)) != NULL)
sb383fs/sysv/inode.cif ((found = detect_sysv4(sb,bh)) != NULL) {
sb384fs/sysv/inode.csb->sv_block_base = offsets[i] << sb->sv_block_size_ratio_bits;
sb387fs/sysv/inode.cif ((found = detect_sysv2(sb,bh)) != NULL) {
sb388fs/sysv/inode.csb->sv_block_base = offsets[i] << sb->sv_block_size_ratio_bits;
sb394fs/sysv/inode.csb->s_dev = 0;
sb395fs/sysv/inode.cunlock_super(sb);
sb404fs/sysv/inode.cif (sb->sv_block_size == BLOCK_SIZE) {
sb405fs/sysv/inode.cswitch (sb->sv_type) {
sb407fs/sysv/inode.cif (!detected_xenix(sb,bh,bh))
sb411fs/sysv/inode.cif (!detected_sysv4(sb,bh))
sb415fs/sysv/inode.cif (!detected_sysv2(sb,bh))
sb421fs/sysv/inode.csb->s_dev = 0;
sb422fs/sysv/inode.cunlock_super(sb);
sb430fs/sysv/inode.cunsigned long blocknr = bh->b_blocknr << sb->sv_block_size_ratio_bits;
sb433fs/sysv/inode.cset_blocksize(dev,sb->sv_block_size);
sb435fs/sysv/inode.cswitch (sb->sv_type) {
sb437fs/sysv/inode.cif ((bh1 = bread(dev, blocknr, sb->sv_block_size)) == NULL)
sb439fs/sysv/inode.cif ((bh2 = bread(dev, blocknr+1, sb->sv_block_size)) == NULL)
sb441fs/sysv/inode.cif (!detected_xenix(sb,bh1,bh2))
sb445fs/sysv/inode.cif ((bh2 = bread(dev, blocknr+1, sb->sv_block_size)) == NULL)
sb447fs/sysv/inode.cif (!detected_sysv4(sb,bh2))
sb451fs/sysv/inode.cif ((bh2 = bread(dev, blocknr+1, sb->sv_block_size)) == NULL)
sb453fs/sysv/inode.cif (!detected_sysv2(sb,bh2))
sb457fs/sysv/inode.cif ((bh2 = bread(dev, blocknr+1, sb->sv_block_size)) == NULL)
sb459fs/sysv/inode.cif (!detected_coherent(sb,bh2))
sb466fs/sysv/inode.cset_blocksize(sb->s_dev,BLOCK_SIZE);
sb467fs/sysv/inode.csb->s_dev = 0;
sb468fs/sysv/inode.cunlock_super(sb);
sb473fs/sysv/inode.csb->sv_ninodes = (sb->sv_firstdatazone - sb->sv_firstinodezone) << sb->sv_inodes_per_block_bits;
sb476fs/sysv/inode.cfound, sb->sv_block_size, kdevname(dev));
sb477fs/sysv/inode.csb->s_magic = SYSV_MAGIC_BASE + sb->sv_type;
sb479fs/sysv/inode.csb->s_blocksize = sb->sv_block_size;
sb480fs/sysv/inode.csb->s_blocksize_bits = sb->sv_block_size_bits;
sb482fs/sysv/inode.csb->s_dev = dev;
sb483fs/sysv/inode.csb->s_op = &sysv_sops;
sb484fs/sysv/inode.csb->s_mounted = iget(sb,SYSV_ROOT_INO);
sb485fs/sysv/inode.cunlock_super(sb);
sb486fs/sysv/inode.cif (!sb->s_mounted) {
sb488fs/sysv/inode.csysv_put_super(sb);
sb491fs/sysv/inode.csb->s_dirt = 1;
sb494fs/sysv/inode.creturn sb;
sb498fs/sysv/inode.cvoid sysv_write_super (struct super_block *sb)
sb500fs/sysv/inode.clock_super(sb);
sb501fs/sysv/inode.cif (buffer_dirty(sb->sv_bh1) || buffer_dirty(sb->sv_bh2)) {
sb506fs/sysv/inode.cunsigned long old_time = *sb->sv_sb_time;
sb507fs/sysv/inode.cif (sb->sv_convert)
sb509fs/sysv/inode.cif (sb->sv_type == FSTYPE_SYSV4)
sb510fs/sysv/inode.cif (*sb->sv_sb_state == 0x7c269d38 - old_time)
sb511fs/sysv/inode.c*sb->sv_sb_state = 0x7c269d38 - time;
sb512fs/sysv/inode.cif (sb->sv_convert)
sb514fs/sysv/inode.c*sb->sv_sb_time = time;
sb515fs/sysv/inode.cmark_buffer_dirty(sb->sv_bh2, 1);
sb517fs/sysv/inode.csb->s_dirt = 0;
sb518fs/sysv/inode.cunlock_super(sb);
sb521fs/sysv/inode.cvoid sysv_put_super(struct super_block *sb)
sb524fs/sysv/inode.clock_super(sb);
sb525fs/sysv/inode.cbrelse(sb->sv_bh1);
sb526fs/sysv/inode.cif (sb->sv_bh1 != sb->sv_bh2) brelse(sb->sv_bh2);
sb528fs/sysv/inode.cif (sb->s_blocksize != BLOCK_SIZE)
sb529fs/sysv/inode.cset_blocksize(sb->s_dev,BLOCK_SIZE);
sb530fs/sysv/inode.csb->s_dev = 0;
sb531fs/sysv/inode.cunlock_super(sb);
sb535fs/sysv/inode.cvoid sysv_statfs(struct super_block *sb, struct statfs *buf, int bufsiz)
sb539fs/sysv/inode.ctmp.f_type = sb->s_magic;      /* type of filesystem */
sb540fs/sysv/inode.ctmp.f_bsize = sb->sv_block_size;    /* block size */
sb541fs/sysv/inode.ctmp.f_blocks = sb->sv_ndatazones;    /* total data blocks in file system */
sb542fs/sysv/inode.ctmp.f_bfree = sysv_count_free_blocks(sb);  /* free blocks in fs */
sb544fs/sysv/inode.ctmp.f_files = sb->sv_ninodes;      /* total file nodes in file system */
sb545fs/sysv/inode.ctmp.f_ffree = sysv_count_free_inodes(sb);  /* free file nodes in fs */
sb554fs/sysv/inode.cstatic inline int inode_bmap(struct super_block * sb, struct inode * inode, int nr)
sb559fs/sysv/inode.creturn tmp + sb->sv_block_base;
sb562fs/sysv/inode.cstatic int block_bmap(struct super_block * sb, struct buffer_head * bh, int nr, int convert)
sb574fs/sysv/inode.creturn tmp + sb->sv_block_base;
sb580fs/sysv/inode.cstruct super_block * sb = inode->i_sb;
sb586fs/sysv/inode.creturn inode_bmap(sb,inode,block);
sb588fs/sysv/inode.cconvert = sb->sv_convert;
sb589fs/sysv/inode.cif (block < sb->sv_ind_per_block) {
sb590fs/sysv/inode.ci = inode_bmap(sb,inode,10);
sb593fs/sysv/inode.cbh = bread(inode->i_dev,i,sb->sv_block_size);
sb594fs/sysv/inode.creturn block_bmap(sb, bh, block, convert);
sb596fs/sysv/inode.cblock -= sb->sv_ind_per_block;
sb597fs/sysv/inode.cif (block < sb->sv_ind_per_block_2) {
sb598fs/sysv/inode.ci = inode_bmap(sb,inode,11);
sb601fs/sysv/inode.cbh = bread(inode->i_dev,i,sb->sv_block_size);
sb602fs/sysv/inode.ci = block_bmap(sb, bh, block >> sb->sv_ind_per_block_bits, convert);
sb605fs/sysv/inode.cbh = bread(inode->i_dev,i,sb->sv_block_size);
sb606fs/sysv/inode.creturn block_bmap(sb, bh, block & sb->sv_ind_per_block_1, convert);
sb608fs/sysv/inode.cblock -= sb->sv_ind_per_block_2;
sb609fs/sysv/inode.cif (block < sb->sv_ind_per_block_3) {
sb610fs/sysv/inode.ci = inode_bmap(sb,inode,12);
sb613fs/sysv/inode.cbh = bread(inode->i_dev,i,sb->sv_block_size);
sb614fs/sysv/inode.ci = block_bmap(sb, bh, block >> sb->sv_ind_per_block_2_bits, convert);
sb617fs/sysv/inode.cbh = bread(inode->i_dev,i,sb->sv_block_size);
sb618fs/sysv/inode.ci = block_bmap(sb, bh, (block >> sb->sv_ind_per_block_bits) & sb->sv_ind_per_block_1,convert);
sb621fs/sysv/inode.cbh = bread(inode->i_dev,i,sb->sv_block_size);
sb622fs/sysv/inode.creturn block_bmap(sb, bh, block & sb->sv_ind_per_block_1, convert);
sb639fs/sysv/inode.cstruct super_block *sb;
sb644fs/sysv/inode.csb = inode->i_sb;
sb649fs/sysv/inode.cresult = sv_getblk(sb, inode->i_dev, tmp);
sb657fs/sysv/inode.ctmp = sysv_new_block(sb);
sb660fs/sysv/inode.cresult = sv_getblk(sb, inode->i_dev, tmp);
sb662fs/sysv/inode.csysv_free_block(sb,tmp);
sb675fs/sysv/inode.cstruct super_block *sb;
sb690fs/sysv/inode.csb = inode->i_sb;
sb694fs/sysv/inode.cif (sb->sv_convert)
sb697fs/sysv/inode.cresult = sv_getblk(sb, bh->b_dev, block);
sb709fs/sysv/inode.cblock = sysv_new_block(sb);
sb714fs/sysv/inode.cresult = sv_getblk(sb, bh->b_dev, block);
sb716fs/sysv/inode.csysv_free_block(sb,block);
sb720fs/sysv/inode.c*p = (sb->sv_convert ? to_coh_ulong(block) : block);
sb728fs/sysv/inode.cstruct super_block * sb = inode->i_sb;
sb734fs/sysv/inode.cif (block < sb->sv_ind_per_block) {
sb738fs/sysv/inode.cblock -= sb->sv_ind_per_block;
sb739fs/sysv/inode.cif (block < sb->sv_ind_per_block_2) {
sb741fs/sysv/inode.cbh = block_getblk(inode, bh, block >> sb->sv_ind_per_block_bits, create);
sb742fs/sysv/inode.creturn block_getblk(inode, bh, block & sb->sv_ind_per_block_1, create);
sb744fs/sysv/inode.cblock -= sb->sv_ind_per_block_2;
sb745fs/sysv/inode.cif (block < sb->sv_ind_per_block_3) {
sb747fs/sysv/inode.cbh = block_getblk(inode, bh, block >> sb->sv_ind_per_block_2_bits, create);
sb748fs/sysv/inode.cbh = block_getblk(inode, bh, (block >> sb->sv_ind_per_block_bits) & sb->sv_ind_per_block_1, create);
sb749fs/sysv/inode.creturn block_getblk(inode, bh, block & sb->sv_ind_per_block_1, create);
sb801fs/sysv/inode.cstruct super_block * sb = inode->i_sb;
sb810fs/sysv/inode.cif (!ino || ino > sb->sv_ninodes) {
sb816fs/sysv/inode.cblock = sb->sv_firstinodezone + ((ino-1) >> sb->sv_inodes_per_block_bits);
sb817fs/sysv/inode.cif (!(bh = sv_bread(sb,inode->i_dev,block))) {
sb823fs/sysv/inode.craw_inode = (struct sysv_inode *) bh->b_data + ((ino-1) & sb->sv_inodes_per_block_1);
sb825fs/sysv/inode.cif (sb->sv_kludge_symlinks)
sb832fs/sysv/inode.cif (sb->sv_convert) {
sb847fs/sysv/inode.cif (sb->sv_convert)
sb890fs/sysv/inode.cstruct super_block * sb = inode->i_sb;
sb897fs/sysv/inode.cif (!ino || ino > sb->sv_ninodes) {
sb904fs/sysv/inode.cblock = sb->sv_firstinodezone + ((ino-1) >> sb->sv_inodes_per_block_bits);
sb905fs/sysv/inode.cif (!(bh = sv_bread(sb,inode->i_dev,block))) {
sb910fs/sysv/inode.craw_inode = (struct sysv_inode *) bh->b_data + ((ino-1) & sb->sv_inodes_per_block_1);
sb912fs/sysv/inode.cif (sb->sv_kludge_symlinks)
sb918fs/sysv/inode.cif (sb->sv_convert) {
sb932fs/sysv/inode.cif (sb->sv_convert)
sb63fs/sysv/namei.cstruct super_block * sb;
sb70fs/sysv/namei.csb = dir->i_sb;
sb72fs/sysv/namei.cif (sb->sv_truncate)
sb83fs/sysv/namei.cpos += sb->sv_block_size;
sb92fs/sysv/namei.cif (offset < sb->sv_block_size)
sb146fs/sysv/namei.cstruct super_block * sb;
sb156fs/sysv/namei.csb = dir->i_sb;
sb158fs/sysv/namei.cif (sb->sv_truncate)
sb194fs/sysv/namei.cif (offset < sb->sv_block_size)
sb367fs/sysv/namei.cstruct super_block * sb;
sb390fs/sysv/namei.csb = inode->i_sb;
sb396fs/sysv/namei.cpos += sb->sv_block_size;
sb407fs/sysv/namei.cif (offset < sb->sv_block_size)
sb538fs/sysv/namei.cstruct super_block * sb;
sb557fs/sysv/namei.csb = inode->i_sb;
sb560fs/sysv/namei.cwhile (i < sb->sv_block_size_1 && (c = *(symname++)))
sb42fs/sysv/truncate.cstruct super_block * sb;
sb49fs/sysv/truncate.csb = inode->i_sb;
sb51fs/sysv/truncate.cfor (i = ((unsigned long) inode->i_size + sb->sv_block_size_1) >> sb->sv_block_size_bits; i < 10; i++) {
sb56fs/sysv/truncate.cbh = sv_get_hash_table(sb, inode->i_dev, block);
sb57fs/sysv/truncate.cif ((i << sb->sv_block_size_bits) < inode->i_size) {
sb69fs/sysv/truncate.csysv_free_block(sb,block);
sb77fs/sysv/truncate.cstruct super_block * sb;
sb90fs/sysv/truncate.csb = inode->i_sb;
sb91fs/sysv/truncate.cindbh = sv_bread(sb, inode->i_dev, indblock);
sb105fs/sysv/truncate.ci = (inode->i_size - offset + sb->sv_block_size_1) >> sb->sv_block_size_bits;
sb106fs/sysv/truncate.cfor (; i < sb->sv_ind_per_block; i++) {
sb109fs/sysv/truncate.cif (sb->sv_convert)
sb113fs/sysv/truncate.cbh = sv_get_hash_table(sb, inode->i_dev, block);
sb114fs/sysv/truncate.cif ((i << sb->sv_block_size_bits) + offset < inode->i_size) {
sb126fs/sysv/truncate.csysv_free_block(sb,block);
sb128fs/sysv/truncate.cfor (i = 0; i < sb->sv_ind_per_block; i++)
sb137fs/sysv/truncate.csysv_free_block(sb,indblock);
sb146fs/sysv/truncate.cstruct super_block * sb;
sb158fs/sysv/truncate.csb = inode->i_sb;
sb159fs/sysv/truncate.cindbh = sv_bread(sb, inode->i_dev, indblock);
sb172fs/sysv/truncate.ci = (inode->i_size - offset + sb->sv_ind_per_block_block_size_1) >> sb->sv_ind_per_block_block_size_bits;
sb173fs/sysv/truncate.cfor (; i < sb->sv_ind_per_block; i++) {
sb177fs/sysv/truncate.cif (sb->sv_convert)
sb181fs/sysv/truncate.cretry |= trunc_indirect(inode,offset+(i<<sb->sv_ind_per_block_bits),ind,sb->sv_convert,&dirty);
sb185fs/sysv/truncate.cfor (i = 0; i < sb->sv_ind_per_block; i++)
sb194fs/sysv/truncate.csysv_free_block(sb,indblock);
sb203fs/sysv/truncate.cstruct super_block * sb;
sb215fs/sysv/truncate.csb = inode->i_sb;
sb216fs/sysv/truncate.cindbh = sv_bread(sb, inode->i_dev, indblock);
sb229fs/sysv/truncate.ci = (inode->i_size - offset + sb->sv_ind_per_block_2_block_size_1) >> sb->sv_ind_per_block_2_block_size_bits;
sb230fs/sysv/truncate.cfor (; i < sb->sv_ind_per_block; i++) {
sb234fs/sysv/truncate.cif (sb->sv_convert)
sb238fs/sysv/truncate.cretry |= trunc_dindirect(inode,offset+(i<<sb->sv_ind_per_block_2_bits),ind,sb->sv_convert,&dirty);
sb242fs/sysv/truncate.cfor (i = 0; i < sb->sv_ind_per_block; i++)
sb251fs/sysv/truncate.csysv_free_block(sb,indblock);
sb259fs/sysv/truncate.cstruct super_block * sb;
sb261fs/sysv/truncate.csb = inode->i_sb;
sb263fs/sysv/truncate.c| trunc_indirect(inode,sb->sv_ind0_size,&inode->u.sysv_i.i_data[10],0,&inode->i_dirt)
sb264fs/sysv/truncate.c| trunc_dindirect(inode,sb->sv_ind1_size,&inode->u.sysv_i.i_data[11],0,&inode->i_dirt)
sb265fs/sysv/truncate.c| trunc_tindirect(inode,sb->sv_ind2_size,&inode->u.sysv_i.i_data[12],0,&inode->i_dirt);
sb51fs/umsdos/inode.cvoid UMSDOS_put_super(struct super_block *sb)
sb53fs/umsdos/inode.cmsdos_put_super(sb);
sb58fs/umsdos/inode.cvoid UMSDOS_statfs(struct super_block *sb,struct statfs *buf, int bufsiz)
sb60fs/umsdos/inode.cfat_statfs(sb,buf,bufsiz);
sb401fs/umsdos/inode.cstruct super_block *sb;
sb403fs/umsdos/inode.csb = msdos_read_super(s,data,silent);
sb406fs/umsdos/inode.cif (sb != NULL){
sb407fs/umsdos/inode.cMSDOS_SB(sb)->options.dotsOK = 0;  /* disable hidden==dotfile */
sb408fs/umsdos/inode.csb->s_op = &umsdos_sops;
sb409fs/umsdos/inode.cPRINTK (("umsdos_read_super %p\n",sb->s_mounted));
sb410fs/umsdos/inode.cumsdos_setup_dir_inode (sb->s_mounted);
sb446fs/umsdos/inode.cif (umsdos_real_lookup (sb->s_mounted,UMSDOS_PSDROOT_NAME
sb493fs/umsdos/inode.creturn sb;
sb61fs/vfat/namei.cvoid vfat_put_super(struct super_block *sb)
sb63fs/vfat/namei.cfat_put_super(sb);
sb130fs/vfat/namei.cstruct super_block *vfat_read_super(struct super_block *sb,void *data,
sb137fs/vfat/namei.csb->s_op = &vfat_sops;
sb138fs/vfat/namei.cres = fat_read_super(sb, data, silent);
sb140fs/vfat/namei.csb->s_dev = 0;
sb145fs/vfat/namei.cif (!parse_options((char *) data, &(MSDOS_SB(sb)->options))) {
sb148fs/vfat/namei.cMSDOS_SB(sb)->options.isvfat = 1;
sb149fs/vfat/namei.cMSDOS_SB(sb)->options.dotsOK = 0;
sb182fs/vfat/namei.cstatic void dump_fat(struct super_block *sb,int start)
sb187fs/vfat/namei.cstart = fat_access(sb,start,-1);
sb544fs/vfat/namei.cstruct super_block *sb = dir->i_sb;
sb565fs/vfat/namei.cinode = iget(sb,ino);
sb805fs/vfat/namei.cstruct super_block *sb = dir->i_sb;
sb823fs/vfat/namei.cvf.posix = MSDOS_SB(sb)->options.posixfs;
sb982fs/vfat/namei.cstruct super_block *sb = dir->i_sb;
sb1041fs/vfat/namei.cstruct super_block *sb = dir->i_sb;
sb1085fs/vfat/namei.cstruct super_block *sb = dir->i_sb;
sb1124fs/vfat/namei.cstruct super_block *sb = dir->i_sb;
sb1154fs/vfat/namei.cstruct super_block *sb = dir->i_sb;
sb1188fs/vfat/namei.cstruct super_block *sb = dir->i_sb;
sb1212fs/vfat/namei.cstruct super_block *sb = dir->i_sb;
sb1245fs/vfat/namei.cstruct super_block *sb = dir->i_sb;
sb1288fs/vfat/namei.cstruct super_block *sb = dir->i_sb;
sb1355fs/vfat/namei.cstruct super_block *sb = old_dir->i_sb;
sb91fs/xiafs/bitmap.c#define get_imap_zone(sb, bit_nr, not_que) \
sb92fs/xiafs/bitmap.cget__map_zone((sb), (sb)->u.xiafs_sb.s_imap_buf, \
sb93fs/xiafs/bitmap.c(sb)->u.xiafs_sb.s_imap_iznr, \
sb94fs/xiafs/bitmap.c(sb)->u.xiafs_sb.s_imap_cached, 1, \
sb95fs/xiafs/bitmap.c(sb)->u.xiafs_sb.s_imap_zones, _XIAFS_IMAP_SLOTS, \
sb98fs/xiafs/bitmap.c#define get_zmap_zone(sb, bit_nr, not_que) \
sb99fs/xiafs/bitmap.cget__map_zone((sb), (sb)->u.xiafs_sb.s_zmap_buf, \
sb100fs/xiafs/bitmap.c(sb)->u.xiafs_sb.s_zmap_zznr, \
sb101fs/xiafs/bitmap.c(sb)->u.xiafs_sb.s_zmap_cached, \
sb102fs/xiafs/bitmap.c1+(sb)->u.xiafs_sb.s_imap_zones, \
sb103fs/xiafs/bitmap.c(sb)->u.xiafs_sb.s_zmap_zones, _XIAFS_ZMAP_SLOTS, \
sb107fs/xiafs/bitmap.cget__map_zone(struct super_block *sb, struct buffer_head * bmap_buf[],
sb114fs/xiafs/bitmap.cz_nr = bit_nr >> XIAFS_BITS_PER_Z_BITS(sb);
sb121fs/xiafs/bitmap.clock_super(sb);
sb134fs/xiafs/bitmap.ctmp_bh=bread(sb->s_dev, z_nr+first_zone, XIAFS_ZSIZE(sb)); /* cache not hit */
sb137fs/xiafs/bitmap.cunlock_super(sb);
sb150fs/xiafs/bitmap.c#define xiafs_unlock_super(sb, cache)  if (cache) unlock_super(sb);
sb152fs/xiafs/bitmap.c#define get_free_ibit(sb, prev_bit) \
sb153fs/xiafs/bitmap.cget_free__bit(sb, sb->u.xiafs_sb.s_imap_buf, \
sb154fs/xiafs/bitmap.csb->u.xiafs_sb.s_imap_iznr, \
sb155fs/xiafs/bitmap.csb->u.xiafs_sb.s_imap_cached, \
sb156fs/xiafs/bitmap.c1, sb->u.xiafs_sb.s_imap_zones, \
sb159fs/xiafs/bitmap.c#define get_free_zbit(sb, prev_bit) \
sb160fs/xiafs/bitmap.cget_free__bit(sb, sb->u.xiafs_sb.s_zmap_buf, \
sb161fs/xiafs/bitmap.csb->u.xiafs_sb.s_zmap_zznr, \
sb162fs/xiafs/bitmap.csb->u.xiafs_sb.s_zmap_cached, \
sb163fs/xiafs/bitmap.c1 + sb->u.xiafs_sb.s_imap_zones, \
sb164fs/xiafs/bitmap.csb->u.xiafs_sb.s_zmap_zones, \
sb168fs/xiafs/bitmap.cget_free__bit(struct super_block *sb, struct buffer_head * bmap_buf[],
sb177fs/xiafs/bitmap.ctotal_bits=bmap_zones << XIAFS_BITS_PER_Z_BITS(sb); 
sb181fs/xiafs/bitmap.cend_bit=XIAFS_BITS_PER_Z(sb);
sb195fs/xiafs/bitmap.cbh = get__map_zone(sb, bmap_buf, bznr, cache, first_zone, 
sb202fs/xiafs/bitmap.cxiafs_unlock_super(sb, sb->u.xiafs_sb.s_zmap_cached);
sb210fs/xiafs/bitmap.cxiafs_unlock_super(sb, cache);
sb211fs/xiafs/bitmap.creturn (pos & ~(XIAFS_BITS_PER_Z(sb)-1))+tmp;
sb214fs/xiafs/bitmap.cvoid xiafs_free_zone(struct super_block * sb, int d_addr)
sb219fs/xiafs/bitmap.cif (!sb) {
sb223fs/xiafs/bitmap.cif (d_addr < sb->u.xiafs_sb.s_firstdatazone ||
sb224fs/xiafs/bitmap.cd_addr >= sb->u.xiafs_sb.s_nzones) {
sb228fs/xiafs/bitmap.cbh = get_hash_table(sb->s_dev, d_addr, XIAFS_ZSIZE(sb));
sb232fs/xiafs/bitmap.cbit=d_addr - sb->u.xiafs_sb.s_firstdatazone + 1;
sb233fs/xiafs/bitmap.cbh = get_zmap_zone(sb, bit, NULL);
sb236fs/xiafs/bitmap.coffset = bit & (XIAFS_BITS_PER_Z(sb) -1);
sb240fs/xiafs/bitmap.ckdevname(sb->s_dev), bit, bit, WHERE_ERR);
sb242fs/xiafs/bitmap.cxiafs_unlock_super(sb, sb->u.xiafs_sb.s_zmap_cached);
sb245fs/xiafs/bitmap.cint xiafs_new_zone(struct super_block * sb, u_long prev_addr)
sb250fs/xiafs/bitmap.cif (!sb) {
sb254fs/xiafs/bitmap.cif (prev_addr < sb->u.xiafs_sb.s_firstdatazone || 
sb255fs/xiafs/bitmap.cprev_addr >= sb->u.xiafs_sb.s_nzones) {
sb256fs/xiafs/bitmap.cprev_addr=sb->u.xiafs_sb.s_firstdatazone;
sb258fs/xiafs/bitmap.cprev_znr=prev_addr-sb->u.xiafs_sb.s_firstdatazone+1;
sb259fs/xiafs/bitmap.ctmp=get_free_zbit(sb, prev_znr);
sb262fs/xiafs/bitmap.ctmp += sb->u.xiafs_sb.s_firstdatazone -1;
sb263fs/xiafs/bitmap.cif (!(bh = getblk(sb->s_dev, tmp, XIAFS_ZSIZE(sb)))) {
sb281fs/xiafs/bitmap.cstruct super_block * sb;
sb292fs/xiafs/bitmap.csb = inode->i_sb;
sb294fs/xiafs/bitmap.cbh = get_imap_zone(sb, ino, NULL);
sb298fs/xiafs/bitmap.cif (!clear_bit(ino & (XIAFS_BITS_PER_Z(sb)-1), bh->b_data))
sb303fs/xiafs/bitmap.cxiafs_unlock_super(sb, sb->u.xiafs_sb.s_imap_cached);
sb308fs/xiafs/bitmap.cstruct super_block * sb;
sb312fs/xiafs/bitmap.csb = dir->i_sb;
sb315fs/xiafs/bitmap.cinode->i_sb = sb;
sb318fs/xiafs/bitmap.ctmp=get_free_ibit(sb, dir->i_ino); 
sb325fs/xiafs/bitmap.cinode->i_dev = sb->s_dev;
sb353fs/xiafs/bitmap.cunsigned long xiafs_count_free_inodes(struct super_block *sb)
sb360fs/xiafs/bitmap.cizones=sb->u.xiafs_sb.s_imap_zones;
sb362fs/xiafs/bitmap.cbh=get_imap_zone(sb, i << XIAFS_BITS_PER_Z_BITS(sb), &not_que);
sb365fs/xiafs/bitmap.cxiafs_unlock_super(sb, sb->u.xiafs_sb.s_imap_cached);
sb368fs/xiafs/bitmap.ci=izones << XIAFS_BITS_PER_Z_BITS(sb);
sb372fs/xiafs/bitmap.cunsigned long xiafs_count_free_zones(struct super_block *sb)
sb379fs/xiafs/bitmap.czzones=sb->u.xiafs_sb.s_zmap_zones;
sb381fs/xiafs/bitmap.cbh=get_zmap_zone(sb, i << XIAFS_BITS_PER_Z_BITS(sb), &not_que);
sb384fs/xiafs/bitmap.cxiafs_unlock_super(sb, sb->u.xiafs_sb.s_zmap_cached);
sb387fs/xiafs/bitmap.ci=zzones << XIAFS_BITS_PER_Z_BITS(sb);
sb37fs/xiafs/inode.cvoid xiafs_put_super(struct super_block *sb)
sb41fs/xiafs/inode.clock_super(sb);
sb42fs/xiafs/inode.csb->s_dev = 0;
sb44fs/xiafs/inode.cbrelse(sb->u.xiafs_sb.s_imap_buf[i]);
sb46fs/xiafs/inode.cbrelse(sb->u.xiafs_sb.s_zmap_buf[i]);
sb47fs/xiafs/inode.cunlock_super(sb);
sb169fs/xiafs/inode.cvoid xiafs_statfs(struct super_block *sb, struct statfs *buf, int bufsiz)
sb174fs/xiafs/inode.ctmp.f_bsize = XIAFS_ZSIZE(sb);
sb175fs/xiafs/inode.ctmp.f_blocks = sb->u.xiafs_sb.s_ndatazones;
sb176fs/xiafs/inode.ctmp.f_bfree = xiafs_count_free_zones(sb);
sb178fs/xiafs/inode.ctmp.f_files = sb->u.xiafs_sb.s_ninodes;
sb179fs/xiafs/inode.ctmp.f_ffree = xiafs_count_free_inodes(sb);
sb292include/linux/ext2_fs.h#define test_opt(sb, opt)    ((sb)->u.ext2_sb.s_mount_opt & \
sb80include/linux/ext_fs.hextern unsigned long ext_count_free_inodes(struct super_block *sb);
sb81include/linux/ext_fs.hextern int ext_new_block(struct super_block * sb);
sb82include/linux/ext_fs.hextern void ext_free_block(struct super_block * sb, int block);
sb83include/linux/ext_fs.hextern unsigned long ext_count_free_blocks(struct super_block *sb);
sb571include/linux/fs.hextern struct inode * __iget(struct super_block * sb,int nr,int crsmnt);
sb634include/linux/fs.hextern inline struct inode * iget(struct super_block * sb,int nr)
sb636include/linux/fs.hreturn __iget(sb, nr, 1);
sb171include/linux/iso_fs.hextern unsigned long isofs_count_free_inodes(struct super_block *sb);
sb45include/linux/locks.hextern inline void wait_on_super(struct super_block * sb)
sb47include/linux/locks.hif (sb->s_lock)
sb48include/linux/locks.h__wait_on_super(sb);
sb51include/linux/locks.hextern inline void lock_super(struct super_block * sb)
sb53include/linux/locks.hif (sb->s_lock)
sb54include/linux/locks.h__wait_on_super(sb);
sb55include/linux/locks.hsb->s_lock = 1;
sb58include/linux/locks.hextern inline void unlock_super(struct super_block * sb)
sb60include/linux/locks.hsb->s_lock = 0;
sb61include/linux/locks.hwake_up(&sb->s_wait);
sb106include/linux/minix_fs.hextern unsigned long minix_count_free_inodes(struct super_block *sb);
sb107include/linux/minix_fs.hextern int minix_new_block(struct super_block * sb);
sb108include/linux/minix_fs.hextern void minix_free_block(struct super_block * sb, int block);
sb109include/linux/minix_fs.hextern unsigned long minix_count_free_blocks(struct super_block *sb);
sb121include/linux/minix_fs.hextern int minix_remount (struct super_block * sb, int * flags, char * data);
sb174include/linux/msdos_fs.hextern void lock_fat(struct super_block *sb);
sb175include/linux/msdos_fs.hextern void unlock_fat(struct super_block *sb);
sb190include/linux/msdos_fs.hextern int fat_access(struct super_block *sb,int nr,int new_value);
sb204include/linux/msdos_fs.hextern void fat_put_super(struct super_block *sb);
sb207include/linux/msdos_fs.hextern void msdos_put_super(struct super_block *sb);
sb208include/linux/msdos_fs.hextern void fat_statfs(struct super_block *sb,struct statfs *buf, int);
sb241include/linux/msdos_fs.hextern struct super_block *msdos_read_super(struct super_block *sb,void *data, int silent);
sb74include/linux/ncp_fs.h#define NCP_SBP(sb)          ((struct ncp_server *)((sb)->u.generic_sbp))
sb147include/linux/ncp_fs.hstruct super_block *ncp_read_super(struct super_block *sb,
sb105include/linux/nfs_fs.hextern struct super_block *nfs_read_super(struct super_block *sb, 
sb108include/linux/nfs_fs.hextern struct inode *nfs_fhget(struct super_block *sb, struct nfs_fh *fhandle,
sb134include/linux/nfs_fs.hextern int nfs_root_mount(struct super_block *sb);
sb42include/linux/smb_fs.h#define SMB_SBP(sb)          ((struct smb_sb_info *)(sb->u.generic_sbp))
sb115include/linux/smb_fs.hstruct super_block *smb_read_super(struct super_block *sb,
sb340include/linux/sysv_fs.hsv_get_hash_table (struct super_block *sb, kdev_t dev, unsigned int block)
sb342include/linux/sysv_fs.hreturn get_hash_table (dev, block + sb->sv_block_base, sb->sv_block_size);
sb347include/linux/sysv_fs.hsv_getblk (struct super_block *sb, kdev_t dev, unsigned int block)
sb349include/linux/sysv_fs.hreturn getblk (dev, block + sb->sv_block_base, sb->sv_block_size);
sb354include/linux/sysv_fs.hsv_bread (struct super_block *sb, kdev_t dev, unsigned int block)
sb356include/linux/sysv_fs.hreturn bread (dev, block + sb->sv_block_base, sb->sv_block_size);
sb379include/linux/sysv_fs.hextern unsigned long sysv_count_free_inodes(struct super_block *sb);
sb380include/linux/sysv_fs.hextern int sysv_new_block(struct super_block * sb);
sb381include/linux/sysv_fs.hextern void sysv_free_block(struct super_block * sb, unsigned int block);
sb382include/linux/sysv_fs.hextern unsigned long sysv_count_free_blocks(struct super_block *sb);
sb85include/linux/xia_fs.hextern unsigned long xiafs_count_free_inodes(struct super_block *sb);
sb86include/linux/xia_fs.hextern int xiafs_new_zone(struct super_block * sb, u_long prev_addr);
sb87include/linux/xia_fs.hextern void xiafs_free_zone(struct super_block * sb, int block);
sb88include/linux/xia_fs.hextern unsigned long xiafs_count_free_zones(struct super_block *sb);