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

/* * Find a block of the specified size in the specified cylinder group. * @sp: pointer to super block * @ucpi: pointer to cylinder group info * @goal: near which block we want find new one * @count: specified size */static u64 ufs_bitmap_search(struct super_block *sb,			     struct ufs_cg_private_info *ucpi,			     u64 goal, unsigned count){	/*	 * Bit patterns for identifying fragments in the block map	 * used as ((map & mask_arr) == want_arr)	 */	static const int mask_arr[9] = {		0x3, 0x7, 0xf, 0x1f, 0x3f, 0x7f, 0xff, 0x1ff, 0x3ff	};	static const int want_arr[9] = {		0x0, 0x2, 0x6, 0xe, 0x1e, 0x3e, 0x7e, 0xfe, 0x1fe	};	struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;	struct ufs_super_block_first *usb1;	struct ufs_cylinder_group *ucg;	unsigned start, length, loc;	unsigned pos, want, blockmap, mask, end;	u64 result;	UFSD("ENTER, cg %u, goal %llu, count %u/n", ucpi->c_cgx,	     (unsigned long long)goal, count);	usb1 = ubh_get_usb_first (uspi);	ucg = ubh_get_ucg(UCPI_UBH(ucpi));	if (goal)		start = ufs_dtogd(uspi, goal) >> 3;	else

unsigned ufs_new_fragments (struct inode * inode, u32 * p, unsigned fragment,	unsigned goal, unsigned count, int * err ){	struct super_block * sb;	struct ufs_sb_private_info * uspi;	struct ufs_super_block_first * usb1;	struct buffer_head * bh;	unsigned cgno, oldcount, newcount, tmp, request, i, result;	unsigned swab;		UFSD(("ENTER, ino %lu, fragment %u, goal %u, count %u/n", inode->i_ino, fragment, goal, count))		sb = inode->i_sb;	swab = sb->u.ufs_sb.s_swab;	uspi = sb->u.ufs_sb.s_uspi;	usb1 = ubh_get_usb_first(USPI_UBH);	*err = -ENOSPC;	lock_super (sb);		tmp = SWAB32(*p);	if (count + ufs_fragnum(fragment) > uspi->s_fpb) {		ufs_warning (sb, "ufs_new_fragments", "internal warning"			" fragment %u, count %u", fragment, count);		count = uspi->s_fpb - ufs_fragnum(fragment); 	}	oldcount = ufs_fragnum (fragment);	newcount = oldcount + count;	/*	 * Somebody else has just allocated our fragments	 */	if (oldcount) {		if (!tmp) {			ufs_error (sb, "ufs_new_fragments", "internal error, "				"fragment %u, tmp %u/n", fragment, tmp);			return (unsigned)-1;		}		if (fragment < inode->u.ufs_i.i_lastfrag) {			UFSD(("EXIT (ALREADY ALLOCATED)/n"))			unlock_super (sb);			return 0;		}	}	else {		if (tmp) {			UFSD(("EXIT (ALREADY ALLOCATED)/n"))			unlock_super(sb);			return 0;		}	}		/*	 * There is not enough space for user on the device	 */	if (!fsuser() && ufs_freespace(usb1, UFS_MINFREE) <= 0) {		unlock_super (sb);		UFSD(("EXIT (FAILED)/n"))		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_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;}

void ufs_error (struct super_block * sb, const char * function,	const char * fmt, ...){	struct ufs_sb_private_info * uspi;	struct ufs_super_block_first * usb1;	va_list args;	uspi = UFS_SB(sb)->s_uspi;	usb1 = ubh_get_usb_first(uspi);		if (!(sb->s_flags & MS_RDONLY)) {		usb1->fs_clean = UFS_FSBAD;		ubh_mark_buffer_dirty(USPI_UBH(uspi));		ufs_mark_sb_dirty(sb);		sb->s_flags |= MS_RDONLY;	}	va_start (args, fmt);	vsnprintf (error_buf, sizeof(error_buf), fmt, args);	va_end (args);	switch (UFS_SB(sb)->s_mount_opt & UFS_MOUNT_ONERROR) {	case UFS_MOUNT_ONERROR_PANIC:		panic ("UFS-fs panic (device %s): %s: %s/n", 			sb->s_id, function, error_buf);	case UFS_MOUNT_ONERROR_LOCK:	case UFS_MOUNT_ONERROR_UMOUNT:	case UFS_MOUNT_ONERROR_REPAIR:		printk (KERN_CRIT "UFS-fs error (device %s): %s: %s/n",			sb->s_id, function, error_buf);	}		}

void ufs_error (struct super_block * sb, const char * function,	const char * fmt, ...){	struct ufs_sb_private_info * uspi;	struct ufs_super_block_first * usb1;	struct va_format vaf;	va_list args;	uspi = UFS_SB(sb)->s_uspi;	usb1 = ubh_get_usb_first(uspi);		if (!(sb->s_flags & MS_RDONLY)) {		usb1->fs_clean = UFS_FSBAD;		ubh_mark_buffer_dirty(USPI_UBH(uspi));		ufs_mark_sb_dirty(sb);		sb->s_flags |= MS_RDONLY;	}	va_start(args, fmt);	vaf.fmt = fmt;	vaf.va = &args;	switch (UFS_SB(sb)->s_mount_opt & UFS_MOUNT_ONERROR) {	case UFS_MOUNT_ONERROR_PANIC:		panic("panic (device %s): %s: %pV/n",		      sb->s_id, function, &vaf);	case UFS_MOUNT_ONERROR_LOCK:	case UFS_MOUNT_ONERROR_UMOUNT:	case UFS_MOUNT_ONERROR_REPAIR:		pr_crit("error (device %s): %s: %pV/n",			sb->s_id, function, &vaf);	}	va_end(args);}

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 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();}

static u64 ufs_alloccg_block(struct inode *inode,			     struct ufs_cg_private_info *ucpi,			     u64 goal, int *err){	struct super_block * sb;	struct ufs_sb_private_info * uspi;	struct ufs_super_block_first * usb1;	struct ufs_cylinder_group * ucg;	u64 result, blkno;	UFSD("ENTER, goal %llu/n", (unsigned long long)goal);	sb = inode->i_sb;	uspi = UFS_SB(sb)->s_uspi;	usb1 = ubh_get_usb_first(uspi);	ucg = ubh_get_ucg(UCPI_UBH(ucpi));	if (goal == 0) {		goal = ucpi->c_rotor;		goto norot;	}	goal = ufs_blknum (goal);	goal = ufs_dtogd(uspi, goal);		/*	 * If the requested block is available, use it.	 */	if (ubh_isblockset(UCPI_UBH(ucpi), ucpi->c_freeoff, ufs_fragstoblks(goal))) {		result = goal;		goto gotit;	}	norot:		result = ufs_bitmap_search (sb, ucpi, goal, uspi->s_fpb);	if (result == INVBLOCK)		return INVBLOCK;	ucpi->c_rotor = result;gotit:	blkno = ufs_fragstoblks(result);	ubh_clrblock (UCPI_UBH(ucpi), ucpi->c_freeoff, blkno);	if ((UFS_SB(sb)->s_flags & UFS_CG_MASK) == UFS_CG_44BSD)		ufs_clusteracct (sb, ucpi, blkno, -1);	fs32_sub(sb, &ucg->cg_cs.cs_nbfree, 1);	uspi->cs_total.cs_nbfree--;	fs32_sub(sb, &UFS_SB(sb)->fs_cs(ucpi->c_cgx).cs_nbfree, 1);	if (uspi->fs_magic != UFS2_MAGIC) {		unsigned cylno = ufs_cbtocylno((unsigned)result);		fs16_sub(sb, &ubh_cg_blks(ucpi, cylno,					  ufs_cbtorpos((unsigned)result)), 1);		fs32_sub(sb, &ubh_cg_blktot(ucpi, cylno), 1);	}		UFSD("EXIT, result %llu/n", (unsigned long long)result);	return result;}

void ufs_panic (struct super_block * sb, const char * function,	const char * fmt, ...){	struct ufs_sb_private_info * uspi;	struct ufs_super_block_first * usb1;	va_list args;		uspi = UFS_SB(sb)->s_uspi;	usb1 = ubh_get_usb_first(uspi);		if (!(sb->s_flags & MS_RDONLY)) {		usb1->fs_clean = UFS_FSBAD;		ubh_mark_buffer_dirty(USPI_UBH(uspi));		sb->s_dirt = 1;	}	va_start (args, fmt);	vsnprintf (error_buf, sizeof(error_buf), fmt, args);	va_end (args);	sb->s_flags |= MS_RDONLY;	printk (KERN_CRIT "UFS-fs panic (device %s): %s: %s/n",		sb->s_id, function, error_buf);}

/* * 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");}

void ufs_panic (struct super_block * sb, const char * function,	const char * fmt, ...){	struct ufs_sb_private_info * uspi;	struct ufs_super_block_first * usb1;	struct va_format vaf;	va_list args;		uspi = UFS_SB(sb)->s_uspi;	usb1 = ubh_get_usb_first(uspi);		if (!(sb->s_flags & MS_RDONLY)) {		usb1->fs_clean = UFS_FSBAD;		ubh_mark_buffer_dirty(USPI_UBH(uspi));		ufs_mark_sb_dirty(sb);	}	va_start(args, fmt);	vaf.fmt = fmt;	vaf.va = &args;	sb->s_flags |= MS_RDONLY;	pr_crit("panic (device %s): %s: %pV/n",		sb->s_id, function, &vaf);	va_end(args);}

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;}

/* * 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;}

/* * 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))//.........这里部分代码省略.........

//.........这里部分代码省略.........		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)) {			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;	}

//.........这里部分代码省略.........		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)				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:

/* * 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;}