if (sbi->s_prefix) kfree(sbi->s_prefix); 
kfree(sbi->s_prefix); 
static int affs_fill_super(struct super_block *sb, void *data, int silent){	struct affs_sb_info	*sbi;	struct buffer_head	*root_bh = NULL;	struct buffer_head	*boot_bh;	struct inode		*root_inode = NULL;	s32			 root_block;	int			 size, blocksize;	u32			 chksum;	int			 num_bm;	int			 i, j;	s32			 key;	uid_t			 uid;	gid_t			 gid;	int			 reserved;	unsigned long		 mount_flags;	int			 tmp_flags;	/* fix remount prototype... */	pr_debug("AFFS: read_super(%s)\n",data ? (const char *)data : "no options");	sb->s_magic             = AFFS_SUPER_MAGIC;	sb->s_op                = &affs_sops;	sb->s_flags |= MS_NODIRATIME;	sbi = kmalloc(sizeof(struct affs_sb_info), GFP_KERNEL);	if (!sbi)		return -ENOMEM;	sb->s_fs_info = sbi;	memset(sbi, 0, sizeof(*sbi));	init_MUTEX(&sbi->s_bmlock);	if (!parse_options(data,&uid,&gid,&i,&reserved,&root_block,				&blocksize,&sbi->s_prefix,				sbi->s_volume, &mount_flags)) {		printk(KERN_ERR "AFFS: Error parsing options\n");		return -EINVAL;	}	/* N.B. after this point s_prefix must be released */	sbi->s_flags   = mount_flags;	sbi->s_mode    = i;	sbi->s_uid     = uid;	sbi->s_gid     = gid;	sbi->s_reserved= reserved;	/* Get the size of the device in 512-byte blocks.	 * If we later see that the partition uses bigger	 * blocks, we will have to change it.	 */	size = sb->s_bdev->bd_inode->i_size >> 9;	pr_debug("AFFS: initial blocksize=%d, #blocks=%d\n", 512, size);	affs_set_blocksize(sb, PAGE_SIZE);	/* Try to find root block. Its location depends on the block size. */	i = 512;	j = 4096;	if (blocksize > 0) {		i = j = blocksize;		size = size / (blocksize / 512);	}	for (blocksize = i, key = 0; blocksize <= j; blocksize <<= 1, size >>= 1) {		sbi->s_root_block = root_block;		if (root_block < 0)			sbi->s_root_block = (reserved + size - 1) / 2;		pr_debug("AFFS: setting blocksize to %d\n", blocksize);		affs_set_blocksize(sb, blocksize);		sbi->s_partition_size = size;		/* The root block location that was calculated above is not		 * correct if the partition size is an odd number of 512-		 * byte blocks, which will be rounded down to a number of		 * 1024-byte blocks, and if there were an even number of		 * reserved blocks. Ideally, all partition checkers should		 * report the real number of blocks of the real blocksize,		 * but since this just cannot be done, we have to try to		 * find the root block anyways. In the above case, it is one		 * block behind the calculated one. So we check this one, too.		 */		for (num_bm = 0; num_bm < 2; num_bm++) {			pr_debug("AFFS: Dev %s, trying root=%u, bs=%d, "				"size=%d, reserved=%d\n",				sb->s_id,				sbi->s_root_block + num_bm,				blocksize, size, reserved);			root_bh = affs_bread(sb, sbi->s_root_block + num_bm);			if (!root_bh)				continue;			if (!affs_checksum_block(sb, root_bh) &&			    be32_to_cpu(AFFS_ROOT_HEAD(root_bh)->ptype) == T_SHORT &&			    be32_to_cpu(AFFS_ROOT_TAIL(sb, root_bh)->stype) == ST_ROOT) {				sbi->s_hashsize    = blocksize / 4 - 56;				sbi->s_root_block += num_bm;				key                        = 1;				goto got_root;			}			affs_brelse(root_bh);			root_bh = NULL;		}	}	if (!silent)		printk(KERN_ERR "AFFS: No valid root block on device %s\n",			sb->s_id);	goto out_error;	/* N.B. after this point bh must be released */got_root:	root_block = sbi->s_root_block;	/* Find out which kind of FS we have */	boot_bh = sb_bread(sb, 0);	if (!boot_bh) {		printk(KERN_ERR "AFFS: Cannot read boot block\n");		goto out_error;	}	chksum = be32_to_cpu(*(__be32 *)boot_bh->b_data);	brelse(boot_bh);	/* Dircache filesystems are compatible with non-dircache ones	 * when reading. As long as they aren't supported, writing is	 * not recommended.	 */	if ((chksum == FS_DCFFS || chksum == MUFS_DCFFS || chksum == FS_DCOFS	     || chksum == MUFS_DCOFS) && !(sb->s_flags & MS_RDONLY)) {		printk(KERN_NOTICE "AFFS: Dircache FS - mounting %s read only\n",			sb->s_id);		sb->s_flags |= MS_RDONLY;	}	switch (chksum) {		case MUFS_FS:		case MUFS_INTLFFS:		case MUFS_DCFFS:			sbi->s_flags |= SF_MUFS;			/* fall thru */		case FS_INTLFFS:		case FS_DCFFS:			sbi->s_flags |= SF_INTL;			break;		case MUFS_FFS:			sbi->s_flags |= SF_MUFS;			break;		case FS_FFS:			break;		case MUFS_OFS:			sbi->s_flags |= SF_MUFS;			/* fall thru */		case FS_OFS:			sbi->s_flags |= SF_OFS;			sb->s_flags |= MS_NOEXEC;			break;		case MUFS_DCOFS:		case MUFS_INTLOFS:			sbi->s_flags |= SF_MUFS;		case FS_DCOFS:		case FS_INTLOFS:			sbi->s_flags |= SF_INTL | SF_OFS;			sb->s_flags |= MS_NOEXEC;			break;		default:			printk(KERN_ERR "AFFS: Unknown filesystem on device %s: %08X\n",				sb->s_id, chksum);			goto out_error;	}	if (mount_flags & SF_VERBOSE) {		chksum = cpu_to_be32(chksum);		printk(KERN_NOTICE "AFFS: Mounting volume \"%*s\": Type=%.3s\\%c, Blocksize=%d\n",			AFFS_ROOT_TAIL(sb, root_bh)->disk_name[0],			AFFS_ROOT_TAIL(sb, root_bh)->disk_name + 1,			(char *)&chksum,((char *)&chksum)[3] + '0',blocksize);	}	sb->s_flags |= MS_NODEV | MS_NOSUID;	sbi->s_data_blksize = sb->s_blocksize;	if (sbi->s_flags & SF_OFS)		sbi->s_data_blksize -= 24;	/* Keep super block in cache */	sbi->s_root_bh = root_bh;	/* N.B. after this point s_root_bh must be released */	tmp_flags = sb->s_flags;	if (affs_init_bitmap(sb, &tmp_flags))		goto out_error;	sb->s_flags = tmp_flags;	/* set up enough so that it can read an inode */	root_inode = iget(sb, root_block);	sb->s_root = d_alloc_root(root_inode);	if (!sb->s_root) {		printk(KERN_ERR "AFFS: Get root inode failed\n");		goto out_error;	}	sb->s_root->d_op = &affs_dentry_operations;	pr_debug("AFFS: s_flags=%lX\n",sb->s_flags);	return 0;	/*	 * Begin the cascaded cleanup ...	 */out_error:	if (root_inode)		iput(root_inode);	if (sbi->s_bitmap)		kfree(sbi->s_bitmap);	affs_brelse(root_bh);	if (sbi->s_prefix)		kfree(sbi->s_prefix);	kfree(sbi);	sb->s_fs_info = NULL;	return -EINVAL;}
4520	/local/tlutelli/issta_data/temp/c/2005_temp/2005/4520/f99d49adf527fa6f7a9c42257fa76bca6b8df1e3/super.c/clean/fs/affs/super.c