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

static int ufs_sync_fs(struct super_block *sb, int wait){	struct ufs_sb_private_info * uspi;	struct ufs_super_block_first * usb1;	struct ufs_super_block_third * usb3;	unsigned flags;	mutex_lock(&UFS_SB(sb)->s_lock);	UFSD("ENTER/n");	flags = UFS_SB(sb)->s_flags;	uspi = UFS_SB(sb)->s_uspi;	usb1 = ubh_get_usb_first(uspi);	usb3 = ubh_get_usb_third(uspi);	usb1->fs_time = cpu_to_fs32(sb, get_seconds());	if ((flags & UFS_ST_MASK) == UFS_ST_SUN  ||	    (flags & UFS_ST_MASK) == UFS_ST_SUNOS ||	    (flags & UFS_ST_MASK) == UFS_ST_SUNx86)		ufs_set_fs_state(sb, usb1, usb3,				UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));	ufs_put_cstotal(sb);	UFSD("EXIT/n");	mutex_unlock(&UFS_SB(sb)->s_lock);	return 0;}

/* * Different types of UFS hold fs_cstotal in different * places, and use different data structure for it. * To make things simpler we just copy fs_cstotal to ufs_sb_private_info */static void ufs_setup_cstotal(struct super_block *sb){	struct ufs_sb_info *sbi = UFS_SB(sb);	struct ufs_sb_private_info *uspi = sbi->s_uspi;	struct ufs_super_block_first *usb1;	struct ufs_super_block_second *usb2;	struct ufs_super_block_third *usb3;	unsigned mtype = sbi->s_mount_opt & UFS_MOUNT_UFSTYPE;	UFSD("ENTER, mtype=%u/n", mtype);	usb1 = ubh_get_usb_first(uspi);	usb2 = ubh_get_usb_second(uspi);	usb3 = ubh_get_usb_third(uspi);	if ((mtype == UFS_MOUNT_UFSTYPE_44BSD &&	     (usb1->fs_flags & UFS_FLAGS_UPDATED)) ||	    mtype == UFS_MOUNT_UFSTYPE_UFS2) {		/*we have statistic in different place, then usual*/		uspi->cs_total.cs_ndir = fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_ndir);		uspi->cs_total.cs_nbfree = fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_nbfree);		uspi->cs_total.cs_nifree = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nifree);		uspi->cs_total.cs_nffree = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nffree);	} else {		uspi->cs_total.cs_ndir = fs32_to_cpu(sb, usb1->fs_cstotal.cs_ndir);		uspi->cs_total.cs_nbfree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nbfree);		uspi->cs_total.cs_nifree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nifree);		uspi->cs_total.cs_nffree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree);	}	UFSD("EXIT/n");}

static int ufs_statfs(struct dentry *dentry, struct kstatfs *buf){    struct super_block *sb = dentry->d_sb;    struct ufs_sb_private_info *uspi= UFS_SB(sb)->s_uspi;    unsigned  flags = UFS_SB(sb)->s_flags;    struct ufs_super_block_first *usb1;    struct ufs_super_block_second *usb2;    struct ufs_super_block_third *usb3;    lock_kernel();    usb1 = ubh_get_usb_first(uspi);    usb2 = ubh_get_usb_second(uspi);    usb3 = ubh_get_usb_third(uspi);    if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) {        buf->f_type = UFS2_MAGIC;        buf->f_blocks = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_dsize);    } else {        buf->f_type = UFS_MAGIC;        buf->f_blocks = uspi->s_dsize;    }    buf->f_bfree = ufs_blkstofrags(uspi->cs_total.cs_nbfree) +                   uspi->cs_total.cs_nffree;    buf->f_ffree = uspi->cs_total.cs_nifree;    buf->f_bsize = sb->s_blocksize;    buf->f_bavail = (buf->f_bfree > (((long)buf->f_blocks / 100) * uspi->s_minfree))                    ? (buf->f_bfree - (((long)buf->f_blocks / 100) * uspi->s_minfree)) : 0;    buf->f_files = uspi->s_ncg * uspi->s_ipg;    buf->f_namelen = UFS_MAXNAMLEN;    unlock_kernel();    return 0;}

static int ufs_statfs(struct dentry *dentry, struct kstatfs *buf){	struct super_block *sb = dentry->d_sb;	struct ufs_sb_private_info *uspi= UFS_SB(sb)->s_uspi;	unsigned  flags = UFS_SB(sb)->s_flags;	struct ufs_super_block_third *usb3;	u64 id = huge_encode_dev(sb->s_bdev->bd_dev);	mutex_lock(&UFS_SB(sb)->s_lock);	usb3 = ubh_get_usb_third(uspi);		if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) {		buf->f_type = UFS2_MAGIC;		buf->f_blocks = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_dsize);	} else {		buf->f_type = UFS_MAGIC;		buf->f_blocks = uspi->s_dsize;	}	buf->f_bfree = ufs_blkstofrags(uspi->cs_total.cs_nbfree) +		uspi->cs_total.cs_nffree;	buf->f_ffree = uspi->cs_total.cs_nifree;	buf->f_bsize = sb->s_blocksize;	buf->f_bavail = (buf->f_bfree > (((long)buf->f_blocks / 100) * uspi->s_minfree))		? (buf->f_bfree - (((long)buf->f_blocks / 100) * uspi->s_minfree)) : 0;	buf->f_files = uspi->s_ncg * uspi->s_ipg;	buf->f_namelen = UFS_MAXNAMLEN;	buf->f_fsid.val[0] = (u32)id;	buf->f_fsid.val[1] = (u32)(id >> 32);	mutex_unlock(&UFS_SB(sb)->s_lock);	return 0;}

static void ufs_write_super(struct super_block *sb){    struct ufs_sb_private_info * uspi;    struct ufs_super_block_first * usb1;    struct ufs_super_block_third * usb3;    unsigned flags;    lock_kernel();    UFSD("ENTER/n");    flags = UFS_SB(sb)->s_flags;    uspi = UFS_SB(sb)->s_uspi;    usb1 = ubh_get_usb_first(uspi);    usb3 = ubh_get_usb_third(uspi);    if (!(sb->s_flags & MS_RDONLY)) {        usb1->fs_time = cpu_to_fs32(sb, get_seconds());        if ((flags & UFS_ST_MASK) == UFS_ST_SUN                || (flags & UFS_ST_MASK) == UFS_ST_SUNx86)            ufs_set_fs_state(sb, usb1, usb3,                             UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));        ufs_put_cstotal(sb);    }    sb->s_dirt = 0;    UFSD("EXIT/n");    unlock_kernel();}

/* * Sync our internal copy of fs_cstotal with disk */static void ufs_put_cstotal(struct super_block *sb){	unsigned mtype = UFS_SB(sb)->s_mount_opt & UFS_MOUNT_UFSTYPE;	struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;	struct ufs_super_block_first *usb1;	struct ufs_super_block_second *usb2;	struct ufs_super_block_third *usb3;	UFSD("ENTER/n");	usb1 = ubh_get_usb_first(uspi);	usb2 = ubh_get_usb_second(uspi);	usb3 = ubh_get_usb_third(uspi);	if ((mtype == UFS_MOUNT_UFSTYPE_44BSD &&	     (usb1->fs_flags & UFS_FLAGS_UPDATED)) ||	    mtype == UFS_MOUNT_UFSTYPE_UFS2) {		/*we have statistic in different place, then usual*/		usb2->fs_un.fs_u2.cs_ndir =			cpu_to_fs64(sb, uspi->cs_total.cs_ndir);		usb2->fs_un.fs_u2.cs_nbfree =			cpu_to_fs64(sb, uspi->cs_total.cs_nbfree);		usb3->fs_un1.fs_u2.cs_nifree =			cpu_to_fs64(sb, uspi->cs_total.cs_nifree);		usb3->fs_un1.fs_u2.cs_nffree =			cpu_to_fs64(sb, uspi->cs_total.cs_nffree);	} else {		usb1->fs_cstotal.cs_ndir =			cpu_to_fs32(sb, uspi->cs_total.cs_ndir);		usb1->fs_cstotal.cs_nbfree =			cpu_to_fs32(sb, uspi->cs_total.cs_nbfree);		usb1->fs_cstotal.cs_nifree =			cpu_to_fs32(sb, uspi->cs_total.cs_nifree);		usb1->fs_cstotal.cs_nffree =			cpu_to_fs32(sb, uspi->cs_total.cs_nffree);	}	ubh_mark_buffer_dirty(USPI_UBH(uspi));	ufs_print_super_stuff(sb, usb1, usb2, usb3);	UFSD("EXIT/n");}

//.........这里部分代码省略.........		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)				pr_info("ufstype=hp is supported read-only/n");			sb->s_flags |= MS_RDONLY; 		} 		break;	default:		if (!silent)			pr_err("unknown ufstype/n");		goto failed;	}	again:		if (!sb_set_blocksize(sb, block_size)) {		pr_err("failed to set blocksize/n");		goto failed;	}	/*	 * read ufs super block from device	 */	ubh = ubh_bread_uspi(uspi, sb, uspi->s_sbbase + super_block_offset/block_size, super_block_size);		if (!ubh)             goto failed;	usb1 = ubh_get_usb_first(uspi);	usb2 = ubh_get_usb_second(uspi);	usb3 = ubh_get_usb_third(uspi);	/* Sort out mod used on SunOS 4.1.3 for fs_state */	uspi->s_postblformat = fs32_to_cpu(sb, usb3->fs_postblformat);	if (((flags & UFS_ST_MASK) == UFS_ST_SUNOS) &&	    (uspi->s_postblformat != UFS_42POSTBLFMT)) {		flags &= ~UFS_ST_MASK;		flags |=  UFS_ST_SUN;	}	/*	 * Check ufs magic number	 */	sbi->s_bytesex = BYTESEX_LE;	switch ((uspi->fs_magic = fs32_to_cpu(sb, usb3->fs_magic))) {		case UFS_MAGIC:		case UFS_MAGIC_BW:		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 UFS_MAGIC_BW:		case UFS2_MAGIC:		case UFS_MAGIC_LFN:	        case UFS_MAGIC_FEA:	        case UFS_MAGIC_4GB:			goto magic_found;	}

static int ufs_remount (struct super_block *sb, int *mount_flags, char *data){	struct ufs_sb_private_info * uspi;	struct ufs_super_block_first * usb1;	struct ufs_super_block_third * usb3;	unsigned new_mount_opt, ufstype;	unsigned flags;	sync_filesystem(sb);	mutex_lock(&UFS_SB(sb)->s_lock);	uspi = UFS_SB(sb)->s_uspi;	flags = UFS_SB(sb)->s_flags;	usb1 = ubh_get_usb_first(uspi);	usb3 = ubh_get_usb_third(uspi);		/*	 * Allow the "check" option to be passed as a remount option.	 * It is not possible to change ufstype option during remount	 */	ufstype = UFS_SB(sb)->s_mount_opt & UFS_MOUNT_UFSTYPE;	new_mount_opt = 0;	ufs_set_opt (new_mount_opt, ONERROR_LOCK);	if (!ufs_parse_options (data, &new_mount_opt)) {		mutex_unlock(&UFS_SB(sb)->s_lock);		return -EINVAL;	}	if (!(new_mount_opt & UFS_MOUNT_UFSTYPE)) {		new_mount_opt |= ufstype;	} else if ((new_mount_opt & UFS_MOUNT_UFSTYPE) != ufstype) {		pr_err("ufstype can't be changed during remount/n");		mutex_unlock(&UFS_SB(sb)->s_lock);		return -EINVAL;	}	if ((*mount_flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY)) {		UFS_SB(sb)->s_mount_opt = new_mount_opt;		mutex_unlock(&UFS_SB(sb)->s_lock);		return 0;	}		/*	 * fs was mouted as rw, remounting ro	 */	if (*mount_flags & MS_RDONLY) {		ufs_put_super_internal(sb);		usb1->fs_time = cpu_to_fs32(sb, get_seconds());		if ((flags & UFS_ST_MASK) == UFS_ST_SUN		  || (flags & UFS_ST_MASK) == UFS_ST_SUNOS		  || (flags & UFS_ST_MASK) == UFS_ST_SUNx86) 			ufs_set_fs_state(sb, usb1, usb3,				UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));		ubh_mark_buffer_dirty (USPI_UBH(uspi));		sb->s_flags |= MS_RDONLY;	} else {	/*	 * fs was mounted as ro, remounting rw	 */#ifndef CONFIG_UFS_FS_WRITE		pr_err("ufs was compiled with read-only support, can't be mounted as read-write/n");		mutex_unlock(&UFS_SB(sb)->s_lock);		return -EINVAL;#else		if (ufstype != UFS_MOUNT_UFSTYPE_SUN && 		    ufstype != UFS_MOUNT_UFSTYPE_SUNOS &&		    ufstype != UFS_MOUNT_UFSTYPE_44BSD &&		    ufstype != UFS_MOUNT_UFSTYPE_SUNx86 &&		    ufstype != UFS_MOUNT_UFSTYPE_UFS2) {			pr_err("this ufstype is read-only supported/n");			mutex_unlock(&UFS_SB(sb)->s_lock);			return -EINVAL;		}		if (!ufs_read_cylinder_structures(sb)) {			pr_err("failed during remounting/n");			mutex_unlock(&UFS_SB(sb)->s_lock);			return -EPERM;		}		sb->s_flags &= ~MS_RDONLY;#endif	}	UFS_SB(sb)->s_mount_opt = new_mount_opt;	mutex_unlock(&UFS_SB(sb)->s_lock);	return 0;}

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;	struct ufs_super_block_third *usb3;	UFSD("ENTER/n");	usb3 = ubh_get_usb_third(uspi);	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;	}	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;}

//.........这里部分代码省略.........	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)) {			printk(KERN_INFO "ufstype=hp is supported read-only/n");			sb->s_flags |= MS_RDONLY; 		} 		break;	default:		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	 */	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);	/*	 * Check ufs magic number	 */	switch (__constant_le32_to_cpu(usb3->fs_magic)) {		case UFS_MAGIC:		case UFS_MAGIC_LFN:	        case UFS_MAGIC_FEA:	        case UFS_MAGIC_4GB:			sbi->s_bytesex = BYTESEX_LE;			goto magic_found;	}	switch (__constant_be32_to_cpu(usb3->fs_magic)) {		case UFS_MAGIC:		case UFS_MAGIC_LFN:	        case UFS_MAGIC_FEA:	        case UFS_MAGIC_4GB:			sbi->s_bytesex = BYTESEX_BE;			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;	}	printk("ufs_read_super: bad magic number/n");	goto failed;

/* * 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;    unsigned flags = sbi->s_flags;    struct ufs_buffer_head * ubh;    unsigned char * base, * space;    unsigned size, blks, i;    struct ufs_super_block_third *usb3;    UFSD("ENTER/n");    usb3 = ubh_get_usb_third(uspi);    /*     * 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;    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;        if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)            ubh = ubh_bread(sb,                            fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_csaddr) + i, size);        else            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_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;        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_KERNEL)))            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;}