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

/* * Guts of jfs_truncate.  Called with locks already held.  Can be called * with directory for truncating directory index table. */void jfs_truncate_nolock(struct inode *ip, loff_t length){	loff_t newsize;	tid_t tid;	ASSERT(length >= 0);	if (test_cflag(COMMIT_Nolink, ip)) {		xtTruncate(0, ip, length, COMMIT_WMAP);		return;	}	do {		tid = txBegin(ip->i_sb, 0);		/*		 * The commit_mutex cannot be taken before txBegin.		 * txBegin may block and there is a chance the inode		 * could be marked dirty and need to be committed		 * before txBegin unblocks		 */		mutex_lock(&JFS_IP(ip)->commit_mutex);		newsize = xtTruncate(tid, ip, length,				     COMMIT_TRUNCATE | COMMIT_PWMAP);		if (newsize < 0) {			txEnd(tid);			mutex_unlock(&JFS_IP(ip)->commit_mutex);			break;		}		ip->i_mtime = ip->i_ctime = CURRENT_TIME;		mark_inode_dirty(ip);		txCommit(tid, 1, &ip, 0);		txEnd(tid);		mutex_unlock(&JFS_IP(ip)->commit_mutex);	} while (newsize > length);	/* Truncate isn't always atomic */}

/* * Workhorse of both fsync & write_inode */int jfs_commit_inode(struct inode *inode, int wait){	int rc = 0;	tid_t tid;	static int noisy = 5;	jfs_info("In jfs_commit_inode, inode = 0x%p", inode);	/*	 * Don't commit if inode has been committed since last being	 * marked dirty, or if it has been deleted.	 */	if (test_cflag(COMMIT_Nolink, inode) ||	    !test_cflag(COMMIT_Dirty, inode))		return 0;	if (isReadOnly(inode)) {		/* kernel allows writes to devices on read-only		 * partitions and may think inode is dirty		 */		if (!special_file(inode->i_mode) && noisy) {			jfs_err("jfs_commit_inode(0x%p) called on "				   "read-only volume", inode);			jfs_err("Is remount racy?");			noisy--;		}		return 0;	}	tid = txBegin(inode->i_sb, COMMIT_INODE);	down(&JFS_IP(inode)->commit_sem);	rc = txCommit(tid, 1, &inode, wait ? COMMIT_SYNC : 0);	txEnd(tid);	up(&JFS_IP(inode)->commit_sem);	return rc;}

//.........这里部分代码省略.........        if (ssize > sizeof (JFS_IP(ip)->i_inline))            JFS_IP(ip)->mode2 &= ~INLINEEA;        jfs_info("jfs_symlink: fast symlink added  ssize:%d name:%s ",                 ssize, name);    }    /*     * write source path name in a single extent     */    else {        jfs_info("jfs_symlink: allocate extent ip:0x%p", ip);        ip->i_op = &jfs_symlink_inode_operations;        ip->i_mapping->a_ops = &jfs_aops;        /*         * even though the data of symlink object (source         * path name) is treated as non-journaled user data,         * it is read/written thru buffer cache for performance.         */        sb = ip->i_sb;        bmask = JFS_SBI(sb)->bsize - 1;        xsize = (ssize + bmask) & ~bmask;        xaddr = 0;        xlen = xsize >> JFS_SBI(sb)->l2bsize;        if ((rc = xtInsert(tid, ip, 0, 0, xlen, &xaddr, 0))) {            txAbort(tid, 0);            goto out3;        }        extent = xaddr;        ip->i_size = ssize - 1;        while (ssize) {            /* This is kind of silly since PATH_MAX == 4K */            int copy_size = min(ssize, PSIZE);            mp = get_metapage(ip, xaddr, PSIZE, 1);            if (mp == NULL) {                xtTruncate(tid, ip, 0, COMMIT_PWMAP);                rc = -EIO;                txAbort(tid, 0);                goto out3;            }            memcpy(mp->data, name, copy_size);            flush_metapage(mp);            ssize -= copy_size;            name += copy_size;            xaddr += JFS_SBI(sb)->nbperpage;        }    }    /*     * create entry for symbolic link in parent directory     */    rc = dtSearch(dip, &dname, &ino, &btstack, JFS_CREATE);    if (rc == 0) {        ino = ip->i_ino;        rc = dtInsert(tid, dip, &dname, &ino, &btstack);    }    if (rc) {        if (xlen)            xtTruncate(tid, ip, 0, COMMIT_PWMAP);        txAbort(tid, 0);        /* discard new inode */        goto out3;    }    mark_inode_dirty(ip);    dip->i_ctime = dip->i_mtime = CURRENT_TIME;    mark_inode_dirty(dip);    /*     * commit update of parent directory and link object     */    iplist[0] = dip;    iplist[1] = ip;    rc = txCommit(tid, 2, &iplist[0], 0);out3:    txEnd(tid);    mutex_unlock(&JFS_IP(ip)->commit_mutex);    mutex_unlock(&JFS_IP(dip)->commit_mutex);    if (rc) {        free_ea_wmap(ip);        ip->i_nlink = 0;        unlock_new_inode(ip);        iput(ip);    } else {        d_instantiate(dentry, ip);        unlock_new_inode(ip);    }out2:    free_UCSname(&dname);out1:    jfs_info("jfs_symlink: rc:%d", rc);    return rc;}

//.........这里部分代码省略.........    /*     * search parent directory for entry/freespace     * (dtSearch() returns parent directory page pinned)     */    if ((rc = get_UCSname(&dname, dentry)))        goto out1;    /*     * Either iAlloc() or txBegin() may block.  Deadlock can occur if we     * block there while holding dtree page, so we allocate the inode &     * begin the transaction before we search the directory.     */    ip = ialloc(dip, mode);    if (IS_ERR(ip)) {        rc = PTR_ERR(ip);        goto out2;    }    tid = txBegin(dip->i_sb, 0);    mutex_lock_nested(&JFS_IP(dip)->commit_mutex, COMMIT_MUTEX_PARENT);    mutex_lock_nested(&JFS_IP(ip)->commit_mutex, COMMIT_MUTEX_CHILD);    rc = jfs_init_acl(tid, ip, dip);    if (rc)        goto out3;    rc = jfs_init_security(tid, ip, dip, &dentry->d_name);    if (rc) {        txAbort(tid, 0);        goto out3;    }    if ((rc = dtSearch(dip, &dname, &ino, &btstack, JFS_CREATE))) {        jfs_err("jfs_create: dtSearch returned %d", rc);        txAbort(tid, 0);        goto out3;    }    tblk = tid_to_tblock(tid);    tblk->xflag |= COMMIT_CREATE;    tblk->ino = ip->i_ino;    tblk->u.ixpxd = JFS_IP(ip)->ixpxd;    iplist[0] = dip;    iplist[1] = ip;    /*     * initialize the child XAD tree root in-line in inode     */    xtInitRoot(tid, ip);    /*     * create entry in parent directory for child directory     * (dtInsert() releases parent directory page)     */    ino = ip->i_ino;    if ((rc = dtInsert(tid, dip, &dname, &ino, &btstack))) {        if (rc == -EIO) {            jfs_err("jfs_create: dtInsert returned -EIO");            txAbort(tid, 1);	/* Marks Filesystem dirty */        } else            txAbort(tid, 0);	/* Filesystem full */        goto out3;    }    ip->i_op = &jfs_file_inode_operations;    ip->i_fop = &jfs_file_operations;    ip->i_mapping->a_ops = &jfs_aops;    mark_inode_dirty(ip);    dip->i_ctime = dip->i_mtime = CURRENT_TIME;    mark_inode_dirty(dip);    rc = txCommit(tid, 2, &iplist[0], 0);out3:    txEnd(tid);    mutex_unlock(&JFS_IP(ip)->commit_mutex);    mutex_unlock(&JFS_IP(dip)->commit_mutex);    if (rc) {        free_ea_wmap(ip);        ip->i_nlink = 0;        unlock_new_inode(ip);        iput(ip);    } else {        d_instantiate(dentry, ip);        unlock_new_inode(ip);    }out2:    free_UCSname(&dname);out1:    jfs_info("jfs_create: rc:%d", rc);    return rc;}

/* * NAME:	jfs_rmdir(dip, dentry) * * FUNCTION:	remove a link to child directory * * PARAMETER:	dip	- parent inode *		dentry	- child directory dentry * * RETURN:	-EINVAL	- if name is . or .. *		-EINVAL - if . or .. exist but are invalid. *		errors from subroutines * * note: * if other threads have the directory open when the last link * is removed, the "." and ".." entries, if present, are removed before * rmdir() returns and no new entries may be created in the directory, * but the directory is not removed until the last reference to * the directory is released (cf.unlink() of regular file). */static int jfs_rmdir(struct inode *dip, struct dentry *dentry){    int rc;    tid_t tid;		/* transaction id */    struct inode *ip = dentry->d_inode;    ino_t ino;    struct component_name dname;    struct inode *iplist[2];    struct tblock *tblk;    jfs_info("jfs_rmdir: dip:0x%p name:%s", dip, dentry->d_name.name);    /* Init inode for quota operations. */    dquot_initialize(dip);    dquot_initialize(ip);    /* directory must be empty to be removed */    if (!dtEmpty(ip)) {        rc = -ENOTEMPTY;        goto out;    }    if ((rc = get_UCSname(&dname, dentry))) {        goto out;    }    tid = txBegin(dip->i_sb, 0);    mutex_lock_nested(&JFS_IP(dip)->commit_mutex, COMMIT_MUTEX_PARENT);    mutex_lock_nested(&JFS_IP(ip)->commit_mutex, COMMIT_MUTEX_CHILD);    iplist[0] = dip;    iplist[1] = ip;    tblk = tid_to_tblock(tid);    tblk->xflag |= COMMIT_DELETE;    tblk->u.ip = ip;    /*     * delete the entry of target directory from parent directory     */    ino = ip->i_ino;    if ((rc = dtDelete(tid, dip, &dname, &ino, JFS_REMOVE))) {        jfs_err("jfs_rmdir: dtDelete returned %d", rc);        if (rc == -EIO)            txAbort(tid, 1);        txEnd(tid);        mutex_unlock(&JFS_IP(ip)->commit_mutex);        mutex_unlock(&JFS_IP(dip)->commit_mutex);        goto out2;    }    /* update parent directory's link count corresponding     * to ".." entry of the target directory deleted     */    dip->i_ctime = dip->i_mtime = CURRENT_TIME;    inode_dec_link_count(dip);    /*     * OS/2 could have created EA and/or ACL     */    /* free EA from both persistent and working map */    if (JFS_IP(ip)->ea.flag & DXD_EXTENT) {        /* free EA pages */        txEA(tid, ip, &JFS_IP(ip)->ea, NULL);    }    JFS_IP(ip)->ea.flag = 0;    /* free ACL from both persistent and working map */    if (JFS_IP(ip)->acl.flag & DXD_EXTENT) {        /* free ACL pages */        txEA(tid, ip, &JFS_IP(ip)->acl, NULL);    }    JFS_IP(ip)->acl.flag = 0;    /* mark the target directory as deleted */    clear_nlink(ip);    mark_inode_dirty(ip);    rc = txCommit(tid, 2, &iplist[0], 0);//.........这里部分代码省略.........

//.........这里部分代码省略.........			JFS_IP(ip)->mode2 &= ~INLINEEA;		jFYI(1,		     ("jfs_symlink: fast symlink added  ssize:%d name:%s /n",		      ssize, name));	}	/*	 * write source path name in a single extent	 */	else {		jFYI(1, ("jfs_symlink: allocate extent ip:0x%p/n", ip));		ip->i_op = &page_symlink_inode_operations;		ip->i_mapping->a_ops = &jfs_aops;		/*		 * even though the data of symlink object (source 		 * path name) is treated as non-journaled user data,		 * it is read/written thru buffer cache for performance.		 */		sb = ip->i_sb;		bmask = JFS_SBI(sb)->bsize - 1;		xsize = (ssize + bmask) & ~bmask;		xaddr = 0;		xlen = xsize >> JFS_SBI(sb)->l2bsize;		if ((rc = xtInsert(tid, ip, 0, 0, xlen, &xaddr, 0)) == 0) {			ip->i_size = ssize - 1;			while (ssize) {				int copy_size = min(ssize, PSIZE);				mp = get_metapage(ip, xaddr, PSIZE, 1);				if (mp == NULL) {					dtDelete(tid, dip, &dname, &ino,						 JFS_REMOVE);					rc = EIO;					goto out3;				}				memcpy(mp->data, name, copy_size);				flush_metapage(mp);#if 0				mark_buffer_uptodate(bp, 1);				mark_buffer_dirty(bp, 1);				if (IS_SYNC(dip)) {					ll_rw_block(WRITE, 1, &bp);					wait_on_buffer(bp);				}				brelse(bp);#endif				/* 0 */				ssize -= copy_size;				xaddr += JFS_SBI(sb)->nbperpage;			}			ip->i_blocks = LBLK2PBLK(sb, xlen);		} else {			dtDelete(tid, dip, &dname, &ino, JFS_REMOVE);			rc = ENOSPC;			goto out3;		}	}	insert_inode_hash(ip);	mark_inode_dirty(ip);	d_instantiate(dentry, ip);	/*	 * commit update of parent directory and link object	 *	 * if extent allocation failed (ENOSPC),	 * the parent inode is committed regardless to avoid	 * backing out parent directory update (by dtInsert())	 * and subsequent dtDelete() which is harmless wrt 	 * integrity concern.  	 * the symlink inode will be freed by iput() at exit	 * as it has a zero link count (by dtDelete()) and 	 * no permanant resources. 	 */	iplist[0] = dip;	if (rc == 0) {		iplist[1] = ip;		rc = txCommit(tid, 2, &iplist[0], 0);	} else		rc = txCommit(tid, 1, &iplist[0], 0);      out3:	txEnd(tid);	up(&JFS_IP(dip)->commit_sem);	up(&JFS_IP(ip)->commit_sem);	if (rc) {		ip->i_nlink = 0;		iput(ip);	}      out2:	free_UCSname(&dname);      out1:	jFYI(1, ("jfs_symlink: rc:%d/n", -rc));	return -rc;}

/* * NAME:	jfs_link(vp, dvp, name, crp) * * FUNCTION:	create a link to <vp> by the name = <name> *		in the parent directory <dvp> * * PARAMETER:	vp 	- target object *		dvp	- parent directory of new link *		name	- name of new link to target object *		crp	- credential * * RETURN:	Errors from subroutines * * note: * JFS does NOT support link() on directories (to prevent circular * path in the directory hierarchy); * EPERM: the target object is a directory, and either the caller * does not have appropriate privileges or the implementation prohibits * using link() on directories [XPG4.2]. * * JFS does NOT support links between file systems: * EXDEV: target object and new link are on different file systems and * implementation does not support links between file systems [XPG4.2]. */int jfs_link(struct dentry *old_dentry,	     struct inode *dir, struct dentry *dentry){	int rc;	tid_t tid;	struct inode *ip = old_dentry->d_inode;	ino_t ino;	struct component_name dname;	struct btstack btstack;	struct inode *iplist[2];	jFYI(1,	     ("jfs_link: %s %s/n", old_dentry->d_name.name,	      dentry->d_name.name));	/* JFS does NOT support link() on directories */	if (S_ISDIR(ip->i_mode))		return -EPERM;	tid = txBegin(ip->i_sb, 0);	down(&JFS_IP(dir)->commit_sem);	down(&JFS_IP(ip)->commit_sem);	if (ip->i_nlink == JFS_LINK_MAX) {		rc = EMLINK;		goto out;	}	/*	 * scan parent directory for entry/freespace	 */	if ((rc = get_UCSname(&dname, dentry, JFS_SBI(ip->i_sb)->nls_tab)))		goto out;	if ((rc = dtSearch(dir, &dname, &ino, &btstack, JFS_CREATE)))		goto out;	/*	 * create entry for new link in parent directory	 */	ino = ip->i_ino;	if ((rc = dtInsert(tid, dir, &dname, &ino, &btstack)))		goto out;	/* update object inode */	ip->i_nlink++;		/* for new link */	ip->i_ctime = CURRENT_TIME;	mark_inode_dirty(dir);	atomic_inc(&ip->i_count);	d_instantiate(dentry, ip);	iplist[0] = ip;	iplist[1] = dir;	rc = txCommit(tid, 2, &iplist[0], 0);      out:	txEnd(tid);	up(&JFS_IP(dir)->commit_sem);	up(&JFS_IP(ip)->commit_sem);	jFYI(1, ("jfs_link: rc:%d/n", rc));	return -rc;}

/* * NAME:	jfs_create(dip, dentry, mode) * * FUNCTION:	create a regular file in the parent directory <dip> *		with name = <from dentry> and mode = <mode> * * PARAMETER:	dip 	- parent directory vnode *		dentry	- dentry of new file *		mode	- create mode (rwxrwxrwx). * * RETURN:	Errors from subroutines * */int jfs_create(struct inode *dip, struct dentry *dentry, int mode){	int rc = 0;	tid_t tid;		/* transaction id */	struct inode *ip = NULL;	/* child directory inode */	ino_t ino;	struct component_name dname;	/* child directory name */	struct btstack btstack;	struct inode *iplist[2];	struct tblock *tblk;	jFYI(1, ("jfs_create: dip:0x%p name:%s/n", dip, dentry->d_name.name));	/*	 * search parent directory for entry/freespace	 * (dtSearch() returns parent directory page pinned)	 */	if ((rc = get_UCSname(&dname, dentry, JFS_SBI(dip->i_sb)->nls_tab)))		goto out1;	/*	 * Either iAlloc() or txBegin() may block.  Deadlock can occur if we	 * block there while holding dtree page, so we allocate the inode &	 * begin the transaction before we search the directory.	 */	ip = ialloc(dip, mode);	if (ip == NULL) {		rc = ENOSPC;		goto out2;	}	tid = txBegin(dip->i_sb, 0);	down(&JFS_IP(dip)->commit_sem);	down(&JFS_IP(ip)->commit_sem);	if ((rc = dtSearch(dip, &dname, &ino, &btstack, JFS_CREATE))) {		jERROR(1, ("jfs_create: dtSearch returned %d/n", rc));		goto out3;	}	tblk = tid_to_tblock(tid);	tblk->xflag |= COMMIT_CREATE;	tblk->ip = ip;	iplist[0] = dip;	iplist[1] = ip;	/*	 * initialize the child XAD tree root in-line in inode	 */	xtInitRoot(tid, ip);	/*	 * create entry in parent directory for child directory	 * (dtInsert() releases parent directory page)	 */	ino = ip->i_ino;	if ((rc = dtInsert(tid, dip, &dname, &ino, &btstack))) {		jERROR(1, ("jfs_create: dtInsert returned %d/n", rc));		if (rc == EIO)			txAbort(tid, 1);	/* Marks Filesystem dirty */		else			txAbort(tid, 0);	/* Filesystem full */		goto out3;	}	ip->i_op = &jfs_file_inode_operations;	ip->i_fop = &jfs_file_operations;	ip->i_mapping->a_ops = &jfs_aops;	insert_inode_hash(ip);	mark_inode_dirty(ip);	d_instantiate(dentry, ip);	dip->i_ctime = dip->i_mtime = CURRENT_TIME;	mark_inode_dirty(dip);	rc = txCommit(tid, 2, &iplist[0], 0);      out3:	txEnd(tid);	up(&JFS_IP(dip)->commit_sem);	up(&JFS_IP(ip)->commit_sem);	if (rc) {		ip->i_nlink = 0;//.........这里部分代码省略.........

//.........这里部分代码省略.........	 */	ino = ip->i_ino;	if ((rc = dtDelete(tid, dip, &dname, &ino, JFS_REMOVE))) {		jERROR(1, ("jfs_unlink: dtDelete returned %d/n", rc));		if (rc == EIO)			txAbort(tid, 1);	/* Marks FS Dirty */		txEnd(tid);		up(&JFS_IP(dip)->commit_sem);		up(&JFS_IP(ip)->commit_sem);		IWRITE_UNLOCK(ip);		goto out1;	}	ASSERT(ip->i_nlink);	ip->i_ctime = dip->i_ctime = dip->i_mtime = CURRENT_TIME;	mark_inode_dirty(dip);	/* update target's inode */	ip->i_nlink--;	mark_inode_dirty(ip);	/*	 *      commit zero link count object	 */	if (ip->i_nlink == 0) {		assert(!test_cflag(COMMIT_Nolink, ip));		/* free block resources */		if ((new_size = commitZeroLink(tid, ip)) < 0) {			txAbort(tid, 1);	/* Marks FS Dirty */			txEnd(tid);			up(&JFS_IP(dip)->commit_sem);			up(&JFS_IP(ip)->commit_sem);			IWRITE_UNLOCK(ip);			rc = -new_size;		/* We return -rc */			goto out1;		}		tblk = tid_to_tblock(tid);		tblk->xflag |= COMMIT_DELETE;		tblk->ip = ip;	}	/*	 * Incomplete truncate of file data can	 * result in timing problems unless we synchronously commit the	 * transaction.	 */	if (new_size)		commit_flag = COMMIT_SYNC;	else		commit_flag = 0;	/*	 * If xtTruncate was incomplete, commit synchronously to avoid	 * timing complications	 */	rc = txCommit(tid, 2, &iplist[0], commit_flag);	txEnd(tid);	up(&JFS_IP(dip)->commit_sem);	up(&JFS_IP(ip)->commit_sem);	while (new_size && (rc == 0)) {		tid = txBegin(dip->i_sb, 0);		down(&JFS_IP(ip)->commit_sem);		new_size = xtTruncate_pmap(tid, ip, new_size);		if (new_size < 0) {			txAbort(tid, 1);	/* Marks FS Dirty */			rc = -new_size;		/* We return -rc */		} else			rc = txCommit(tid, 2, &iplist[0], COMMIT_SYNC);		txEnd(tid);		up(&JFS_IP(ip)->commit_sem);	}	if (ip->i_nlink == 0)		set_cflag(COMMIT_Nolink, ip);	if (!test_cflag(COMMIT_Holdlock, ip))		IWRITE_UNLOCK(ip);	/*	 * Truncating the directory index table is not guaranteed.  It	 * may need to be done iteratively	 */	if (test_cflag(COMMIT_Stale, dip)) {		if (dip->i_size > 1)			jfs_truncate_nolock(dip, 0);		clear_cflag(COMMIT_Stale, dip);	}      out1:	free_UCSname(&dname);      out:	jFYI(1, ("jfs_unlink: rc:%d/n", -rc));	return -rc;}

/* * NAME:	jfs_rmdir(dip, dentry) * * FUNCTION:	remove a link to child directory * * PARAMETER:	dip 	- parent inode *		dentry	- child directory dentry * * RETURN:	EINVAL	- if name is . or .. *		EINVAL  - if . or .. exist but are invalid. *		errors from subroutines * * note: * if other threads have the directory open when the last link  * is removed, the "." and ".." entries, if present, are removed before  * rmdir() returns and no new entries may be created in the directory,  * but the directory is not removed until the last reference to  * the directory is released (cf.unlink() of regular file). */int jfs_rmdir(struct inode *dip, struct dentry *dentry){	int rc;	tid_t tid;		/* transaction id */	struct inode *ip = dentry->d_inode;	ino_t ino;	struct component_name dname;	struct inode *iplist[2];	struct tblock *tblk;	jFYI(1, ("jfs_rmdir: dip:0x%p name:%s/n", dip, dentry->d_name.name));	/* directory must be empty to be removed */	if (!dtEmpty(ip)) {		rc = ENOTEMPTY;		goto out;	}	if ((rc = get_UCSname(&dname, dentry, JFS_SBI(dip->i_sb)->nls_tab))) {		goto out;	}	tid = txBegin(dip->i_sb, 0);	down(&JFS_IP(dip)->commit_sem);	down(&JFS_IP(ip)->commit_sem);	iplist[0] = dip;	iplist[1] = ip;	tblk = tid_to_tblock(tid);	tblk->xflag |= COMMIT_DELETE;	tblk->ip = ip;	/*	 * delete the entry of target directory from parent directory	 */	ino = ip->i_ino;	if ((rc = dtDelete(tid, dip, &dname, &ino, JFS_REMOVE))) {		jERROR(1, ("jfs_rmdir: dtDelete returned %d/n", rc));		if (rc == EIO)			txAbort(tid, 1);		txEnd(tid);		up(&JFS_IP(dip)->commit_sem);		up(&JFS_IP(ip)->commit_sem);		goto out2;	}	/* update parent directory's link count corresponding	 * to ".." entry of the target directory deleted	 */	dip->i_nlink--;	dip->i_ctime = dip->i_mtime = CURRENT_TIME;	mark_inode_dirty(dip);	/*	 * OS/2 could have created EA and/or ACL	 */	/* free EA from both persistent and working map */	if (JFS_IP(ip)->ea.flag & DXD_EXTENT) {		/* free EA pages */		txEA(tid, ip, &JFS_IP(ip)->ea, NULL);	}	JFS_IP(ip)->ea.flag = 0;	/* free ACL from both persistent and working map */	if (JFS_IP(ip)->acl.flag & DXD_EXTENT) {		/* free ACL pages */		txEA(tid, ip, &JFS_IP(ip)->acl, NULL);	}	JFS_IP(ip)->acl.flag = 0;	/* mark the target directory as deleted */	ip->i_nlink = 0;	mark_inode_dirty(ip);	rc = txCommit(tid, 2, &iplist[0], 0);	txEnd(tid);//.........这里部分代码省略.........

/* * NAME:        jfs_mknod * * FUNCTION:    Create a special file (device) */int jfs_mknod(struct inode *dir, struct dentry *dentry, int mode, int rdev){	struct btstack btstack;	struct component_name dname;	ino_t ino;	struct inode *ip;	struct inode *iplist[2];	int rc;	tid_t tid;	struct tblock *tblk;	jFYI(1, ("jfs_mknod: %s/n", dentry->d_name.name));	if ((rc = get_UCSname(&dname, dentry, JFS_SBI(dir->i_sb)->nls_tab)))		goto out;	ip = ialloc(dir, mode);	if (ip == NULL) {		rc = ENOSPC;		goto out1;	}	tid = txBegin(dir->i_sb, 0);	down(&JFS_IP(dir)->commit_sem);	down(&JFS_IP(ip)->commit_sem);	if ((rc = dtSearch(dir, &dname, &ino, &btstack, JFS_CREATE)))		goto out3;	tblk = tid_to_tblock(tid);	tblk->xflag |= COMMIT_CREATE;	tblk->ip = ip;	ino = ip->i_ino;	if ((rc = dtInsert(tid, dir, &dname, &ino, &btstack)))		goto out3;	ip->i_op = &jfs_file_inode_operations;	init_special_inode(ip, ip->i_mode, rdev);	insert_inode_hash(ip);	mark_inode_dirty(ip);	d_instantiate(dentry, ip);	dir->i_ctime = dir->i_mtime = CURRENT_TIME;	mark_inode_dirty(dir);	iplist[0] = dir;	iplist[1] = ip;	rc = txCommit(tid, 2, iplist, 0);      out3:	txEnd(tid);	up(&JFS_IP(ip)->commit_sem);	up(&JFS_IP(dir)->commit_sem);	if (rc) {		ip->i_nlink = 0;		iput(ip);	}      out1:	free_UCSname(&dname);      out:	jFYI(1, ("jfs_mknod: returning %d/n", rc));	return -rc;}

//.........这里部分代码省略.........			/* Linelock header of dtree */			tlck = txLock(tid, old_ip,				    (struct metapage *) &JFS_IP(old_ip)->bxflag,				      tlckDTREE | tlckBTROOT);			dtlck = (struct dt_lock *) & tlck->lock;			ASSERT(dtlck->index == 0);			lv = & dtlck->lv[0];			lv->offset = 0;			lv->length = 1;			dtlck->index++;		}	}	/*	 * Update ctime on changed/moved inodes & mark dirty	 */	old_ip->i_ctime = CURRENT_TIME;	mark_inode_dirty(old_ip);	new_dir->i_ctime = CURRENT_TIME;	mark_inode_dirty(new_dir);	/* Build list of inodes modified by this transaction */	ipcount = 0;	iplist[ipcount++] = old_ip;	if (new_ip)		iplist[ipcount++] = new_ip;	iplist[ipcount++] = old_dir;	if (old_dir != new_dir) {		iplist[ipcount++] = new_dir;		old_dir->i_ctime = CURRENT_TIME;		mark_inode_dirty(old_dir);	}	/*	 * Incomplete truncate of file data can	 * result in timing problems unless we synchronously commit the	 * transaction.	 */	if (new_size)		commit_flag = COMMIT_SYNC;	else		commit_flag = 0;	rc = txCommit(tid, ipcount, iplist, commit_flag);	/*	 * Don't unlock new_ip if COMMIT_HOLDLOCK is set	 */	if (new_ip && test_cflag(COMMIT_Holdlock, new_ip)) {		up(&JFS_IP(new_ip)->commit_sem);		new_ip = 0;	}      out4:	txEnd(tid);	up(&JFS_IP(new_dir)->commit_sem);	up(&JFS_IP(old_ip)->commit_sem);	if (old_dir != new_dir)		up(&JFS_IP(old_dir)->commit_sem);	if (new_ip)		up(&JFS_IP(new_ip)->commit_sem);	while (new_size && (rc == 0)) {		tid = txBegin(new_ip->i_sb, 0);		down(&JFS_IP(new_ip)->commit_sem);		new_size = xtTruncate_pmap(tid, new_ip, new_size);		if (new_size < 0) {			txAbort(tid, 1);			rc = -new_size;		/* We return -rc */		} else			rc = txCommit(tid, 1, &new_ip, COMMIT_SYNC);		txEnd(tid);		up(&JFS_IP(new_ip)->commit_sem);	}	if (new_ip && (new_ip->i_nlink == 0))		set_cflag(COMMIT_Nolink, new_ip);      out3:	free_UCSname(&new_dname);      out2:	free_UCSname(&old_dname);      out1:	if (new_ip && !S_ISDIR(new_ip->i_mode))		IWRITE_UNLOCK(new_ip);	/*	 * Truncating the directory index table is not guaranteed.  It	 * may need to be done iteratively	 */	if (test_cflag(COMMIT_Stale, old_dir)) {		if (old_dir->i_size > 1)			jfs_truncate_nolock(old_dir, 0);		clear_cflag(COMMIT_Stale, old_dir);	}	jFYI(1, ("jfs_rename: returning %d/n", rc));	return -rc;}

//.........这里部分代码省略.........        drop_nlink(old_dir);        if (old_dir != new_dir) {            /*             * Change inode number of parent for moved directory             */            JFS_IP(old_ip)->i_dtroot.header.idotdot =                cpu_to_le32(new_dir->i_ino);            /* Linelock header of dtree */            tlck = txLock(tid, old_ip,                          (struct metapage *) &JFS_IP(old_ip)->bxflag,                          tlckDTREE | tlckBTROOT | tlckRELINK);            dtlck = (struct dt_lock *) & tlck->lock;            ASSERT(dtlck->index == 0);            lv = & dtlck->lv[0];            lv->offset = 0;            lv->length = 1;            dtlck->index++;        }    }    /*     * Update ctime on changed/moved inodes & mark dirty     */    old_ip->i_ctime = CURRENT_TIME;    mark_inode_dirty(old_ip);    new_dir->i_ctime = new_dir->i_mtime = current_fs_time(new_dir->i_sb);    mark_inode_dirty(new_dir);    /* Build list of inodes modified by this transaction */    ipcount = 0;    iplist[ipcount++] = old_ip;    if (new_ip)        iplist[ipcount++] = new_ip;    iplist[ipcount++] = old_dir;    if (old_dir != new_dir) {        iplist[ipcount++] = new_dir;        old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME;        mark_inode_dirty(old_dir);    }    /*     * Incomplete truncate of file data can     * result in timing problems unless we synchronously commit the     * transaction.     */    if (new_size)        commit_flag = COMMIT_SYNC;    else        commit_flag = 0;    rc = txCommit(tid, ipcount, iplist, commit_flag);out4:    txEnd(tid);    if (new_ip)        mutex_unlock(&JFS_IP(new_ip)->commit_mutex);    if (old_dir != new_dir)        mutex_unlock(&JFS_IP(old_dir)->commit_mutex);    mutex_unlock(&JFS_IP(old_ip)->commit_mutex);    mutex_unlock(&JFS_IP(new_dir)->commit_mutex);    while (new_size && (rc == 0)) {        tid = txBegin(new_ip->i_sb, 0);        mutex_lock(&JFS_IP(new_ip)->commit_mutex);        new_size = xtTruncate_pmap(tid, new_ip, new_size);        if (new_size < 0) {            txAbort(tid, 1);            rc = new_size;        } else            rc = txCommit(tid, 1, &new_ip, COMMIT_SYNC);        txEnd(tid);        mutex_unlock(&JFS_IP(new_ip)->commit_mutex);    }    if (new_ip && (new_ip->i_nlink == 0))        set_cflag(COMMIT_Nolink, new_ip);out3:    free_UCSname(&new_dname);out2:    free_UCSname(&old_dname);out1:    if (new_ip && !S_ISDIR(new_ip->i_mode))        IWRITE_UNLOCK(new_ip);    /*     * Truncating the directory index table is not guaranteed.  It     * may need to be done iteratively     */    if (test_cflag(COMMIT_Stale, old_dir)) {        if (old_dir->i_size > 1)            jfs_truncate_nolock(old_dir, 0);        clear_cflag(COMMIT_Stale, old_dir);    }    jfs_info("jfs_rename: returning %d", rc);    return rc;}

/* * NAME:	jfs_mknod * * FUNCTION:	Create a special file (device) */static int jfs_mknod(struct inode *dir, struct dentry *dentry,                     int mode, dev_t rdev){    struct jfs_inode_info *jfs_ip;    struct btstack btstack;    struct component_name dname;    ino_t ino;    struct inode *ip;    struct inode *iplist[2];    int rc;    tid_t tid;    struct tblock *tblk;    if (!new_valid_dev(rdev))        return -EINVAL;    jfs_info("jfs_mknod: %s", dentry->d_name.name);    dquot_initialize(dir);    if ((rc = get_UCSname(&dname, dentry)))        goto out;    ip = ialloc(dir, mode);    if (IS_ERR(ip)) {        rc = PTR_ERR(ip);        goto out1;    }    jfs_ip = JFS_IP(ip);    tid = txBegin(dir->i_sb, 0);    mutex_lock_nested(&JFS_IP(dir)->commit_mutex, COMMIT_MUTEX_PARENT);    mutex_lock_nested(&JFS_IP(ip)->commit_mutex, COMMIT_MUTEX_CHILD);    rc = jfs_init_acl(tid, ip, dir);    if (rc)        goto out3;    rc = jfs_init_security(tid, ip, dir, &dentry->d_name);    if (rc) {        txAbort(tid, 0);        goto out3;    }    if ((rc = dtSearch(dir, &dname, &ino, &btstack, JFS_CREATE))) {        txAbort(tid, 0);        goto out3;    }    tblk = tid_to_tblock(tid);    tblk->xflag |= COMMIT_CREATE;    tblk->ino = ip->i_ino;    tblk->u.ixpxd = JFS_IP(ip)->ixpxd;    ino = ip->i_ino;    if ((rc = dtInsert(tid, dir, &dname, &ino, &btstack))) {        txAbort(tid, 0);        goto out3;    }    ip->i_op = &jfs_file_inode_operations;    jfs_ip->dev = new_encode_dev(rdev);    init_special_inode(ip, ip->i_mode, rdev);    mark_inode_dirty(ip);    dir->i_ctime = dir->i_mtime = CURRENT_TIME;    mark_inode_dirty(dir);    iplist[0] = dir;    iplist[1] = ip;    rc = txCommit(tid, 2, iplist, 0);out3:    txEnd(tid);    mutex_unlock(&JFS_IP(ip)->commit_mutex);    mutex_unlock(&JFS_IP(dir)->commit_mutex);    if (rc) {        free_ea_wmap(ip);        ip->i_nlink = 0;        unlock_new_inode(ip);        iput(ip);    } else {        d_instantiate(dentry, ip);        unlock_new_inode(ip);    }out1:    free_UCSname(&dname);out:    jfs_info("jfs_mknod: returning %d", rc);    return rc;//.........这里部分代码省略.........

//.........这里部分代码省略.........    /*     * delete the entry of target file from parent directory     */    ino = ip->i_ino;    if ((rc = dtDelete(tid, dip, &dname, &ino, JFS_REMOVE))) {        jfs_err("jfs_unlink: dtDelete returned %d", rc);        if (rc == -EIO)            txAbort(tid, 1);	/* Marks FS Dirty */        txEnd(tid);        mutex_unlock(&JFS_IP(ip)->commit_mutex);        mutex_unlock(&JFS_IP(dip)->commit_mutex);        IWRITE_UNLOCK(ip);        goto out1;    }    ASSERT(ip->i_nlink);    ip->i_ctime = dip->i_ctime = dip->i_mtime = CURRENT_TIME;    mark_inode_dirty(dip);    /* update target's inode */    inode_dec_link_count(ip);    /*     *	commit zero link count object     */    if (ip->i_nlink == 0) {        assert(!test_cflag(COMMIT_Nolink, ip));        /* free block resources */        if ((new_size = commitZeroLink(tid, ip)) < 0) {            txAbort(tid, 1);	/* Marks FS Dirty */            txEnd(tid);            mutex_unlock(&JFS_IP(ip)->commit_mutex);            mutex_unlock(&JFS_IP(dip)->commit_mutex);            IWRITE_UNLOCK(ip);            rc = new_size;            goto out1;        }        tblk = tid_to_tblock(tid);        tblk->xflag |= COMMIT_DELETE;        tblk->u.ip = ip;    }    /*     * Incomplete truncate of file data can     * result in timing problems unless we synchronously commit the     * transaction.     */    if (new_size)        commit_flag = COMMIT_SYNC;    else        commit_flag = 0;    /*     * If xtTruncate was incomplete, commit synchronously to avoid     * timing complications     */    rc = txCommit(tid, 2, &iplist[0], commit_flag);    txEnd(tid);    mutex_unlock(&JFS_IP(ip)->commit_mutex);    mutex_unlock(&JFS_IP(dip)->commit_mutex);    while (new_size && (rc == 0)) {        tid = txBegin(dip->i_sb, 0);        mutex_lock(&JFS_IP(ip)->commit_mutex);        new_size = xtTruncate_pmap(tid, ip, new_size);        if (new_size < 0) {            txAbort(tid, 1);	/* Marks FS Dirty */            rc = new_size;        } else            rc = txCommit(tid, 2, &iplist[0], COMMIT_SYNC);        txEnd(tid);        mutex_unlock(&JFS_IP(ip)->commit_mutex);    }    if (ip->i_nlink == 0)        set_cflag(COMMIT_Nolink, ip);    IWRITE_UNLOCK(ip);    /*     * Truncating the directory index table is not guaranteed.  It     * may need to be done iteratively     */    if (test_cflag(COMMIT_Stale, dip)) {        if (dip->i_size > 1)            jfs_truncate_nolock(dip, 0);        clear_cflag(COMMIT_Stale, dip);    }out1:    free_UCSname(&dname);out:    jfs_info("jfs_unlink: rc:%d", rc);    return rc;}

//.........这里部分代码省略.........	/*	 * search parent directory for entry/freespace	 * (dtSearch() returns parent directory page pinned)	 */	if ((rc = get_UCSname(&dname, dentry)))		goto out1;	/*	 * Either iAlloc() or txBegin() may block.  Deadlock can occur if we	 * block there while holding dtree page, so we allocate the inode &	 * begin the transaction before we search the directory.	 */	ip = ialloc(dip, S_IFDIR | mode);	if (ip == NULL) {		rc = -ENOSPC;		goto out2;	}	tid = txBegin(dip->i_sb, 0);	mutex_lock(&JFS_IP(dip)->commit_mutex);	mutex_lock(&JFS_IP(ip)->commit_mutex);	rc = jfs_init_acl(tid, ip, dip);	if (rc)		goto out3;	rc = jfs_init_security(tid, ip, dip);	if (rc) {		txAbort(tid, 0);		goto out3;	}	if ((rc = dtSearch(dip, &dname, &ino, &btstack, JFS_CREATE))) {		jfs_err("jfs_mkdir: dtSearch returned %d", rc);		txAbort(tid, 0);		goto out3;	}	tblk = tid_to_tblock(tid);	tblk->xflag |= COMMIT_CREATE;	tblk->ino = ip->i_ino;	tblk->u.ixpxd = JFS_IP(ip)->ixpxd;	iplist[0] = dip;	iplist[1] = ip;	/*	 * initialize the child directory in-line in inode	 */	dtInitRoot(tid, ip, dip->i_ino);	/*	 * create entry in parent directory for child directory	 * (dtInsert() releases parent directory page)	 */	ino = ip->i_ino;	if ((rc = dtInsert(tid, dip, &dname, &ino, &btstack))) {		if (rc == -EIO) {			jfs_err("jfs_mkdir: dtInsert returned -EIO");			txAbort(tid, 1);	/* Marks Filesystem dirty */		} else			txAbort(tid, 0);	/* Filesystem full */		goto out3;	}	ip->i_nlink = 2;	/* for '.' */	ip->i_op = &jfs_dir_inode_operations;	ip->i_fop = &jfs_dir_operations;	insert_inode_hash(ip);	mark_inode_dirty(ip);	/* update parent directory inode */	dip->i_nlink++;		/* for '..' from child directory */	dip->i_ctime = dip->i_mtime = CURRENT_TIME;	mark_inode_dirty(dip);	rc = txCommit(tid, 2, &iplist[0], 0);      out3:	txEnd(tid);	mutex_unlock(&JFS_IP(ip)->commit_mutex);	mutex_unlock(&JFS_IP(dip)->commit_mutex);	if (rc) {		free_ea_wmap(ip);		ip->i_nlink = 0;		iput(ip);	} else		d_instantiate(dentry, ip);      out2:	free_UCSname(&dname);      out1:	jfs_info("jfs_mkdir: rc:%d", rc);	return rc;}

/* * NAME:	jfs_link(vp, dvp, name, crp) * * FUNCTION:	create a link to <vp> by the name = <name> *		in the parent directory <dvp> * * PARAMETER:	vp	- target object *		dvp	- parent directory of new link *		name	- name of new link to target object *		crp	- credential * * RETURN:	Errors from subroutines * * note: * JFS does NOT support link() on directories (to prevent circular * path in the directory hierarchy); * EPERM: the target object is a directory, and either the caller * does not have appropriate privileges or the implementation prohibits * using link() on directories [XPG4.2]. * * JFS does NOT support links between file systems: * EXDEV: target object and new link are on different file systems and * implementation does not support links between file systems [XPG4.2]. */static int jfs_link(struct dentry *old_dentry,                    struct inode *dir, struct dentry *dentry){    int rc;    tid_t tid;    struct inode *ip = old_dentry->d_inode;    ino_t ino;    struct component_name dname;    struct btstack btstack;    struct inode *iplist[2];    jfs_info("jfs_link: %s %s", old_dentry->d_name.name,             dentry->d_name.name);    if (ip->i_nlink == JFS_LINK_MAX)        return -EMLINK;    dquot_initialize(dir);    tid = txBegin(ip->i_sb, 0);    mutex_lock_nested(&JFS_IP(dir)->commit_mutex, COMMIT_MUTEX_PARENT);    mutex_lock_nested(&JFS_IP(ip)->commit_mutex, COMMIT_MUTEX_CHILD);    /*     * scan parent directory for entry/freespace     */    if ((rc = get_UCSname(&dname, dentry)))        goto out;    if ((rc = dtSearch(dir, &dname, &ino, &btstack, JFS_CREATE)))        goto free_dname;    /*     * create entry for new link in parent directory     */    ino = ip->i_ino;    if ((rc = dtInsert(tid, dir, &dname, &ino, &btstack)))        goto free_dname;    /* update object inode */    inc_nlink(ip);		/* for new link */    ip->i_ctime = CURRENT_TIME;    dir->i_ctime = dir->i_mtime = CURRENT_TIME;    mark_inode_dirty(dir);    ihold(ip);    iplist[0] = ip;    iplist[1] = dir;    rc = txCommit(tid, 2, &iplist[0], 0);    if (rc) {        ip->i_nlink--; /* never instantiated */        iput(ip);    } else        d_instantiate(dentry, ip);free_dname:    free_UCSname(&dname);out:    txEnd(tid);    mutex_unlock(&JFS_IP(ip)->commit_mutex);    mutex_unlock(&JFS_IP(dir)->commit_mutex);    jfs_info("jfs_link: rc:%d", rc);    return rc;}

/* * NAME:        jfs_mknod * * FUNCTION:    Create a special file (device) */static int jfs_mknod(struct inode *dir, struct dentry *dentry,		int mode, dev_t rdev){	struct jfs_inode_info *jfs_ip;	struct btstack btstack;	struct component_name dname;	ino_t ino;	struct inode *ip;	struct inode *iplist[2];	int rc;	tid_t tid;	struct tblock *tblk;	if (!new_valid_dev(rdev))		return -EINVAL;	jfs_info("jfs_mknod: %s", dentry->d_name.name);	if ((rc = get_UCSname(&dname, dentry)))		goto out;	ip = ialloc(dir, mode);	if (ip == NULL) {		rc = -ENOSPC;		goto out1;	}	jfs_ip = JFS_IP(ip);	tid = txBegin(dir->i_sb, 0);	down(&JFS_IP(dir)->commit_sem);	down(&JFS_IP(ip)->commit_sem);	if ((rc = dtSearch(dir, &dname, &ino, &btstack, JFS_CREATE)))		goto out3;	tblk = tid_to_tblock(tid);	tblk->xflag |= COMMIT_CREATE;	tblk->ino = ip->i_ino;	tblk->u.ixpxd = JFS_IP(ip)->ixpxd;	ino = ip->i_ino;	if ((rc = dtInsert(tid, dir, &dname, &ino, &btstack)))		goto out3;	ip->i_op = &jfs_file_inode_operations;	jfs_ip->dev = new_encode_dev(rdev);	init_special_inode(ip, ip->i_mode, rdev);	insert_inode_hash(ip);	mark_inode_dirty(ip);	dir->i_ctime = dir->i_mtime = CURRENT_TIME;	mark_inode_dirty(dir);	iplist[0] = dir;	iplist[1] = ip;	rc = txCommit(tid, 2, iplist, 0);      out3:	txEnd(tid);	up(&JFS_IP(ip)->commit_sem);	up(&JFS_IP(dir)->commit_sem);	if (rc) {		ip->i_nlink = 0;		iput(ip);	} else		d_instantiate(dentry, ip);      out1:	free_UCSname(&dname);#ifdef CONFIG_JFS_POSIX_ACL	if (rc == 0)		jfs_init_acl(ip, dir);#endif      out:	jfs_info("jfs_mknod: returning %d", rc);	return rc;}