if (ubh) ubh_brelse_uspi (uspi); if (uspi) kfree (uspi); if (sbi) kfree(sbi); 
if (ubh) ubh_brelse_uspi (uspi); kfree (uspi); kfree(sbi); 
static int ufs_fill_super(struct super_block *sb, void *data, int silent){	struct ufs_sb_info * sbi;	struct ufs_sb_private_info * uspi;	struct ufs_super_block_first * usb1;	struct ufs_super_block_second * usb2;	struct ufs_super_block_third * usb3;	struct ufs_super_block *usb;	struct ufs_buffer_head * ubh;		struct inode *inode;	unsigned block_size, super_block_size;	unsigned flags;	uspi = NULL;	ubh = NULL;	flags = 0;		UFSD(("ENTER\n"))			sbi = kmalloc(sizeof(struct ufs_sb_info), GFP_KERNEL);	if (!sbi)		goto failed_nomem;	sb->s_fs_info = sbi;	memset(sbi, 0, sizeof(struct ufs_sb_info));	UFSD(("flag %u\n", (int)(sb->s_flags & MS_RDONLY)))	#ifndef CONFIG_UFS_FS_WRITE	if (!(sb->s_flags & MS_RDONLY)) {		printk("ufs was compiled with read-only support, "		"can't be mounted as read-write\n");		goto failed;	}#endif	/*	 * Set default mount options	 * Parse mount options	 */	sbi->s_mount_opt = 0;	ufs_set_opt (sbi->s_mount_opt, ONERROR_LOCK);	if (!ufs_parse_options ((char *) data, &sbi->s_mount_opt)) {		printk("wrong mount options\n");		goto failed;	}	if (!(sbi->s_mount_opt & UFS_MOUNT_UFSTYPE)) {		if (!silent)			printk("You didn't specify the type of your ufs filesystem\n\n"			"mount -t ufs -o ufstype="			"sun|sunx86|44bsd|ufs2|5xbsd|old|hp|nextstep|netxstep-cd|openstep ...\n\n"			">>>WARNING<<< Wrong ufstype may corrupt your filesystem, "			"default is ufstype=old\n");		ufs_set_opt (sbi->s_mount_opt, UFSTYPE_OLD);	}	sbi->s_uspi = uspi =		kmalloc (sizeof(struct ufs_sb_private_info), GFP_KERNEL);	if (!uspi)		goto failed;	/* Keep 2Gig file limit. Some UFS variants need to override 	   this but as I don't know which I'll let those in the know loosen	   the rules */	   	switch (sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) {	case UFS_MOUNT_UFSTYPE_44BSD:		UFSD(("ufstype=44bsd\n"))		uspi->s_fsize = block_size = 512;		uspi->s_fmask = ~(512 - 1);		uspi->s_fshift = 9;		uspi->s_sbsize = super_block_size = 1536;		uspi->s_sbbase = 0;		flags |= UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;		break;	case UFS_MOUNT_UFSTYPE_UFS2:		UFSD(("ufstype=ufs2\n"))		uspi->s_fsize = block_size = 512;		uspi->s_fmask = ~(512 - 1);		uspi->s_fshift = 9;		uspi->s_sbsize = super_block_size = 1536;		uspi->s_sbbase =  0;		flags |= UFS_TYPE_UFS2 | UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;		if (!(sb->s_flags & MS_RDONLY)) {			printk(KERN_INFO "ufstype=ufs2 is supported read-only\n");			sb->s_flags |= MS_RDONLY; 		}		break;			case UFS_MOUNT_UFSTYPE_SUN:		UFSD(("ufstype=sun\n"))		uspi->s_fsize = block_size = 1024;		uspi->s_fmask = ~(1024 - 1);		uspi->s_fshift = 10;		uspi->s_sbsize = super_block_size = 2048;		uspi->s_sbbase = 0;		uspi->s_maxsymlinklen = 56;		flags |= UFS_DE_OLD | UFS_UID_EFT | UFS_ST_SUN | UFS_CG_SUN;		break;	case UFS_MOUNT_UFSTYPE_SUNx86:		UFSD(("ufstype=sunx86\n"))		uspi->s_fsize = block_size = 1024;		uspi->s_fmask = ~(1024 - 1);		uspi->s_fshift = 10;		uspi->s_sbsize = super_block_size = 2048;		uspi->s_sbbase = 0;		uspi->s_maxsymlinklen = 56;		flags |= UFS_DE_OLD | UFS_UID_EFT | UFS_ST_SUNx86 | UFS_CG_SUN;		break;	case UFS_MOUNT_UFSTYPE_OLD:		UFSD(("ufstype=old\n"))		uspi->s_fsize = block_size = 1024;		uspi->s_fmask = ~(1024 - 1);		uspi->s_fshift = 10;		uspi->s_sbsize = super_block_size = 2048;		uspi->s_sbbase = 0;		flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;		if (!(sb->s_flags & MS_RDONLY)) {			if (!silent)				printk(KERN_INFO "ufstype=old is supported read-only\n");			sb->s_flags |= MS_RDONLY;		}		break;		case UFS_MOUNT_UFSTYPE_NEXTSTEP:		UFSD(("ufstype=nextstep\n"))		uspi->s_fsize = block_size = 1024;		uspi->s_fmask = ~(1024 - 1);		uspi->s_fshift = 10;		uspi->s_sbsize = super_block_size = 2048;		uspi->s_sbbase = 0;		flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;		if (!(sb->s_flags & MS_RDONLY)) {			if (!silent)				printk(KERN_INFO "ufstype=nextstep is supported read-only\n");			sb->s_flags |= MS_RDONLY;		}		break;		case UFS_MOUNT_UFSTYPE_NEXTSTEP_CD:		UFSD(("ufstype=nextstep-cd\n"))		uspi->s_fsize = block_size = 2048;		uspi->s_fmask = ~(2048 - 1);		uspi->s_fshift = 11;		uspi->s_sbsize = super_block_size = 2048;		uspi->s_sbbase = 0;		flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;		if (!(sb->s_flags & MS_RDONLY)) {			if (!silent)				printk(KERN_INFO "ufstype=nextstep-cd is supported read-only\n");			sb->s_flags |= MS_RDONLY;		}		break;		case UFS_MOUNT_UFSTYPE_OPENSTEP:		UFSD(("ufstype=openstep\n"))		uspi->s_fsize = block_size = 1024;		uspi->s_fmask = ~(1024 - 1);		uspi->s_fshift = 10;		uspi->s_sbsize = super_block_size = 2048;		uspi->s_sbbase = 0;		flags |= UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;		if (!(sb->s_flags & MS_RDONLY)) {			if (!silent)				printk(KERN_INFO "ufstype=openstep is supported read-only\n");			sb->s_flags |= MS_RDONLY;		}		break;		case UFS_MOUNT_UFSTYPE_HP:		UFSD(("ufstype=hp\n"))		uspi->s_fsize = block_size = 1024;		uspi->s_fmask = ~(1024 - 1);		uspi->s_fshift = 10;		uspi->s_sbsize = super_block_size = 2048;		uspi->s_sbbase = 0;		flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;		if (!(sb->s_flags & MS_RDONLY)) {			if (!silent)				printk(KERN_INFO "ufstype=hp is supported read-only\n");			sb->s_flags |= MS_RDONLY; 		} 		break;	default:		if (!silent)			printk("unknown ufstype\n");		goto failed;	}	again:		if (!sb_set_blocksize(sb, block_size)) {		printk(KERN_ERR "UFS: failed to set blocksize\n");		goto failed;	}	/*	 * read ufs super block from device	 */	if ( (flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) {		ubh = ubh_bread_uspi(uspi, sb, uspi->s_sbbase + SBLOCK_UFS2/block_size, super_block_size);	}	else {		ubh = ubh_bread_uspi(uspi, sb, uspi->s_sbbase + UFS_SBLOCK/block_size, super_block_size);	}	if (!ubh)             goto failed;		usb1 = ubh_get_usb_first(USPI_UBH);	usb2 = ubh_get_usb_second(USPI_UBH);	usb3 = ubh_get_usb_third(USPI_UBH);	usb  = (struct ufs_super_block *)		((struct ufs_buffer_head *)uspi)->bh[0]->b_data ;	/*	 * Check ufs magic number	 */	sbi->s_bytesex = BYTESEX_LE;	switch ((uspi->fs_magic = fs32_to_cpu(sb, usb3->fs_magic))) {		case UFS_MAGIC:		case UFS2_MAGIC:		case UFS_MAGIC_LFN:	        case UFS_MAGIC_FEA:	        case UFS_MAGIC_4GB:			goto magic_found;	}	sbi->s_bytesex = BYTESEX_BE;	switch ((uspi->fs_magic = fs32_to_cpu(sb, usb3->fs_magic))) {		case UFS_MAGIC:		case UFS2_MAGIC:		case UFS_MAGIC_LFN:	        case UFS_MAGIC_FEA:	        case UFS_MAGIC_4GB:			goto magic_found;	}	if ((((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_NEXTSTEP) 	  || ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_NEXTSTEP_CD) 	  || ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_OPENSTEP)) 	  && uspi->s_sbbase < 256) {		ubh_brelse_uspi(uspi);		ubh = NULL;		uspi->s_sbbase += 8;		goto again;	}	if (!silent)		printk("ufs_read_super: bad magic number\n");	goto failed;magic_found:	/*	 * Check block and fragment sizes	 */	uspi->s_bsize = fs32_to_cpu(sb, usb1->fs_bsize);	uspi->s_fsize = fs32_to_cpu(sb, usb1->fs_fsize);	uspi->s_sbsize = fs32_to_cpu(sb, usb1->fs_sbsize);	uspi->s_fmask = fs32_to_cpu(sb, usb1->fs_fmask);	uspi->s_fshift = fs32_to_cpu(sb, usb1->fs_fshift);	if (uspi->s_fsize & (uspi->s_fsize - 1)) {		printk(KERN_ERR "ufs_read_super: fragment size %u is not a power of 2\n",			uspi->s_fsize);			goto failed;	}	if (uspi->s_fsize < 512) {		printk(KERN_ERR "ufs_read_super: fragment size %u is too small\n",			uspi->s_fsize);		goto failed;	}	if (uspi->s_fsize > 4096) {		printk(KERN_ERR "ufs_read_super: fragment size %u is too large\n",			uspi->s_fsize);		goto failed;	}	if (uspi->s_bsize & (uspi->s_bsize - 1)) {		printk(KERN_ERR "ufs_read_super: block size %u is not a power of 2\n",			uspi->s_bsize);		goto failed;	}	if (uspi->s_bsize < 4096) {		printk(KERN_ERR "ufs_read_super: block size %u is too small\n",			uspi->s_bsize);		goto failed;	}	if (uspi->s_bsize / uspi->s_fsize > 8) {		printk(KERN_ERR "ufs_read_super: too many fragments per block (%u)\n",			uspi->s_bsize / uspi->s_fsize);		goto failed;	}	if (uspi->s_fsize != block_size || uspi->s_sbsize != super_block_size) {		ubh_brelse_uspi(uspi);		ubh = NULL;		block_size = uspi->s_fsize;		super_block_size = uspi->s_sbsize;		UFSD(("another value of block_size or super_block_size %u, %u\n", block_size, super_block_size))		goto again;	}#ifdef UFS_SUPER_DEBUG_MORE        if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)		ufs2_print_super_stuff(sb,usb);        else		ufs_print_super_stuff(sb, usb1, usb2, usb3);#endif	/*	 * Check, if file system was correctly unmounted.	 * If not, make it read only.	 */	if (((flags & UFS_ST_MASK) == UFS_ST_44BSD) ||	  ((flags & UFS_ST_MASK) == UFS_ST_OLD) ||	  (((flags & UFS_ST_MASK) == UFS_ST_SUN || 	  (flags & UFS_ST_MASK) == UFS_ST_SUNx86) && 	  (ufs_get_fs_state(sb, usb1, usb3) == (UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time))))) {		switch(usb1->fs_clean) {		case UFS_FSCLEAN:			UFSD(("fs is clean\n"))			break;		case UFS_FSSTABLE:			UFSD(("fs is stable\n"))			break;		case UFS_FSOSF1:			UFSD(("fs is DEC OSF/1\n"))			break;		case UFS_FSACTIVE:			printk("ufs_read_super: fs is active\n");			sb->s_flags |= MS_RDONLY;			break;		case UFS_FSBAD:			printk("ufs_read_super: fs is bad\n");			sb->s_flags |= MS_RDONLY;			break;		default:			printk("ufs_read_super: can't grok fs_clean 0x%x\n", usb1->fs_clean);			sb->s_flags |= MS_RDONLY;			break;		}	}	else {		printk("ufs_read_super: fs needs fsck\n");		sb->s_flags |= MS_RDONLY;	}	/*	 * Read ufs_super_block into internal data structures	 */	sb->s_op = &ufs_super_ops;	sb->dq_op = NULL; /***/	sb->s_magic = fs32_to_cpu(sb, usb3->fs_magic);	uspi->s_sblkno = fs32_to_cpu(sb, usb1->fs_sblkno);	uspi->s_cblkno = fs32_to_cpu(sb, usb1->fs_cblkno);	uspi->s_iblkno = fs32_to_cpu(sb, usb1->fs_iblkno);	uspi->s_dblkno = fs32_to_cpu(sb, usb1->fs_dblkno);	uspi->s_cgoffset = fs32_to_cpu(sb, usb1->fs_cgoffset);	uspi->s_cgmask = fs32_to_cpu(sb, usb1->fs_cgmask);	if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) {		uspi->s_u2_size  = fs64_to_cpu(sb, usb->fs_u11.fs_u2.fs_size);		uspi->s_u2_dsize = fs64_to_cpu(sb, usb->fs_u11.fs_u2.fs_dsize);	}	else {		uspi->s_size  =  fs32_to_cpu(sb, usb1->fs_size);		uspi->s_dsize =  fs32_to_cpu(sb, usb1->fs_dsize);	}	uspi->s_ncg = fs32_to_cpu(sb, usb1->fs_ncg);	/* s_bsize already set */	/* s_fsize already set */	uspi->s_fpb = fs32_to_cpu(sb, usb1->fs_frag);	uspi->s_minfree = fs32_to_cpu(sb, usb1->fs_minfree);	uspi->s_bmask = fs32_to_cpu(sb, usb1->fs_bmask);	uspi->s_fmask = fs32_to_cpu(sb, usb1->fs_fmask);	uspi->s_bshift = fs32_to_cpu(sb, usb1->fs_bshift);	uspi->s_fshift = fs32_to_cpu(sb, usb1->fs_fshift);	UFSD(("uspi->s_bshift = %d,uspi->s_fshift = %d", uspi->s_bshift,		uspi->s_fshift));	uspi->s_fpbshift = fs32_to_cpu(sb, usb1->fs_fragshift);	uspi->s_fsbtodb = fs32_to_cpu(sb, usb1->fs_fsbtodb);	/* s_sbsize already set */	uspi->s_csmask = fs32_to_cpu(sb, usb1->fs_csmask);	uspi->s_csshift = fs32_to_cpu(sb, usb1->fs_csshift);	uspi->s_nindir = fs32_to_cpu(sb, usb1->fs_nindir);	uspi->s_inopb = fs32_to_cpu(sb, usb1->fs_inopb);	uspi->s_nspf = fs32_to_cpu(sb, usb1->fs_nspf);	uspi->s_npsect = ufs_get_fs_npsect(sb, usb1, usb3);	uspi->s_interleave = fs32_to_cpu(sb, usb1->fs_interleave);	uspi->s_trackskew = fs32_to_cpu(sb, usb1->fs_trackskew);	uspi->s_csaddr = fs32_to_cpu(sb, usb1->fs_csaddr);	uspi->s_cssize = fs32_to_cpu(sb, usb1->fs_cssize);	uspi->s_cgsize = fs32_to_cpu(sb, usb1->fs_cgsize);	uspi->s_ntrak = fs32_to_cpu(sb, usb1->fs_ntrak);	uspi->s_nsect = fs32_to_cpu(sb, usb1->fs_nsect);	uspi->s_spc = fs32_to_cpu(sb, usb1->fs_spc);	uspi->s_ipg = fs32_to_cpu(sb, usb1->fs_ipg);	uspi->s_fpg = fs32_to_cpu(sb, usb1->fs_fpg);	uspi->s_cpc = fs32_to_cpu(sb, usb2->fs_cpc);	uspi->s_contigsumsize = fs32_to_cpu(sb, usb3->fs_u2.fs_44.fs_contigsumsize);	uspi->s_qbmask = ufs_get_fs_qbmask(sb, usb3);	uspi->s_qfmask = ufs_get_fs_qfmask(sb, usb3);	uspi->s_postblformat = fs32_to_cpu(sb, usb3->fs_postblformat);	uspi->s_nrpos = fs32_to_cpu(sb, usb3->fs_nrpos);	uspi->s_postbloff = fs32_to_cpu(sb, usb3->fs_postbloff);	uspi->s_rotbloff = fs32_to_cpu(sb, usb3->fs_rotbloff);	/*	 * Compute another frequently used values	 */	uspi->s_fpbmask = uspi->s_fpb - 1;	if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) {		uspi->s_apbshift = uspi->s_bshift - 3;	}	else {		uspi->s_apbshift = uspi->s_bshift - 2;	}	uspi->s_2apbshift = uspi->s_apbshift * 2;	uspi->s_3apbshift = uspi->s_apbshift * 3;	uspi->s_apb = 1 << uspi->s_apbshift;	uspi->s_2apb = 1 << uspi->s_2apbshift;	uspi->s_3apb = 1 << uspi->s_3apbshift;	uspi->s_apbmask = uspi->s_apb - 1;	uspi->s_nspfshift = uspi->s_fshift - UFS_SECTOR_BITS;	uspi->s_nspb = uspi->s_nspf << uspi->s_fpbshift;	uspi->s_inopf = uspi->s_inopb >> uspi->s_fpbshift;	uspi->s_bpf = uspi->s_fsize << 3;	uspi->s_bpfshift = uspi->s_fshift + 3;	uspi->s_bpfmask = uspi->s_bpf - 1;	if ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) ==	    UFS_MOUNT_UFSTYPE_44BSD)		uspi->s_maxsymlinklen =		    fs32_to_cpu(sb, usb3->fs_u2.fs_44.fs_maxsymlinklen);		sbi->s_flags = flags;	inode = iget(sb, UFS_ROOTINO);	if (!inode || is_bad_inode(inode))		goto failed;	sb->s_root = d_alloc_root(inode);	if (!sb->s_root)		goto dalloc_failed;	/*	 * Read cylinder group structures	 */	if (!(sb->s_flags & MS_RDONLY))		if (!ufs_read_cylinder_structures(sb))			goto failed;	UFSD(("EXIT\n"))	return 0;dalloc_failed:	iput(inode);failed:	if (ubh) ubh_brelse_uspi (uspi);	if (uspi) kfree (uspi);	if (sbi) kfree(sbi);	sb->s_fs_info = NULL;	UFSD(("EXIT (FAILED)\n"))	return -EINVAL;failed_nomem:	UFSD(("EXIT (NOMEM)\n"))	return -ENOMEM;}
4520	/local/tlutelli/issta_data/temp/c/2005_temp/2005/4520/f99d49adf527fa6f7a9c42257fa76bca6b8df1e3/super.c/buggy/fs/ufs/super.c