自学教程：C++ ufs_cg_chkmagic函数代码示例

/* * Read on-disk structures associated with cylinder groups */static int ufs_read_cylinder_structures(struct super_block *sb){	struct ufs_sb_info *sbi = UFS_SB(sb);	struct ufs_sb_private_info *uspi = sbi->s_uspi;	struct ufs_buffer_head * ubh;	unsigned char * base, * space;	unsigned size, blks, i;	UFSD("ENTER/n");	/*	 * Read cs structures from (usually) first data block	 * on the device. 	 */	size = uspi->s_cssize;	blks = (size + uspi->s_fsize - 1) >> uspi->s_fshift;	base = space = kmalloc(size, GFP_NOFS);	if (!base)		goto failed; 	sbi->s_csp = (struct ufs_csum *)space;	for (i = 0; i < blks; i += uspi->s_fpb) {		size = uspi->s_bsize;		if (i + uspi->s_fpb > blks)			size = (blks - i) * uspi->s_fsize;		ubh = ubh_bread(sb, uspi->s_csaddr + i, size);				if (!ubh)			goto failed;		ubh_ubhcpymem (space, ubh, size);		space += size;		ubh_brelse (ubh);		ubh = NULL;	}	/*	 * Read cylinder group (we read only first fragment from block	 * at this time) and prepare internal data structures for cg caching.	 */	if (!(sbi->s_ucg = kmalloc (sizeof(struct buffer_head *) * uspi->s_ncg, GFP_NOFS)))		goto failed;	for (i = 0; i < uspi->s_ncg; i++) 		sbi->s_ucg[i] = NULL;	for (i = 0; i < UFS_MAX_GROUP_LOADED; i++) {		sbi->s_ucpi[i] = NULL;		sbi->s_cgno[i] = UFS_CGNO_EMPTY;	}	for (i = 0; i < uspi->s_ncg; i++) {		UFSD("read cg %u/n", i);		if (!(sbi->s_ucg[i] = sb_bread(sb, ufs_cgcmin(i))))			goto failed;		if (!ufs_cg_chkmagic (sb, (struct ufs_cylinder_group *) sbi->s_ucg[i]->b_data))			goto failed;		ufs_print_cylinder_stuff(sb, (struct ufs_cylinder_group *) sbi->s_ucg[i]->b_data);	}	for (i = 0; i < UFS_MAX_GROUP_LOADED; i++) {		if (!(sbi->s_ucpi[i] = kmalloc (sizeof(struct ufs_cg_private_info), GFP_NOFS)))			goto failed;		sbi->s_cgno[i] = UFS_CGNO_EMPTY;	}	sbi->s_cg_loaded = 0;	UFSD("EXIT/n");	return 1;failed:	kfree (base);	if (sbi->s_ucg) {		for (i = 0; i < uspi->s_ncg; i++)			if (sbi->s_ucg[i])				brelse (sbi->s_ucg[i]);		kfree (sbi->s_ucg);		for (i = 0; i < UFS_MAX_GROUP_LOADED; i++)			kfree (sbi->s_ucpi[i]);	}	UFSD("EXIT (FAILED)/n");	return 0;}

/* * NOTE! When we get the inode, we're the only people * that have access to it, and as such there are no * race conditions we have to worry about. The inode * is not on the hash-lists, and it cannot be reached * through the filesystem because the directory entry * has been deleted earlier. * * HOWEVER: we must make sure that we get no aliases, * which means that we have to call "clear_inode()" * _before_ we mark the inode not in use in the inode * bitmaps. Otherwise a newly created file might use * the same inode number (not actually the same pointer * though), and then we'd have two inodes sharing the * same inode number and space on the harddisk. */void ufs_free_inode (struct inode * inode){    struct super_block * sb;    struct ufs_sb_private_info * uspi;    struct ufs_super_block_first * usb1;    struct ufs_cg_private_info * ucpi;    struct ufs_cylinder_group * ucg;    int is_directory;    unsigned ino, cg, bit;        UFSD("ENTER, ino %lu/n", inode->i_ino);    sb = inode->i_sb;    uspi = UFS_SB(sb)->s_uspi;    usb1 = ubh_get_usb_first(uspi);        ino = inode->i_ino;    lock_super (sb);    if (!((ino > 1) && (ino < (uspi->s_ncg * uspi->s_ipg )))) {        ufs_warning(sb, "ufs_free_inode", "reserved inode or nonexistent inode %u/n", ino);        unlock_super (sb);        return;    }        cg = ufs_inotocg (ino);    bit = ufs_inotocgoff (ino);    ucpi = ufs_load_cylinder (sb, cg);    if (!ucpi) {        unlock_super (sb);        return;    }    ucg = ubh_get_ucg(UCPI_UBH(ucpi));    if (!ufs_cg_chkmagic(sb, ucg))        ufs_panic (sb, "ufs_free_fragments", "internal error, bad cg magic number");    ucg->cg_time = cpu_to_fs32(sb, get_seconds());    is_directory = S_ISDIR(inode->i_mode);    DQUOT_FREE_INODE(inode);    DQUOT_DROP(inode);    clear_inode (inode);    if (ubh_isclr (UCPI_UBH(ucpi), ucpi->c_iusedoff, bit))        ufs_error(sb, "ufs_free_inode", "bit already cleared for inode %u", ino);    else {        ubh_clrbit (UCPI_UBH(ucpi), ucpi->c_iusedoff, bit);        if (ino < ucpi->c_irotor)            ucpi->c_irotor = ino;        fs32_add(sb, &ucg->cg_cs.cs_nifree, 1);        uspi->cs_total.cs_nifree++;        fs32_add(sb, &UFS_SB(sb)->fs_cs(cg).cs_nifree, 1);        if (is_directory) {            fs32_sub(sb, &ucg->cg_cs.cs_ndir, 1);            uspi->cs_total.cs_ndir--;            fs32_sub(sb, &UFS_SB(sb)->fs_cs(cg).cs_ndir, 1);        }    }    ubh_mark_buffer_dirty (USPI_UBH(uspi));    ubh_mark_buffer_dirty (UCPI_UBH(ucpi));    if (sb->s_flags & MS_SYNCHRONOUS) {        ubh_ll_rw_block(SWRITE, UCPI_UBH(ucpi));        ubh_wait_on_buffer (UCPI_UBH(ucpi));    }        sb->s_dirt = 1;    unlock_super (sb);    UFSD("EXIT/n");}

/* * There are two policies for allocating an inode.  If the new inode is * a directory, then a forward search is made for a block group with both * free space and a low directory-to-inode ratio; if that fails, then of * the groups with above-average free space, that group with the fewest * directories already is chosen. * * For other inodes, search forward from the parent directory's block * group to find a free inode. */struct inode * ufs_new_inode(struct inode * dir, int mode){    struct super_block * sb;    struct ufs_sb_info * sbi;    struct ufs_sb_private_info * uspi;    struct ufs_super_block_first * usb1;    struct ufs_cg_private_info * ucpi;    struct ufs_cylinder_group * ucg;    struct inode * inode;    unsigned cg, bit, i, j, start;    struct ufs_inode_info *ufsi;    int err = -ENOSPC;    UFSD("ENTER/n");        /* Cannot create files in a deleted directory */    if (!dir || !dir->i_nlink)        return ERR_PTR(-EPERM);    sb = dir->i_sb;    inode = new_inode(sb);    if (!inode)        return ERR_PTR(-ENOMEM);    ufsi = UFS_I(inode);    sbi = UFS_SB(sb);    uspi = sbi->s_uspi;    usb1 = ubh_get_usb_first(uspi);    lock_super (sb);    /*     * Try to place the inode in its parent directory     */    i = ufs_inotocg(dir->i_ino);    if (sbi->fs_cs(i).cs_nifree) {        cg = i;        goto cg_found;    }    /*     * Use a quadratic hash to find a group with a free inode     */    for ( j = 1; j < uspi->s_ncg; j <<= 1 ) {        i += j;        if (i >= uspi->s_ncg)            i -= uspi->s_ncg;        if (sbi->fs_cs(i).cs_nifree) {            cg = i;            goto cg_found;        }    }    /*     * That failed: try linear search for a free inode     */    i = ufs_inotocg(dir->i_ino) + 1;    for (j = 2; j < uspi->s_ncg; j++) {        i++;        if (i >= uspi->s_ncg)            i = 0;        if (sbi->fs_cs(i).cs_nifree) {            cg = i;            goto cg_found;        }    }    goto failed;cg_found:    ucpi = ufs_load_cylinder (sb, cg);    if (!ucpi) {        err = -EIO;        goto failed;    }    ucg = ubh_get_ucg(UCPI_UBH(ucpi));    if (!ufs_cg_chkmagic(sb, ucg))         ufs_panic (sb, "ufs_new_inode", "internal error, bad cg magic number");    start = ucpi->c_irotor;    bit = ubh_find_next_zero_bit (UCPI_UBH(ucpi), ucpi->c_iusedoff, uspi->s_ipg, start);    if (!(bit < uspi->s_ipg)) {        bit = ubh_find_first_zero_bit (UCPI_UBH(ucpi), ucpi->c_iusedoff, start);        if (!(bit < start)) {            ufs_error (sb, "ufs_new_inode",                "cylinder group %u corrupted - error in inode bitmap/n", cg);            err = -EIO;            goto failed;        }    }    UFSD("start = %u, bit = %u, ipg = %u/n", start, bit, uspi->s_ipg);    if (ubh_isclr (UCPI_UBH(ucpi), ucpi->c_iusedoff, bit))//.........这里部分代码省略.........

/* * There are two policies for allocating an inode.  If the new inode is * a directory, then a forward search is made for a block group with both * free space and a low directory-to-inode ratio; if that fails, then of * the groups with above-average free space, that group with the fewest * directories already is chosen. * * For other inodes, search forward from the parent directory's block * group to find a free inode. */struct inode * ufs_new_inode(struct inode * dir, int mode){	struct super_block * sb;	struct ufs_sb_info * sbi;	struct ufs_sb_private_info * uspi;	struct ufs_super_block_first * usb1;	struct ufs_cg_private_info * ucpi;	struct ufs_cylinder_group * ucg;	struct inode * inode;	unsigned cg, bit, i, j, start;	struct ufs_inode_info *ufsi;	UFSD(("ENTER/n"))		/* Cannot create files in a deleted directory */	if (!dir || !dir->i_nlink)		return ERR_PTR(-EPERM);	sb = dir->i_sb;	inode = new_inode(sb);	if (!inode)		return ERR_PTR(-ENOMEM);	ufsi = UFS_I(inode);	sbi = UFS_SB(sb);	uspi = sbi->s_uspi;	usb1 = ubh_get_usb_first(USPI_UBH);	lock_super (sb);	/*	 * Try to place the inode in its parent directory	 */	i = ufs_inotocg(dir->i_ino);	if (sbi->fs_cs(i).cs_nifree) {		cg = i;		goto cg_found;	}	/*	 * Use a quadratic hash to find a group with a free inode	 */	for ( j = 1; j < uspi->s_ncg; j <<= 1 ) {		i += j;		if (i >= uspi->s_ncg)			i -= uspi->s_ncg;		if (sbi->fs_cs(i).cs_nifree) {			cg = i;			goto cg_found;		}	}	/*	 * That failed: try linear search for a free inode	 */	i = ufs_inotocg(dir->i_ino) + 1;	for (j = 2; j < uspi->s_ncg; j++) {		i++;		if (i >= uspi->s_ncg)			i = 0;		if (sbi->fs_cs(i).cs_nifree) {			cg = i;			goto cg_found;		}	}		goto failed;cg_found:	ucpi = ufs_load_cylinder (sb, cg);	if (!ucpi)		goto failed;	ucg = ubh_get_ucg(UCPI_UBH);	if (!ufs_cg_chkmagic(sb, ucg)) 		ufs_panic (sb, "ufs_new_inode", "internal error, bad cg magic number");	start = ucpi->c_irotor;	bit = ubh_find_next_zero_bit (UCPI_UBH, ucpi->c_iusedoff, uspi->s_ipg, start);	if (!(bit < uspi->s_ipg)) {		bit = ubh_find_first_zero_bit (UCPI_UBH, ucpi->c_iusedoff, start);		if (!(bit < start)) {			ufs_error (sb, "ufs_new_inode",			    "cylinder group %u corrupted - error in inode bitmap/n", cg);			goto failed;		}	}	UFSD(("start = %u, bit = %u, ipg = %u/n", start, bit, uspi->s_ipg))	if (ubh_isclr (UCPI_UBH, ucpi->c_iusedoff, bit))		ubh_setbit (UCPI_UBH, ucpi->c_iusedoff, bit);	else {		ufs_panic (sb, "ufs_new_inode", "internal error");		goto failed;//.........这里部分代码省略.........

/* * Free 'count' fragments from fragment number 'fragment' */void ufs_free_fragments (struct inode * inode, unsigned fragment, unsigned count) {	struct super_block * sb;	struct ufs_sb_private_info * uspi;	struct ufs_super_block_first * usb1;	struct ufs_cg_private_info * ucpi;	struct ufs_cylinder_group * ucg;	unsigned cgno, bit, end_bit, bbase, blkmap, i, blkno, cylno;	unsigned swab;		sb = inode->i_sb;	uspi = sb->u.ufs_sb.s_uspi;	swab = sb->u.ufs_sb.s_swab;	usb1 = ubh_get_usb_first(USPI_UBH);		UFSD(("ENTER, fragment %u, count %u/n", fragment, count))		if (ufs_fragnum(fragment) + count > uspi->s_fpg)		ufs_error (sb, "ufs_free_fragments", "internal error");		lock_super(sb);		cgno = ufs_dtog(fragment);	bit = ufs_dtogd(fragment);	if (cgno >= uspi->s_ncg) {		ufs_panic (sb, "ufs_free_fragments", "freeing blocks are outside device");		goto failed;	}			ucpi = ufs_load_cylinder (sb, cgno);	if (!ucpi) 		goto failed;	ucg = ubh_get_ucg (UCPI_UBH);	if (!ufs_cg_chkmagic (ucg)) {		ufs_panic (sb, "ufs_free_fragments", "internal error, bad magic number on cg %u", cgno);		goto failed;	}	end_bit = bit + count;	bbase = ufs_blknum (bit);	blkmap = ubh_blkmap (UCPI_UBH, ucpi->c_freeoff, bbase);	ufs_fragacct (sb, blkmap, ucg->cg_frsum, -1);	for (i = bit; i < end_bit; i++) {		if (ubh_isclr (UCPI_UBH, ucpi->c_freeoff, i))			ubh_setbit (UCPI_UBH, ucpi->c_freeoff, i);		else ufs_error (sb, "ufs_free_fragments",			"bit already cleared for fragment %u", i);	}		DQUOT_FREE_BLOCK (sb, inode, count);	ADD_SWAB32(ucg->cg_cs.cs_nffree, count);	ADD_SWAB32(usb1->fs_cstotal.cs_nffree, count);	ADD_SWAB32(sb->fs_cs(cgno).cs_nffree, count);	blkmap = ubh_blkmap (UCPI_UBH, ucpi->c_freeoff, bbase);	ufs_fragacct(sb, blkmap, ucg->cg_frsum, 1);	/*	 * Trying to reassemble free fragments into block	 */	blkno = ufs_fragstoblks (bbase);	if (ubh_isblockset(UCPI_UBH, ucpi->c_freeoff, blkno)) {		SUB_SWAB32(ucg->cg_cs.cs_nffree, uspi->s_fpb);		SUB_SWAB32(usb1->fs_cstotal.cs_nffree, uspi->s_fpb);		SUB_SWAB32(sb->fs_cs(cgno).cs_nffree, uspi->s_fpb);		if ((sb->u.ufs_sb.s_flags & UFS_CG_MASK) == UFS_CG_44BSD)			ufs_clusteracct (sb, ucpi, blkno, 1);		INC_SWAB32(ucg->cg_cs.cs_nbfree);		INC_SWAB32(usb1->fs_cstotal.cs_nbfree);		INC_SWAB32(sb->fs_cs(cgno).cs_nbfree);		cylno = ufs_cbtocylno (bbase);		INC_SWAB16(ubh_cg_blks (ucpi, cylno, ufs_cbtorpos(bbase)));		INC_SWAB32(ubh_cg_blktot (ucpi, cylno));	}		ubh_mark_buffer_dirty (USPI_UBH);	ubh_mark_buffer_dirty (UCPI_UBH);	if (sb->s_flags & MS_SYNCHRONOUS) {		ubh_ll_rw_block (WRITE, 1, (struct ufs_buffer_head **)&ucpi);		ubh_wait_on_buffer (UCPI_UBH);	}	sb->s_dirt = 1;		unlock_super (sb);	UFSD(("EXIT/n"))	return;failed:	unlock_super (sb);	UFSD(("EXIT (FAILED)/n"))	return;}

/* * Free 'count' fragments from fragment number 'fragment' (free whole blocks) */void ufs_free_blocks (struct inode * inode, unsigned fragment, unsigned count) {	struct super_block * sb;	struct ufs_sb_private_info * uspi;	struct ufs_super_block_first * usb1;	struct ufs_cg_private_info * ucpi;	struct ufs_cylinder_group * ucg;	unsigned overflow, cgno, bit, end_bit, blkno, i, cylno;	unsigned swab;		sb = inode->i_sb;	uspi = sb->u.ufs_sb.s_uspi;	swab = sb->u.ufs_sb.s_swab;	usb1 = ubh_get_usb_first(USPI_UBH);	UFSD(("ENTER, fragment %u, count %u/n", fragment, count))		if ((fragment & uspi->s_fpbmask) || (count & uspi->s_fpbmask)) {		ufs_error (sb, "ufs_free_blocks", "internal error, "			"fragment %u, count %u/n", fragment, count);		goto failed;	}	lock_super(sb);	do_more:	overflow = 0;	cgno = ufs_dtog (fragment);	bit = ufs_dtogd (fragment);	if (cgno >= uspi->s_ncg) {		ufs_panic (sb, "ufs_free_blocks", "freeing blocks are outside device");		goto failed;	}	end_bit = bit + count;	if (end_bit > uspi->s_fpg) {		overflow = bit + count - uspi->s_fpg;		count -= overflow;		end_bit -= overflow;	}	ucpi = ufs_load_cylinder (sb, cgno);	if (!ucpi) 		goto failed;	ucg = ubh_get_ucg (UCPI_UBH);	if (!ufs_cg_chkmagic (ucg)) {		ufs_panic (sb, "ufs_free_blocks", "internal error, bad magic number on cg %u", cgno);		goto failed;	}	for (i = bit; i < end_bit; i += uspi->s_fpb) {		blkno = ufs_fragstoblks(i);		if (ubh_isblockset(UCPI_UBH, ucpi->c_freeoff, blkno)) {			ufs_error(sb, "ufs_free_blocks", "freeing free fragment");		}		ubh_setblock(UCPI_UBH, ucpi->c_freeoff, blkno);		if ((sb->u.ufs_sb.s_flags & UFS_CG_MASK) == UFS_CG_44BSD)			ufs_clusteracct (sb, ucpi, blkno, 1);		DQUOT_FREE_BLOCK(sb, inode, uspi->s_fpb);		INC_SWAB32(ucg->cg_cs.cs_nbfree);		INC_SWAB32(usb1->fs_cstotal.cs_nbfree);		INC_SWAB32(sb->fs_cs(cgno).cs_nbfree);		cylno = ufs_cbtocylno(i);		INC_SWAB16(ubh_cg_blks(ucpi, cylno, ufs_cbtorpos(i)));		INC_SWAB32(ubh_cg_blktot(ucpi, cylno));	}	ubh_mark_buffer_dirty (USPI_UBH);	ubh_mark_buffer_dirty (UCPI_UBH);	if (sb->s_flags & MS_SYNCHRONOUS) {		ubh_ll_rw_block (WRITE, 1, (struct ufs_buffer_head **)&ucpi);		ubh_wait_on_buffer (UCPI_UBH);	}	if (overflow) {		fragment += count;		count = overflow;		goto do_more;	}	sb->s_dirt = 1;	unlock_super (sb);	UFSD(("EXIT/n"))	return;failed:	unlock_super (sb);	UFSD(("EXIT (FAILED)/n"))	return;}

/* * Read on-disk structures associated with cylinder groups */static int ufs_read_cylinder_structures (struct super_block *sb) {	struct ufs_sb_info * sbi = UFS_SB(sb);	struct ufs_sb_private_info * uspi;	struct ufs_super_block *usb;	struct ufs_buffer_head * ubh;	unsigned char * base, * space;	unsigned size, blks, i;	unsigned flags = 0;		UFSD(("ENTER/n"))		uspi = sbi->s_uspi;	usb  = (struct ufs_super_block *)		((struct ufs_buffer_head *)uspi)->bh[0]->b_data;        flags = UFS_SB(sb)->s_flags;		/*	 * Read cs structures from (usually) first data block	 * on the device. 	 */	size = uspi->s_cssize;	blks = (size + uspi->s_fsize - 1) >> uspi->s_fshift;	base = space = kmalloc(size, GFP_KERNEL);	if (!base)		goto failed; 	for (i = 0; i < blks; i += uspi->s_fpb) {		size = uspi->s_bsize;		if (i + uspi->s_fpb > blks)			size = (blks - i) * uspi->s_fsize;		if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) {			ubh = ubh_bread(sb,				fs64_to_cpu(sb, usb->fs_u11.fs_u2.fs_csaddr) + i, size);			if (!ubh)				goto failed;			ubh_ubhcpymem (space, ubh, size);			sbi->s_csp[ufs_fragstoblks(i)]=(struct ufs_csum *)space;		}		else {			ubh = ubh_bread(sb, uspi->s_csaddr + i, size);			if (!ubh)				goto failed;			ubh_ubhcpymem(space, ubh, size);			sbi->s_csp[ufs_fragstoblks(i)]=(struct ufs_csum *)space;		}		space += size;		ubh_brelse (ubh);		ubh = NULL;	}	/*	 * Read cylinder group (we read only first fragment from block	 * at this time) and prepare internal data structures for cg caching.	 */	if (!(sbi->s_ucg = kmalloc (sizeof(struct buffer_head *) * uspi->s_ncg, GFP_KERNEL)))		goto failed;	for (i = 0; i < uspi->s_ncg; i++) 		sbi->s_ucg[i] = NULL;	for (i = 0; i < UFS_MAX_GROUP_LOADED; i++) {		sbi->s_ucpi[i] = NULL;		sbi->s_cgno[i] = UFS_CGNO_EMPTY;	}	for (i = 0; i < uspi->s_ncg; i++) {		UFSD(("read cg %u/n", i))		if (!(sbi->s_ucg[i] = sb_bread(sb, ufs_cgcmin(i))))			goto failed;		if (!ufs_cg_chkmagic (sb, (struct ufs_cylinder_group *) sbi->s_ucg[i]->b_data))			goto failed;#ifdef UFS_SUPER_DEBUG_MORE		ufs_print_cylinder_stuff(sb, (struct ufs_cylinder_group *) sbi->s_ucg[i]->b_data);#endif	}	for (i = 0; i < UFS_MAX_GROUP_LOADED; i++) {		if (!(sbi->s_ucpi[i] = kmalloc (sizeof(struct ufs_cg_private_info), GFP_KERNEL)))			goto failed;		sbi->s_cgno[i] = UFS_CGNO_EMPTY;	}	sbi->s_cg_loaded = 0;	UFSD(("EXIT/n"))	return 1;failed:	if (base) kfree (base);	if (sbi->s_ucg) {		for (i = 0; i < uspi->s_ncg; i++)			if (sbi->s_ucg[i]) brelse (sbi->s_ucg[i]);		kfree (sbi->s_ucg);		for (i = 0; i < UFS_MAX_GROUP_LOADED; i++)			if (sbi->s_ucpi[i]) kfree (sbi->s_ucpi[i]);	}	UFSD(("EXIT (FAILED)/n"))	return 0;}