From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Darrick J. Wong" Subject: Re: [PATCH v5 01/78] xfs: Rename xa_ elements to ail_ Date: Tue, 2 Jan 2018 17:01:05 -0800 Message-ID: <20180103010105.GA16402@magnolia> References: <20171215220450.7899-1-willy@infradead.org> <20171215220450.7899-2-willy@infradead.org> Mime-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Return-path: Received: from sfi-mx-1.v28.ch3.sourceforge.com ([172.29.28.191] helo=mx.sourceforge.net) by sfs-ml-3.v29.ch3.sourceforge.com with esmtps (TLSv1.2:ECDHE-RSA-AES256-GCM-SHA384:256) (Exim 4.89) (envelope-from ) id 1eWXRA-0007St-91 for linux-f2fs-devel@lists.sourceforge.net; Wed, 03 Jan 2018 01:01:44 +0000 Received: from aserp2130.oracle.com ([141.146.126.79]) by sfi-mx-1.v28.ch3.sourceforge.com with esmtps (TLSv1.2:ECDHE-RSA-AES256-GCM-SHA384:256) (Exim 4.89) id 1eWXR7-0002Wn-79 for linux-f2fs-devel@lists.sourceforge.net; Wed, 03 Jan 2018 01:01:43 +0000 Content-Disposition: inline In-Reply-To: <20171215220450.7899-2-willy@infradead.org> List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: linux-f2fs-devel-bounces@lists.sourceforge.net To: Matthew Wilcox Cc: Jens Axboe , linux-xfs@vger.kernel.org, linux-nilfs@vger.kernel.org, linux-raid@vger.kernel.org, Matthew Wilcox , Marc Zyngier , linux-usb@vger.kernel.org, linux-kernel@vger.kernel.org, linux-f2fs-devel@lists.sourceforge.net, David Howells , linux-mm@kvack.org, linux-fsdevel@vger.kernel.org, Ross Zwisler , Rehas Sachdeva , Shaohua Li , linux-btrfs@vger.kernel.org On Fri, Dec 15, 2017 at 02:03:33PM -0800, Matthew Wilcox wrote: > From: Matthew Wilcox > > This is a simple rename, except that xa_ail becomes ail_head. > > Signed-off-by: Matthew Wilcox That was an eyeful, Reviewed-by: Darrick J. Wong > --- > fs/xfs/xfs_buf_item.c | 10 ++-- > fs/xfs/xfs_dquot.c | 4 +- > fs/xfs/xfs_dquot_item.c | 11 ++-- > fs/xfs/xfs_inode_item.c | 22 +++---- > fs/xfs/xfs_log.c | 6 +- > fs/xfs/xfs_log_recover.c | 80 ++++++++++++------------- > fs/xfs/xfs_trans.c | 18 +++--- > fs/xfs/xfs_trans_ail.c | 152 +++++++++++++++++++++++------------------------ > fs/xfs/xfs_trans_buf.c | 4 +- > fs/xfs/xfs_trans_priv.h | 42 ++++++------- > 10 files changed, 175 insertions(+), 174 deletions(-) > > diff --git a/fs/xfs/xfs_buf_item.c b/fs/xfs/xfs_buf_item.c > index e0a0af0946f2..6c5035544a93 100644 > --- a/fs/xfs/xfs_buf_item.c > +++ b/fs/xfs/xfs_buf_item.c > @@ -459,7 +459,7 @@ xfs_buf_item_unpin( > bp->b_fspriv = NULL; > bp->b_iodone = NULL; > } else { > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > xfs_trans_ail_delete(ailp, lip, SHUTDOWN_LOG_IO_ERROR); > xfs_buf_item_relse(bp); > ASSERT(bp->b_fspriv == NULL); > @@ -1056,13 +1056,13 @@ xfs_buf_do_callbacks_fail( > struct xfs_log_item *lip = bp->b_fspriv; > struct xfs_ail *ailp = lip->li_ailp; > > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > for (; lip; lip = next) { > next = lip->li_bio_list; > if (lip->li_ops->iop_error) > lip->li_ops->iop_error(lip, bp); > } > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > } > > static bool > @@ -1215,7 +1215,7 @@ xfs_buf_iodone( > * > * Either way, AIL is useless if we're forcing a shutdown. > */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > xfs_trans_ail_delete(ailp, lip, SHUTDOWN_CORRUPT_INCORE); > xfs_buf_item_free(BUF_ITEM(lip)); > } > @@ -1236,7 +1236,7 @@ xfs_buf_resubmit_failed_buffers( > /* > * Clear XFS_LI_FAILED flag from all items before resubmit > * > - * XFS_LI_FAILED set/clear is protected by xa_lock, caller this > + * XFS_LI_FAILED set/clear is protected by ail_lock, caller this > * function already have it acquired > */ > for (; lip; lip = next) { > diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c > index f248708c10ff..e2a466df5dd1 100644 > --- a/fs/xfs/xfs_dquot.c > +++ b/fs/xfs/xfs_dquot.c > @@ -974,7 +974,7 @@ xfs_qm_dqflush_done( > (lip->li_flags & XFS_LI_FAILED))) { > > /* xfs_trans_ail_delete() drops the AIL lock. */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > if (lip->li_lsn == qip->qli_flush_lsn) { > xfs_trans_ail_delete(ailp, lip, SHUTDOWN_CORRUPT_INCORE); > } else { > @@ -984,7 +984,7 @@ xfs_qm_dqflush_done( > */ > if (lip->li_flags & XFS_LI_FAILED) > xfs_clear_li_failed(lip); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > } > } > > diff --git a/fs/xfs/xfs_dquot_item.c b/fs/xfs/xfs_dquot_item.c > index 664dea105e76..62637a226601 100644 > --- a/fs/xfs/xfs_dquot_item.c > +++ b/fs/xfs/xfs_dquot_item.c > @@ -160,8 +160,9 @@ xfs_dquot_item_error( > STATIC uint > xfs_qm_dquot_logitem_push( > struct xfs_log_item *lip, > - struct list_head *buffer_list) __releases(&lip->li_ailp->xa_lock) > - __acquires(&lip->li_ailp->xa_lock) > + struct list_head *buffer_list) > + __releases(&lip->li_ailp->ail_lock) > + __acquires(&lip->li_ailp->ail_lock) > { > struct xfs_dquot *dqp = DQUOT_ITEM(lip)->qli_dquot; > struct xfs_buf *bp = lip->li_buf; > @@ -208,7 +209,7 @@ xfs_qm_dquot_logitem_push( > goto out_unlock; > } > > - spin_unlock(&lip->li_ailp->xa_lock); > + spin_unlock(&lip->li_ailp->ail_lock); > > error = xfs_qm_dqflush(dqp, &bp); > if (error) { > @@ -220,7 +221,7 @@ xfs_qm_dquot_logitem_push( > xfs_buf_relse(bp); > } > > - spin_lock(&lip->li_ailp->xa_lock); > + spin_lock(&lip->li_ailp->ail_lock); > out_unlock: > xfs_dqunlock(dqp); > return rval; > @@ -403,7 +404,7 @@ xfs_qm_qoffend_logitem_committed( > * Delete the qoff-start logitem from the AIL. > * xfs_trans_ail_delete() drops the AIL lock. > */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > xfs_trans_ail_delete(ailp, &qfs->qql_item, SHUTDOWN_LOG_IO_ERROR); > > kmem_free(qfs->qql_item.li_lv_shadow); > diff --git a/fs/xfs/xfs_inode_item.c b/fs/xfs/xfs_inode_item.c > index 6ee5c3bf19ad..071acd4249a0 100644 > --- a/fs/xfs/xfs_inode_item.c > +++ b/fs/xfs/xfs_inode_item.c > @@ -501,8 +501,8 @@ STATIC uint > xfs_inode_item_push( > struct xfs_log_item *lip, > struct list_head *buffer_list) > - __releases(&lip->li_ailp->xa_lock) > - __acquires(&lip->li_ailp->xa_lock) > + __releases(&lip->li_ailp->ail_lock) > + __acquires(&lip->li_ailp->ail_lock) > { > struct xfs_inode_log_item *iip = INODE_ITEM(lip); > struct xfs_inode *ip = iip->ili_inode; > @@ -561,7 +561,7 @@ xfs_inode_item_push( > ASSERT(iip->ili_fields != 0 || XFS_FORCED_SHUTDOWN(ip->i_mount)); > ASSERT(iip->ili_logged == 0 || XFS_FORCED_SHUTDOWN(ip->i_mount)); > > - spin_unlock(&lip->li_ailp->xa_lock); > + spin_unlock(&lip->li_ailp->ail_lock); > > error = xfs_iflush(ip, &bp); > if (!error) { > @@ -570,7 +570,7 @@ xfs_inode_item_push( > xfs_buf_relse(bp); > } > > - spin_lock(&lip->li_ailp->xa_lock); > + spin_lock(&lip->li_ailp->ail_lock); > out_unlock: > xfs_iunlock(ip, XFS_ILOCK_SHARED); > return rval; > @@ -774,7 +774,7 @@ xfs_iflush_done( > bool mlip_changed = false; > > /* this is an opencoded batch version of xfs_trans_ail_delete */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > for (blip = lip; blip; blip = blip->li_bio_list) { > if (INODE_ITEM(blip)->ili_logged && > blip->li_lsn == INODE_ITEM(blip)->ili_flush_lsn) > @@ -785,15 +785,15 @@ xfs_iflush_done( > } > > if (mlip_changed) { > - if (!XFS_FORCED_SHUTDOWN(ailp->xa_mount)) > - xlog_assign_tail_lsn_locked(ailp->xa_mount); > - if (list_empty(&ailp->xa_ail)) > - wake_up_all(&ailp->xa_empty); > + if (!XFS_FORCED_SHUTDOWN(ailp->ail_mount)) > + xlog_assign_tail_lsn_locked(ailp->ail_mount); > + if (list_empty(&ailp->ail_head)) > + wake_up_all(&ailp->ail_empty); > } > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > if (mlip_changed) > - xfs_log_space_wake(ailp->xa_mount); > + xfs_log_space_wake(ailp->ail_mount); > } > > /* > diff --git a/fs/xfs/xfs_log.c b/fs/xfs/xfs_log.c > index a503af96d780..7148625eebf2 100644 > --- a/fs/xfs/xfs_log.c > +++ b/fs/xfs/xfs_log.c > @@ -1148,7 +1148,7 @@ xlog_assign_tail_lsn_locked( > struct xfs_log_item *lip; > xfs_lsn_t tail_lsn; > > - assert_spin_locked(&mp->m_ail->xa_lock); > + assert_spin_locked(&mp->m_ail->ail_lock); > > /* > * To make sure we always have a valid LSN for the log tail we keep > @@ -1171,9 +1171,9 @@ xlog_assign_tail_lsn( > { > xfs_lsn_t tail_lsn; > > - spin_lock(&mp->m_ail->xa_lock); > + spin_lock(&mp->m_ail->ail_lock); > tail_lsn = xlog_assign_tail_lsn_locked(mp); > - spin_unlock(&mp->m_ail->xa_lock); > + spin_unlock(&mp->m_ail->ail_lock); > > return tail_lsn; > } > diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c > index 28d1abfe835e..d871761626fb 100644 > --- a/fs/xfs/xfs_log_recover.c > +++ b/fs/xfs/xfs_log_recover.c > @@ -3424,7 +3424,7 @@ xlog_recover_efi_pass2( > } > atomic_set(&efip->efi_next_extent, efi_formatp->efi_nextents); > > - spin_lock(&log->l_ailp->xa_lock); > + spin_lock(&log->l_ailp->ail_lock); > /* > * The EFI has two references. One for the EFD and one for EFI to ensure > * it makes it into the AIL. Insert the EFI into the AIL directly and > @@ -3467,7 +3467,7 @@ xlog_recover_efd_pass2( > * Search for the EFI with the id in the EFD format structure in the > * AIL. > */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > lip = xfs_trans_ail_cursor_first(ailp, &cur, 0); > while (lip != NULL) { > if (lip->li_type == XFS_LI_EFI) { > @@ -3477,9 +3477,9 @@ xlog_recover_efd_pass2( > * Drop the EFD reference to the EFI. This > * removes the EFI from the AIL and frees it. > */ > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > xfs_efi_release(efip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > break; > } > } > @@ -3487,7 +3487,7 @@ xlog_recover_efd_pass2( > } > > xfs_trans_ail_cursor_done(&cur); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > return 0; > } > @@ -3520,7 +3520,7 @@ xlog_recover_rui_pass2( > } > atomic_set(&ruip->rui_next_extent, rui_formatp->rui_nextents); > > - spin_lock(&log->l_ailp->xa_lock); > + spin_lock(&log->l_ailp->ail_lock); > /* > * The RUI has two references. One for the RUD and one for RUI to ensure > * it makes it into the AIL. Insert the RUI into the AIL directly and > @@ -3560,7 +3560,7 @@ xlog_recover_rud_pass2( > * Search for the RUI with the id in the RUD format structure in the > * AIL. > */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > lip = xfs_trans_ail_cursor_first(ailp, &cur, 0); > while (lip != NULL) { > if (lip->li_type == XFS_LI_RUI) { > @@ -3570,9 +3570,9 @@ xlog_recover_rud_pass2( > * Drop the RUD reference to the RUI. This > * removes the RUI from the AIL and frees it. > */ > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > xfs_rui_release(ruip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > break; > } > } > @@ -3580,7 +3580,7 @@ xlog_recover_rud_pass2( > } > > xfs_trans_ail_cursor_done(&cur); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > return 0; > } > @@ -3636,7 +3636,7 @@ xlog_recover_cui_pass2( > } > atomic_set(&cuip->cui_next_extent, cui_formatp->cui_nextents); > > - spin_lock(&log->l_ailp->xa_lock); > + spin_lock(&log->l_ailp->ail_lock); > /* > * The CUI has two references. One for the CUD and one for CUI to ensure > * it makes it into the AIL. Insert the CUI into the AIL directly and > @@ -3677,7 +3677,7 @@ xlog_recover_cud_pass2( > * Search for the CUI with the id in the CUD format structure in the > * AIL. > */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > lip = xfs_trans_ail_cursor_first(ailp, &cur, 0); > while (lip != NULL) { > if (lip->li_type == XFS_LI_CUI) { > @@ -3687,9 +3687,9 @@ xlog_recover_cud_pass2( > * Drop the CUD reference to the CUI. This > * removes the CUI from the AIL and frees it. > */ > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > xfs_cui_release(cuip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > break; > } > } > @@ -3697,7 +3697,7 @@ xlog_recover_cud_pass2( > } > > xfs_trans_ail_cursor_done(&cur); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > return 0; > } > @@ -3755,7 +3755,7 @@ xlog_recover_bui_pass2( > } > atomic_set(&buip->bui_next_extent, bui_formatp->bui_nextents); > > - spin_lock(&log->l_ailp->xa_lock); > + spin_lock(&log->l_ailp->ail_lock); > /* > * The RUI has two references. One for the RUD and one for RUI to ensure > * it makes it into the AIL. Insert the RUI into the AIL directly and > @@ -3796,7 +3796,7 @@ xlog_recover_bud_pass2( > * Search for the BUI with the id in the BUD format structure in the > * AIL. > */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > lip = xfs_trans_ail_cursor_first(ailp, &cur, 0); > while (lip != NULL) { > if (lip->li_type == XFS_LI_BUI) { > @@ -3806,9 +3806,9 @@ xlog_recover_bud_pass2( > * Drop the BUD reference to the BUI. This > * removes the BUI from the AIL and frees it. > */ > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > xfs_bui_release(buip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > break; > } > } > @@ -3816,7 +3816,7 @@ xlog_recover_bud_pass2( > } > > xfs_trans_ail_cursor_done(&cur); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > return 0; > } > @@ -4649,9 +4649,9 @@ xlog_recover_process_efi( > if (test_bit(XFS_EFI_RECOVERED, &efip->efi_flags)) > return 0; > > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > error = xfs_efi_recover(mp, efip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > > return error; > } > @@ -4667,9 +4667,9 @@ xlog_recover_cancel_efi( > > efip = container_of(lip, struct xfs_efi_log_item, efi_item); > > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > xfs_efi_release(efip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > } > > /* Recover the RUI if necessary. */ > @@ -4689,9 +4689,9 @@ xlog_recover_process_rui( > if (test_bit(XFS_RUI_RECOVERED, &ruip->rui_flags)) > return 0; > > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > error = xfs_rui_recover(mp, ruip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > > return error; > } > @@ -4707,9 +4707,9 @@ xlog_recover_cancel_rui( > > ruip = container_of(lip, struct xfs_rui_log_item, rui_item); > > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > xfs_rui_release(ruip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > } > > /* Recover the CUI if necessary. */ > @@ -4730,9 +4730,9 @@ xlog_recover_process_cui( > if (test_bit(XFS_CUI_RECOVERED, &cuip->cui_flags)) > return 0; > > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > error = xfs_cui_recover(mp, cuip, dfops); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > > return error; > } > @@ -4748,9 +4748,9 @@ xlog_recover_cancel_cui( > > cuip = container_of(lip, struct xfs_cui_log_item, cui_item); > > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > xfs_cui_release(cuip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > } > > /* Recover the BUI if necessary. */ > @@ -4771,9 +4771,9 @@ xlog_recover_process_bui( > if (test_bit(XFS_BUI_RECOVERED, &buip->bui_flags)) > return 0; > > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > error = xfs_bui_recover(mp, buip, dfops); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > > return error; > } > @@ -4789,9 +4789,9 @@ xlog_recover_cancel_bui( > > buip = container_of(lip, struct xfs_bui_log_item, bui_item); > > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > xfs_bui_release(buip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > } > > /* Is this log item a deferred action intent? */ > @@ -4879,7 +4879,7 @@ xlog_recover_process_intents( > #endif > > ailp = log->l_ailp; > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > lip = xfs_trans_ail_cursor_first(ailp, &cur, 0); > #if defined(DEBUG) || defined(XFS_WARN) > last_lsn = xlog_assign_lsn(log->l_curr_cycle, log->l_curr_block); > @@ -4933,7 +4933,7 @@ xlog_recover_process_intents( > } > out: > xfs_trans_ail_cursor_done(&cur); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > if (error) > xfs_defer_cancel(&dfops); > else > @@ -4956,7 +4956,7 @@ xlog_recover_cancel_intents( > struct xfs_ail *ailp; > > ailp = log->l_ailp; > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > lip = xfs_trans_ail_cursor_first(ailp, &cur, 0); > while (lip != NULL) { > /* > @@ -4990,7 +4990,7 @@ xlog_recover_cancel_intents( > } > > xfs_trans_ail_cursor_done(&cur); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > return error; > } > > diff --git a/fs/xfs/xfs_trans.c b/fs/xfs/xfs_trans.c > index a87f657f59c9..756e01999c24 100644 > --- a/fs/xfs/xfs_trans.c > +++ b/fs/xfs/xfs_trans.c > @@ -781,8 +781,8 @@ xfs_log_item_batch_insert( > { > int i; > > - spin_lock(&ailp->xa_lock); > - /* xfs_trans_ail_update_bulk drops ailp->xa_lock */ > + spin_lock(&ailp->ail_lock); > + /* xfs_trans_ail_update_bulk drops ailp->ail_lock */ > xfs_trans_ail_update_bulk(ailp, cur, log_items, nr_items, commit_lsn); > > for (i = 0; i < nr_items; i++) { > @@ -825,9 +825,9 @@ xfs_trans_committed_bulk( > struct xfs_ail_cursor cur; > int i = 0; > > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > xfs_trans_ail_cursor_last(ailp, &cur, commit_lsn); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > /* unpin all the log items */ > for (lv = log_vector; lv; lv = lv->lv_next ) { > @@ -847,7 +847,7 @@ xfs_trans_committed_bulk( > * object into the AIL as we are in a shutdown situation. > */ > if (aborted) { > - ASSERT(XFS_FORCED_SHUTDOWN(ailp->xa_mount)); > + ASSERT(XFS_FORCED_SHUTDOWN(ailp->ail_mount)); > lip->li_ops->iop_unpin(lip, 1); > continue; > } > @@ -861,11 +861,11 @@ xfs_trans_committed_bulk( > * not affect the AIL cursor the bulk insert path is > * using. > */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > if (XFS_LSN_CMP(item_lsn, lip->li_lsn) > 0) > xfs_trans_ail_update(ailp, lip, item_lsn); > else > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > lip->li_ops->iop_unpin(lip, 0); > continue; > } > @@ -883,9 +883,9 @@ xfs_trans_committed_bulk( > if (i) > xfs_log_item_batch_insert(ailp, &cur, log_items, i, commit_lsn); > > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > xfs_trans_ail_cursor_done(&cur); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > } > > /* > diff --git a/fs/xfs/xfs_trans_ail.c b/fs/xfs/xfs_trans_ail.c > index cef89f7127d3..d4a2445215e6 100644 > --- a/fs/xfs/xfs_trans_ail.c > +++ b/fs/xfs/xfs_trans_ail.c > @@ -40,7 +40,7 @@ xfs_ail_check( > { > xfs_log_item_t *prev_lip; > > - if (list_empty(&ailp->xa_ail)) > + if (list_empty(&ailp->ail_head)) > return; > > /* > @@ -48,11 +48,11 @@ xfs_ail_check( > */ > ASSERT((lip->li_flags & XFS_LI_IN_AIL) != 0); > prev_lip = list_entry(lip->li_ail.prev, xfs_log_item_t, li_ail); > - if (&prev_lip->li_ail != &ailp->xa_ail) > + if (&prev_lip->li_ail != &ailp->ail_head) > ASSERT(XFS_LSN_CMP(prev_lip->li_lsn, lip->li_lsn) <= 0); > > prev_lip = list_entry(lip->li_ail.next, xfs_log_item_t, li_ail); > - if (&prev_lip->li_ail != &ailp->xa_ail) > + if (&prev_lip->li_ail != &ailp->ail_head) > ASSERT(XFS_LSN_CMP(prev_lip->li_lsn, lip->li_lsn) >= 0); > > > @@ -69,10 +69,10 @@ static xfs_log_item_t * > xfs_ail_max( > struct xfs_ail *ailp) > { > - if (list_empty(&ailp->xa_ail)) > + if (list_empty(&ailp->ail_head)) > return NULL; > > - return list_entry(ailp->xa_ail.prev, xfs_log_item_t, li_ail); > + return list_entry(ailp->ail_head.prev, xfs_log_item_t, li_ail); > } > > /* > @@ -84,7 +84,7 @@ xfs_ail_next( > struct xfs_ail *ailp, > xfs_log_item_t *lip) > { > - if (lip->li_ail.next == &ailp->xa_ail) > + if (lip->li_ail.next == &ailp->ail_head) > return NULL; > > return list_first_entry(&lip->li_ail, xfs_log_item_t, li_ail); > @@ -105,11 +105,11 @@ xfs_ail_min_lsn( > xfs_lsn_t lsn = 0; > xfs_log_item_t *lip; > > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > lip = xfs_ail_min(ailp); > if (lip) > lsn = lip->li_lsn; > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > return lsn; > } > @@ -124,11 +124,11 @@ xfs_ail_max_lsn( > xfs_lsn_t lsn = 0; > xfs_log_item_t *lip; > > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > lip = xfs_ail_max(ailp); > if (lip) > lsn = lip->li_lsn; > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > return lsn; > } > @@ -146,7 +146,7 @@ xfs_trans_ail_cursor_init( > struct xfs_ail_cursor *cur) > { > cur->item = NULL; > - list_add_tail(&cur->list, &ailp->xa_cursors); > + list_add_tail(&cur->list, &ailp->ail_cursors); > } > > /* > @@ -194,7 +194,7 @@ xfs_trans_ail_cursor_clear( > { > struct xfs_ail_cursor *cur; > > - list_for_each_entry(cur, &ailp->xa_cursors, list) { > + list_for_each_entry(cur, &ailp->ail_cursors, list) { > if (cur->item == lip) > cur->item = (struct xfs_log_item *) > ((uintptr_t)cur->item | 1); > @@ -222,7 +222,7 @@ xfs_trans_ail_cursor_first( > goto out; > } > > - list_for_each_entry(lip, &ailp->xa_ail, li_ail) { > + list_for_each_entry(lip, &ailp->ail_head, li_ail) { > if (XFS_LSN_CMP(lip->li_lsn, lsn) >= 0) > goto out; > } > @@ -241,7 +241,7 @@ __xfs_trans_ail_cursor_last( > { > xfs_log_item_t *lip; > > - list_for_each_entry_reverse(lip, &ailp->xa_ail, li_ail) { > + list_for_each_entry_reverse(lip, &ailp->ail_head, li_ail) { > if (XFS_LSN_CMP(lip->li_lsn, lsn) <= 0) > return lip; > } > @@ -310,7 +310,7 @@ xfs_ail_splice( > if (lip) > list_splice(list, &lip->li_ail); > else > - list_splice(list, &ailp->xa_ail); > + list_splice(list, &ailp->ail_head); > } > > /* > @@ -335,17 +335,17 @@ xfsaild_push_item( > * If log item pinning is enabled, skip the push and track the item as > * pinned. This can help induce head-behind-tail conditions. > */ > - if (XFS_TEST_ERROR(false, ailp->xa_mount, XFS_ERRTAG_LOG_ITEM_PIN)) > + if (XFS_TEST_ERROR(false, ailp->ail_mount, XFS_ERRTAG_LOG_ITEM_PIN)) > return XFS_ITEM_PINNED; > > - return lip->li_ops->iop_push(lip, &ailp->xa_buf_list); > + return lip->li_ops->iop_push(lip, &ailp->ail_buf_list); > } > > static long > xfsaild_push( > struct xfs_ail *ailp) > { > - xfs_mount_t *mp = ailp->xa_mount; > + xfs_mount_t *mp = ailp->ail_mount; > struct xfs_ail_cursor cur; > xfs_log_item_t *lip; > xfs_lsn_t lsn; > @@ -360,30 +360,30 @@ xfsaild_push( > * buffers the last time we ran, force the log first and wait for it > * before pushing again. > */ > - if (ailp->xa_log_flush && ailp->xa_last_pushed_lsn == 0 && > - (!list_empty_careful(&ailp->xa_buf_list) || > + if (ailp->ail_log_flush && ailp->ail_last_pushed_lsn == 0 && > + (!list_empty_careful(&ailp->ail_buf_list) || > xfs_ail_min_lsn(ailp))) { > - ailp->xa_log_flush = 0; > + ailp->ail_log_flush = 0; > > XFS_STATS_INC(mp, xs_push_ail_flush); > xfs_log_force(mp, XFS_LOG_SYNC); > } > > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > > - /* barrier matches the xa_target update in xfs_ail_push() */ > + /* barrier matches the ail_target update in xfs_ail_push() */ > smp_rmb(); > - target = ailp->xa_target; > - ailp->xa_target_prev = target; > + target = ailp->ail_target; > + ailp->ail_target_prev = target; > > - lip = xfs_trans_ail_cursor_first(ailp, &cur, ailp->xa_last_pushed_lsn); > + lip = xfs_trans_ail_cursor_first(ailp, &cur, ailp->ail_last_pushed_lsn); > if (!lip) { > /* > * If the AIL is empty or our push has reached the end we are > * done now. > */ > xfs_trans_ail_cursor_done(&cur); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > goto out_done; > } > > @@ -404,7 +404,7 @@ xfsaild_push( > XFS_STATS_INC(mp, xs_push_ail_success); > trace_xfs_ail_push(lip); > > - ailp->xa_last_pushed_lsn = lsn; > + ailp->ail_last_pushed_lsn = lsn; > break; > > case XFS_ITEM_FLUSHING: > @@ -423,7 +423,7 @@ xfsaild_push( > trace_xfs_ail_flushing(lip); > > flushing++; > - ailp->xa_last_pushed_lsn = lsn; > + ailp->ail_last_pushed_lsn = lsn; > break; > > case XFS_ITEM_PINNED: > @@ -431,7 +431,7 @@ xfsaild_push( > trace_xfs_ail_pinned(lip); > > stuck++; > - ailp->xa_log_flush++; > + ailp->ail_log_flush++; > break; > case XFS_ITEM_LOCKED: > XFS_STATS_INC(mp, xs_push_ail_locked); > @@ -468,10 +468,10 @@ xfsaild_push( > lsn = lip->li_lsn; > } > xfs_trans_ail_cursor_done(&cur); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > - if (xfs_buf_delwri_submit_nowait(&ailp->xa_buf_list)) > - ailp->xa_log_flush++; > + if (xfs_buf_delwri_submit_nowait(&ailp->ail_buf_list)) > + ailp->ail_log_flush++; > > if (!count || XFS_LSN_CMP(lsn, target) >= 0) { > out_done: > @@ -481,7 +481,7 @@ xfsaild_push( > * AIL before we start the next scan from the start of the AIL. > */ > tout = 50; > - ailp->xa_last_pushed_lsn = 0; > + ailp->ail_last_pushed_lsn = 0; > } else if (((stuck + flushing) * 100) / count > 90) { > /* > * Either there is a lot of contention on the AIL or we are > @@ -494,7 +494,7 @@ xfsaild_push( > * the restart to issue a log force to unpin the stuck items. > */ > tout = 20; > - ailp->xa_last_pushed_lsn = 0; > + ailp->ail_last_pushed_lsn = 0; > } else { > /* > * Assume we have more work to do in a short while. > @@ -536,26 +536,26 @@ xfsaild( > break; > } > > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > > /* > * Idle if the AIL is empty and we are not racing with a target > * update. We check the AIL after we set the task to a sleep > - * state to guarantee that we either catch an xa_target update > + * state to guarantee that we either catch an ail_target update > * or that a wake_up resets the state to TASK_RUNNING. > * Otherwise, we run the risk of sleeping indefinitely. > * > - * The barrier matches the xa_target update in xfs_ail_push(). > + * The barrier matches the ail_target update in xfs_ail_push(). > */ > smp_rmb(); > if (!xfs_ail_min(ailp) && > - ailp->xa_target == ailp->xa_target_prev) { > - spin_unlock(&ailp->xa_lock); > + ailp->ail_target == ailp->ail_target_prev) { > + spin_unlock(&ailp->ail_lock); > freezable_schedule(); > tout = 0; > continue; > } > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > if (tout) > freezable_schedule_timeout(msecs_to_jiffies(tout)); > @@ -592,8 +592,8 @@ xfs_ail_push( > xfs_log_item_t *lip; > > lip = xfs_ail_min(ailp); > - if (!lip || XFS_FORCED_SHUTDOWN(ailp->xa_mount) || > - XFS_LSN_CMP(threshold_lsn, ailp->xa_target) <= 0) > + if (!lip || XFS_FORCED_SHUTDOWN(ailp->ail_mount) || > + XFS_LSN_CMP(threshold_lsn, ailp->ail_target) <= 0) > return; > > /* > @@ -601,10 +601,10 @@ xfs_ail_push( > * the XFS_AIL_PUSHING_BIT. > */ > smp_wmb(); > - xfs_trans_ail_copy_lsn(ailp, &ailp->xa_target, &threshold_lsn); > + xfs_trans_ail_copy_lsn(ailp, &ailp->ail_target, &threshold_lsn); > smp_wmb(); > > - wake_up_process(ailp->xa_task); > + wake_up_process(ailp->ail_task); > } > > /* > @@ -630,18 +630,18 @@ xfs_ail_push_all_sync( > struct xfs_log_item *lip; > DEFINE_WAIT(wait); > > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > while ((lip = xfs_ail_max(ailp)) != NULL) { > - prepare_to_wait(&ailp->xa_empty, &wait, TASK_UNINTERRUPTIBLE); > - ailp->xa_target = lip->li_lsn; > - wake_up_process(ailp->xa_task); > - spin_unlock(&ailp->xa_lock); > + prepare_to_wait(&ailp->ail_empty, &wait, TASK_UNINTERRUPTIBLE); > + ailp->ail_target = lip->li_lsn; > + wake_up_process(ailp->ail_task); > + spin_unlock(&ailp->ail_lock); > schedule(); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > } > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > - finish_wait(&ailp->xa_empty, &wait); > + finish_wait(&ailp->ail_empty, &wait); > } > > /* > @@ -672,7 +672,7 @@ xfs_trans_ail_update_bulk( > struct xfs_ail_cursor *cur, > struct xfs_log_item **log_items, > int nr_items, > - xfs_lsn_t lsn) __releases(ailp->xa_lock) > + xfs_lsn_t lsn) __releases(ailp->ail_lock) > { > xfs_log_item_t *mlip; > int mlip_changed = 0; > @@ -705,13 +705,13 @@ xfs_trans_ail_update_bulk( > xfs_ail_splice(ailp, cur, &tmp, lsn); > > if (mlip_changed) { > - if (!XFS_FORCED_SHUTDOWN(ailp->xa_mount)) > - xlog_assign_tail_lsn_locked(ailp->xa_mount); > - spin_unlock(&ailp->xa_lock); > + if (!XFS_FORCED_SHUTDOWN(ailp->ail_mount)) > + xlog_assign_tail_lsn_locked(ailp->ail_mount); > + spin_unlock(&ailp->ail_lock); > > - xfs_log_space_wake(ailp->xa_mount); > + xfs_log_space_wake(ailp->ail_mount); > } else { > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > } > } > > @@ -756,13 +756,13 @@ void > xfs_trans_ail_delete( > struct xfs_ail *ailp, > struct xfs_log_item *lip, > - int shutdown_type) __releases(ailp->xa_lock) > + int shutdown_type) __releases(ailp->ail_lock) > { > - struct xfs_mount *mp = ailp->xa_mount; > + struct xfs_mount *mp = ailp->ail_mount; > bool mlip_changed; > > if (!(lip->li_flags & XFS_LI_IN_AIL)) { > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > if (!XFS_FORCED_SHUTDOWN(mp)) { > xfs_alert_tag(mp, XFS_PTAG_AILDELETE, > "%s: attempting to delete a log item that is not in the AIL", > @@ -776,13 +776,13 @@ xfs_trans_ail_delete( > if (mlip_changed) { > if (!XFS_FORCED_SHUTDOWN(mp)) > xlog_assign_tail_lsn_locked(mp); > - if (list_empty(&ailp->xa_ail)) > - wake_up_all(&ailp->xa_empty); > + if (list_empty(&ailp->ail_head)) > + wake_up_all(&ailp->ail_empty); > } > > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > if (mlip_changed) > - xfs_log_space_wake(ailp->xa_mount); > + xfs_log_space_wake(ailp->ail_mount); > } > > int > @@ -795,16 +795,16 @@ xfs_trans_ail_init( > if (!ailp) > return -ENOMEM; > > - ailp->xa_mount = mp; > - INIT_LIST_HEAD(&ailp->xa_ail); > - INIT_LIST_HEAD(&ailp->xa_cursors); > - spin_lock_init(&ailp->xa_lock); > - INIT_LIST_HEAD(&ailp->xa_buf_list); > - init_waitqueue_head(&ailp->xa_empty); > + ailp->ail_mount = mp; > + INIT_LIST_HEAD(&ailp->ail_head); > + INIT_LIST_HEAD(&ailp->ail_cursors); > + spin_lock_init(&ailp->ail_lock); > + INIT_LIST_HEAD(&ailp->ail_buf_list); > + init_waitqueue_head(&ailp->ail_empty); > > - ailp->xa_task = kthread_run(xfsaild, ailp, "xfsaild/%s", > - ailp->xa_mount->m_fsname); > - if (IS_ERR(ailp->xa_task)) > + ailp->ail_task = kthread_run(xfsaild, ailp, "xfsaild/%s", > + ailp->ail_mount->m_fsname); > + if (IS_ERR(ailp->ail_task)) > goto out_free_ailp; > > mp->m_ail = ailp; > @@ -821,6 +821,6 @@ xfs_trans_ail_destroy( > { > struct xfs_ail *ailp = mp->m_ail; > > - kthread_stop(ailp->xa_task); > + kthread_stop(ailp->ail_task); > kmem_free(ailp); > } > diff --git a/fs/xfs/xfs_trans_buf.c b/fs/xfs/xfs_trans_buf.c > index 3ba7a96a8abd..b8871bcfe00b 100644 > --- a/fs/xfs/xfs_trans_buf.c > +++ b/fs/xfs/xfs_trans_buf.c > @@ -429,8 +429,8 @@ xfs_trans_brelse(xfs_trans_t *tp, > * If the fs has shutdown and we dropped the last reference, it may fall > * on us to release a (possibly dirty) bli if it never made it to the > * AIL (e.g., the aborted unpin already happened and didn't release it > - * due to our reference). Since we're already shutdown and need xa_lock, > - * just force remove from the AIL and release the bli here. > + * due to our reference). Since we're already shutdown and need > + * ail_lock, just force remove from the AIL and release the bli here. > */ > if (XFS_FORCED_SHUTDOWN(tp->t_mountp) && freed) { > xfs_trans_ail_remove(&bip->bli_item, SHUTDOWN_LOG_IO_ERROR); > diff --git a/fs/xfs/xfs_trans_priv.h b/fs/xfs/xfs_trans_priv.h > index b317a3644c00..be24b0c8a332 100644 > --- a/fs/xfs/xfs_trans_priv.h > +++ b/fs/xfs/xfs_trans_priv.h > @@ -65,17 +65,17 @@ struct xfs_ail_cursor { > * Eventually we need to drive the locking in here as well. > */ > struct xfs_ail { > - struct xfs_mount *xa_mount; > - struct task_struct *xa_task; > - struct list_head xa_ail; > - xfs_lsn_t xa_target; > - xfs_lsn_t xa_target_prev; > - struct list_head xa_cursors; > - spinlock_t xa_lock; > - xfs_lsn_t xa_last_pushed_lsn; > - int xa_log_flush; > - struct list_head xa_buf_list; > - wait_queue_head_t xa_empty; > + struct xfs_mount *ail_mount; > + struct task_struct *ail_task; > + struct list_head ail_head; > + xfs_lsn_t ail_target; > + xfs_lsn_t ail_target_prev; > + struct list_head ail_cursors; > + spinlock_t ail_lock; > + xfs_lsn_t ail_last_pushed_lsn; > + int ail_log_flush; > + struct list_head ail_buf_list; > + wait_queue_head_t ail_empty; > }; > > /* > @@ -84,7 +84,7 @@ struct xfs_ail { > void xfs_trans_ail_update_bulk(struct xfs_ail *ailp, > struct xfs_ail_cursor *cur, > struct xfs_log_item **log_items, int nr_items, > - xfs_lsn_t lsn) __releases(ailp->xa_lock); > + xfs_lsn_t lsn) __releases(ailp->ail_lock); > /* > * Return a pointer to the first item in the AIL. If the AIL is empty, then > * return NULL. > @@ -93,7 +93,7 @@ static inline struct xfs_log_item * > xfs_ail_min( > struct xfs_ail *ailp) > { > - return list_first_entry_or_null(&ailp->xa_ail, struct xfs_log_item, > + return list_first_entry_or_null(&ailp->ail_head, struct xfs_log_item, > li_ail); > } > > @@ -101,14 +101,14 @@ static inline void > xfs_trans_ail_update( > struct xfs_ail *ailp, > struct xfs_log_item *lip, > - xfs_lsn_t lsn) __releases(ailp->xa_lock) > + xfs_lsn_t lsn) __releases(ailp->ail_lock) > { > xfs_trans_ail_update_bulk(ailp, NULL, &lip, 1, lsn); > } > > bool xfs_ail_delete_one(struct xfs_ail *ailp, struct xfs_log_item *lip); > void xfs_trans_ail_delete(struct xfs_ail *ailp, struct xfs_log_item *lip, > - int shutdown_type) __releases(ailp->xa_lock); > + int shutdown_type) __releases(ailp->ail_lock); > > static inline void > xfs_trans_ail_remove( > @@ -117,12 +117,12 @@ xfs_trans_ail_remove( > { > struct xfs_ail *ailp = lip->li_ailp; > > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > /* xfs_trans_ail_delete() drops the AIL lock */ > if (lip->li_flags & XFS_LI_IN_AIL) > xfs_trans_ail_delete(ailp, lip, shutdown_type); > else > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > } > > void xfs_ail_push(struct xfs_ail *, xfs_lsn_t); > @@ -149,9 +149,9 @@ xfs_trans_ail_copy_lsn( > xfs_lsn_t *src) > { > ASSERT(sizeof(xfs_lsn_t) == 8); /* don't lock if it shrinks */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > *dst = *src; > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > } > #else > static inline void > @@ -172,7 +172,7 @@ xfs_clear_li_failed( > struct xfs_buf *bp = lip->li_buf; > > ASSERT(lip->li_flags & XFS_LI_IN_AIL); > - lockdep_assert_held(&lip->li_ailp->xa_lock); > + lockdep_assert_held(&lip->li_ailp->ail_lock); > > if (lip->li_flags & XFS_LI_FAILED) { > lip->li_flags &= ~XFS_LI_FAILED; > @@ -186,7 +186,7 @@ xfs_set_li_failed( > struct xfs_log_item *lip, > struct xfs_buf *bp) > { > - lockdep_assert_held(&lip->li_ailp->xa_lock); > + lockdep_assert_held(&lip->li_ailp->ail_lock); > > if (!(lip->li_flags & XFS_LI_FAILED)) { > xfs_buf_hold(bp); > -- > 2.15.1 > > -- > To unsubscribe from this list: send the line "unsubscribe linux-xfs" in > the body of a message to majordomo@vger.kernel.org > More majordomo info at http://vger.kernel.org/majordomo-info.html ------------------------------------------------------------------------------ Check out the vibrant tech community on one of the world's most engaging tech sites, Slashdot.org! http://sdm.link/slashdot From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [v5,01/78] xfs: Rename xa_ elements to ail_ From: "Darrick J. Wong" Message-Id: <20180103010105.GA16402@magnolia> Date: Tue, 2 Jan 2018 17:01:05 -0800 To: Matthew Wilcox Cc: linux-kernel@vger.kernel.org, Matthew Wilcox , Ross Zwisler , David Howells , Shaohua Li , Jens Axboe , Rehas Sachdeva , Marc Zyngier , linux-mm@kvack.org, linux-fsdevel@vger.kernel.org, linux-f2fs-devel@lists.sourceforge.net, linux-nilfs@vger.kernel.org, linux-btrfs@vger.kernel.org, linux-xfs@vger.kernel.org, linux-usb@vger.kernel.org, linux-raid@vger.kernel.org List-ID: T24gRnJpLCBEZWMgMTUsIDIwMTcgYXQgMDI6MDM6MzNQTSAtMDgwMCwgTWF0dGhldyBXaWxjb3gg d3JvdGU6Cj4gRnJvbTogTWF0dGhldyBXaWxjb3ggPG1hd2lsY294QG1pY3Jvc29mdC5jb20+Cj4g Cj4gVGhpcyBpcyBhIHNpbXBsZSByZW5hbWUsIGV4Y2VwdCB0aGF0IHhhX2FpbCBiZWNvbWVzIGFp bF9oZWFkLgo+IAo+IFNpZ25lZC1vZmYtYnk6IE1hdHRoZXcgV2lsY294IDxtYXdpbGNveEBtaWNy b3NvZnQuY29tPgoKVGhhdCB3YXMgYW4gZXllZnVsLApSZXZpZXdlZC1ieTogRGFycmljayBKLiBX b25nIDxkYXJyaWNrLndvbmdAb3JhY2xlLmNvbT4KCj4gLS0tCj4gIGZzL3hmcy94ZnNfYnVmX2l0 ZW0uYyAgICB8ICAxMCArKy0tCj4gIGZzL3hmcy94ZnNfZHF1b3QuYyAgICAgICB8ICAgNCArLQo+ ICBmcy94ZnMveGZzX2RxdW90X2l0ZW0uYyAgfCAgMTEgKystLQo+ICBmcy94ZnMveGZzX2lub2Rl X2l0ZW0uYyAgfCAgMjIgKysrLS0tLQo+ICBmcy94ZnMveGZzX2xvZy5jICAgICAgICAgfCAgIDYg Ky0KPiAgZnMveGZzL3hmc19sb2dfcmVjb3Zlci5jIHwgIDgwICsrKysrKysrKysrKy0tLS0tLS0t LS0tLS0KPiAgZnMveGZzL3hmc190cmFucy5jICAgICAgIHwgIDE4ICsrKy0tLQo+ICBmcy94ZnMv eGZzX3RyYW5zX2FpbC5jICAgfCAxNTIgKysrKysrKysrKysrKysrKysrKysrKystLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0KPiAgZnMveGZzL3hmc190cmFuc19idWYuYyAgIHwgICA0ICstCj4gIGZz L3hmcy94ZnNfdHJhbnNfcHJpdi5oICB8ICA0MiArKysrKystLS0tLS0tCj4gIDEwIGZpbGVzIGNo YW5nZWQsIDE3NSBpbnNlcnRpb25zKCspLCAxNzQgZGVsZXRpb25zKC0pCj4gCj4gZGlmZiAtLWdp dCBhL2ZzL3hmcy94ZnNfYnVmX2l0ZW0uYyBiL2ZzL3hmcy94ZnNfYnVmX2l0ZW0uYwo+IGluZGV4 IGUwYTBhZjA5NDZmMi4uNmM1MDM1NTQ0YTkzIDEwMDY0NAo+IC0tLSBhL2ZzL3hmcy94ZnNfYnVm X2l0ZW0uYwo+ICsrKyBiL2ZzL3hmcy94ZnNfYnVmX2l0ZW0uYwo+IEBAIC00NTksNyArNDU5LDcg QEAgeGZzX2J1Zl9pdGVtX3VucGluKAo+ICAJCQlicC0+Yl9mc3ByaXYgPSBOVUxMOwo+ICAJCQli cC0+Yl9pb2RvbmUgPSBOVUxMOwo+ICAJCX0gZWxzZSB7Cj4gLQkJCXNwaW5fbG9jaygmYWlscC0+ eGFfbG9jayk7Cj4gKwkJCXNwaW5fbG9jaygmYWlscC0+YWlsX2xvY2spOwo+ICAJCQl4ZnNfdHJh bnNfYWlsX2RlbGV0ZShhaWxwLCBsaXAsIFNIVVRET1dOX0xPR19JT19FUlJPUik7Cj4gIAkJCXhm c19idWZfaXRlbV9yZWxzZShicCk7Cj4gIAkJCUFTU0VSVChicC0+Yl9mc3ByaXYgPT0gTlVMTCk7 Cj4gQEAgLTEwNTYsMTMgKzEwNTYsMTMgQEAgeGZzX2J1Zl9kb19jYWxsYmFja3NfZmFpbCgKPiAg CXN0cnVjdCB4ZnNfbG9nX2l0ZW0JKmxpcCA9IGJwLT5iX2ZzcHJpdjsKPiAgCXN0cnVjdCB4ZnNf YWlsCQkqYWlscCA9IGxpcC0+bGlfYWlscDsKPiAgCj4gLQlzcGluX2xvY2soJmFpbHAtPnhhX2xv Y2spOwo+ICsJc3Bpbl9sb2NrKCZhaWxwLT5haWxfbG9jayk7Cj4gIAlmb3IgKDsgbGlwOyBsaXAg PSBuZXh0KSB7Cj4gIAkJbmV4dCA9IGxpcC0+bGlfYmlvX2xpc3Q7Cj4gIAkJaWYgKGxpcC0+bGlf b3BzLT5pb3BfZXJyb3IpCj4gIAkJCWxpcC0+bGlfb3BzLT5pb3BfZXJyb3IobGlwLCBicCk7Cj4g IAl9Cj4gLQlzcGluX3VubG9jaygmYWlscC0+eGFfbG9jayk7Cj4gKwlzcGluX3VubG9jaygmYWls cC0+YWlsX2xvY2spOwo+ICB9Cj4gIAo+ICBzdGF0aWMgYm9vbAo+IEBAIC0xMjE1LDcgKzEyMTUs NyBAQCB4ZnNfYnVmX2lvZG9uZSgKPiAgCSAqCj4gIAkgKiBFaXRoZXIgd2F5LCBBSUwgaXMgdXNl bGVzcyBpZiB3ZSdyZSBmb3JjaW5nIGEgc2h1dGRvd24uCj4gIAkgKi8KPiAtCXNwaW5fbG9jaygm YWlscC0+eGFfbG9jayk7Cj4gKwlzcGluX2xvY2soJmFpbHAtPmFpbF9sb2NrKTsKPiAgCXhmc190 cmFuc19haWxfZGVsZXRlKGFpbHAsIGxpcCwgU0hVVERPV05fQ09SUlVQVF9JTkNPUkUpOwo+ICAJ eGZzX2J1Zl9pdGVtX2ZyZWUoQlVGX0lURU0obGlwKSk7Cj4gIH0KPiBAQCAtMTIzNiw3ICsxMjM2 LDcgQEAgeGZzX2J1Zl9yZXN1Ym1pdF9mYWlsZWRfYnVmZmVycygKPiAgCS8qCj4gIAkgKiBDbGVh ciBYRlNfTElfRkFJTEVEIGZsYWcgZnJvbSBhbGwgaXRlbXMgYmVmb3JlIHJlc3VibWl0Cj4gIAkg Kgo+IC0JICogWEZTX0xJX0ZBSUxFRCBzZXQvY2xlYXIgaXMgcHJvdGVjdGVkIGJ5IHhhX2xvY2ss IGNhbGxlciAgdGhpcwo+ICsJICogWEZTX0xJX0ZBSUxFRCBzZXQvY2xlYXIgaXMgcHJvdGVjdGVk IGJ5IGFpbF9sb2NrLCBjYWxsZXIgIHRoaXMKPiAgCSAqIGZ1bmN0aW9uIGFscmVhZHkgaGF2ZSBp dCBhY3F1aXJlZAo+ICAJICovCj4gIAlmb3IgKDsgbGlwOyBsaXAgPSBuZXh0KSB7Cj4gZGlmZiAt LWdpdCBhL2ZzL3hmcy94ZnNfZHF1b3QuYyBiL2ZzL3hmcy94ZnNfZHF1b3QuYwo+IGluZGV4IGYy NDg3MDhjMTBmZi4uZTJhNDY2ZGY1ZGQxIDEwMDY0NAo+IC0tLSBhL2ZzL3hmcy94ZnNfZHF1b3Qu Ywo+ICsrKyBiL2ZzL3hmcy94ZnNfZHF1b3QuYwo+IEBAIC05NzQsNyArOTc0LDcgQEAgeGZzX3Ft X2RxZmx1c2hfZG9uZSgKPiAgCSAgICAgKGxpcC0+bGlfZmxhZ3MgJiBYRlNfTElfRkFJTEVEKSkp IHsKPiAgCj4gIAkJLyogeGZzX3RyYW5zX2FpbF9kZWxldGUoKSBkcm9wcyB0aGUgQUlMIGxvY2su ICovCj4gLQkJc3Bpbl9sb2NrKCZhaWxwLT54YV9sb2NrKTsKPiArCQlzcGluX2xvY2soJmFpbHAt PmFpbF9sb2NrKTsKPiAgCQlpZiAobGlwLT5saV9sc24gPT0gcWlwLT5xbGlfZmx1c2hfbHNuKSB7 Cj4gIAkJCXhmc190cmFuc19haWxfZGVsZXRlKGFpbHAsIGxpcCwgU0hVVERPV05fQ09SUlVQVF9J TkNPUkUpOwo+ICAJCX0gZWxzZSB7Cj4gQEAgLTk4NCw3ICs5ODQsNyBAQCB4ZnNfcW1fZHFmbHVz aF9kb25lKAo+ICAJCQkgKi8KPiAgCQkJaWYgKGxpcC0+bGlfZmxhZ3MgJiBYRlNfTElfRkFJTEVE KQo+ICAJCQkJeGZzX2NsZWFyX2xpX2ZhaWxlZChsaXApOwo+IC0JCQlzcGluX3VubG9jaygmYWls cC0+eGFfbG9jayk7Cj4gKwkJCXNwaW5fdW5sb2NrKCZhaWxwLT5haWxfbG9jayk7Cj4gIAkJfQo+ ICAJfQo+ICAKPiBkaWZmIC0tZ2l0IGEvZnMveGZzL3hmc19kcXVvdF9pdGVtLmMgYi9mcy94ZnMv eGZzX2RxdW90X2l0ZW0uYwo+IGluZGV4IDY2NGRlYTEwNWU3Ni4uNjI2MzdhMjI2NjAxIDEwMDY0 NAo+IC0tLSBhL2ZzL3hmcy94ZnNfZHF1b3RfaXRlbS5jCj4gKysrIGIvZnMveGZzL3hmc19kcXVv dF9pdGVtLmMKPiBAQCAtMTYwLDggKzE2MCw5IEBAIHhmc19kcXVvdF9pdGVtX2Vycm9yKAo+ICBT VEFUSUMgdWludAo+ICB4ZnNfcW1fZHF1b3RfbG9naXRlbV9wdXNoKAo+ICAJc3RydWN0IHhmc19s b2dfaXRlbQkqbGlwLAo+IC0Jc3RydWN0IGxpc3RfaGVhZAkqYnVmZmVyX2xpc3QpIF9fcmVsZWFz ZXMoJmxpcC0+bGlfYWlscC0+eGFfbG9jaykKPiAtCQkJCQkgICAgICBfX2FjcXVpcmVzKCZsaXAt PmxpX2FpbHAtPnhhX2xvY2spCj4gKwlzdHJ1Y3QgbGlzdF9oZWFkCSpidWZmZXJfbGlzdCkKPiAr CQlfX3JlbGVhc2VzKCZsaXAtPmxpX2FpbHAtPmFpbF9sb2NrKQo+ICsJCV9fYWNxdWlyZXMoJmxp cC0+bGlfYWlscC0+YWlsX2xvY2spCj4gIHsKPiAgCXN0cnVjdCB4ZnNfZHF1b3QJKmRxcCA9IERR VU9UX0lURU0obGlwKS0+cWxpX2RxdW90Owo+ICAJc3RydWN0IHhmc19idWYJCSpicCA9IGxpcC0+ bGlfYnVmOwo+IEBAIC0yMDgsNyArMjA5LDcgQEAgeGZzX3FtX2RxdW90X2xvZ2l0ZW1fcHVzaCgK PiAgCQlnb3RvIG91dF91bmxvY2s7Cj4gIAl9Cj4gIAo+IC0Jc3Bpbl91bmxvY2soJmxpcC0+bGlf YWlscC0+eGFfbG9jayk7Cj4gKwlzcGluX3VubG9jaygmbGlwLT5saV9haWxwLT5haWxfbG9jayk7 Cj4gIAo+ICAJZXJyb3IgPSB4ZnNfcW1fZHFmbHVzaChkcXAsICZicCk7Cj4gIAlpZiAoZXJyb3Ip IHsKPiBAQCAtMjIwLDcgKzIyMSw3IEBAIHhmc19xbV9kcXVvdF9sb2dpdGVtX3B1c2goCj4gIAkJ eGZzX2J1Zl9yZWxzZShicCk7Cj4gIAl9Cj4gIAo+IC0Jc3Bpbl9sb2NrKCZsaXAtPmxpX2FpbHAt PnhhX2xvY2spOwo+ICsJc3Bpbl9sb2NrKCZsaXAtPmxpX2FpbHAtPmFpbF9sb2NrKTsKPiAgb3V0 X3VubG9jazoKPiAgCXhmc19kcXVubG9jayhkcXApOwo+ICAJcmV0dXJuIHJ2YWw7Cj4gQEAgLTQw Myw3ICs0MDQsNyBAQCB4ZnNfcW1fcW9mZmVuZF9sb2dpdGVtX2NvbW1pdHRlZCgKPiAgCSAqIERl bGV0ZSB0aGUgcW9mZi1zdGFydCBsb2dpdGVtIGZyb20gdGhlIEFJTC4KPiAgCSAqIHhmc190cmFu c19haWxfZGVsZXRlKCkgZHJvcHMgdGhlIEFJTCBsb2NrLgo+ICAJICovCj4gLQlzcGluX2xvY2so JmFpbHAtPnhhX2xvY2spOwo+ICsJc3Bpbl9sb2NrKCZhaWxwLT5haWxfbG9jayk7Cj4gIAl4ZnNf dHJhbnNfYWlsX2RlbGV0ZShhaWxwLCAmcWZzLT5xcWxfaXRlbSwgU0hVVERPV05fTE9HX0lPX0VS Uk9SKTsKPiAgCj4gIAlrbWVtX2ZyZWUocWZzLT5xcWxfaXRlbS5saV9sdl9zaGFkb3cpOwo+IGRp ZmYgLS1naXQgYS9mcy94ZnMveGZzX2lub2RlX2l0ZW0uYyBiL2ZzL3hmcy94ZnNfaW5vZGVfaXRl bS5jCj4gaW5kZXggNmVlNWMzYmYxOWFkLi4wNzFhY2Q0MjQ5YTAgMTAwNjQ0Cj4gLS0tIGEvZnMv eGZzL3hmc19pbm9kZV9pdGVtLmMKPiArKysgYi9mcy94ZnMveGZzX2lub2RlX2l0ZW0uYwo+IEBA IC01MDEsOCArNTAxLDggQEAgU1RBVElDIHVpbnQKPiAgeGZzX2lub2RlX2l0ZW1fcHVzaCgKPiAg CXN0cnVjdCB4ZnNfbG9nX2l0ZW0JKmxpcCwKPiAgCXN0cnVjdCBsaXN0X2hlYWQJKmJ1ZmZlcl9s aXN0KQo+IC0JCV9fcmVsZWFzZXMoJmxpcC0+bGlfYWlscC0+eGFfbG9jaykKPiAtCQlfX2FjcXVp cmVzKCZsaXAtPmxpX2FpbHAtPnhhX2xvY2spCj4gKwkJX19yZWxlYXNlcygmbGlwLT5saV9haWxw LT5haWxfbG9jaykKPiArCQlfX2FjcXVpcmVzKCZsaXAtPmxpX2FpbHAtPmFpbF9sb2NrKQo+ICB7 Cj4gIAlzdHJ1Y3QgeGZzX2lub2RlX2xvZ19pdGVtICppaXAgPSBJTk9ERV9JVEVNKGxpcCk7Cj4g IAlzdHJ1Y3QgeGZzX2lub2RlCSppcCA9IGlpcC0+aWxpX2lub2RlOwo+IEBAIC01NjEsNyArNTYx LDcgQEAgeGZzX2lub2RlX2l0ZW1fcHVzaCgKPiAgCUFTU0VSVChpaXAtPmlsaV9maWVsZHMgIT0g MCB8fCBYRlNfRk9SQ0VEX1NIVVRET1dOKGlwLT5pX21vdW50KSk7Cj4gIAlBU1NFUlQoaWlwLT5p bGlfbG9nZ2VkID09IDAgfHwgWEZTX0ZPUkNFRF9TSFVURE9XTihpcC0+aV9tb3VudCkpOwo+ICAK PiAtCXNwaW5fdW5sb2NrKCZsaXAtPmxpX2FpbHAtPnhhX2xvY2spOwo+ICsJc3Bpbl91bmxvY2so JmxpcC0+bGlfYWlscC0+YWlsX2xvY2spOwo+ICAKPiAgCWVycm9yID0geGZzX2lmbHVzaChpcCwg JmJwKTsKPiAgCWlmICghZXJyb3IpIHsKPiBAQCAtNTcwLDcgKzU3MCw3IEBAIHhmc19pbm9kZV9p dGVtX3B1c2goCj4gIAkJeGZzX2J1Zl9yZWxzZShicCk7Cj4gIAl9Cj4gIAo+IC0Jc3Bpbl9sb2Nr KCZsaXAtPmxpX2FpbHAtPnhhX2xvY2spOwo+ICsJc3Bpbl9sb2NrKCZsaXAtPmxpX2FpbHAtPmFp bF9sb2NrKTsKPiAgb3V0X3VubG9jazoKPiAgCXhmc19pdW5sb2NrKGlwLCBYRlNfSUxPQ0tfU0hB UkVEKTsKPiAgCXJldHVybiBydmFsOwo+IEBAIC03NzQsNyArNzc0LDcgQEAgeGZzX2lmbHVzaF9k b25lKAo+ICAJCWJvb2wJCQltbGlwX2NoYW5nZWQgPSBmYWxzZTsKPiAgCj4gIAkJLyogdGhpcyBp cyBhbiBvcGVuY29kZWQgYmF0Y2ggdmVyc2lvbiBvZiB4ZnNfdHJhbnNfYWlsX2RlbGV0ZSAqLwo+ IC0JCXNwaW5fbG9jaygmYWlscC0+eGFfbG9jayk7Cj4gKwkJc3Bpbl9sb2NrKCZhaWxwLT5haWxf bG9jayk7Cj4gIAkJZm9yIChibGlwID0gbGlwOyBibGlwOyBibGlwID0gYmxpcC0+bGlfYmlvX2xp c3QpIHsKPiAgCQkJaWYgKElOT0RFX0lURU0oYmxpcCktPmlsaV9sb2dnZWQgJiYKPiAgCQkJICAg IGJsaXAtPmxpX2xzbiA9PSBJTk9ERV9JVEVNKGJsaXApLT5pbGlfZmx1c2hfbHNuKQo+IEBAIC03 ODUsMTUgKzc4NSwxNSBAQCB4ZnNfaWZsdXNoX2RvbmUoCj4gIAkJfQo+ICAKPiAgCQlpZiAobWxp cF9jaGFuZ2VkKSB7Cj4gLQkJCWlmICghWEZTX0ZPUkNFRF9TSFVURE9XTihhaWxwLT54YV9tb3Vu dCkpCj4gLQkJCQl4bG9nX2Fzc2lnbl90YWlsX2xzbl9sb2NrZWQoYWlscC0+eGFfbW91bnQpOwo+ IC0JCQlpZiAobGlzdF9lbXB0eSgmYWlscC0+eGFfYWlsKSkKPiAtCQkJCXdha2VfdXBfYWxsKCZh aWxwLT54YV9lbXB0eSk7Cj4gKwkJCWlmICghWEZTX0ZPUkNFRF9TSFVURE9XTihhaWxwLT5haWxf bW91bnQpKQo+ICsJCQkJeGxvZ19hc3NpZ25fdGFpbF9sc25fbG9ja2VkKGFpbHAtPmFpbF9tb3Vu dCk7Cj4gKwkJCWlmIChsaXN0X2VtcHR5KCZhaWxwLT5haWxfaGVhZCkpCj4gKwkJCQl3YWtlX3Vw X2FsbCgmYWlscC0+YWlsX2VtcHR5KTsKPiAgCQl9Cj4gLQkJc3Bpbl91bmxvY2soJmFpbHAtPnhh X2xvY2spOwo+ICsJCXNwaW5fdW5sb2NrKCZhaWxwLT5haWxfbG9jayk7Cj4gIAo+ICAJCWlmICht bGlwX2NoYW5nZWQpCj4gLQkJCXhmc19sb2dfc3BhY2Vfd2FrZShhaWxwLT54YV9tb3VudCk7Cj4g KwkJCXhmc19sb2dfc3BhY2Vfd2FrZShhaWxwLT5haWxfbW91bnQpOwo+ICAJfQo+ICAKPiAgCS8q Cj4gZGlmZiAtLWdpdCBhL2ZzL3hmcy94ZnNfbG9nLmMgYi9mcy94ZnMveGZzX2xvZy5jCj4gaW5k ZXggYTUwM2FmOTZkNzgwLi43MTQ4NjI1ZWViZjIgMTAwNjQ0Cj4gLS0tIGEvZnMveGZzL3hmc19s b2cuYwo+ICsrKyBiL2ZzL3hmcy94ZnNfbG9nLmMKPiBAQCAtMTE0OCw3ICsxMTQ4LDcgQEAgeGxv Z19hc3NpZ25fdGFpbF9sc25fbG9ja2VkKAo+ICAJc3RydWN0IHhmc19sb2dfaXRlbQkqbGlwOwo+ ICAJeGZzX2xzbl90CQl0YWlsX2xzbjsKPiAgCj4gLQlhc3NlcnRfc3Bpbl9sb2NrZWQoJm1wLT5t X2FpbC0+eGFfbG9jayk7Cj4gKwlhc3NlcnRfc3Bpbl9sb2NrZWQoJm1wLT5tX2FpbC0+YWlsX2xv Y2spOwo+ICAKPiAgCS8qCj4gIAkgKiBUbyBtYWtlIHN1cmUgd2UgYWx3YXlzIGhhdmUgYSB2YWxp ZCBMU04gZm9yIHRoZSBsb2cgdGFpbCB3ZSBrZWVwCj4gQEAgLTExNzEsOSArMTE3MSw5IEBAIHhs b2dfYXNzaWduX3RhaWxfbHNuKAo+ICB7Cj4gIAl4ZnNfbHNuX3QJCXRhaWxfbHNuOwo+ICAKPiAt CXNwaW5fbG9jaygmbXAtPm1fYWlsLT54YV9sb2NrKTsKPiArCXNwaW5fbG9jaygmbXAtPm1fYWls LT5haWxfbG9jayk7Cj4gIAl0YWlsX2xzbiA9IHhsb2dfYXNzaWduX3RhaWxfbHNuX2xvY2tlZCht cCk7Cj4gLQlzcGluX3VubG9jaygmbXAtPm1fYWlsLT54YV9sb2NrKTsKPiArCXNwaW5fdW5sb2Nr KCZtcC0+bV9haWwtPmFpbF9sb2NrKTsKPiAgCj4gIAlyZXR1cm4gdGFpbF9sc247Cj4gIH0KPiBk aWZmIC0tZ2l0IGEvZnMveGZzL3hmc19sb2dfcmVjb3Zlci5jIGIvZnMveGZzL3hmc19sb2dfcmVj b3Zlci5jCj4gaW5kZXggMjhkMWFiZmU4MzVlLi5kODcxNzYxNjI2ZmIgMTAwNjQ0Cj4gLS0tIGEv ZnMveGZzL3hmc19sb2dfcmVjb3Zlci5jCj4gKysrIGIvZnMveGZzL3hmc19sb2dfcmVjb3Zlci5j Cj4gQEAgLTM0MjQsNyArMzQyNCw3IEBAIHhsb2dfcmVjb3Zlcl9lZmlfcGFzczIoCj4gIAl9Cj4g IAlhdG9taWNfc2V0KCZlZmlwLT5lZmlfbmV4dF9leHRlbnQsIGVmaV9mb3JtYXRwLT5lZmlfbmV4 dGVudHMpOwo+ICAKPiAtCXNwaW5fbG9jaygmbG9nLT5sX2FpbHAtPnhhX2xvY2spOwo+ICsJc3Bp bl9sb2NrKCZsb2ctPmxfYWlscC0+YWlsX2xvY2spOwo+ICAJLyoKPiAgCSAqIFRoZSBFRkkgaGFz IHR3byByZWZlcmVuY2VzLiBPbmUgZm9yIHRoZSBFRkQgYW5kIG9uZSBmb3IgRUZJIHRvIGVuc3Vy ZQo+ICAJICogaXQgbWFrZXMgaXQgaW50byB0aGUgQUlMLiBJbnNlcnQgdGhlIEVGSSBpbnRvIHRo ZSBBSUwgZGlyZWN0bHkgYW5kCj4gQEAgLTM0NjcsNyArMzQ2Nyw3IEBAIHhsb2dfcmVjb3Zlcl9l ZmRfcGFzczIoCj4gIAkgKiBTZWFyY2ggZm9yIHRoZSBFRkkgd2l0aCB0aGUgaWQgaW4gdGhlIEVG RCBmb3JtYXQgc3RydWN0dXJlIGluIHRoZQo+ICAJICogQUlMLgo+ICAJICovCj4gLQlzcGluX2xv Y2soJmFpbHAtPnhhX2xvY2spOwo+ICsJc3Bpbl9sb2NrKCZhaWxwLT5haWxfbG9jayk7Cj4gIAls aXAgPSB4ZnNfdHJhbnNfYWlsX2N1cnNvcl9maXJzdChhaWxwLCAmY3VyLCAwKTsKPiAgCXdoaWxl IChsaXAgIT0gTlVMTCkgewo+ICAJCWlmIChsaXAtPmxpX3R5cGUgPT0gWEZTX0xJX0VGSSkgewo+ IEBAIC0zNDc3LDkgKzM0NzcsOSBAQCB4bG9nX3JlY292ZXJfZWZkX3Bhc3MyKAo+ICAJCQkJICog RHJvcCB0aGUgRUZEIHJlZmVyZW5jZSB0byB0aGUgRUZJLiBUaGlzCj4gIAkJCQkgKiByZW1vdmVz IHRoZSBFRkkgZnJvbSB0aGUgQUlMIGFuZCBmcmVlcyBpdC4KPiAgCQkJCSAqLwo+IC0JCQkJc3Bp bl91bmxvY2soJmFpbHAtPnhhX2xvY2spOwo+ICsJCQkJc3Bpbl91bmxvY2soJmFpbHAtPmFpbF9s b2NrKTsKPiAgCQkJCXhmc19lZmlfcmVsZWFzZShlZmlwKTsKPiAtCQkJCXNwaW5fbG9jaygmYWls cC0+eGFfbG9jayk7Cj4gKwkJCQlzcGluX2xvY2soJmFpbHAtPmFpbF9sb2NrKTsKPiAgCQkJCWJy ZWFrOwo+ICAJCQl9Cj4gIAkJfQo+IEBAIC0zNDg3LDcgKzM0ODcsNyBAQCB4bG9nX3JlY292ZXJf ZWZkX3Bhc3MyKAo+ICAJfQo+ICAKPiAgCXhmc190cmFuc19haWxfY3Vyc29yX2RvbmUoJmN1cik7 Cj4gLQlzcGluX3VubG9jaygmYWlscC0+eGFfbG9jayk7Cj4gKwlzcGluX3VubG9jaygmYWlscC0+ YWlsX2xvY2spOwo+ICAKPiAgCXJldHVybiAwOwo+ICB9Cj4gQEAgLTM1MjAsNyArMzUyMCw3IEBA IHhsb2dfcmVjb3Zlcl9ydWlfcGFzczIoCj4gIAl9Cj4gIAlhdG9taWNfc2V0KCZydWlwLT5ydWlf bmV4dF9leHRlbnQsIHJ1aV9mb3JtYXRwLT5ydWlfbmV4dGVudHMpOwo+ICAKPiAtCXNwaW5fbG9j aygmbG9nLT5sX2FpbHAtPnhhX2xvY2spOwo+ICsJc3Bpbl9sb2NrKCZsb2ctPmxfYWlscC0+YWls X2xvY2spOwo+ICAJLyoKPiAgCSAqIFRoZSBSVUkgaGFzIHR3byByZWZlcmVuY2VzLiBPbmUgZm9y IHRoZSBSVUQgYW5kIG9uZSBmb3IgUlVJIHRvIGVuc3VyZQo+ICAJICogaXQgbWFrZXMgaXQgaW50 byB0aGUgQUlMLiBJbnNlcnQgdGhlIFJVSSBpbnRvIHRoZSBBSUwgZGlyZWN0bHkgYW5kCj4gQEAg LTM1NjAsNyArMzU2MCw3IEBAIHhsb2dfcmVjb3Zlcl9ydWRfcGFzczIoCj4gIAkgKiBTZWFyY2gg Zm9yIHRoZSBSVUkgd2l0aCB0aGUgaWQgaW4gdGhlIFJVRCBmb3JtYXQgc3RydWN0dXJlIGluIHRo ZQo+ICAJICogQUlMLgo+ICAJICovCj4gLQlzcGluX2xvY2soJmFpbHAtPnhhX2xvY2spOwo+ICsJ c3Bpbl9sb2NrKCZhaWxwLT5haWxfbG9jayk7Cj4gIAlsaXAgPSB4ZnNfdHJhbnNfYWlsX2N1cnNv cl9maXJzdChhaWxwLCAmY3VyLCAwKTsKPiAgCXdoaWxlIChsaXAgIT0gTlVMTCkgewo+ICAJCWlm IChsaXAtPmxpX3R5cGUgPT0gWEZTX0xJX1JVSSkgewo+IEBAIC0zNTcwLDkgKzM1NzAsOSBAQCB4 bG9nX3JlY292ZXJfcnVkX3Bhc3MyKAo+ICAJCQkJICogRHJvcCB0aGUgUlVEIHJlZmVyZW5jZSB0 byB0aGUgUlVJLiBUaGlzCj4gIAkJCQkgKiByZW1vdmVzIHRoZSBSVUkgZnJvbSB0aGUgQUlMIGFu ZCBmcmVlcyBpdC4KPiAgCQkJCSAqLwo+IC0JCQkJc3Bpbl91bmxvY2soJmFpbHAtPnhhX2xvY2sp Owo+ICsJCQkJc3Bpbl91bmxvY2soJmFpbHAtPmFpbF9sb2NrKTsKPiAgCQkJCXhmc19ydWlfcmVs ZWFzZShydWlwKTsKPiAtCQkJCXNwaW5fbG9jaygmYWlscC0+eGFfbG9jayk7Cj4gKwkJCQlzcGlu X2xvY2soJmFpbHAtPmFpbF9sb2NrKTsKPiAgCQkJCWJyZWFrOwo+ICAJCQl9Cj4gIAkJfQo+IEBA IC0zNTgwLDcgKzM1ODAsNyBAQCB4bG9nX3JlY292ZXJfcnVkX3Bhc3MyKAo+ICAJfQo+ICAKPiAg CXhmc190cmFuc19haWxfY3Vyc29yX2RvbmUoJmN1cik7Cj4gLQlzcGluX3VubG9jaygmYWlscC0+ eGFfbG9jayk7Cj4gKwlzcGluX3VubG9jaygmYWlscC0+YWlsX2xvY2spOwo+ICAKPiAgCXJldHVy biAwOwo+ICB9Cj4gQEAgLTM2MzYsNyArMzYzNiw3IEBAIHhsb2dfcmVjb3Zlcl9jdWlfcGFzczIo Cj4gIAl9Cj4gIAlhdG9taWNfc2V0KCZjdWlwLT5jdWlfbmV4dF9leHRlbnQsIGN1aV9mb3JtYXRw LT5jdWlfbmV4dGVudHMpOwo+ICAKPiAtCXNwaW5fbG9jaygmbG9nLT5sX2FpbHAtPnhhX2xvY2sp Owo+ICsJc3Bpbl9sb2NrKCZsb2ctPmxfYWlscC0+YWlsX2xvY2spOwo+ICAJLyoKPiAgCSAqIFRo ZSBDVUkgaGFzIHR3byByZWZlcmVuY2VzLiBPbmUgZm9yIHRoZSBDVUQgYW5kIG9uZSBmb3IgQ1VJ IHRvIGVuc3VyZQo+ICAJICogaXQgbWFrZXMgaXQgaW50byB0aGUgQUlMLiBJbnNlcnQgdGhlIENV SSBpbnRvIHRoZSBBSUwgZGlyZWN0bHkgYW5kCj4gQEAgLTM2NzcsNyArMzY3Nyw3IEBAIHhsb2df cmVjb3Zlcl9jdWRfcGFzczIoCj4gIAkgKiBTZWFyY2ggZm9yIHRoZSBDVUkgd2l0aCB0aGUgaWQg aW4gdGhlIENVRCBmb3JtYXQgc3RydWN0dXJlIGluIHRoZQo+ICAJICogQUlMLgo+ICAJICovCj4g LQlzcGluX2xvY2soJmFpbHAtPnhhX2xvY2spOwo+ICsJc3Bpbl9sb2NrKCZhaWxwLT5haWxfbG9j ayk7Cj4gIAlsaXAgPSB4ZnNfdHJhbnNfYWlsX2N1cnNvcl9maXJzdChhaWxwLCAmY3VyLCAwKTsK PiAgCXdoaWxlIChsaXAgIT0gTlVMTCkgewo+ICAJCWlmIChsaXAtPmxpX3R5cGUgPT0gWEZTX0xJ X0NVSSkgewo+IEBAIC0zNjg3LDkgKzM2ODcsOSBAQCB4bG9nX3JlY292ZXJfY3VkX3Bhc3MyKAo+ ICAJCQkJICogRHJvcCB0aGUgQ1VEIHJlZmVyZW5jZSB0byB0aGUgQ1VJLiBUaGlzCj4gIAkJCQkg KiByZW1vdmVzIHRoZSBDVUkgZnJvbSB0aGUgQUlMIGFuZCBmcmVlcyBpdC4KPiAgCQkJCSAqLwo+ IC0JCQkJc3Bpbl91bmxvY2soJmFpbHAtPnhhX2xvY2spOwo+ICsJCQkJc3Bpbl91bmxvY2soJmFp bHAtPmFpbF9sb2NrKTsKPiAgCQkJCXhmc19jdWlfcmVsZWFzZShjdWlwKTsKPiAtCQkJCXNwaW5f bG9jaygmYWlscC0+eGFfbG9jayk7Cj4gKwkJCQlzcGluX2xvY2soJmFpbHAtPmFpbF9sb2NrKTsK PiAgCQkJCWJyZWFrOwo+ICAJCQl9Cj4gIAkJfQo+IEBAIC0zNjk3LDcgKzM2OTcsNyBAQCB4bG9n X3JlY292ZXJfY3VkX3Bhc3MyKAo+ICAJfQo+ICAKPiAgCXhmc190cmFuc19haWxfY3Vyc29yX2Rv bmUoJmN1cik7Cj4gLQlzcGluX3VubG9jaygmYWlscC0+eGFfbG9jayk7Cj4gKwlzcGluX3VubG9j aygmYWlscC0+YWlsX2xvY2spOwo+ICAKPiAgCXJldHVybiAwOwo+ICB9Cj4gQEAgLTM3NTUsNyAr Mzc1NSw3IEBAIHhsb2dfcmVjb3Zlcl9idWlfcGFzczIoCj4gIAl9Cj4gIAlhdG9taWNfc2V0KCZi dWlwLT5idWlfbmV4dF9leHRlbnQsIGJ1aV9mb3JtYXRwLT5idWlfbmV4dGVudHMpOwo+ICAKPiAt CXNwaW5fbG9jaygmbG9nLT5sX2FpbHAtPnhhX2xvY2spOwo+ICsJc3Bpbl9sb2NrKCZsb2ctPmxf YWlscC0+YWlsX2xvY2spOwo+ICAJLyoKPiAgCSAqIFRoZSBSVUkgaGFzIHR3byByZWZlcmVuY2Vz LiBPbmUgZm9yIHRoZSBSVUQgYW5kIG9uZSBmb3IgUlVJIHRvIGVuc3VyZQo+ICAJICogaXQgbWFr ZXMgaXQgaW50byB0aGUgQUlMLiBJbnNlcnQgdGhlIFJVSSBpbnRvIHRoZSBBSUwgZGlyZWN0bHkg YW5kCj4gQEAgLTM3OTYsNyArMzc5Niw3IEBAIHhsb2dfcmVjb3Zlcl9idWRfcGFzczIoCj4gIAkg KiBTZWFyY2ggZm9yIHRoZSBCVUkgd2l0aCB0aGUgaWQgaW4gdGhlIEJVRCBmb3JtYXQgc3RydWN0 dXJlIGluIHRoZQo+ICAJICogQUlMLgo+ICAJICovCj4gLQlzcGluX2xvY2soJmFpbHAtPnhhX2xv Y2spOwo+ICsJc3Bpbl9sb2NrKCZhaWxwLT5haWxfbG9jayk7Cj4gIAlsaXAgPSB4ZnNfdHJhbnNf YWlsX2N1cnNvcl9maXJzdChhaWxwLCAmY3VyLCAwKTsKPiAgCXdoaWxlIChsaXAgIT0gTlVMTCkg ewo+ICAJCWlmIChsaXAtPmxpX3R5cGUgPT0gWEZTX0xJX0JVSSkgewo+IEBAIC0zODA2LDkgKzM4 MDYsOSBAQCB4bG9nX3JlY292ZXJfYnVkX3Bhc3MyKAo+ICAJCQkJICogRHJvcCB0aGUgQlVEIHJl ZmVyZW5jZSB0byB0aGUgQlVJLiBUaGlzCj4gIAkJCQkgKiByZW1vdmVzIHRoZSBCVUkgZnJvbSB0 aGUgQUlMIGFuZCBmcmVlcyBpdC4KPiAgCQkJCSAqLwo+IC0JCQkJc3Bpbl91bmxvY2soJmFpbHAt PnhhX2xvY2spOwo+ICsJCQkJc3Bpbl91bmxvY2soJmFpbHAtPmFpbF9sb2NrKTsKPiAgCQkJCXhm c19idWlfcmVsZWFzZShidWlwKTsKPiAtCQkJCXNwaW5fbG9jaygmYWlscC0+eGFfbG9jayk7Cj4g KwkJCQlzcGluX2xvY2soJmFpbHAtPmFpbF9sb2NrKTsKPiAgCQkJCWJyZWFrOwo+ICAJCQl9Cj4g IAkJfQo+IEBAIC0zODE2LDcgKzM4MTYsNyBAQCB4bG9nX3JlY292ZXJfYnVkX3Bhc3MyKAo+ICAJ fQo+ICAKPiAgCXhmc190cmFuc19haWxfY3Vyc29yX2RvbmUoJmN1cik7Cj4gLQlzcGluX3VubG9j aygmYWlscC0+eGFfbG9jayk7Cj4gKwlzcGluX3VubG9jaygmYWlscC0+YWlsX2xvY2spOwo+ICAK PiAgCXJldHVybiAwOwo+ICB9Cj4gQEAgLTQ2NDksOSArNDY0OSw5IEBAIHhsb2dfcmVjb3Zlcl9w cm9jZXNzX2VmaSgKPiAgCWlmICh0ZXN0X2JpdChYRlNfRUZJX1JFQ09WRVJFRCwgJmVmaXAtPmVm aV9mbGFncykpCj4gIAkJcmV0dXJuIDA7Cj4gIAo+IC0Jc3Bpbl91bmxvY2soJmFpbHAtPnhhX2xv Y2spOwo+ICsJc3Bpbl91bmxvY2soJmFpbHAtPmFpbF9sb2NrKTsKPiAgCWVycm9yID0geGZzX2Vm aV9yZWNvdmVyKG1wLCBlZmlwKTsKPiAtCXNwaW5fbG9jaygmYWlscC0+eGFfbG9jayk7Cj4gKwlz cGluX2xvY2soJmFpbHAtPmFpbF9sb2NrKTsKPiAgCj4gIAlyZXR1cm4gZXJyb3I7Cj4gIH0KPiBA QCAtNDY2Nyw5ICs0NjY3LDkgQEAgeGxvZ19yZWNvdmVyX2NhbmNlbF9lZmkoCj4gIAo+ICAJZWZp cCA9IGNvbnRhaW5lcl9vZihsaXAsIHN0cnVjdCB4ZnNfZWZpX2xvZ19pdGVtLCBlZmlfaXRlbSk7 Cj4gIAo+IC0Jc3Bpbl91bmxvY2soJmFpbHAtPnhhX2xvY2spOwo+ICsJc3Bpbl91bmxvY2soJmFp bHAtPmFpbF9sb2NrKTsKPiAgCXhmc19lZmlfcmVsZWFzZShlZmlwKTsKPiAtCXNwaW5fbG9jaygm YWlscC0+eGFfbG9jayk7Cj4gKwlzcGluX2xvY2soJmFpbHAtPmFpbF9sb2NrKTsKPiAgfQo+ICAK PiAgLyogUmVjb3ZlciB0aGUgUlVJIGlmIG5lY2Vzc2FyeS4gKi8KPiBAQCAtNDY4OSw5ICs0Njg5 LDkgQEAgeGxvZ19yZWNvdmVyX3Byb2Nlc3NfcnVpKAo+ICAJaWYgKHRlc3RfYml0KFhGU19SVUlf UkVDT1ZFUkVELCAmcnVpcC0+cnVpX2ZsYWdzKSkKPiAgCQlyZXR1cm4gMDsKPiAgCj4gLQlzcGlu X3VubG9jaygmYWlscC0+eGFfbG9jayk7Cj4gKwlzcGluX3VubG9jaygmYWlscC0+YWlsX2xvY2sp Owo+ICAJZXJyb3IgPSB4ZnNfcnVpX3JlY292ZXIobXAsIHJ1aXApOwo+IC0Jc3Bpbl9sb2NrKCZh aWxwLT54YV9sb2NrKTsKPiArCXNwaW5fbG9jaygmYWlscC0+YWlsX2xvY2spOwo+ICAKPiAgCXJl dHVybiBlcnJvcjsKPiAgfQo+IEBAIC00NzA3LDkgKzQ3MDcsOSBAQCB4bG9nX3JlY292ZXJfY2Fu Y2VsX3J1aSgKPiAgCj4gIAlydWlwID0gY29udGFpbmVyX29mKGxpcCwgc3RydWN0IHhmc19ydWlf bG9nX2l0ZW0sIHJ1aV9pdGVtKTsKPiAgCj4gLQlzcGluX3VubG9jaygmYWlscC0+eGFfbG9jayk7 Cj4gKwlzcGluX3VubG9jaygmYWlscC0+YWlsX2xvY2spOwo+ICAJeGZzX3J1aV9yZWxlYXNlKHJ1 aXApOwo+IC0Jc3Bpbl9sb2NrKCZhaWxwLT54YV9sb2NrKTsKPiArCXNwaW5fbG9jaygmYWlscC0+ YWlsX2xvY2spOwo+ICB9Cj4gIAo+ICAvKiBSZWNvdmVyIHRoZSBDVUkgaWYgbmVjZXNzYXJ5LiAq Lwo+IEBAIC00NzMwLDkgKzQ3MzAsOSBAQCB4bG9nX3JlY292ZXJfcHJvY2Vzc19jdWkoCj4gIAlp ZiAodGVzdF9iaXQoWEZTX0NVSV9SRUNPVkVSRUQsICZjdWlwLT5jdWlfZmxhZ3MpKQo+ICAJCXJl dHVybiAwOwo+ICAKPiAtCXNwaW5fdW5sb2NrKCZhaWxwLT54YV9sb2NrKTsKPiArCXNwaW5fdW5s b2NrKCZhaWxwLT5haWxfbG9jayk7Cj4gIAllcnJvciA9IHhmc19jdWlfcmVjb3ZlcihtcCwgY3Vp cCwgZGZvcHMpOwo+IC0Jc3Bpbl9sb2NrKCZhaWxwLT54YV9sb2NrKTsKPiArCXNwaW5fbG9jaygm YWlscC0+YWlsX2xvY2spOwo+ICAKPiAgCXJldHVybiBlcnJvcjsKPiAgfQo+IEBAIC00NzQ4LDkg KzQ3NDgsOSBAQCB4bG9nX3JlY292ZXJfY2FuY2VsX2N1aSgKPiAgCj4gIAljdWlwID0gY29udGFp bmVyX29mKGxpcCwgc3RydWN0IHhmc19jdWlfbG9nX2l0ZW0sIGN1aV9pdGVtKTsKPiAgCj4gLQlz cGluX3VubG9jaygmYWlscC0+eGFfbG9jayk7Cj4gKwlzcGluX3VubG9jaygmYWlscC0+YWlsX2xv Y2spOwo+ICAJeGZzX2N1aV9yZWxlYXNlKGN1aXApOwo+IC0Jc3Bpbl9sb2NrKCZhaWxwLT54YV9s b2NrKTsKPiArCXNwaW5fbG9jaygmYWlscC0+YWlsX2xvY2spOwo+ICB9Cj4gIAo+ICAvKiBSZWNv dmVyIHRoZSBCVUkgaWYgbmVjZXNzYXJ5LiAqLwo+IEBAIC00NzcxLDkgKzQ3NzEsOSBAQCB4bG9n X3JlY292ZXJfcHJvY2Vzc19idWkoCj4gIAlpZiAodGVzdF9iaXQoWEZTX0JVSV9SRUNPVkVSRUQs ICZidWlwLT5idWlfZmxhZ3MpKQo+ICAJCXJldHVybiAwOwo+ICAKPiAtCXNwaW5fdW5sb2NrKCZh aWxwLT54YV9sb2NrKTsKPiArCXNwaW5fdW5sb2NrKCZhaWxwLT5haWxfbG9jayk7Cj4gIAllcnJv ciA9IHhmc19idWlfcmVjb3ZlcihtcCwgYnVpcCwgZGZvcHMpOwo+IC0Jc3Bpbl9sb2NrKCZhaWxw LT54YV9sb2NrKTsKPiArCXNwaW5fbG9jaygmYWlscC0+YWlsX2xvY2spOwo+ICAKPiAgCXJldHVy biBlcnJvcjsKPiAgfQo+IEBAIC00Nzg5LDkgKzQ3ODksOSBAQCB4bG9nX3JlY292ZXJfY2FuY2Vs X2J1aSgKPiAgCj4gIAlidWlwID0gY29udGFpbmVyX29mKGxpcCwgc3RydWN0IHhmc19idWlfbG9n X2l0ZW0sIGJ1aV9pdGVtKTsKPiAgCj4gLQlzcGluX3VubG9jaygmYWlscC0+eGFfbG9jayk7Cj4g KwlzcGluX3VubG9jaygmYWlscC0+YWlsX2xvY2spOwo+ICAJeGZzX2J1aV9yZWxlYXNlKGJ1aXAp Owo+IC0Jc3Bpbl9sb2NrKCZhaWxwLT54YV9sb2NrKTsKPiArCXNwaW5fbG9jaygmYWlscC0+YWls X2xvY2spOwo+ICB9Cj4gIAo+ICAvKiBJcyB0aGlzIGxvZyBpdGVtIGEgZGVmZXJyZWQgYWN0aW9u IGludGVudD8gKi8KPiBAQCAtNDg3OSw3ICs0ODc5LDcgQEAgeGxvZ19yZWNvdmVyX3Byb2Nlc3Nf aW50ZW50cygKPiAgI2VuZGlmCj4gIAo+ICAJYWlscCA9IGxvZy0+bF9haWxwOwo+IC0Jc3Bpbl9s b2NrKCZhaWxwLT54YV9sb2NrKTsKPiArCXNwaW5fbG9jaygmYWlscC0+YWlsX2xvY2spOwo+ICAJ bGlwID0geGZzX3RyYW5zX2FpbF9jdXJzb3JfZmlyc3QoYWlscCwgJmN1ciwgMCk7Cj4gICNpZiBk ZWZpbmVkKERFQlVHKSB8fCBkZWZpbmVkKFhGU19XQVJOKQo+ICAJbGFzdF9sc24gPSB4bG9nX2Fz c2lnbl9sc24obG9nLT5sX2N1cnJfY3ljbGUsIGxvZy0+bF9jdXJyX2Jsb2NrKTsKPiBAQCAtNDkz Myw3ICs0OTMzLDcgQEAgeGxvZ19yZWNvdmVyX3Byb2Nlc3NfaW50ZW50cygKPiAgCX0KPiAgb3V0 Ogo+ICAJeGZzX3RyYW5zX2FpbF9jdXJzb3JfZG9uZSgmY3VyKTsKPiAtCXNwaW5fdW5sb2NrKCZh aWxwLT54YV9sb2NrKTsKPiArCXNwaW5fdW5sb2NrKCZhaWxwLT5haWxfbG9jayk7Cj4gIAlpZiAo ZXJyb3IpCj4gIAkJeGZzX2RlZmVyX2NhbmNlbCgmZGZvcHMpOwo+ICAJZWxzZQo+IEBAIC00OTU2 LDcgKzQ5NTYsNyBAQCB4bG9nX3JlY292ZXJfY2FuY2VsX2ludGVudHMoCj4gIAlzdHJ1Y3QgeGZz X2FpbAkJKmFpbHA7Cj4gIAo+ICAJYWlscCA9IGxvZy0+bF9haWxwOwo+IC0Jc3Bpbl9sb2NrKCZh aWxwLT54YV9sb2NrKTsKPiArCXNwaW5fbG9jaygmYWlscC0+YWlsX2xvY2spOwo+ICAJbGlwID0g eGZzX3RyYW5zX2FpbF9jdXJzb3JfZmlyc3QoYWlscCwgJmN1ciwgMCk7Cj4gIAl3aGlsZSAobGlw ICE9IE5VTEwpIHsKPiAgCQkvKgo+IEBAIC00OTkwLDcgKzQ5OTAsNyBAQCB4bG9nX3JlY292ZXJf Y2FuY2VsX2ludGVudHMoCj4gIAl9Cj4gIAo+ICAJeGZzX3RyYW5zX2FpbF9jdXJzb3JfZG9uZSgm Y3VyKTsKPiAtCXNwaW5fdW5sb2NrKCZhaWxwLT54YV9sb2NrKTsKPiArCXNwaW5fdW5sb2NrKCZh aWxwLT5haWxfbG9jayk7Cj4gIAlyZXR1cm4gZXJyb3I7Cj4gIH0KPiAgCj4gZGlmZiAtLWdpdCBh L2ZzL3hmcy94ZnNfdHJhbnMuYyBiL2ZzL3hmcy94ZnNfdHJhbnMuYwo+IGluZGV4IGE4N2Y2NTdm NTljOS4uNzU2ZTAxOTk5YzI0IDEwMDY0NAo+IC0tLSBhL2ZzL3hmcy94ZnNfdHJhbnMuYwo+ICsr KyBiL2ZzL3hmcy94ZnNfdHJhbnMuYwo+IEBAIC03ODEsOCArNzgxLDggQEAgeGZzX2xvZ19pdGVt X2JhdGNoX2luc2VydCgKPiAgewo+ICAJaW50CWk7Cj4gIAo+IC0Jc3Bpbl9sb2NrKCZhaWxwLT54 YV9sb2NrKTsKPiAtCS8qIHhmc190cmFuc19haWxfdXBkYXRlX2J1bGsgZHJvcHMgYWlscC0+eGFf bG9jayAqLwo+ICsJc3Bpbl9sb2NrKCZhaWxwLT5haWxfbG9jayk7Cj4gKwkvKiB4ZnNfdHJhbnNf YWlsX3VwZGF0ZV9idWxrIGRyb3BzIGFpbHAtPmFpbF9sb2NrICovCj4gIAl4ZnNfdHJhbnNfYWls X3VwZGF0ZV9idWxrKGFpbHAsIGN1ciwgbG9nX2l0ZW1zLCBucl9pdGVtcywgY29tbWl0X2xzbik7 Cj4gIAo+ICAJZm9yIChpID0gMDsgaSA8IG5yX2l0ZW1zOyBpKyspIHsKPiBAQCAtODI1LDkgKzgy NSw5IEBAIHhmc190cmFuc19jb21taXR0ZWRfYnVsaygKPiAgCXN0cnVjdCB4ZnNfYWlsX2N1cnNv cgljdXI7Cj4gIAlpbnQJCQlpID0gMDsKPiAgCj4gLQlzcGluX2xvY2soJmFpbHAtPnhhX2xvY2sp Owo+ICsJc3Bpbl9sb2NrKCZhaWxwLT5haWxfbG9jayk7Cj4gIAl4ZnNfdHJhbnNfYWlsX2N1cnNv cl9sYXN0KGFpbHAsICZjdXIsIGNvbW1pdF9sc24pOwo+IC0Jc3Bpbl91bmxvY2soJmFpbHAtPnhh X2xvY2spOwo+ICsJc3Bpbl91bmxvY2soJmFpbHAtPmFpbF9sb2NrKTsKPiAgCj4gIAkvKiB1bnBp biBhbGwgdGhlIGxvZyBpdGVtcyAqLwo+ICAJZm9yIChsdiA9IGxvZ192ZWN0b3I7IGx2OyBsdiA9 IGx2LT5sdl9uZXh0ICkgewo+IEBAIC04NDcsNyArODQ3LDcgQEAgeGZzX3RyYW5zX2NvbW1pdHRl ZF9idWxrKAo+ICAJCSAqIG9iamVjdCBpbnRvIHRoZSBBSUwgYXMgd2UgYXJlIGluIGEgc2h1dGRv d24gc2l0dWF0aW9uLgo+ICAJCSAqLwo+ICAJCWlmIChhYm9ydGVkKSB7Cj4gLQkJCUFTU0VSVChY RlNfRk9SQ0VEX1NIVVRET1dOKGFpbHAtPnhhX21vdW50KSk7Cj4gKwkJCUFTU0VSVChYRlNfRk9S Q0VEX1NIVVRET1dOKGFpbHAtPmFpbF9tb3VudCkpOwo+ICAJCQlsaXAtPmxpX29wcy0+aW9wX3Vu cGluKGxpcCwgMSk7Cj4gIAkJCWNvbnRpbnVlOwo+ICAJCX0KPiBAQCAtODYxLDExICs4NjEsMTEg QEAgeGZzX3RyYW5zX2NvbW1pdHRlZF9idWxrKAo+ICAJCQkgKiBub3QgYWZmZWN0IHRoZSBBSUwg Y3Vyc29yIHRoZSBidWxrIGluc2VydCBwYXRoIGlzCj4gIAkJCSAqIHVzaW5nLgo+ICAJCQkgKi8K PiAtCQkJc3Bpbl9sb2NrKCZhaWxwLT54YV9sb2NrKTsKPiArCQkJc3Bpbl9sb2NrKCZhaWxwLT5h aWxfbG9jayk7Cj4gIAkJCWlmIChYRlNfTFNOX0NNUChpdGVtX2xzbiwgbGlwLT5saV9sc24pID4g MCkKPiAgCQkJCXhmc190cmFuc19haWxfdXBkYXRlKGFpbHAsIGxpcCwgaXRlbV9sc24pOwo+ICAJ CQllbHNlCj4gLQkJCQlzcGluX3VubG9jaygmYWlscC0+eGFfbG9jayk7Cj4gKwkJCQlzcGluX3Vu bG9jaygmYWlscC0+YWlsX2xvY2spOwo+ICAJCQlsaXAtPmxpX29wcy0+aW9wX3VucGluKGxpcCwg MCk7Cj4gIAkJCWNvbnRpbnVlOwo+ICAJCX0KPiBAQCAtODgzLDkgKzg4Myw5IEBAIHhmc190cmFu c19jb21taXR0ZWRfYnVsaygKPiAgCWlmIChpKQo+ICAJCXhmc19sb2dfaXRlbV9iYXRjaF9pbnNl cnQoYWlscCwgJmN1ciwgbG9nX2l0ZW1zLCBpLCBjb21taXRfbHNuKTsKPiAgCj4gLQlzcGluX2xv Y2soJmFpbHAtPnhhX2xvY2spOwo+ICsJc3Bpbl9sb2NrKCZhaWxwLT5haWxfbG9jayk7Cj4gIAl4 ZnNfdHJhbnNfYWlsX2N1cnNvcl9kb25lKCZjdXIpOwo+IC0Jc3Bpbl91bmxvY2soJmFpbHAtPnhh X2xvY2spOwo+ICsJc3Bpbl91bmxvY2soJmFpbHAtPmFpbF9sb2NrKTsKPiAgfQo+ICAKPiAgLyoK PiBkaWZmIC0tZ2l0IGEvZnMveGZzL3hmc190cmFuc19haWwuYyBiL2ZzL3hmcy94ZnNfdHJhbnNf YWlsLmMKPiBpbmRleCBjZWY4OWY3MTI3ZDMuLmQ0YTI0NDUyMTVlNiAxMDA2NDQKPiAtLS0gYS9m cy94ZnMveGZzX3RyYW5zX2FpbC5jCj4gKysrIGIvZnMveGZzL3hmc190cmFuc19haWwuYwo+IEBA IC00MCw3ICs0MCw3IEBAIHhmc19haWxfY2hlY2soCj4gIHsKPiAgCXhmc19sb2dfaXRlbV90CSpw cmV2X2xpcDsKPiAgCj4gLQlpZiAobGlzdF9lbXB0eSgmYWlscC0+eGFfYWlsKSkKPiArCWlmIChs aXN0X2VtcHR5KCZhaWxwLT5haWxfaGVhZCkpCj4gIAkJcmV0dXJuOwo+ICAKPiAgCS8qCj4gQEAg LTQ4LDExICs0OCwxMSBAQCB4ZnNfYWlsX2NoZWNrKAo+ICAJICovCj4gIAlBU1NFUlQoKGxpcC0+ bGlfZmxhZ3MgJiBYRlNfTElfSU5fQUlMKSAhPSAwKTsKPiAgCXByZXZfbGlwID0gbGlzdF9lbnRy eShsaXAtPmxpX2FpbC5wcmV2LCB4ZnNfbG9nX2l0ZW1fdCwgbGlfYWlsKTsKPiAtCWlmICgmcHJl dl9saXAtPmxpX2FpbCAhPSAmYWlscC0+eGFfYWlsKQo+ICsJaWYgKCZwcmV2X2xpcC0+bGlfYWls ICE9ICZhaWxwLT5haWxfaGVhZCkKPiAgCQlBU1NFUlQoWEZTX0xTTl9DTVAocHJldl9saXAtPmxp X2xzbiwgbGlwLT5saV9sc24pIDw9IDApOwo+ICAKPiAgCXByZXZfbGlwID0gbGlzdF9lbnRyeShs aXAtPmxpX2FpbC5uZXh0LCB4ZnNfbG9nX2l0ZW1fdCwgbGlfYWlsKTsKPiAtCWlmICgmcHJldl9s aXAtPmxpX2FpbCAhPSAmYWlscC0+eGFfYWlsKQo+ICsJaWYgKCZwcmV2X2xpcC0+bGlfYWlsICE9 ICZhaWxwLT5haWxfaGVhZCkKPiAgCQlBU1NFUlQoWEZTX0xTTl9DTVAocHJldl9saXAtPmxpX2xz biwgbGlwLT5saV9sc24pID49IDApOwo+ICAKPiAgCj4gQEAgLTY5LDEwICs2OSwxMCBAQCBzdGF0 aWMgeGZzX2xvZ19pdGVtX3QgKgo+ICB4ZnNfYWlsX21heCgKPiAgCXN0cnVjdCB4ZnNfYWlsICAq YWlscCkKPiAgewo+IC0JaWYgKGxpc3RfZW1wdHkoJmFpbHAtPnhhX2FpbCkpCj4gKwlpZiAobGlz dF9lbXB0eSgmYWlscC0+YWlsX2hlYWQpKQo+ICAJCXJldHVybiBOVUxMOwo+ICAKPiAtCXJldHVy biBsaXN0X2VudHJ5KGFpbHAtPnhhX2FpbC5wcmV2LCB4ZnNfbG9nX2l0ZW1fdCwgbGlfYWlsKTsK PiArCXJldHVybiBsaXN0X2VudHJ5KGFpbHAtPmFpbF9oZWFkLnByZXYsIHhmc19sb2dfaXRlbV90 LCBsaV9haWwpOwo+ICB9Cj4gIAo+ICAvKgo+IEBAIC04NCw3ICs4NCw3IEBAIHhmc19haWxfbmV4 dCgKPiAgCXN0cnVjdCB4ZnNfYWlsICAqYWlscCwKPiAgCXhmc19sb2dfaXRlbV90ICAqbGlwKQo+ ICB7Cj4gLQlpZiAobGlwLT5saV9haWwubmV4dCA9PSAmYWlscC0+eGFfYWlsKQo+ICsJaWYgKGxp cC0+bGlfYWlsLm5leHQgPT0gJmFpbHAtPmFpbF9oZWFkKQo+ICAJCXJldHVybiBOVUxMOwo+ICAK PiAgCXJldHVybiBsaXN0X2ZpcnN0X2VudHJ5KCZsaXAtPmxpX2FpbCwgeGZzX2xvZ19pdGVtX3Qs IGxpX2FpbCk7Cj4gQEAgLTEwNSwxMSArMTA1LDExIEBAIHhmc19haWxfbWluX2xzbigKPiAgCXhm c19sc25fdAlsc24gPSAwOwo+ICAJeGZzX2xvZ19pdGVtX3QJKmxpcDsKPiAgCj4gLQlzcGluX2xv Y2soJmFpbHAtPnhhX2xvY2spOwo+ICsJc3Bpbl9sb2NrKCZhaWxwLT5haWxfbG9jayk7Cj4gIAls aXAgPSB4ZnNfYWlsX21pbihhaWxwKTsKPiAgCWlmIChsaXApCj4gIAkJbHNuID0gbGlwLT5saV9s c247Cj4gLQlzcGluX3VubG9jaygmYWlscC0+eGFfbG9jayk7Cj4gKwlzcGluX3VubG9jaygmYWls cC0+YWlsX2xvY2spOwo+ICAKPiAgCXJldHVybiBsc247Cj4gIH0KPiBAQCAtMTI0LDExICsxMjQs MTEgQEAgeGZzX2FpbF9tYXhfbHNuKAo+ICAJeGZzX2xzbl90ICAgICAgIGxzbiA9IDA7Cj4gIAl4 ZnNfbG9nX2l0ZW1fdCAgKmxpcDsKPiAgCj4gLQlzcGluX2xvY2soJmFpbHAtPnhhX2xvY2spOwo+ ICsJc3Bpbl9sb2NrKCZhaWxwLT5haWxfbG9jayk7Cj4gIAlsaXAgPSB4ZnNfYWlsX21heChhaWxw KTsKPiAgCWlmIChsaXApCj4gIAkJbHNuID0gbGlwLT5saV9sc247Cj4gLQlzcGluX3VubG9jaygm YWlscC0+eGFfbG9jayk7Cj4gKwlzcGluX3VubG9jaygmYWlscC0+YWlsX2xvY2spOwo+ICAKPiAg CXJldHVybiBsc247Cj4gIH0KPiBAQCAtMTQ2LDcgKzE0Niw3IEBAIHhmc190cmFuc19haWxfY3Vy c29yX2luaXQoCj4gIAlzdHJ1Y3QgeGZzX2FpbF9jdXJzb3IJKmN1cikKPiAgewo+ICAJY3VyLT5p dGVtID0gTlVMTDsKPiAtCWxpc3RfYWRkX3RhaWwoJmN1ci0+bGlzdCwgJmFpbHAtPnhhX2N1cnNv cnMpOwo+ICsJbGlzdF9hZGRfdGFpbCgmY3VyLT5saXN0LCAmYWlscC0+YWlsX2N1cnNvcnMpOwo+ ICB9Cj4gIAo+ICAvKgo+IEBAIC0xOTQsNyArMTk0LDcgQEAgeGZzX3RyYW5zX2FpbF9jdXJzb3Jf Y2xlYXIoCj4gIHsKPiAgCXN0cnVjdCB4ZnNfYWlsX2N1cnNvcgkqY3VyOwo+ICAKPiAtCWxpc3Rf Zm9yX2VhY2hfZW50cnkoY3VyLCAmYWlscC0+eGFfY3Vyc29ycywgbGlzdCkgewo+ICsJbGlzdF9m b3JfZWFjaF9lbnRyeShjdXIsICZhaWxwLT5haWxfY3Vyc29ycywgbGlzdCkgewo+ICAJCWlmIChj dXItPml0ZW0gPT0gbGlwKQo+ICAJCQljdXItPml0ZW0gPSAoc3RydWN0IHhmc19sb2dfaXRlbSAq KQo+ICAJCQkJCSgodWludHB0cl90KWN1ci0+aXRlbSB8IDEpOwo+IEBAIC0yMjIsNyArMjIyLDcg QEAgeGZzX3RyYW5zX2FpbF9jdXJzb3JfZmlyc3QoCj4gIAkJZ290byBvdXQ7Cj4gIAl9Cj4gIAo+ IC0JbGlzdF9mb3JfZWFjaF9lbnRyeShsaXAsICZhaWxwLT54YV9haWwsIGxpX2FpbCkgewo+ICsJ bGlzdF9mb3JfZWFjaF9lbnRyeShsaXAsICZhaWxwLT5haWxfaGVhZCwgbGlfYWlsKSB7Cj4gIAkJ aWYgKFhGU19MU05fQ01QKGxpcC0+bGlfbHNuLCBsc24pID49IDApCj4gIAkJCWdvdG8gb3V0Owo+ ICAJfQo+IEBAIC0yNDEsNyArMjQxLDcgQEAgX194ZnNfdHJhbnNfYWlsX2N1cnNvcl9sYXN0KAo+ ICB7Cj4gIAl4ZnNfbG9nX2l0ZW1fdAkJKmxpcDsKPiAgCj4gLQlsaXN0X2Zvcl9lYWNoX2VudHJ5 X3JldmVyc2UobGlwLCAmYWlscC0+eGFfYWlsLCBsaV9haWwpIHsKPiArCWxpc3RfZm9yX2VhY2hf ZW50cnlfcmV2ZXJzZShsaXAsICZhaWxwLT5haWxfaGVhZCwgbGlfYWlsKSB7Cj4gIAkJaWYgKFhG U19MU05fQ01QKGxpcC0+bGlfbHNuLCBsc24pIDw9IDApCj4gIAkJCXJldHVybiBsaXA7Cj4gIAl9 Cj4gQEAgLTMxMCw3ICszMTAsNyBAQCB4ZnNfYWlsX3NwbGljZSgKPiAgCWlmIChsaXApCj4gIAkJ bGlzdF9zcGxpY2UobGlzdCwgJmxpcC0+bGlfYWlsKTsKPiAgCWVsc2UKPiAtCQlsaXN0X3NwbGlj ZShsaXN0LCAmYWlscC0+eGFfYWlsKTsKPiArCQlsaXN0X3NwbGljZShsaXN0LCAmYWlscC0+YWls X2hlYWQpOwo+ICB9Cj4gIAo+ICAvKgo+IEBAIC0zMzUsMTcgKzMzNSwxNyBAQCB4ZnNhaWxkX3B1 c2hfaXRlbSgKPiAgCSAqIElmIGxvZyBpdGVtIHBpbm5pbmcgaXMgZW5hYmxlZCwgc2tpcCB0aGUg cHVzaCBhbmQgdHJhY2sgdGhlIGl0ZW0gYXMKPiAgCSAqIHBpbm5lZC4gVGhpcyBjYW4gaGVscCBp bmR1Y2UgaGVhZC1iZWhpbmQtdGFpbCBjb25kaXRpb25zLgo+ICAJICovCj4gLQlpZiAoWEZTX1RF U1RfRVJST1IoZmFsc2UsIGFpbHAtPnhhX21vdW50LCBYRlNfRVJSVEFHX0xPR19JVEVNX1BJTikp Cj4gKwlpZiAoWEZTX1RFU1RfRVJST1IoZmFsc2UsIGFpbHAtPmFpbF9tb3VudCwgWEZTX0VSUlRB R19MT0dfSVRFTV9QSU4pKQo+ICAJCXJldHVybiBYRlNfSVRFTV9QSU5ORUQ7Cj4gIAo+IC0JcmV0 dXJuIGxpcC0+bGlfb3BzLT5pb3BfcHVzaChsaXAsICZhaWxwLT54YV9idWZfbGlzdCk7Cj4gKwly ZXR1cm4gbGlwLT5saV9vcHMtPmlvcF9wdXNoKGxpcCwgJmFpbHAtPmFpbF9idWZfbGlzdCk7Cj4g IH0KPiAgCj4gIHN0YXRpYyBsb25nCj4gIHhmc2FpbGRfcHVzaCgKPiAgCXN0cnVjdCB4ZnNfYWls CQkqYWlscCkKPiAgewo+IC0JeGZzX21vdW50X3QJCSptcCA9IGFpbHAtPnhhX21vdW50Owo+ICsJ eGZzX21vdW50X3QJCSptcCA9IGFpbHAtPmFpbF9tb3VudDsKPiAgCXN0cnVjdCB4ZnNfYWlsX2N1 cnNvcgljdXI7Cj4gIAl4ZnNfbG9nX2l0ZW1fdAkJKmxpcDsKPiAgCXhmc19sc25fdAkJbHNuOwo+ IEBAIC0zNjAsMzAgKzM2MCwzMCBAQCB4ZnNhaWxkX3B1c2goCj4gIAkgKiBidWZmZXJzIHRoZSBs YXN0IHRpbWUgd2UgcmFuLCBmb3JjZSB0aGUgbG9nIGZpcnN0IGFuZCB3YWl0IGZvciBpdAo+ICAJ ICogYmVmb3JlIHB1c2hpbmcgYWdhaW4uCj4gIAkgKi8KPiAtCWlmIChhaWxwLT54YV9sb2dfZmx1 c2ggJiYgYWlscC0+eGFfbGFzdF9wdXNoZWRfbHNuID09IDAgJiYKPiAtCSAgICAoIWxpc3RfZW1w dHlfY2FyZWZ1bCgmYWlscC0+eGFfYnVmX2xpc3QpIHx8Cj4gKwlpZiAoYWlscC0+YWlsX2xvZ19m bHVzaCAmJiBhaWxwLT5haWxfbGFzdF9wdXNoZWRfbHNuID09IDAgJiYKPiArCSAgICAoIWxpc3Rf ZW1wdHlfY2FyZWZ1bCgmYWlscC0+YWlsX2J1Zl9saXN0KSB8fAo+ICAJICAgICB4ZnNfYWlsX21p bl9sc24oYWlscCkpKSB7Cj4gLQkJYWlscC0+eGFfbG9nX2ZsdXNoID0gMDsKPiArCQlhaWxwLT5h aWxfbG9nX2ZsdXNoID0gMDsKPiAgCj4gIAkJWEZTX1NUQVRTX0lOQyhtcCwgeHNfcHVzaF9haWxf Zmx1c2gpOwo+ICAJCXhmc19sb2dfZm9yY2UobXAsIFhGU19MT0dfU1lOQyk7Cj4gIAl9Cj4gIAo+ IC0Jc3Bpbl9sb2NrKCZhaWxwLT54YV9sb2NrKTsKPiArCXNwaW5fbG9jaygmYWlscC0+YWlsX2xv Y2spOwo+ICAKPiAtCS8qIGJhcnJpZXIgbWF0Y2hlcyB0aGUgeGFfdGFyZ2V0IHVwZGF0ZSBpbiB4 ZnNfYWlsX3B1c2goKSAqLwo+ICsJLyogYmFycmllciBtYXRjaGVzIHRoZSBhaWxfdGFyZ2V0IHVw ZGF0ZSBpbiB4ZnNfYWlsX3B1c2goKSAqLwo+ICAJc21wX3JtYigpOwo+IC0JdGFyZ2V0ID0gYWls cC0+eGFfdGFyZ2V0Owo+IC0JYWlscC0+eGFfdGFyZ2V0X3ByZXYgPSB0YXJnZXQ7Cj4gKwl0YXJn ZXQgPSBhaWxwLT5haWxfdGFyZ2V0Owo+ICsJYWlscC0+YWlsX3RhcmdldF9wcmV2ID0gdGFyZ2V0 Owo+ICAKPiAtCWxpcCA9IHhmc190cmFuc19haWxfY3Vyc29yX2ZpcnN0KGFpbHAsICZjdXIsIGFp bHAtPnhhX2xhc3RfcHVzaGVkX2xzbik7Cj4gKwlsaXAgPSB4ZnNfdHJhbnNfYWlsX2N1cnNvcl9m aXJzdChhaWxwLCAmY3VyLCBhaWxwLT5haWxfbGFzdF9wdXNoZWRfbHNuKTsKPiAgCWlmICghbGlw KSB7Cj4gIAkJLyoKPiAgCQkgKiBJZiB0aGUgQUlMIGlzIGVtcHR5IG9yIG91ciBwdXNoIGhhcyBy ZWFjaGVkIHRoZSBlbmQgd2UgYXJlCj4gIAkJICogZG9uZSBub3cuCj4gIAkJICovCj4gIAkJeGZz X3RyYW5zX2FpbF9jdXJzb3JfZG9uZSgmY3VyKTsKPiAtCQlzcGluX3VubG9jaygmYWlscC0+eGFf bG9jayk7Cj4gKwkJc3Bpbl91bmxvY2soJmFpbHAtPmFpbF9sb2NrKTsKPiAgCQlnb3RvIG91dF9k b25lOwo+ICAJfQo+ICAKPiBAQCAtNDA0LDcgKzQwNCw3IEBAIHhmc2FpbGRfcHVzaCgKPiAgCQkJ WEZTX1NUQVRTX0lOQyhtcCwgeHNfcHVzaF9haWxfc3VjY2Vzcyk7Cj4gIAkJCXRyYWNlX3hmc19h aWxfcHVzaChsaXApOwo+ICAKPiAtCQkJYWlscC0+eGFfbGFzdF9wdXNoZWRfbHNuID0gbHNuOwo+ ICsJCQlhaWxwLT5haWxfbGFzdF9wdXNoZWRfbHNuID0gbHNuOwo+ICAJCQlicmVhazsKPiAgCj4g IAkJY2FzZSBYRlNfSVRFTV9GTFVTSElORzoKPiBAQCAtNDIzLDcgKzQyMyw3IEBAIHhmc2FpbGRf cHVzaCgKPiAgCQkJdHJhY2VfeGZzX2FpbF9mbHVzaGluZyhsaXApOwo+ICAKPiAgCQkJZmx1c2hp bmcrKzsKPiAtCQkJYWlscC0+eGFfbGFzdF9wdXNoZWRfbHNuID0gbHNuOwo+ICsJCQlhaWxwLT5h aWxfbGFzdF9wdXNoZWRfbHNuID0gbHNuOwo+ICAJCQlicmVhazsKPiAgCj4gIAkJY2FzZSBYRlNf SVRFTV9QSU5ORUQ6Cj4gQEAgLTQzMSw3ICs0MzEsNyBAQCB4ZnNhaWxkX3B1c2goCj4gIAkJCXRy YWNlX3hmc19haWxfcGlubmVkKGxpcCk7Cj4gIAo+ICAJCQlzdHVjaysrOwo+IC0JCQlhaWxwLT54 YV9sb2dfZmx1c2grKzsKPiArCQkJYWlscC0+YWlsX2xvZ19mbHVzaCsrOwo+ICAJCQlicmVhazsK PiAgCQljYXNlIFhGU19JVEVNX0xPQ0tFRDoKPiAgCQkJWEZTX1NUQVRTX0lOQyhtcCwgeHNfcHVz aF9haWxfbG9ja2VkKTsKPiBAQCAtNDY4LDEwICs0NjgsMTAgQEAgeGZzYWlsZF9wdXNoKAo+ICAJ CWxzbiA9IGxpcC0+bGlfbHNuOwo+ICAJfQo+ICAJeGZzX3RyYW5zX2FpbF9jdXJzb3JfZG9uZSgm Y3VyKTsKPiAtCXNwaW5fdW5sb2NrKCZhaWxwLT54YV9sb2NrKTsKPiArCXNwaW5fdW5sb2NrKCZh aWxwLT5haWxfbG9jayk7Cj4gIAo+IC0JaWYgKHhmc19idWZfZGVsd3JpX3N1Ym1pdF9ub3dhaXQo JmFpbHAtPnhhX2J1Zl9saXN0KSkKPiAtCQlhaWxwLT54YV9sb2dfZmx1c2grKzsKPiArCWlmICh4 ZnNfYnVmX2RlbHdyaV9zdWJtaXRfbm93YWl0KCZhaWxwLT5haWxfYnVmX2xpc3QpKQo+ICsJCWFp bHAtPmFpbF9sb2dfZmx1c2grKzsKPiAgCj4gIAlpZiAoIWNvdW50IHx8IFhGU19MU05fQ01QKGxz biwgdGFyZ2V0KSA+PSAwKSB7Cj4gIG91dF9kb25lOgo+IEBAIC00ODEsNyArNDgxLDcgQEAgeGZz YWlsZF9wdXNoKAo+ICAJCSAqIEFJTCBiZWZvcmUgd2Ugc3RhcnQgdGhlIG5leHQgc2NhbiBmcm9t IHRoZSBzdGFydCBvZiB0aGUgQUlMLgo+ICAJCSAqLwo+ICAJCXRvdXQgPSA1MDsKPiAtCQlhaWxw LT54YV9sYXN0X3B1c2hlZF9sc24gPSAwOwo+ICsJCWFpbHAtPmFpbF9sYXN0X3B1c2hlZF9sc24g PSAwOwo+ICAJfSBlbHNlIGlmICgoKHN0dWNrICsgZmx1c2hpbmcpICogMTAwKSAvIGNvdW50ID4g OTApIHsKPiAgCQkvKgo+ICAJCSAqIEVpdGhlciB0aGVyZSBpcyBhIGxvdCBvZiBjb250ZW50aW9u IG9uIHRoZSBBSUwgb3Igd2UgYXJlCj4gQEAgLTQ5NCw3ICs0OTQsNyBAQCB4ZnNhaWxkX3B1c2go Cj4gIAkJICogdGhlIHJlc3RhcnQgdG8gaXNzdWUgYSBsb2cgZm9yY2UgdG8gdW5waW4gdGhlIHN0 dWNrIGl0ZW1zLgo+ICAJCSAqLwo+ICAJCXRvdXQgPSAyMDsKPiAtCQlhaWxwLT54YV9sYXN0X3B1 c2hlZF9sc24gPSAwOwo+ICsJCWFpbHAtPmFpbF9sYXN0X3B1c2hlZF9sc24gPSAwOwo+ICAJfSBl bHNlIHsKPiAgCQkvKgo+ICAJCSAqIEFzc3VtZSB3ZSBoYXZlIG1vcmUgd29yayB0byBkbyBpbiBh IHNob3J0IHdoaWxlLgo+IEBAIC01MzYsMjYgKzUzNiwyNiBAQCB4ZnNhaWxkKAo+ICAJCQlicmVh azsKPiAgCQl9Cj4gIAo+IC0JCXNwaW5fbG9jaygmYWlscC0+eGFfbG9jayk7Cj4gKwkJc3Bpbl9s b2NrKCZhaWxwLT5haWxfbG9jayk7Cj4gIAo+ICAJCS8qCj4gIAkJICogSWRsZSBpZiB0aGUgQUlM IGlzIGVtcHR5IGFuZCB3ZSBhcmUgbm90IHJhY2luZyB3aXRoIGEgdGFyZ2V0Cj4gIAkJICogdXBk YXRlLiBXZSBjaGVjayB0aGUgQUlMIGFmdGVyIHdlIHNldCB0aGUgdGFzayB0byBhIHNsZWVwCj4g LQkJICogc3RhdGUgdG8gZ3VhcmFudGVlIHRoYXQgd2UgZWl0aGVyIGNhdGNoIGFuIHhhX3Rhcmdl dCB1cGRhdGUKPiArCQkgKiBzdGF0ZSB0byBndWFyYW50ZWUgdGhhdCB3ZSBlaXRoZXIgY2F0Y2gg YW4gYWlsX3RhcmdldCB1cGRhdGUKPiAgCQkgKiBvciB0aGF0IGEgd2FrZV91cCByZXNldHMgdGhl IHN0YXRlIHRvIFRBU0tfUlVOTklORy4KPiAgCQkgKiBPdGhlcndpc2UsIHdlIHJ1biB0aGUgcmlz ayBvZiBzbGVlcGluZyBpbmRlZmluaXRlbHkuCj4gIAkJICoKPiAtCQkgKiBUaGUgYmFycmllciBt YXRjaGVzIHRoZSB4YV90YXJnZXQgdXBkYXRlIGluIHhmc19haWxfcHVzaCgpLgo+ICsJCSAqIFRo ZSBiYXJyaWVyIG1hdGNoZXMgdGhlIGFpbF90YXJnZXQgdXBkYXRlIGluIHhmc19haWxfcHVzaCgp Lgo+ICAJCSAqLwo+ICAJCXNtcF9ybWIoKTsKPiAgCQlpZiAoIXhmc19haWxfbWluKGFpbHApICYm Cj4gLQkJICAgIGFpbHAtPnhhX3RhcmdldCA9PSBhaWxwLT54YV90YXJnZXRfcHJldikgewo+IC0J CQlzcGluX3VubG9jaygmYWlscC0+eGFfbG9jayk7Cj4gKwkJICAgIGFpbHAtPmFpbF90YXJnZXQg PT0gYWlscC0+YWlsX3RhcmdldF9wcmV2KSB7Cj4gKwkJCXNwaW5fdW5sb2NrKCZhaWxwLT5haWxf bG9jayk7Cj4gIAkJCWZyZWV6YWJsZV9zY2hlZHVsZSgpOwo+ICAJCQl0b3V0ID0gMDsKPiAgCQkJ Y29udGludWU7Cj4gIAkJfQo+IC0JCXNwaW5fdW5sb2NrKCZhaWxwLT54YV9sb2NrKTsKPiArCQlz cGluX3VubG9jaygmYWlscC0+YWlsX2xvY2spOwo+ICAKPiAgCQlpZiAodG91dCkKPiAgCQkJZnJl ZXphYmxlX3NjaGVkdWxlX3RpbWVvdXQobXNlY3NfdG9famlmZmllcyh0b3V0KSk7Cj4gQEAgLTU5 Miw4ICs1OTIsOCBAQCB4ZnNfYWlsX3B1c2goCj4gIAl4ZnNfbG9nX2l0ZW1fdAkqbGlwOwo+ICAK PiAgCWxpcCA9IHhmc19haWxfbWluKGFpbHApOwo+IC0JaWYgKCFsaXAgfHwgWEZTX0ZPUkNFRF9T SFVURE9XTihhaWxwLT54YV9tb3VudCkgfHwKPiAtCSAgICBYRlNfTFNOX0NNUCh0aHJlc2hvbGRf bHNuLCBhaWxwLT54YV90YXJnZXQpIDw9IDApCj4gKwlpZiAoIWxpcCB8fCBYRlNfRk9SQ0VEX1NI VVRET1dOKGFpbHAtPmFpbF9tb3VudCkgfHwKPiArCSAgICBYRlNfTFNOX0NNUCh0aHJlc2hvbGRf bHNuLCBhaWxwLT5haWxfdGFyZ2V0KSA8PSAwKQo+ICAJCXJldHVybjsKPiAgCj4gIAkvKgo+IEBA IC02MDEsMTAgKzYwMSwxMCBAQCB4ZnNfYWlsX3B1c2goCj4gIAkgKiB0aGUgWEZTX0FJTF9QVVNI SU5HX0JJVC4KPiAgCSAqLwo+ICAJc21wX3dtYigpOwo+IC0JeGZzX3RyYW5zX2FpbF9jb3B5X2xz bihhaWxwLCAmYWlscC0+eGFfdGFyZ2V0LCAmdGhyZXNob2xkX2xzbik7Cj4gKwl4ZnNfdHJhbnNf YWlsX2NvcHlfbHNuKGFpbHAsICZhaWxwLT5haWxfdGFyZ2V0LCAmdGhyZXNob2xkX2xzbik7Cj4g IAlzbXBfd21iKCk7Cj4gIAo+IC0Jd2FrZV91cF9wcm9jZXNzKGFpbHAtPnhhX3Rhc2spOwo+ICsJ d2FrZV91cF9wcm9jZXNzKGFpbHAtPmFpbF90YXNrKTsKPiAgfQo+ICAKPiAgLyoKPiBAQCAtNjMw LDE4ICs2MzAsMTggQEAgeGZzX2FpbF9wdXNoX2FsbF9zeW5jKAo+ICAJc3RydWN0IHhmc19sb2df aXRlbQkqbGlwOwo+ICAJREVGSU5FX1dBSVQod2FpdCk7Cj4gIAo+IC0Jc3Bpbl9sb2NrKCZhaWxw LT54YV9sb2NrKTsKPiArCXNwaW5fbG9jaygmYWlscC0+YWlsX2xvY2spOwo+ICAJd2hpbGUgKChs aXAgPSB4ZnNfYWlsX21heChhaWxwKSkgIT0gTlVMTCkgewo+IC0JCXByZXBhcmVfdG9fd2FpdCgm YWlscC0+eGFfZW1wdHksICZ3YWl0LCBUQVNLX1VOSU5URVJSVVBUSUJMRSk7Cj4gLQkJYWlscC0+ eGFfdGFyZ2V0ID0gbGlwLT5saV9sc247Cj4gLQkJd2FrZV91cF9wcm9jZXNzKGFpbHAtPnhhX3Rh c2spOwo+IC0JCXNwaW5fdW5sb2NrKCZhaWxwLT54YV9sb2NrKTsKPiArCQlwcmVwYXJlX3RvX3dh aXQoJmFpbHAtPmFpbF9lbXB0eSwgJndhaXQsIFRBU0tfVU5JTlRFUlJVUFRJQkxFKTsKPiArCQlh aWxwLT5haWxfdGFyZ2V0ID0gbGlwLT5saV9sc247Cj4gKwkJd2FrZV91cF9wcm9jZXNzKGFpbHAt PmFpbF90YXNrKTsKPiArCQlzcGluX3VubG9jaygmYWlscC0+YWlsX2xvY2spOwo+ICAJCXNjaGVk dWxlKCk7Cj4gLQkJc3Bpbl9sb2NrKCZhaWxwLT54YV9sb2NrKTsKPiArCQlzcGluX2xvY2soJmFp bHAtPmFpbF9sb2NrKTsKPiAgCX0KPiAtCXNwaW5fdW5sb2NrKCZhaWxwLT54YV9sb2NrKTsKPiAr CXNwaW5fdW5sb2NrKCZhaWxwLT5haWxfbG9jayk7Cj4gIAo+IC0JZmluaXNoX3dhaXQoJmFpbHAt PnhhX2VtcHR5LCAmd2FpdCk7Cj4gKwlmaW5pc2hfd2FpdCgmYWlscC0+YWlsX2VtcHR5LCAmd2Fp dCk7Cj4gIH0KPiAgCj4gIC8qCj4gQEAgLTY3Miw3ICs2NzIsNyBAQCB4ZnNfdHJhbnNfYWlsX3Vw ZGF0ZV9idWxrKAo+ICAJc3RydWN0IHhmc19haWxfY3Vyc29yCSpjdXIsCj4gIAlzdHJ1Y3QgeGZz X2xvZ19pdGVtCSoqbG9nX2l0ZW1zLAo+ICAJaW50CQkJbnJfaXRlbXMsCj4gLQl4ZnNfbHNuX3QJ CWxzbikgX19yZWxlYXNlcyhhaWxwLT54YV9sb2NrKQo+ICsJeGZzX2xzbl90CQlsc24pIF9fcmVs ZWFzZXMoYWlscC0+YWlsX2xvY2spCj4gIHsKPiAgCXhmc19sb2dfaXRlbV90CQkqbWxpcDsKPiAg CWludAkJCW1saXBfY2hhbmdlZCA9IDA7Cj4gQEAgLTcwNSwxMyArNzA1LDEzIEBAIHhmc190cmFu c19haWxfdXBkYXRlX2J1bGsoCj4gIAkJeGZzX2FpbF9zcGxpY2UoYWlscCwgY3VyLCAmdG1wLCBs c24pOwo+ICAKPiAgCWlmIChtbGlwX2NoYW5nZWQpIHsKPiAtCQlpZiAoIVhGU19GT1JDRURfU0hV VERPV04oYWlscC0+eGFfbW91bnQpKQo+IC0JCQl4bG9nX2Fzc2lnbl90YWlsX2xzbl9sb2NrZWQo YWlscC0+eGFfbW91bnQpOwo+IC0JCXNwaW5fdW5sb2NrKCZhaWxwLT54YV9sb2NrKTsKPiArCQlp ZiAoIVhGU19GT1JDRURfU0hVVERPV04oYWlscC0+YWlsX21vdW50KSkKPiArCQkJeGxvZ19hc3Np Z25fdGFpbF9sc25fbG9ja2VkKGFpbHAtPmFpbF9tb3VudCk7Cj4gKwkJc3Bpbl91bmxvY2soJmFp bHAtPmFpbF9sb2NrKTsKPiAgCj4gLQkJeGZzX2xvZ19zcGFjZV93YWtlKGFpbHAtPnhhX21vdW50 KTsKPiArCQl4ZnNfbG9nX3NwYWNlX3dha2UoYWlscC0+YWlsX21vdW50KTsKPiAgCX0gZWxzZSB7 Cj4gLQkJc3Bpbl91bmxvY2soJmFpbHAtPnhhX2xvY2spOwo+ICsJCXNwaW5fdW5sb2NrKCZhaWxw LT5haWxfbG9jayk7Cj4gIAl9Cj4gIH0KPiAgCj4gQEAgLTc1NiwxMyArNzU2LDEzIEBAIHZvaWQK PiAgeGZzX3RyYW5zX2FpbF9kZWxldGUoCj4gIAlzdHJ1Y3QgeGZzX2FpbAkJKmFpbHAsCj4gIAlz dHJ1Y3QgeGZzX2xvZ19pdGVtCSpsaXAsCj4gLQlpbnQJCQlzaHV0ZG93bl90eXBlKSBfX3JlbGVh c2VzKGFpbHAtPnhhX2xvY2spCj4gKwlpbnQJCQlzaHV0ZG93bl90eXBlKSBfX3JlbGVhc2VzKGFp bHAtPmFpbF9sb2NrKQo+ICB7Cj4gLQlzdHJ1Y3QgeGZzX21vdW50CSptcCA9IGFpbHAtPnhhX21v dW50Owo+ICsJc3RydWN0IHhmc19tb3VudAkqbXAgPSBhaWxwLT5haWxfbW91bnQ7Cj4gIAlib29s CQkJbWxpcF9jaGFuZ2VkOwo+ICAKPiAgCWlmICghKGxpcC0+bGlfZmxhZ3MgJiBYRlNfTElfSU5f QUlMKSkgewo+IC0JCXNwaW5fdW5sb2NrKCZhaWxwLT54YV9sb2NrKTsKPiArCQlzcGluX3VubG9j aygmYWlscC0+YWlsX2xvY2spOwo+ICAJCWlmICghWEZTX0ZPUkNFRF9TSFVURE9XTihtcCkpIHsK PiAgCQkJeGZzX2FsZXJ0X3RhZyhtcCwgWEZTX1BUQUdfQUlMREVMRVRFLAo+ICAJIiVzOiBhdHRl bXB0aW5nIHRvIGRlbGV0ZSBhIGxvZyBpdGVtIHRoYXQgaXMgbm90IGluIHRoZSBBSUwiLAo+IEBA IC03NzYsMTMgKzc3NiwxMyBAQCB4ZnNfdHJhbnNfYWlsX2RlbGV0ZSgKPiAgCWlmIChtbGlwX2No YW5nZWQpIHsKPiAgCQlpZiAoIVhGU19GT1JDRURfU0hVVERPV04obXApKQo+ICAJCQl4bG9nX2Fz c2lnbl90YWlsX2xzbl9sb2NrZWQobXApOwo+IC0JCWlmIChsaXN0X2VtcHR5KCZhaWxwLT54YV9h aWwpKQo+IC0JCQl3YWtlX3VwX2FsbCgmYWlscC0+eGFfZW1wdHkpOwo+ICsJCWlmIChsaXN0X2Vt cHR5KCZhaWxwLT5haWxfaGVhZCkpCj4gKwkJCXdha2VfdXBfYWxsKCZhaWxwLT5haWxfZW1wdHkp Owo+ICAJfQo+ICAKPiAtCXNwaW5fdW5sb2NrKCZhaWxwLT54YV9sb2NrKTsKPiArCXNwaW5fdW5s b2NrKCZhaWxwLT5haWxfbG9jayk7Cj4gIAlpZiAobWxpcF9jaGFuZ2VkKQo+IC0JCXhmc19sb2df c3BhY2Vfd2FrZShhaWxwLT54YV9tb3VudCk7Cj4gKwkJeGZzX2xvZ19zcGFjZV93YWtlKGFpbHAt PmFpbF9tb3VudCk7Cj4gIH0KPiAgCj4gIGludAo+IEBAIC03OTUsMTYgKzc5NSwxNiBAQCB4ZnNf dHJhbnNfYWlsX2luaXQoCj4gIAlpZiAoIWFpbHApCj4gIAkJcmV0dXJuIC1FTk9NRU07Cj4gIAo+ IC0JYWlscC0+eGFfbW91bnQgPSBtcDsKPiAtCUlOSVRfTElTVF9IRUFEKCZhaWxwLT54YV9haWwp Owo+IC0JSU5JVF9MSVNUX0hFQUQoJmFpbHAtPnhhX2N1cnNvcnMpOwo+IC0Jc3Bpbl9sb2NrX2lu aXQoJmFpbHAtPnhhX2xvY2spOwo+IC0JSU5JVF9MSVNUX0hFQUQoJmFpbHAtPnhhX2J1Zl9saXN0 KTsKPiAtCWluaXRfd2FpdHF1ZXVlX2hlYWQoJmFpbHAtPnhhX2VtcHR5KTsKPiArCWFpbHAtPmFp bF9tb3VudCA9IG1wOwo+ICsJSU5JVF9MSVNUX0hFQUQoJmFpbHAtPmFpbF9oZWFkKTsKPiArCUlO SVRfTElTVF9IRUFEKCZhaWxwLT5haWxfY3Vyc29ycyk7Cj4gKwlzcGluX2xvY2tfaW5pdCgmYWls cC0+YWlsX2xvY2spOwo+ICsJSU5JVF9MSVNUX0hFQUQoJmFpbHAtPmFpbF9idWZfbGlzdCk7Cj4g Kwlpbml0X3dhaXRxdWV1ZV9oZWFkKCZhaWxwLT5haWxfZW1wdHkpOwo+ICAKPiAtCWFpbHAtPnhh X3Rhc2sgPSBrdGhyZWFkX3J1bih4ZnNhaWxkLCBhaWxwLCAieGZzYWlsZC8lcyIsCj4gLQkJCWFp bHAtPnhhX21vdW50LT5tX2ZzbmFtZSk7Cj4gLQlpZiAoSVNfRVJSKGFpbHAtPnhhX3Rhc2spKQo+ ICsJYWlscC0+YWlsX3Rhc2sgPSBrdGhyZWFkX3J1bih4ZnNhaWxkLCBhaWxwLCAieGZzYWlsZC8l cyIsCj4gKwkJCWFpbHAtPmFpbF9tb3VudC0+bV9mc25hbWUpOwo+ICsJaWYgKElTX0VSUihhaWxw LT5haWxfdGFzaykpCj4gIAkJZ290byBvdXRfZnJlZV9haWxwOwo+ICAKPiAgCW1wLT5tX2FpbCA9 IGFpbHA7Cj4gQEAgLTgyMSw2ICs4MjEsNiBAQCB4ZnNfdHJhbnNfYWlsX2Rlc3Ryb3koCj4gIHsK PiAgCXN0cnVjdCB4ZnNfYWlsCSphaWxwID0gbXAtPm1fYWlsOwo+ICAKPiAtCWt0aHJlYWRfc3Rv cChhaWxwLT54YV90YXNrKTsKPiArCWt0aHJlYWRfc3RvcChhaWxwLT5haWxfdGFzayk7Cj4gIAlr bWVtX2ZyZWUoYWlscCk7Cj4gIH0KPiBkaWZmIC0tZ2l0IGEvZnMveGZzL3hmc190cmFuc19idWYu YyBiL2ZzL3hmcy94ZnNfdHJhbnNfYnVmLmMKPiBpbmRleCAzYmE3YTk2YThhYmQuLmI4ODcxYmNm ZTAwYiAxMDA2NDQKPiAtLS0gYS9mcy94ZnMveGZzX3RyYW5zX2J1Zi5jCj4gKysrIGIvZnMveGZz L3hmc190cmFuc19idWYuYwo+IEBAIC00MjksOCArNDI5LDggQEAgeGZzX3RyYW5zX2JyZWxzZSh4 ZnNfdHJhbnNfdAkqdHAsCj4gIAkgKiBJZiB0aGUgZnMgaGFzIHNodXRkb3duIGFuZCB3ZSBkcm9w cGVkIHRoZSBsYXN0IHJlZmVyZW5jZSwgaXQgbWF5IGZhbGwKPiAgCSAqIG9uIHVzIHRvIHJlbGVh c2UgYSAocG9zc2libHkgZGlydHkpIGJsaSBpZiBpdCBuZXZlciBtYWRlIGl0IHRvIHRoZQo+ICAJ ICogQUlMIChlLmcuLCB0aGUgYWJvcnRlZCB1bnBpbiBhbHJlYWR5IGhhcHBlbmVkIGFuZCBkaWRu J3QgcmVsZWFzZSBpdAo+IC0JICogZHVlIHRvIG91ciByZWZlcmVuY2UpLiBTaW5jZSB3ZSdyZSBh bHJlYWR5IHNodXRkb3duIGFuZCBuZWVkIHhhX2xvY2ssCj4gLQkgKiBqdXN0IGZvcmNlIHJlbW92 ZSBmcm9tIHRoZSBBSUwgYW5kIHJlbGVhc2UgdGhlIGJsaSBoZXJlLgo+ICsJICogZHVlIHRvIG91 ciByZWZlcmVuY2UpLiBTaW5jZSB3ZSdyZSBhbHJlYWR5IHNodXRkb3duIGFuZCBuZWVkCj4gKwkg KiBhaWxfbG9jaywganVzdCBmb3JjZSByZW1vdmUgZnJvbSB0aGUgQUlMIGFuZCByZWxlYXNlIHRo ZSBibGkgaGVyZS4KPiAgCSAqLwo+ICAJaWYgKFhGU19GT1JDRURfU0hVVERPV04odHAtPnRfbW91 bnRwKSAmJiBmcmVlZCkgewo+ICAJCXhmc190cmFuc19haWxfcmVtb3ZlKCZiaXAtPmJsaV9pdGVt LCBTSFVURE9XTl9MT0dfSU9fRVJST1IpOwo+IGRpZmYgLS1naXQgYS9mcy94ZnMveGZzX3RyYW5z X3ByaXYuaCBiL2ZzL3hmcy94ZnNfdHJhbnNfcHJpdi5oCj4gaW5kZXggYjMxN2EzNjQ0YzAwLi5i ZTI0YjBjOGEzMzIgMTAwNjQ0Cj4gLS0tIGEvZnMveGZzL3hmc190cmFuc19wcml2LmgKPiArKysg Yi9mcy94ZnMveGZzX3RyYW5zX3ByaXYuaAo+IEBAIC02NSwxNyArNjUsMTcgQEAgc3RydWN0IHhm c19haWxfY3Vyc29yIHsKPiAgICogRXZlbnR1YWxseSB3ZSBuZWVkIHRvIGRyaXZlIHRoZSBsb2Nr aW5nIGluIGhlcmUgYXMgd2VsbC4KPiAgICovCj4gIHN0cnVjdCB4ZnNfYWlsIHsKPiAtCXN0cnVj dCB4ZnNfbW91bnQJKnhhX21vdW50Owo+IC0Jc3RydWN0IHRhc2tfc3RydWN0CSp4YV90YXNrOwo+ IC0Jc3RydWN0IGxpc3RfaGVhZAl4YV9haWw7Cj4gLQl4ZnNfbHNuX3QJCXhhX3RhcmdldDsKPiAt CXhmc19sc25fdAkJeGFfdGFyZ2V0X3ByZXY7Cj4gLQlzdHJ1Y3QgbGlzdF9oZWFkCXhhX2N1cnNv cnM7Cj4gLQlzcGlubG9ja190CQl4YV9sb2NrOwo+IC0JeGZzX2xzbl90CQl4YV9sYXN0X3B1c2hl ZF9sc247Cj4gLQlpbnQJCQl4YV9sb2dfZmx1c2g7Cj4gLQlzdHJ1Y3QgbGlzdF9oZWFkCXhhX2J1 Zl9saXN0Owo+IC0Jd2FpdF9xdWV1ZV9oZWFkX3QJeGFfZW1wdHk7Cj4gKwlzdHJ1Y3QgeGZzX21v dW50CSphaWxfbW91bnQ7Cj4gKwlzdHJ1Y3QgdGFza19zdHJ1Y3QJKmFpbF90YXNrOwo+ICsJc3Ry dWN0IGxpc3RfaGVhZAlhaWxfaGVhZDsKPiArCXhmc19sc25fdAkJYWlsX3RhcmdldDsKPiArCXhm c19sc25fdAkJYWlsX3RhcmdldF9wcmV2Owo+ICsJc3RydWN0IGxpc3RfaGVhZAlhaWxfY3Vyc29y czsKPiArCXNwaW5sb2NrX3QJCWFpbF9sb2NrOwo+ICsJeGZzX2xzbl90CQlhaWxfbGFzdF9wdXNo ZWRfbHNuOwo+ICsJaW50CQkJYWlsX2xvZ19mbHVzaDsKPiArCXN0cnVjdCBsaXN0X2hlYWQJYWls X2J1Zl9saXN0Owo+ICsJd2FpdF9xdWV1ZV9oZWFkX3QJYWlsX2VtcHR5Owo+ICB9Owo+ICAKPiAg LyoKPiBAQCAtODQsNyArODQsNyBAQCBzdHJ1Y3QgeGZzX2FpbCB7Cj4gIHZvaWQJeGZzX3RyYW5z X2FpbF91cGRhdGVfYnVsayhzdHJ1Y3QgeGZzX2FpbCAqYWlscCwKPiAgCQkJCXN0cnVjdCB4ZnNf YWlsX2N1cnNvciAqY3VyLAo+ICAJCQkJc3RydWN0IHhmc19sb2dfaXRlbSAqKmxvZ19pdGVtcywg aW50IG5yX2l0ZW1zLAo+IC0JCQkJeGZzX2xzbl90IGxzbikgX19yZWxlYXNlcyhhaWxwLT54YV9s b2NrKTsKPiArCQkJCXhmc19sc25fdCBsc24pIF9fcmVsZWFzZXMoYWlscC0+YWlsX2xvY2spOwo+ ICAvKgo+ICAgKiBSZXR1cm4gYSBwb2ludGVyIHRvIHRoZSBmaXJzdCBpdGVtIGluIHRoZSBBSUwu ICBJZiB0aGUgQUlMIGlzIGVtcHR5LCB0aGVuCj4gICAqIHJldHVybiBOVUxMLgo+IEBAIC05Myw3 ICs5Myw3IEBAIHN0YXRpYyBpbmxpbmUgc3RydWN0IHhmc19sb2dfaXRlbSAqCj4gIHhmc19haWxf bWluKAo+ICAJc3RydWN0IHhmc19haWwgICphaWxwKQo+ICB7Cj4gLQlyZXR1cm4gbGlzdF9maXJz dF9lbnRyeV9vcl9udWxsKCZhaWxwLT54YV9haWwsIHN0cnVjdCB4ZnNfbG9nX2l0ZW0sCj4gKwly ZXR1cm4gbGlzdF9maXJzdF9lbnRyeV9vcl9udWxsKCZhaWxwLT5haWxfaGVhZCwgc3RydWN0IHhm c19sb2dfaXRlbSwKPiAgCQkJCQlsaV9haWwpOwo+ICB9Cj4gIAo+IEBAIC0xMDEsMTQgKzEwMSwx NCBAQCBzdGF0aWMgaW5saW5lIHZvaWQKPiAgeGZzX3RyYW5zX2FpbF91cGRhdGUoCj4gIAlzdHJ1 Y3QgeGZzX2FpbAkJKmFpbHAsCj4gIAlzdHJ1Y3QgeGZzX2xvZ19pdGVtCSpsaXAsCj4gLQl4ZnNf bHNuX3QJCWxzbikgX19yZWxlYXNlcyhhaWxwLT54YV9sb2NrKQo+ICsJeGZzX2xzbl90CQlsc24p IF9fcmVsZWFzZXMoYWlscC0+YWlsX2xvY2spCj4gIHsKPiAgCXhmc190cmFuc19haWxfdXBkYXRl X2J1bGsoYWlscCwgTlVMTCwgJmxpcCwgMSwgbHNuKTsKPiAgfQo+ICAKPiAgYm9vbCB4ZnNfYWls X2RlbGV0ZV9vbmUoc3RydWN0IHhmc19haWwgKmFpbHAsIHN0cnVjdCB4ZnNfbG9nX2l0ZW0gKmxp cCk7Cj4gIHZvaWQgeGZzX3RyYW5zX2FpbF9kZWxldGUoc3RydWN0IHhmc19haWwgKmFpbHAsIHN0 cnVjdCB4ZnNfbG9nX2l0ZW0gKmxpcCwKPiAtCQlpbnQgc2h1dGRvd25fdHlwZSkgX19yZWxlYXNl cyhhaWxwLT54YV9sb2NrKTsKPiArCQlpbnQgc2h1dGRvd25fdHlwZSkgX19yZWxlYXNlcyhhaWxw LT5haWxfbG9jayk7Cj4gIAo+ICBzdGF0aWMgaW5saW5lIHZvaWQKPiAgeGZzX3RyYW5zX2FpbF9y ZW1vdmUoCj4gQEAgLTExNywxMiArMTE3LDEyIEBAIHhmc190cmFuc19haWxfcmVtb3ZlKAo+ICB7 Cj4gIAlzdHJ1Y3QgeGZzX2FpbAkJKmFpbHAgPSBsaXAtPmxpX2FpbHA7Cj4gIAo+IC0Jc3Bpbl9s b2NrKCZhaWxwLT54YV9sb2NrKTsKPiArCXNwaW5fbG9jaygmYWlscC0+YWlsX2xvY2spOwo+ICAJ LyogeGZzX3RyYW5zX2FpbF9kZWxldGUoKSBkcm9wcyB0aGUgQUlMIGxvY2sgKi8KPiAgCWlmIChs aXAtPmxpX2ZsYWdzICYgWEZTX0xJX0lOX0FJTCkKPiAgCQl4ZnNfdHJhbnNfYWlsX2RlbGV0ZShh aWxwLCBsaXAsIHNodXRkb3duX3R5cGUpOwo+ICAJZWxzZQo+IC0JCXNwaW5fdW5sb2NrKCZhaWxw LT54YV9sb2NrKTsKPiArCQlzcGluX3VubG9jaygmYWlscC0+YWlsX2xvY2spOwo+ICB9Cj4gIAo+ ICB2b2lkCQkJeGZzX2FpbF9wdXNoKHN0cnVjdCB4ZnNfYWlsICosIHhmc19sc25fdCk7Cj4gQEAg LTE0OSw5ICsxNDksOSBAQCB4ZnNfdHJhbnNfYWlsX2NvcHlfbHNuKAo+ICAJeGZzX2xzbl90CSpz cmMpCj4gIHsKPiAgCUFTU0VSVChzaXplb2YoeGZzX2xzbl90KSA9PSA4KTsJLyogZG9uJ3QgbG9j ayBpZiBpdCBzaHJpbmtzICovCj4gLQlzcGluX2xvY2soJmFpbHAtPnhhX2xvY2spOwo+ICsJc3Bp bl9sb2NrKCZhaWxwLT5haWxfbG9jayk7Cj4gIAkqZHN0ID0gKnNyYzsKPiAtCXNwaW5fdW5sb2Nr KCZhaWxwLT54YV9sb2NrKTsKPiArCXNwaW5fdW5sb2NrKCZhaWxwLT5haWxfbG9jayk7Cj4gIH0K PiAgI2Vsc2UKPiAgc3RhdGljIGlubGluZSB2b2lkCj4gQEAgLTE3Miw3ICsxNzIsNyBAQCB4ZnNf Y2xlYXJfbGlfZmFpbGVkKAo+ICAJc3RydWN0IHhmc19idWYJKmJwID0gbGlwLT5saV9idWY7Cj4g IAo+ICAJQVNTRVJUKGxpcC0+bGlfZmxhZ3MgJiBYRlNfTElfSU5fQUlMKTsKPiAtCWxvY2tkZXBf YXNzZXJ0X2hlbGQoJmxpcC0+bGlfYWlscC0+eGFfbG9jayk7Cj4gKwlsb2NrZGVwX2Fzc2VydF9o ZWxkKCZsaXAtPmxpX2FpbHAtPmFpbF9sb2NrKTsKPiAgCj4gIAlpZiAobGlwLT5saV9mbGFncyAm IFhGU19MSV9GQUlMRUQpIHsKPiAgCQlsaXAtPmxpX2ZsYWdzICY9IH5YRlNfTElfRkFJTEVEOwo+ IEBAIC0xODYsNyArMTg2LDcgQEAgeGZzX3NldF9saV9mYWlsZWQoCj4gIAlzdHJ1Y3QgeGZzX2xv Z19pdGVtCSpsaXAsCj4gIAlzdHJ1Y3QgeGZzX2J1ZgkJKmJwKQo+ICB7Cj4gLQlsb2NrZGVwX2Fz c2VydF9oZWxkKCZsaXAtPmxpX2FpbHAtPnhhX2xvY2spOwo+ICsJbG9ja2RlcF9hc3NlcnRfaGVs ZCgmbGlwLT5saV9haWxwLT5haWxfbG9jayk7Cj4gIAo+ICAJaWYgKCEobGlwLT5saV9mbGFncyAm IFhGU19MSV9GQUlMRUQpKSB7Cj4gIAkJeGZzX2J1Zl9ob2xkKGJwKTsKPiAtLSAKPiAyLjE1LjEK PiAKPiAtLQo+IFRvIHVuc3Vic2NyaWJlIGZyb20gdGhpcyBsaXN0OiBzZW5kIHRoZSBsaW5lICJ1 bnN1YnNjcmliZSBsaW51eC14ZnMiIGluCj4gdGhlIGJvZHkgb2YgYSBtZXNzYWdlIHRvIG1ham9y ZG9tb0B2Z2VyLmtlcm5lbC5vcmcKPiBNb3JlIG1ham9yZG9tbyBpbmZvIGF0ICBodHRwOi8vdmdl ci5rZXJuZWwub3JnL21ham9yZG9tby1pbmZvLmh0bWwKLS0tClRvIHVuc3Vic2NyaWJlIGZyb20g dGhpcyBsaXN0OiBzZW5kIHRoZSBsaW5lICJ1bnN1YnNjcmliZSBsaW51eC11c2IiIGluCnRoZSBi b2R5IG9mIGEgbWVzc2FnZSB0byBtYWpvcmRvbW9Admdlci5rZXJuZWwub3JnCk1vcmUgbWFqb3Jk b21vIGluZm8gYXQgIGh0dHA6Ly92Z2VyLmtlcm5lbC5vcmcvbWFqb3Jkb21vLWluZm8uaHRtbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from aserp2130.oracle.com ([141.146.126.79]:53466 "EHLO aserp2130.oracle.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750748AbeACBBt (ORCPT ); Tue, 2 Jan 2018 20:01:49 -0500 Date: Tue, 2 Jan 2018 17:01:05 -0800 From: "Darrick J. Wong" Subject: Re: [PATCH v5 01/78] xfs: Rename xa_ elements to ail_ Message-ID: <20180103010105.GA16402@magnolia> References: <20171215220450.7899-1-willy@infradead.org> <20171215220450.7899-2-willy@infradead.org> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20171215220450.7899-2-willy@infradead.org> Sender: linux-xfs-owner@vger.kernel.org List-ID: List-Id: xfs To: Matthew Wilcox Cc: linux-kernel@vger.kernel.org, Matthew Wilcox , Ross Zwisler , David Howells , Shaohua Li , Jens Axboe , Rehas Sachdeva , Marc Zyngier , linux-mm@kvack.org, linux-fsdevel@vger.kernel.org, linux-f2fs-devel@lists.sourceforge.net, linux-nilfs@vger.kernel.org, linux-btrfs@vger.kernel.org, linux-xfs@vger.kernel.org, linux-usb@vger.kernel.org, linux-raid@vger.kernel.org On Fri, Dec 15, 2017 at 02:03:33PM -0800, Matthew Wilcox wrote: > From: Matthew Wilcox > > This is a simple rename, except that xa_ail becomes ail_head. > > Signed-off-by: Matthew Wilcox That was an eyeful, Reviewed-by: Darrick J. Wong > --- > fs/xfs/xfs_buf_item.c | 10 ++-- > fs/xfs/xfs_dquot.c | 4 +- > fs/xfs/xfs_dquot_item.c | 11 ++-- > fs/xfs/xfs_inode_item.c | 22 +++---- > fs/xfs/xfs_log.c | 6 +- > fs/xfs/xfs_log_recover.c | 80 ++++++++++++------------- > fs/xfs/xfs_trans.c | 18 +++--- > fs/xfs/xfs_trans_ail.c | 152 +++++++++++++++++++++++------------------------ > fs/xfs/xfs_trans_buf.c | 4 +- > fs/xfs/xfs_trans_priv.h | 42 ++++++------- > 10 files changed, 175 insertions(+), 174 deletions(-) > > diff --git a/fs/xfs/xfs_buf_item.c b/fs/xfs/xfs_buf_item.c > index e0a0af0946f2..6c5035544a93 100644 > --- a/fs/xfs/xfs_buf_item.c > +++ b/fs/xfs/xfs_buf_item.c > @@ -459,7 +459,7 @@ xfs_buf_item_unpin( > bp->b_fspriv = NULL; > bp->b_iodone = NULL; > } else { > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > xfs_trans_ail_delete(ailp, lip, SHUTDOWN_LOG_IO_ERROR); > xfs_buf_item_relse(bp); > ASSERT(bp->b_fspriv == NULL); > @@ -1056,13 +1056,13 @@ xfs_buf_do_callbacks_fail( > struct xfs_log_item *lip = bp->b_fspriv; > struct xfs_ail *ailp = lip->li_ailp; > > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > for (; lip; lip = next) { > next = lip->li_bio_list; > if (lip->li_ops->iop_error) > lip->li_ops->iop_error(lip, bp); > } > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > } > > static bool > @@ -1215,7 +1215,7 @@ xfs_buf_iodone( > * > * Either way, AIL is useless if we're forcing a shutdown. > */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > xfs_trans_ail_delete(ailp, lip, SHUTDOWN_CORRUPT_INCORE); > xfs_buf_item_free(BUF_ITEM(lip)); > } > @@ -1236,7 +1236,7 @@ xfs_buf_resubmit_failed_buffers( > /* > * Clear XFS_LI_FAILED flag from all items before resubmit > * > - * XFS_LI_FAILED set/clear is protected by xa_lock, caller this > + * XFS_LI_FAILED set/clear is protected by ail_lock, caller this > * function already have it acquired > */ > for (; lip; lip = next) { > diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c > index f248708c10ff..e2a466df5dd1 100644 > --- a/fs/xfs/xfs_dquot.c > +++ b/fs/xfs/xfs_dquot.c > @@ -974,7 +974,7 @@ xfs_qm_dqflush_done( > (lip->li_flags & XFS_LI_FAILED))) { > > /* xfs_trans_ail_delete() drops the AIL lock. */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > if (lip->li_lsn == qip->qli_flush_lsn) { > xfs_trans_ail_delete(ailp, lip, SHUTDOWN_CORRUPT_INCORE); > } else { > @@ -984,7 +984,7 @@ xfs_qm_dqflush_done( > */ > if (lip->li_flags & XFS_LI_FAILED) > xfs_clear_li_failed(lip); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > } > } > > diff --git a/fs/xfs/xfs_dquot_item.c b/fs/xfs/xfs_dquot_item.c > index 664dea105e76..62637a226601 100644 > --- a/fs/xfs/xfs_dquot_item.c > +++ b/fs/xfs/xfs_dquot_item.c > @@ -160,8 +160,9 @@ xfs_dquot_item_error( > STATIC uint > xfs_qm_dquot_logitem_push( > struct xfs_log_item *lip, > - struct list_head *buffer_list) __releases(&lip->li_ailp->xa_lock) > - __acquires(&lip->li_ailp->xa_lock) > + struct list_head *buffer_list) > + __releases(&lip->li_ailp->ail_lock) > + __acquires(&lip->li_ailp->ail_lock) > { > struct xfs_dquot *dqp = DQUOT_ITEM(lip)->qli_dquot; > struct xfs_buf *bp = lip->li_buf; > @@ -208,7 +209,7 @@ xfs_qm_dquot_logitem_push( > goto out_unlock; > } > > - spin_unlock(&lip->li_ailp->xa_lock); > + spin_unlock(&lip->li_ailp->ail_lock); > > error = xfs_qm_dqflush(dqp, &bp); > if (error) { > @@ -220,7 +221,7 @@ xfs_qm_dquot_logitem_push( > xfs_buf_relse(bp); > } > > - spin_lock(&lip->li_ailp->xa_lock); > + spin_lock(&lip->li_ailp->ail_lock); > out_unlock: > xfs_dqunlock(dqp); > return rval; > @@ -403,7 +404,7 @@ xfs_qm_qoffend_logitem_committed( > * Delete the qoff-start logitem from the AIL. > * xfs_trans_ail_delete() drops the AIL lock. > */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > xfs_trans_ail_delete(ailp, &qfs->qql_item, SHUTDOWN_LOG_IO_ERROR); > > kmem_free(qfs->qql_item.li_lv_shadow); > diff --git a/fs/xfs/xfs_inode_item.c b/fs/xfs/xfs_inode_item.c > index 6ee5c3bf19ad..071acd4249a0 100644 > --- a/fs/xfs/xfs_inode_item.c > +++ b/fs/xfs/xfs_inode_item.c > @@ -501,8 +501,8 @@ STATIC uint > xfs_inode_item_push( > struct xfs_log_item *lip, > struct list_head *buffer_list) > - __releases(&lip->li_ailp->xa_lock) > - __acquires(&lip->li_ailp->xa_lock) > + __releases(&lip->li_ailp->ail_lock) > + __acquires(&lip->li_ailp->ail_lock) > { > struct xfs_inode_log_item *iip = INODE_ITEM(lip); > struct xfs_inode *ip = iip->ili_inode; > @@ -561,7 +561,7 @@ xfs_inode_item_push( > ASSERT(iip->ili_fields != 0 || XFS_FORCED_SHUTDOWN(ip->i_mount)); > ASSERT(iip->ili_logged == 0 || XFS_FORCED_SHUTDOWN(ip->i_mount)); > > - spin_unlock(&lip->li_ailp->xa_lock); > + spin_unlock(&lip->li_ailp->ail_lock); > > error = xfs_iflush(ip, &bp); > if (!error) { > @@ -570,7 +570,7 @@ xfs_inode_item_push( > xfs_buf_relse(bp); > } > > - spin_lock(&lip->li_ailp->xa_lock); > + spin_lock(&lip->li_ailp->ail_lock); > out_unlock: > xfs_iunlock(ip, XFS_ILOCK_SHARED); > return rval; > @@ -774,7 +774,7 @@ xfs_iflush_done( > bool mlip_changed = false; > > /* this is an opencoded batch version of xfs_trans_ail_delete */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > for (blip = lip; blip; blip = blip->li_bio_list) { > if (INODE_ITEM(blip)->ili_logged && > blip->li_lsn == INODE_ITEM(blip)->ili_flush_lsn) > @@ -785,15 +785,15 @@ xfs_iflush_done( > } > > if (mlip_changed) { > - if (!XFS_FORCED_SHUTDOWN(ailp->xa_mount)) > - xlog_assign_tail_lsn_locked(ailp->xa_mount); > - if (list_empty(&ailp->xa_ail)) > - wake_up_all(&ailp->xa_empty); > + if (!XFS_FORCED_SHUTDOWN(ailp->ail_mount)) > + xlog_assign_tail_lsn_locked(ailp->ail_mount); > + if (list_empty(&ailp->ail_head)) > + wake_up_all(&ailp->ail_empty); > } > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > if (mlip_changed) > - xfs_log_space_wake(ailp->xa_mount); > + xfs_log_space_wake(ailp->ail_mount); > } > > /* > diff --git a/fs/xfs/xfs_log.c b/fs/xfs/xfs_log.c > index a503af96d780..7148625eebf2 100644 > --- a/fs/xfs/xfs_log.c > +++ b/fs/xfs/xfs_log.c > @@ -1148,7 +1148,7 @@ xlog_assign_tail_lsn_locked( > struct xfs_log_item *lip; > xfs_lsn_t tail_lsn; > > - assert_spin_locked(&mp->m_ail->xa_lock); > + assert_spin_locked(&mp->m_ail->ail_lock); > > /* > * To make sure we always have a valid LSN for the log tail we keep > @@ -1171,9 +1171,9 @@ xlog_assign_tail_lsn( > { > xfs_lsn_t tail_lsn; > > - spin_lock(&mp->m_ail->xa_lock); > + spin_lock(&mp->m_ail->ail_lock); > tail_lsn = xlog_assign_tail_lsn_locked(mp); > - spin_unlock(&mp->m_ail->xa_lock); > + spin_unlock(&mp->m_ail->ail_lock); > > return tail_lsn; > } > diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c > index 28d1abfe835e..d871761626fb 100644 > --- a/fs/xfs/xfs_log_recover.c > +++ b/fs/xfs/xfs_log_recover.c > @@ -3424,7 +3424,7 @@ xlog_recover_efi_pass2( > } > atomic_set(&efip->efi_next_extent, efi_formatp->efi_nextents); > > - spin_lock(&log->l_ailp->xa_lock); > + spin_lock(&log->l_ailp->ail_lock); > /* > * The EFI has two references. One for the EFD and one for EFI to ensure > * it makes it into the AIL. Insert the EFI into the AIL directly and > @@ -3467,7 +3467,7 @@ xlog_recover_efd_pass2( > * Search for the EFI with the id in the EFD format structure in the > * AIL. > */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > lip = xfs_trans_ail_cursor_first(ailp, &cur, 0); > while (lip != NULL) { > if (lip->li_type == XFS_LI_EFI) { > @@ -3477,9 +3477,9 @@ xlog_recover_efd_pass2( > * Drop the EFD reference to the EFI. This > * removes the EFI from the AIL and frees it. > */ > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > xfs_efi_release(efip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > break; > } > } > @@ -3487,7 +3487,7 @@ xlog_recover_efd_pass2( > } > > xfs_trans_ail_cursor_done(&cur); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > return 0; > } > @@ -3520,7 +3520,7 @@ xlog_recover_rui_pass2( > } > atomic_set(&ruip->rui_next_extent, rui_formatp->rui_nextents); > > - spin_lock(&log->l_ailp->xa_lock); > + spin_lock(&log->l_ailp->ail_lock); > /* > * The RUI has two references. One for the RUD and one for RUI to ensure > * it makes it into the AIL. Insert the RUI into the AIL directly and > @@ -3560,7 +3560,7 @@ xlog_recover_rud_pass2( > * Search for the RUI with the id in the RUD format structure in the > * AIL. > */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > lip = xfs_trans_ail_cursor_first(ailp, &cur, 0); > while (lip != NULL) { > if (lip->li_type == XFS_LI_RUI) { > @@ -3570,9 +3570,9 @@ xlog_recover_rud_pass2( > * Drop the RUD reference to the RUI. This > * removes the RUI from the AIL and frees it. > */ > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > xfs_rui_release(ruip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > break; > } > } > @@ -3580,7 +3580,7 @@ xlog_recover_rud_pass2( > } > > xfs_trans_ail_cursor_done(&cur); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > return 0; > } > @@ -3636,7 +3636,7 @@ xlog_recover_cui_pass2( > } > atomic_set(&cuip->cui_next_extent, cui_formatp->cui_nextents); > > - spin_lock(&log->l_ailp->xa_lock); > + spin_lock(&log->l_ailp->ail_lock); > /* > * The CUI has two references. One for the CUD and one for CUI to ensure > * it makes it into the AIL. Insert the CUI into the AIL directly and > @@ -3677,7 +3677,7 @@ xlog_recover_cud_pass2( > * Search for the CUI with the id in the CUD format structure in the > * AIL. > */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > lip = xfs_trans_ail_cursor_first(ailp, &cur, 0); > while (lip != NULL) { > if (lip->li_type == XFS_LI_CUI) { > @@ -3687,9 +3687,9 @@ xlog_recover_cud_pass2( > * Drop the CUD reference to the CUI. This > * removes the CUI from the AIL and frees it. > */ > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > xfs_cui_release(cuip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > break; > } > } > @@ -3697,7 +3697,7 @@ xlog_recover_cud_pass2( > } > > xfs_trans_ail_cursor_done(&cur); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > return 0; > } > @@ -3755,7 +3755,7 @@ xlog_recover_bui_pass2( > } > atomic_set(&buip->bui_next_extent, bui_formatp->bui_nextents); > > - spin_lock(&log->l_ailp->xa_lock); > + spin_lock(&log->l_ailp->ail_lock); > /* > * The RUI has two references. One for the RUD and one for RUI to ensure > * it makes it into the AIL. Insert the RUI into the AIL directly and > @@ -3796,7 +3796,7 @@ xlog_recover_bud_pass2( > * Search for the BUI with the id in the BUD format structure in the > * AIL. > */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > lip = xfs_trans_ail_cursor_first(ailp, &cur, 0); > while (lip != NULL) { > if (lip->li_type == XFS_LI_BUI) { > @@ -3806,9 +3806,9 @@ xlog_recover_bud_pass2( > * Drop the BUD reference to the BUI. This > * removes the BUI from the AIL and frees it. > */ > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > xfs_bui_release(buip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > break; > } > } > @@ -3816,7 +3816,7 @@ xlog_recover_bud_pass2( > } > > xfs_trans_ail_cursor_done(&cur); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > return 0; > } > @@ -4649,9 +4649,9 @@ xlog_recover_process_efi( > if (test_bit(XFS_EFI_RECOVERED, &efip->efi_flags)) > return 0; > > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > error = xfs_efi_recover(mp, efip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > > return error; > } > @@ -4667,9 +4667,9 @@ xlog_recover_cancel_efi( > > efip = container_of(lip, struct xfs_efi_log_item, efi_item); > > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > xfs_efi_release(efip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > } > > /* Recover the RUI if necessary. */ > @@ -4689,9 +4689,9 @@ xlog_recover_process_rui( > if (test_bit(XFS_RUI_RECOVERED, &ruip->rui_flags)) > return 0; > > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > error = xfs_rui_recover(mp, ruip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > > return error; > } > @@ -4707,9 +4707,9 @@ xlog_recover_cancel_rui( > > ruip = container_of(lip, struct xfs_rui_log_item, rui_item); > > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > xfs_rui_release(ruip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > } > > /* Recover the CUI if necessary. */ > @@ -4730,9 +4730,9 @@ xlog_recover_process_cui( > if (test_bit(XFS_CUI_RECOVERED, &cuip->cui_flags)) > return 0; > > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > error = xfs_cui_recover(mp, cuip, dfops); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > > return error; > } > @@ -4748,9 +4748,9 @@ xlog_recover_cancel_cui( > > cuip = container_of(lip, struct xfs_cui_log_item, cui_item); > > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > xfs_cui_release(cuip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > } > > /* Recover the BUI if necessary. */ > @@ -4771,9 +4771,9 @@ xlog_recover_process_bui( > if (test_bit(XFS_BUI_RECOVERED, &buip->bui_flags)) > return 0; > > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > error = xfs_bui_recover(mp, buip, dfops); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > > return error; > } > @@ -4789,9 +4789,9 @@ xlog_recover_cancel_bui( > > buip = container_of(lip, struct xfs_bui_log_item, bui_item); > > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > xfs_bui_release(buip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > } > > /* Is this log item a deferred action intent? */ > @@ -4879,7 +4879,7 @@ xlog_recover_process_intents( > #endif > > ailp = log->l_ailp; > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > lip = xfs_trans_ail_cursor_first(ailp, &cur, 0); > #if defined(DEBUG) || defined(XFS_WARN) > last_lsn = xlog_assign_lsn(log->l_curr_cycle, log->l_curr_block); > @@ -4933,7 +4933,7 @@ xlog_recover_process_intents( > } > out: > xfs_trans_ail_cursor_done(&cur); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > if (error) > xfs_defer_cancel(&dfops); > else > @@ -4956,7 +4956,7 @@ xlog_recover_cancel_intents( > struct xfs_ail *ailp; > > ailp = log->l_ailp; > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > lip = xfs_trans_ail_cursor_first(ailp, &cur, 0); > while (lip != NULL) { > /* > @@ -4990,7 +4990,7 @@ xlog_recover_cancel_intents( > } > > xfs_trans_ail_cursor_done(&cur); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > return error; > } > > diff --git a/fs/xfs/xfs_trans.c b/fs/xfs/xfs_trans.c > index a87f657f59c9..756e01999c24 100644 > --- a/fs/xfs/xfs_trans.c > +++ b/fs/xfs/xfs_trans.c > @@ -781,8 +781,8 @@ xfs_log_item_batch_insert( > { > int i; > > - spin_lock(&ailp->xa_lock); > - /* xfs_trans_ail_update_bulk drops ailp->xa_lock */ > + spin_lock(&ailp->ail_lock); > + /* xfs_trans_ail_update_bulk drops ailp->ail_lock */ > xfs_trans_ail_update_bulk(ailp, cur, log_items, nr_items, commit_lsn); > > for (i = 0; i < nr_items; i++) { > @@ -825,9 +825,9 @@ xfs_trans_committed_bulk( > struct xfs_ail_cursor cur; > int i = 0; > > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > xfs_trans_ail_cursor_last(ailp, &cur, commit_lsn); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > /* unpin all the log items */ > for (lv = log_vector; lv; lv = lv->lv_next ) { > @@ -847,7 +847,7 @@ xfs_trans_committed_bulk( > * object into the AIL as we are in a shutdown situation. > */ > if (aborted) { > - ASSERT(XFS_FORCED_SHUTDOWN(ailp->xa_mount)); > + ASSERT(XFS_FORCED_SHUTDOWN(ailp->ail_mount)); > lip->li_ops->iop_unpin(lip, 1); > continue; > } > @@ -861,11 +861,11 @@ xfs_trans_committed_bulk( > * not affect the AIL cursor the bulk insert path is > * using. > */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > if (XFS_LSN_CMP(item_lsn, lip->li_lsn) > 0) > xfs_trans_ail_update(ailp, lip, item_lsn); > else > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > lip->li_ops->iop_unpin(lip, 0); > continue; > } > @@ -883,9 +883,9 @@ xfs_trans_committed_bulk( > if (i) > xfs_log_item_batch_insert(ailp, &cur, log_items, i, commit_lsn); > > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > xfs_trans_ail_cursor_done(&cur); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > } > > /* > diff --git a/fs/xfs/xfs_trans_ail.c b/fs/xfs/xfs_trans_ail.c > index cef89f7127d3..d4a2445215e6 100644 > --- a/fs/xfs/xfs_trans_ail.c > +++ b/fs/xfs/xfs_trans_ail.c > @@ -40,7 +40,7 @@ xfs_ail_check( > { > xfs_log_item_t *prev_lip; > > - if (list_empty(&ailp->xa_ail)) > + if (list_empty(&ailp->ail_head)) > return; > > /* > @@ -48,11 +48,11 @@ xfs_ail_check( > */ > ASSERT((lip->li_flags & XFS_LI_IN_AIL) != 0); > prev_lip = list_entry(lip->li_ail.prev, xfs_log_item_t, li_ail); > - if (&prev_lip->li_ail != &ailp->xa_ail) > + if (&prev_lip->li_ail != &ailp->ail_head) > ASSERT(XFS_LSN_CMP(prev_lip->li_lsn, lip->li_lsn) <= 0); > > prev_lip = list_entry(lip->li_ail.next, xfs_log_item_t, li_ail); > - if (&prev_lip->li_ail != &ailp->xa_ail) > + if (&prev_lip->li_ail != &ailp->ail_head) > ASSERT(XFS_LSN_CMP(prev_lip->li_lsn, lip->li_lsn) >= 0); > > > @@ -69,10 +69,10 @@ static xfs_log_item_t * > xfs_ail_max( > struct xfs_ail *ailp) > { > - if (list_empty(&ailp->xa_ail)) > + if (list_empty(&ailp->ail_head)) > return NULL; > > - return list_entry(ailp->xa_ail.prev, xfs_log_item_t, li_ail); > + return list_entry(ailp->ail_head.prev, xfs_log_item_t, li_ail); > } > > /* > @@ -84,7 +84,7 @@ xfs_ail_next( > struct xfs_ail *ailp, > xfs_log_item_t *lip) > { > - if (lip->li_ail.next == &ailp->xa_ail) > + if (lip->li_ail.next == &ailp->ail_head) > return NULL; > > return list_first_entry(&lip->li_ail, xfs_log_item_t, li_ail); > @@ -105,11 +105,11 @@ xfs_ail_min_lsn( > xfs_lsn_t lsn = 0; > xfs_log_item_t *lip; > > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > lip = xfs_ail_min(ailp); > if (lip) > lsn = lip->li_lsn; > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > return lsn; > } > @@ -124,11 +124,11 @@ xfs_ail_max_lsn( > xfs_lsn_t lsn = 0; > xfs_log_item_t *lip; > > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > lip = xfs_ail_max(ailp); > if (lip) > lsn = lip->li_lsn; > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > return lsn; > } > @@ -146,7 +146,7 @@ xfs_trans_ail_cursor_init( > struct xfs_ail_cursor *cur) > { > cur->item = NULL; > - list_add_tail(&cur->list, &ailp->xa_cursors); > + list_add_tail(&cur->list, &ailp->ail_cursors); > } > > /* > @@ -194,7 +194,7 @@ xfs_trans_ail_cursor_clear( > { > struct xfs_ail_cursor *cur; > > - list_for_each_entry(cur, &ailp->xa_cursors, list) { > + list_for_each_entry(cur, &ailp->ail_cursors, list) { > if (cur->item == lip) > cur->item = (struct xfs_log_item *) > ((uintptr_t)cur->item | 1); > @@ -222,7 +222,7 @@ xfs_trans_ail_cursor_first( > goto out; > } > > - list_for_each_entry(lip, &ailp->xa_ail, li_ail) { > + list_for_each_entry(lip, &ailp->ail_head, li_ail) { > if (XFS_LSN_CMP(lip->li_lsn, lsn) >= 0) > goto out; > } > @@ -241,7 +241,7 @@ __xfs_trans_ail_cursor_last( > { > xfs_log_item_t *lip; > > - list_for_each_entry_reverse(lip, &ailp->xa_ail, li_ail) { > + list_for_each_entry_reverse(lip, &ailp->ail_head, li_ail) { > if (XFS_LSN_CMP(lip->li_lsn, lsn) <= 0) > return lip; > } > @@ -310,7 +310,7 @@ xfs_ail_splice( > if (lip) > list_splice(list, &lip->li_ail); > else > - list_splice(list, &ailp->xa_ail); > + list_splice(list, &ailp->ail_head); > } > > /* > @@ -335,17 +335,17 @@ xfsaild_push_item( > * If log item pinning is enabled, skip the push and track the item as > * pinned. This can help induce head-behind-tail conditions. > */ > - if (XFS_TEST_ERROR(false, ailp->xa_mount, XFS_ERRTAG_LOG_ITEM_PIN)) > + if (XFS_TEST_ERROR(false, ailp->ail_mount, XFS_ERRTAG_LOG_ITEM_PIN)) > return XFS_ITEM_PINNED; > > - return lip->li_ops->iop_push(lip, &ailp->xa_buf_list); > + return lip->li_ops->iop_push(lip, &ailp->ail_buf_list); > } > > static long > xfsaild_push( > struct xfs_ail *ailp) > { > - xfs_mount_t *mp = ailp->xa_mount; > + xfs_mount_t *mp = ailp->ail_mount; > struct xfs_ail_cursor cur; > xfs_log_item_t *lip; > xfs_lsn_t lsn; > @@ -360,30 +360,30 @@ xfsaild_push( > * buffers the last time we ran, force the log first and wait for it > * before pushing again. > */ > - if (ailp->xa_log_flush && ailp->xa_last_pushed_lsn == 0 && > - (!list_empty_careful(&ailp->xa_buf_list) || > + if (ailp->ail_log_flush && ailp->ail_last_pushed_lsn == 0 && > + (!list_empty_careful(&ailp->ail_buf_list) || > xfs_ail_min_lsn(ailp))) { > - ailp->xa_log_flush = 0; > + ailp->ail_log_flush = 0; > > XFS_STATS_INC(mp, xs_push_ail_flush); > xfs_log_force(mp, XFS_LOG_SYNC); > } > > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > > - /* barrier matches the xa_target update in xfs_ail_push() */ > + /* barrier matches the ail_target update in xfs_ail_push() */ > smp_rmb(); > - target = ailp->xa_target; > - ailp->xa_target_prev = target; > + target = ailp->ail_target; > + ailp->ail_target_prev = target; > > - lip = xfs_trans_ail_cursor_first(ailp, &cur, ailp->xa_last_pushed_lsn); > + lip = xfs_trans_ail_cursor_first(ailp, &cur, ailp->ail_last_pushed_lsn); > if (!lip) { > /* > * If the AIL is empty or our push has reached the end we are > * done now. > */ > xfs_trans_ail_cursor_done(&cur); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > goto out_done; > } > > @@ -404,7 +404,7 @@ xfsaild_push( > XFS_STATS_INC(mp, xs_push_ail_success); > trace_xfs_ail_push(lip); > > - ailp->xa_last_pushed_lsn = lsn; > + ailp->ail_last_pushed_lsn = lsn; > break; > > case XFS_ITEM_FLUSHING: > @@ -423,7 +423,7 @@ xfsaild_push( > trace_xfs_ail_flushing(lip); > > flushing++; > - ailp->xa_last_pushed_lsn = lsn; > + ailp->ail_last_pushed_lsn = lsn; > break; > > case XFS_ITEM_PINNED: > @@ -431,7 +431,7 @@ xfsaild_push( > trace_xfs_ail_pinned(lip); > > stuck++; > - ailp->xa_log_flush++; > + ailp->ail_log_flush++; > break; > case XFS_ITEM_LOCKED: > XFS_STATS_INC(mp, xs_push_ail_locked); > @@ -468,10 +468,10 @@ xfsaild_push( > lsn = lip->li_lsn; > } > xfs_trans_ail_cursor_done(&cur); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > - if (xfs_buf_delwri_submit_nowait(&ailp->xa_buf_list)) > - ailp->xa_log_flush++; > + if (xfs_buf_delwri_submit_nowait(&ailp->ail_buf_list)) > + ailp->ail_log_flush++; > > if (!count || XFS_LSN_CMP(lsn, target) >= 0) { > out_done: > @@ -481,7 +481,7 @@ xfsaild_push( > * AIL before we start the next scan from the start of the AIL. > */ > tout = 50; > - ailp->xa_last_pushed_lsn = 0; > + ailp->ail_last_pushed_lsn = 0; > } else if (((stuck + flushing) * 100) / count > 90) { > /* > * Either there is a lot of contention on the AIL or we are > @@ -494,7 +494,7 @@ xfsaild_push( > * the restart to issue a log force to unpin the stuck items. > */ > tout = 20; > - ailp->xa_last_pushed_lsn = 0; > + ailp->ail_last_pushed_lsn = 0; > } else { > /* > * Assume we have more work to do in a short while. > @@ -536,26 +536,26 @@ xfsaild( > break; > } > > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > > /* > * Idle if the AIL is empty and we are not racing with a target > * update. We check the AIL after we set the task to a sleep > - * state to guarantee that we either catch an xa_target update > + * state to guarantee that we either catch an ail_target update > * or that a wake_up resets the state to TASK_RUNNING. > * Otherwise, we run the risk of sleeping indefinitely. > * > - * The barrier matches the xa_target update in xfs_ail_push(). > + * The barrier matches the ail_target update in xfs_ail_push(). > */ > smp_rmb(); > if (!xfs_ail_min(ailp) && > - ailp->xa_target == ailp->xa_target_prev) { > - spin_unlock(&ailp->xa_lock); > + ailp->ail_target == ailp->ail_target_prev) { > + spin_unlock(&ailp->ail_lock); > freezable_schedule(); > tout = 0; > continue; > } > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > if (tout) > freezable_schedule_timeout(msecs_to_jiffies(tout)); > @@ -592,8 +592,8 @@ xfs_ail_push( > xfs_log_item_t *lip; > > lip = xfs_ail_min(ailp); > - if (!lip || XFS_FORCED_SHUTDOWN(ailp->xa_mount) || > - XFS_LSN_CMP(threshold_lsn, ailp->xa_target) <= 0) > + if (!lip || XFS_FORCED_SHUTDOWN(ailp->ail_mount) || > + XFS_LSN_CMP(threshold_lsn, ailp->ail_target) <= 0) > return; > > /* > @@ -601,10 +601,10 @@ xfs_ail_push( > * the XFS_AIL_PUSHING_BIT. > */ > smp_wmb(); > - xfs_trans_ail_copy_lsn(ailp, &ailp->xa_target, &threshold_lsn); > + xfs_trans_ail_copy_lsn(ailp, &ailp->ail_target, &threshold_lsn); > smp_wmb(); > > - wake_up_process(ailp->xa_task); > + wake_up_process(ailp->ail_task); > } > > /* > @@ -630,18 +630,18 @@ xfs_ail_push_all_sync( > struct xfs_log_item *lip; > DEFINE_WAIT(wait); > > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > while ((lip = xfs_ail_max(ailp)) != NULL) { > - prepare_to_wait(&ailp->xa_empty, &wait, TASK_UNINTERRUPTIBLE); > - ailp->xa_target = lip->li_lsn; > - wake_up_process(ailp->xa_task); > - spin_unlock(&ailp->xa_lock); > + prepare_to_wait(&ailp->ail_empty, &wait, TASK_UNINTERRUPTIBLE); > + ailp->ail_target = lip->li_lsn; > + wake_up_process(ailp->ail_task); > + spin_unlock(&ailp->ail_lock); > schedule(); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > } > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > - finish_wait(&ailp->xa_empty, &wait); > + finish_wait(&ailp->ail_empty, &wait); > } > > /* > @@ -672,7 +672,7 @@ xfs_trans_ail_update_bulk( > struct xfs_ail_cursor *cur, > struct xfs_log_item **log_items, > int nr_items, > - xfs_lsn_t lsn) __releases(ailp->xa_lock) > + xfs_lsn_t lsn) __releases(ailp->ail_lock) > { > xfs_log_item_t *mlip; > int mlip_changed = 0; > @@ -705,13 +705,13 @@ xfs_trans_ail_update_bulk( > xfs_ail_splice(ailp, cur, &tmp, lsn); > > if (mlip_changed) { > - if (!XFS_FORCED_SHUTDOWN(ailp->xa_mount)) > - xlog_assign_tail_lsn_locked(ailp->xa_mount); > - spin_unlock(&ailp->xa_lock); > + if (!XFS_FORCED_SHUTDOWN(ailp->ail_mount)) > + xlog_assign_tail_lsn_locked(ailp->ail_mount); > + spin_unlock(&ailp->ail_lock); > > - xfs_log_space_wake(ailp->xa_mount); > + xfs_log_space_wake(ailp->ail_mount); > } else { > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > } > } > > @@ -756,13 +756,13 @@ void > xfs_trans_ail_delete( > struct xfs_ail *ailp, > struct xfs_log_item *lip, > - int shutdown_type) __releases(ailp->xa_lock) > + int shutdown_type) __releases(ailp->ail_lock) > { > - struct xfs_mount *mp = ailp->xa_mount; > + struct xfs_mount *mp = ailp->ail_mount; > bool mlip_changed; > > if (!(lip->li_flags & XFS_LI_IN_AIL)) { > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > if (!XFS_FORCED_SHUTDOWN(mp)) { > xfs_alert_tag(mp, XFS_PTAG_AILDELETE, > "%s: attempting to delete a log item that is not in the AIL", > @@ -776,13 +776,13 @@ xfs_trans_ail_delete( > if (mlip_changed) { > if (!XFS_FORCED_SHUTDOWN(mp)) > xlog_assign_tail_lsn_locked(mp); > - if (list_empty(&ailp->xa_ail)) > - wake_up_all(&ailp->xa_empty); > + if (list_empty(&ailp->ail_head)) > + wake_up_all(&ailp->ail_empty); > } > > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > if (mlip_changed) > - xfs_log_space_wake(ailp->xa_mount); > + xfs_log_space_wake(ailp->ail_mount); > } > > int > @@ -795,16 +795,16 @@ xfs_trans_ail_init( > if (!ailp) > return -ENOMEM; > > - ailp->xa_mount = mp; > - INIT_LIST_HEAD(&ailp->xa_ail); > - INIT_LIST_HEAD(&ailp->xa_cursors); > - spin_lock_init(&ailp->xa_lock); > - INIT_LIST_HEAD(&ailp->xa_buf_list); > - init_waitqueue_head(&ailp->xa_empty); > + ailp->ail_mount = mp; > + INIT_LIST_HEAD(&ailp->ail_head); > + INIT_LIST_HEAD(&ailp->ail_cursors); > + spin_lock_init(&ailp->ail_lock); > + INIT_LIST_HEAD(&ailp->ail_buf_list); > + init_waitqueue_head(&ailp->ail_empty); > > - ailp->xa_task = kthread_run(xfsaild, ailp, "xfsaild/%s", > - ailp->xa_mount->m_fsname); > - if (IS_ERR(ailp->xa_task)) > + ailp->ail_task = kthread_run(xfsaild, ailp, "xfsaild/%s", > + ailp->ail_mount->m_fsname); > + if (IS_ERR(ailp->ail_task)) > goto out_free_ailp; > > mp->m_ail = ailp; > @@ -821,6 +821,6 @@ xfs_trans_ail_destroy( > { > struct xfs_ail *ailp = mp->m_ail; > > - kthread_stop(ailp->xa_task); > + kthread_stop(ailp->ail_task); > kmem_free(ailp); > } > diff --git a/fs/xfs/xfs_trans_buf.c b/fs/xfs/xfs_trans_buf.c > index 3ba7a96a8abd..b8871bcfe00b 100644 > --- a/fs/xfs/xfs_trans_buf.c > +++ b/fs/xfs/xfs_trans_buf.c > @@ -429,8 +429,8 @@ xfs_trans_brelse(xfs_trans_t *tp, > * If the fs has shutdown and we dropped the last reference, it may fall > * on us to release a (possibly dirty) bli if it never made it to the > * AIL (e.g., the aborted unpin already happened and didn't release it > - * due to our reference). Since we're already shutdown and need xa_lock, > - * just force remove from the AIL and release the bli here. > + * due to our reference). Since we're already shutdown and need > + * ail_lock, just force remove from the AIL and release the bli here. > */ > if (XFS_FORCED_SHUTDOWN(tp->t_mountp) && freed) { > xfs_trans_ail_remove(&bip->bli_item, SHUTDOWN_LOG_IO_ERROR); > diff --git a/fs/xfs/xfs_trans_priv.h b/fs/xfs/xfs_trans_priv.h > index b317a3644c00..be24b0c8a332 100644 > --- a/fs/xfs/xfs_trans_priv.h > +++ b/fs/xfs/xfs_trans_priv.h > @@ -65,17 +65,17 @@ struct xfs_ail_cursor { > * Eventually we need to drive the locking in here as well. > */ > struct xfs_ail { > - struct xfs_mount *xa_mount; > - struct task_struct *xa_task; > - struct list_head xa_ail; > - xfs_lsn_t xa_target; > - xfs_lsn_t xa_target_prev; > - struct list_head xa_cursors; > - spinlock_t xa_lock; > - xfs_lsn_t xa_last_pushed_lsn; > - int xa_log_flush; > - struct list_head xa_buf_list; > - wait_queue_head_t xa_empty; > + struct xfs_mount *ail_mount; > + struct task_struct *ail_task; > + struct list_head ail_head; > + xfs_lsn_t ail_target; > + xfs_lsn_t ail_target_prev; > + struct list_head ail_cursors; > + spinlock_t ail_lock; > + xfs_lsn_t ail_last_pushed_lsn; > + int ail_log_flush; > + struct list_head ail_buf_list; > + wait_queue_head_t ail_empty; > }; > > /* > @@ -84,7 +84,7 @@ struct xfs_ail { > void xfs_trans_ail_update_bulk(struct xfs_ail *ailp, > struct xfs_ail_cursor *cur, > struct xfs_log_item **log_items, int nr_items, > - xfs_lsn_t lsn) __releases(ailp->xa_lock); > + xfs_lsn_t lsn) __releases(ailp->ail_lock); > /* > * Return a pointer to the first item in the AIL. If the AIL is empty, then > * return NULL. > @@ -93,7 +93,7 @@ static inline struct xfs_log_item * > xfs_ail_min( > struct xfs_ail *ailp) > { > - return list_first_entry_or_null(&ailp->xa_ail, struct xfs_log_item, > + return list_first_entry_or_null(&ailp->ail_head, struct xfs_log_item, > li_ail); > } > > @@ -101,14 +101,14 @@ static inline void > xfs_trans_ail_update( > struct xfs_ail *ailp, > struct xfs_log_item *lip, > - xfs_lsn_t lsn) __releases(ailp->xa_lock) > + xfs_lsn_t lsn) __releases(ailp->ail_lock) > { > xfs_trans_ail_update_bulk(ailp, NULL, &lip, 1, lsn); > } > > bool xfs_ail_delete_one(struct xfs_ail *ailp, struct xfs_log_item *lip); > void xfs_trans_ail_delete(struct xfs_ail *ailp, struct xfs_log_item *lip, > - int shutdown_type) __releases(ailp->xa_lock); > + int shutdown_type) __releases(ailp->ail_lock); > > static inline void > xfs_trans_ail_remove( > @@ -117,12 +117,12 @@ xfs_trans_ail_remove( > { > struct xfs_ail *ailp = lip->li_ailp; > > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > /* xfs_trans_ail_delete() drops the AIL lock */ > if (lip->li_flags & XFS_LI_IN_AIL) > xfs_trans_ail_delete(ailp, lip, shutdown_type); > else > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > } > > void xfs_ail_push(struct xfs_ail *, xfs_lsn_t); > @@ -149,9 +149,9 @@ xfs_trans_ail_copy_lsn( > xfs_lsn_t *src) > { > ASSERT(sizeof(xfs_lsn_t) == 8); /* don't lock if it shrinks */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > *dst = *src; > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > } > #else > static inline void > @@ -172,7 +172,7 @@ xfs_clear_li_failed( > struct xfs_buf *bp = lip->li_buf; > > ASSERT(lip->li_flags & XFS_LI_IN_AIL); > - lockdep_assert_held(&lip->li_ailp->xa_lock); > + lockdep_assert_held(&lip->li_ailp->ail_lock); > > if (lip->li_flags & XFS_LI_FAILED) { > lip->li_flags &= ~XFS_LI_FAILED; > @@ -186,7 +186,7 @@ xfs_set_li_failed( > struct xfs_log_item *lip, > struct xfs_buf *bp) > { > - lockdep_assert_held(&lip->li_ailp->xa_lock); > + lockdep_assert_held(&lip->li_ailp->ail_lock); > > if (!(lip->li_flags & XFS_LI_FAILED)) { > xfs_buf_hold(bp); > -- > 2.15.1 > > -- > To unsubscribe from this list: send the line "unsubscribe linux-xfs" in > the body of a message to majordomo@vger.kernel.org > More majordomo info at http://vger.kernel.org/majordomo-info.html From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Date: Tue, 2 Jan 2018 17:01:05 -0800 From: "Darrick J. Wong" To: Matthew Wilcox Cc: linux-kernel@vger.kernel.org, Matthew Wilcox , Ross Zwisler , David Howells , Shaohua Li , Jens Axboe , Rehas Sachdeva , Marc Zyngier , linux-mm@kvack.org, linux-fsdevel@vger.kernel.org, linux-f2fs-devel@lists.sourceforge.net, linux-nilfs@vger.kernel.org, linux-btrfs@vger.kernel.org, linux-xfs@vger.kernel.org, linux-usb@vger.kernel.org, linux-raid@vger.kernel.org Subject: Re: [PATCH v5 01/78] xfs: Rename xa_ elements to ail_ Message-ID: <20180103010105.GA16402@magnolia> References: <20171215220450.7899-1-willy@infradead.org> <20171215220450.7899-2-willy@infradead.org> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20171215220450.7899-2-willy@infradead.org> Sender: owner-linux-mm@kvack.org List-ID: On Fri, Dec 15, 2017 at 02:03:33PM -0800, Matthew Wilcox wrote: > From: Matthew Wilcox > > This is a simple rename, except that xa_ail becomes ail_head. > > Signed-off-by: Matthew Wilcox That was an eyeful, Reviewed-by: Darrick J. Wong > --- > fs/xfs/xfs_buf_item.c | 10 ++-- > fs/xfs/xfs_dquot.c | 4 +- > fs/xfs/xfs_dquot_item.c | 11 ++-- > fs/xfs/xfs_inode_item.c | 22 +++---- > fs/xfs/xfs_log.c | 6 +- > fs/xfs/xfs_log_recover.c | 80 ++++++++++++------------- > fs/xfs/xfs_trans.c | 18 +++--- > fs/xfs/xfs_trans_ail.c | 152 +++++++++++++++++++++++------------------------ > fs/xfs/xfs_trans_buf.c | 4 +- > fs/xfs/xfs_trans_priv.h | 42 ++++++------- > 10 files changed, 175 insertions(+), 174 deletions(-) > > diff --git a/fs/xfs/xfs_buf_item.c b/fs/xfs/xfs_buf_item.c > index e0a0af0946f2..6c5035544a93 100644 > --- a/fs/xfs/xfs_buf_item.c > +++ b/fs/xfs/xfs_buf_item.c > @@ -459,7 +459,7 @@ xfs_buf_item_unpin( > bp->b_fspriv = NULL; > bp->b_iodone = NULL; > } else { > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > xfs_trans_ail_delete(ailp, lip, SHUTDOWN_LOG_IO_ERROR); > xfs_buf_item_relse(bp); > ASSERT(bp->b_fspriv == NULL); > @@ -1056,13 +1056,13 @@ xfs_buf_do_callbacks_fail( > struct xfs_log_item *lip = bp->b_fspriv; > struct xfs_ail *ailp = lip->li_ailp; > > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > for (; lip; lip = next) { > next = lip->li_bio_list; > if (lip->li_ops->iop_error) > lip->li_ops->iop_error(lip, bp); > } > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > } > > static bool > @@ -1215,7 +1215,7 @@ xfs_buf_iodone( > * > * Either way, AIL is useless if we're forcing a shutdown. > */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > xfs_trans_ail_delete(ailp, lip, SHUTDOWN_CORRUPT_INCORE); > xfs_buf_item_free(BUF_ITEM(lip)); > } > @@ -1236,7 +1236,7 @@ xfs_buf_resubmit_failed_buffers( > /* > * Clear XFS_LI_FAILED flag from all items before resubmit > * > - * XFS_LI_FAILED set/clear is protected by xa_lock, caller this > + * XFS_LI_FAILED set/clear is protected by ail_lock, caller this > * function already have it acquired > */ > for (; lip; lip = next) { > diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c > index f248708c10ff..e2a466df5dd1 100644 > --- a/fs/xfs/xfs_dquot.c > +++ b/fs/xfs/xfs_dquot.c > @@ -974,7 +974,7 @@ xfs_qm_dqflush_done( > (lip->li_flags & XFS_LI_FAILED))) { > > /* xfs_trans_ail_delete() drops the AIL lock. */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > if (lip->li_lsn == qip->qli_flush_lsn) { > xfs_trans_ail_delete(ailp, lip, SHUTDOWN_CORRUPT_INCORE); > } else { > @@ -984,7 +984,7 @@ xfs_qm_dqflush_done( > */ > if (lip->li_flags & XFS_LI_FAILED) > xfs_clear_li_failed(lip); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > } > } > > diff --git a/fs/xfs/xfs_dquot_item.c b/fs/xfs/xfs_dquot_item.c > index 664dea105e76..62637a226601 100644 > --- a/fs/xfs/xfs_dquot_item.c > +++ b/fs/xfs/xfs_dquot_item.c > @@ -160,8 +160,9 @@ xfs_dquot_item_error( > STATIC uint > xfs_qm_dquot_logitem_push( > struct xfs_log_item *lip, > - struct list_head *buffer_list) __releases(&lip->li_ailp->xa_lock) > - __acquires(&lip->li_ailp->xa_lock) > + struct list_head *buffer_list) > + __releases(&lip->li_ailp->ail_lock) > + __acquires(&lip->li_ailp->ail_lock) > { > struct xfs_dquot *dqp = DQUOT_ITEM(lip)->qli_dquot; > struct xfs_buf *bp = lip->li_buf; > @@ -208,7 +209,7 @@ xfs_qm_dquot_logitem_push( > goto out_unlock; > } > > - spin_unlock(&lip->li_ailp->xa_lock); > + spin_unlock(&lip->li_ailp->ail_lock); > > error = xfs_qm_dqflush(dqp, &bp); > if (error) { > @@ -220,7 +221,7 @@ xfs_qm_dquot_logitem_push( > xfs_buf_relse(bp); > } > > - spin_lock(&lip->li_ailp->xa_lock); > + spin_lock(&lip->li_ailp->ail_lock); > out_unlock: > xfs_dqunlock(dqp); > return rval; > @@ -403,7 +404,7 @@ xfs_qm_qoffend_logitem_committed( > * Delete the qoff-start logitem from the AIL. > * xfs_trans_ail_delete() drops the AIL lock. > */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > xfs_trans_ail_delete(ailp, &qfs->qql_item, SHUTDOWN_LOG_IO_ERROR); > > kmem_free(qfs->qql_item.li_lv_shadow); > diff --git a/fs/xfs/xfs_inode_item.c b/fs/xfs/xfs_inode_item.c > index 6ee5c3bf19ad..071acd4249a0 100644 > --- a/fs/xfs/xfs_inode_item.c > +++ b/fs/xfs/xfs_inode_item.c > @@ -501,8 +501,8 @@ STATIC uint > xfs_inode_item_push( > struct xfs_log_item *lip, > struct list_head *buffer_list) > - __releases(&lip->li_ailp->xa_lock) > - __acquires(&lip->li_ailp->xa_lock) > + __releases(&lip->li_ailp->ail_lock) > + __acquires(&lip->li_ailp->ail_lock) > { > struct xfs_inode_log_item *iip = INODE_ITEM(lip); > struct xfs_inode *ip = iip->ili_inode; > @@ -561,7 +561,7 @@ xfs_inode_item_push( > ASSERT(iip->ili_fields != 0 || XFS_FORCED_SHUTDOWN(ip->i_mount)); > ASSERT(iip->ili_logged == 0 || XFS_FORCED_SHUTDOWN(ip->i_mount)); > > - spin_unlock(&lip->li_ailp->xa_lock); > + spin_unlock(&lip->li_ailp->ail_lock); > > error = xfs_iflush(ip, &bp); > if (!error) { > @@ -570,7 +570,7 @@ xfs_inode_item_push( > xfs_buf_relse(bp); > } > > - spin_lock(&lip->li_ailp->xa_lock); > + spin_lock(&lip->li_ailp->ail_lock); > out_unlock: > xfs_iunlock(ip, XFS_ILOCK_SHARED); > return rval; > @@ -774,7 +774,7 @@ xfs_iflush_done( > bool mlip_changed = false; > > /* this is an opencoded batch version of xfs_trans_ail_delete */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > for (blip = lip; blip; blip = blip->li_bio_list) { > if (INODE_ITEM(blip)->ili_logged && > blip->li_lsn == INODE_ITEM(blip)->ili_flush_lsn) > @@ -785,15 +785,15 @@ xfs_iflush_done( > } > > if (mlip_changed) { > - if (!XFS_FORCED_SHUTDOWN(ailp->xa_mount)) > - xlog_assign_tail_lsn_locked(ailp->xa_mount); > - if (list_empty(&ailp->xa_ail)) > - wake_up_all(&ailp->xa_empty); > + if (!XFS_FORCED_SHUTDOWN(ailp->ail_mount)) > + xlog_assign_tail_lsn_locked(ailp->ail_mount); > + if (list_empty(&ailp->ail_head)) > + wake_up_all(&ailp->ail_empty); > } > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > if (mlip_changed) > - xfs_log_space_wake(ailp->xa_mount); > + xfs_log_space_wake(ailp->ail_mount); > } > > /* > diff --git a/fs/xfs/xfs_log.c b/fs/xfs/xfs_log.c > index a503af96d780..7148625eebf2 100644 > --- a/fs/xfs/xfs_log.c > +++ b/fs/xfs/xfs_log.c > @@ -1148,7 +1148,7 @@ xlog_assign_tail_lsn_locked( > struct xfs_log_item *lip; > xfs_lsn_t tail_lsn; > > - assert_spin_locked(&mp->m_ail->xa_lock); > + assert_spin_locked(&mp->m_ail->ail_lock); > > /* > * To make sure we always have a valid LSN for the log tail we keep > @@ -1171,9 +1171,9 @@ xlog_assign_tail_lsn( > { > xfs_lsn_t tail_lsn; > > - spin_lock(&mp->m_ail->xa_lock); > + spin_lock(&mp->m_ail->ail_lock); > tail_lsn = xlog_assign_tail_lsn_locked(mp); > - spin_unlock(&mp->m_ail->xa_lock); > + spin_unlock(&mp->m_ail->ail_lock); > > return tail_lsn; > } > diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c > index 28d1abfe835e..d871761626fb 100644 > --- a/fs/xfs/xfs_log_recover.c > +++ b/fs/xfs/xfs_log_recover.c > @@ -3424,7 +3424,7 @@ xlog_recover_efi_pass2( > } > atomic_set(&efip->efi_next_extent, efi_formatp->efi_nextents); > > - spin_lock(&log->l_ailp->xa_lock); > + spin_lock(&log->l_ailp->ail_lock); > /* > * The EFI has two references. One for the EFD and one for EFI to ensure > * it makes it into the AIL. Insert the EFI into the AIL directly and > @@ -3467,7 +3467,7 @@ xlog_recover_efd_pass2( > * Search for the EFI with the id in the EFD format structure in the > * AIL. > */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > lip = xfs_trans_ail_cursor_first(ailp, &cur, 0); > while (lip != NULL) { > if (lip->li_type == XFS_LI_EFI) { > @@ -3477,9 +3477,9 @@ xlog_recover_efd_pass2( > * Drop the EFD reference to the EFI. This > * removes the EFI from the AIL and frees it. > */ > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > xfs_efi_release(efip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > break; > } > } > @@ -3487,7 +3487,7 @@ xlog_recover_efd_pass2( > } > > xfs_trans_ail_cursor_done(&cur); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > return 0; > } > @@ -3520,7 +3520,7 @@ xlog_recover_rui_pass2( > } > atomic_set(&ruip->rui_next_extent, rui_formatp->rui_nextents); > > - spin_lock(&log->l_ailp->xa_lock); > + spin_lock(&log->l_ailp->ail_lock); > /* > * The RUI has two references. One for the RUD and one for RUI to ensure > * it makes it into the AIL. Insert the RUI into the AIL directly and > @@ -3560,7 +3560,7 @@ xlog_recover_rud_pass2( > * Search for the RUI with the id in the RUD format structure in the > * AIL. > */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > lip = xfs_trans_ail_cursor_first(ailp, &cur, 0); > while (lip != NULL) { > if (lip->li_type == XFS_LI_RUI) { > @@ -3570,9 +3570,9 @@ xlog_recover_rud_pass2( > * Drop the RUD reference to the RUI. This > * removes the RUI from the AIL and frees it. > */ > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > xfs_rui_release(ruip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > break; > } > } > @@ -3580,7 +3580,7 @@ xlog_recover_rud_pass2( > } > > xfs_trans_ail_cursor_done(&cur); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > return 0; > } > @@ -3636,7 +3636,7 @@ xlog_recover_cui_pass2( > } > atomic_set(&cuip->cui_next_extent, cui_formatp->cui_nextents); > > - spin_lock(&log->l_ailp->xa_lock); > + spin_lock(&log->l_ailp->ail_lock); > /* > * The CUI has two references. One for the CUD and one for CUI to ensure > * it makes it into the AIL. Insert the CUI into the AIL directly and > @@ -3677,7 +3677,7 @@ xlog_recover_cud_pass2( > * Search for the CUI with the id in the CUD format structure in the > * AIL. > */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > lip = xfs_trans_ail_cursor_first(ailp, &cur, 0); > while (lip != NULL) { > if (lip->li_type == XFS_LI_CUI) { > @@ -3687,9 +3687,9 @@ xlog_recover_cud_pass2( > * Drop the CUD reference to the CUI. This > * removes the CUI from the AIL and frees it. > */ > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > xfs_cui_release(cuip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > break; > } > } > @@ -3697,7 +3697,7 @@ xlog_recover_cud_pass2( > } > > xfs_trans_ail_cursor_done(&cur); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > return 0; > } > @@ -3755,7 +3755,7 @@ xlog_recover_bui_pass2( > } > atomic_set(&buip->bui_next_extent, bui_formatp->bui_nextents); > > - spin_lock(&log->l_ailp->xa_lock); > + spin_lock(&log->l_ailp->ail_lock); > /* > * The RUI has two references. One for the RUD and one for RUI to ensure > * it makes it into the AIL. Insert the RUI into the AIL directly and > @@ -3796,7 +3796,7 @@ xlog_recover_bud_pass2( > * Search for the BUI with the id in the BUD format structure in the > * AIL. > */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > lip = xfs_trans_ail_cursor_first(ailp, &cur, 0); > while (lip != NULL) { > if (lip->li_type == XFS_LI_BUI) { > @@ -3806,9 +3806,9 @@ xlog_recover_bud_pass2( > * Drop the BUD reference to the BUI. This > * removes the BUI from the AIL and frees it. > */ > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > xfs_bui_release(buip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > break; > } > } > @@ -3816,7 +3816,7 @@ xlog_recover_bud_pass2( > } > > xfs_trans_ail_cursor_done(&cur); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > return 0; > } > @@ -4649,9 +4649,9 @@ xlog_recover_process_efi( > if (test_bit(XFS_EFI_RECOVERED, &efip->efi_flags)) > return 0; > > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > error = xfs_efi_recover(mp, efip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > > return error; > } > @@ -4667,9 +4667,9 @@ xlog_recover_cancel_efi( > > efip = container_of(lip, struct xfs_efi_log_item, efi_item); > > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > xfs_efi_release(efip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > } > > /* Recover the RUI if necessary. */ > @@ -4689,9 +4689,9 @@ xlog_recover_process_rui( > if (test_bit(XFS_RUI_RECOVERED, &ruip->rui_flags)) > return 0; > > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > error = xfs_rui_recover(mp, ruip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > > return error; > } > @@ -4707,9 +4707,9 @@ xlog_recover_cancel_rui( > > ruip = container_of(lip, struct xfs_rui_log_item, rui_item); > > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > xfs_rui_release(ruip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > } > > /* Recover the CUI if necessary. */ > @@ -4730,9 +4730,9 @@ xlog_recover_process_cui( > if (test_bit(XFS_CUI_RECOVERED, &cuip->cui_flags)) > return 0; > > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > error = xfs_cui_recover(mp, cuip, dfops); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > > return error; > } > @@ -4748,9 +4748,9 @@ xlog_recover_cancel_cui( > > cuip = container_of(lip, struct xfs_cui_log_item, cui_item); > > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > xfs_cui_release(cuip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > } > > /* Recover the BUI if necessary. */ > @@ -4771,9 +4771,9 @@ xlog_recover_process_bui( > if (test_bit(XFS_BUI_RECOVERED, &buip->bui_flags)) > return 0; > > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > error = xfs_bui_recover(mp, buip, dfops); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > > return error; > } > @@ -4789,9 +4789,9 @@ xlog_recover_cancel_bui( > > buip = container_of(lip, struct xfs_bui_log_item, bui_item); > > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > xfs_bui_release(buip); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > } > > /* Is this log item a deferred action intent? */ > @@ -4879,7 +4879,7 @@ xlog_recover_process_intents( > #endif > > ailp = log->l_ailp; > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > lip = xfs_trans_ail_cursor_first(ailp, &cur, 0); > #if defined(DEBUG) || defined(XFS_WARN) > last_lsn = xlog_assign_lsn(log->l_curr_cycle, log->l_curr_block); > @@ -4933,7 +4933,7 @@ xlog_recover_process_intents( > } > out: > xfs_trans_ail_cursor_done(&cur); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > if (error) > xfs_defer_cancel(&dfops); > else > @@ -4956,7 +4956,7 @@ xlog_recover_cancel_intents( > struct xfs_ail *ailp; > > ailp = log->l_ailp; > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > lip = xfs_trans_ail_cursor_first(ailp, &cur, 0); > while (lip != NULL) { > /* > @@ -4990,7 +4990,7 @@ xlog_recover_cancel_intents( > } > > xfs_trans_ail_cursor_done(&cur); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > return error; > } > > diff --git a/fs/xfs/xfs_trans.c b/fs/xfs/xfs_trans.c > index a87f657f59c9..756e01999c24 100644 > --- a/fs/xfs/xfs_trans.c > +++ b/fs/xfs/xfs_trans.c > @@ -781,8 +781,8 @@ xfs_log_item_batch_insert( > { > int i; > > - spin_lock(&ailp->xa_lock); > - /* xfs_trans_ail_update_bulk drops ailp->xa_lock */ > + spin_lock(&ailp->ail_lock); > + /* xfs_trans_ail_update_bulk drops ailp->ail_lock */ > xfs_trans_ail_update_bulk(ailp, cur, log_items, nr_items, commit_lsn); > > for (i = 0; i < nr_items; i++) { > @@ -825,9 +825,9 @@ xfs_trans_committed_bulk( > struct xfs_ail_cursor cur; > int i = 0; > > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > xfs_trans_ail_cursor_last(ailp, &cur, commit_lsn); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > /* unpin all the log items */ > for (lv = log_vector; lv; lv = lv->lv_next ) { > @@ -847,7 +847,7 @@ xfs_trans_committed_bulk( > * object into the AIL as we are in a shutdown situation. > */ > if (aborted) { > - ASSERT(XFS_FORCED_SHUTDOWN(ailp->xa_mount)); > + ASSERT(XFS_FORCED_SHUTDOWN(ailp->ail_mount)); > lip->li_ops->iop_unpin(lip, 1); > continue; > } > @@ -861,11 +861,11 @@ xfs_trans_committed_bulk( > * not affect the AIL cursor the bulk insert path is > * using. > */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > if (XFS_LSN_CMP(item_lsn, lip->li_lsn) > 0) > xfs_trans_ail_update(ailp, lip, item_lsn); > else > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > lip->li_ops->iop_unpin(lip, 0); > continue; > } > @@ -883,9 +883,9 @@ xfs_trans_committed_bulk( > if (i) > xfs_log_item_batch_insert(ailp, &cur, log_items, i, commit_lsn); > > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > xfs_trans_ail_cursor_done(&cur); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > } > > /* > diff --git a/fs/xfs/xfs_trans_ail.c b/fs/xfs/xfs_trans_ail.c > index cef89f7127d3..d4a2445215e6 100644 > --- a/fs/xfs/xfs_trans_ail.c > +++ b/fs/xfs/xfs_trans_ail.c > @@ -40,7 +40,7 @@ xfs_ail_check( > { > xfs_log_item_t *prev_lip; > > - if (list_empty(&ailp->xa_ail)) > + if (list_empty(&ailp->ail_head)) > return; > > /* > @@ -48,11 +48,11 @@ xfs_ail_check( > */ > ASSERT((lip->li_flags & XFS_LI_IN_AIL) != 0); > prev_lip = list_entry(lip->li_ail.prev, xfs_log_item_t, li_ail); > - if (&prev_lip->li_ail != &ailp->xa_ail) > + if (&prev_lip->li_ail != &ailp->ail_head) > ASSERT(XFS_LSN_CMP(prev_lip->li_lsn, lip->li_lsn) <= 0); > > prev_lip = list_entry(lip->li_ail.next, xfs_log_item_t, li_ail); > - if (&prev_lip->li_ail != &ailp->xa_ail) > + if (&prev_lip->li_ail != &ailp->ail_head) > ASSERT(XFS_LSN_CMP(prev_lip->li_lsn, lip->li_lsn) >= 0); > > > @@ -69,10 +69,10 @@ static xfs_log_item_t * > xfs_ail_max( > struct xfs_ail *ailp) > { > - if (list_empty(&ailp->xa_ail)) > + if (list_empty(&ailp->ail_head)) > return NULL; > > - return list_entry(ailp->xa_ail.prev, xfs_log_item_t, li_ail); > + return list_entry(ailp->ail_head.prev, xfs_log_item_t, li_ail); > } > > /* > @@ -84,7 +84,7 @@ xfs_ail_next( > struct xfs_ail *ailp, > xfs_log_item_t *lip) > { > - if (lip->li_ail.next == &ailp->xa_ail) > + if (lip->li_ail.next == &ailp->ail_head) > return NULL; > > return list_first_entry(&lip->li_ail, xfs_log_item_t, li_ail); > @@ -105,11 +105,11 @@ xfs_ail_min_lsn( > xfs_lsn_t lsn = 0; > xfs_log_item_t *lip; > > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > lip = xfs_ail_min(ailp); > if (lip) > lsn = lip->li_lsn; > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > return lsn; > } > @@ -124,11 +124,11 @@ xfs_ail_max_lsn( > xfs_lsn_t lsn = 0; > xfs_log_item_t *lip; > > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > lip = xfs_ail_max(ailp); > if (lip) > lsn = lip->li_lsn; > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > return lsn; > } > @@ -146,7 +146,7 @@ xfs_trans_ail_cursor_init( > struct xfs_ail_cursor *cur) > { > cur->item = NULL; > - list_add_tail(&cur->list, &ailp->xa_cursors); > + list_add_tail(&cur->list, &ailp->ail_cursors); > } > > /* > @@ -194,7 +194,7 @@ xfs_trans_ail_cursor_clear( > { > struct xfs_ail_cursor *cur; > > - list_for_each_entry(cur, &ailp->xa_cursors, list) { > + list_for_each_entry(cur, &ailp->ail_cursors, list) { > if (cur->item == lip) > cur->item = (struct xfs_log_item *) > ((uintptr_t)cur->item | 1); > @@ -222,7 +222,7 @@ xfs_trans_ail_cursor_first( > goto out; > } > > - list_for_each_entry(lip, &ailp->xa_ail, li_ail) { > + list_for_each_entry(lip, &ailp->ail_head, li_ail) { > if (XFS_LSN_CMP(lip->li_lsn, lsn) >= 0) > goto out; > } > @@ -241,7 +241,7 @@ __xfs_trans_ail_cursor_last( > { > xfs_log_item_t *lip; > > - list_for_each_entry_reverse(lip, &ailp->xa_ail, li_ail) { > + list_for_each_entry_reverse(lip, &ailp->ail_head, li_ail) { > if (XFS_LSN_CMP(lip->li_lsn, lsn) <= 0) > return lip; > } > @@ -310,7 +310,7 @@ xfs_ail_splice( > if (lip) > list_splice(list, &lip->li_ail); > else > - list_splice(list, &ailp->xa_ail); > + list_splice(list, &ailp->ail_head); > } > > /* > @@ -335,17 +335,17 @@ xfsaild_push_item( > * If log item pinning is enabled, skip the push and track the item as > * pinned. This can help induce head-behind-tail conditions. > */ > - if (XFS_TEST_ERROR(false, ailp->xa_mount, XFS_ERRTAG_LOG_ITEM_PIN)) > + if (XFS_TEST_ERROR(false, ailp->ail_mount, XFS_ERRTAG_LOG_ITEM_PIN)) > return XFS_ITEM_PINNED; > > - return lip->li_ops->iop_push(lip, &ailp->xa_buf_list); > + return lip->li_ops->iop_push(lip, &ailp->ail_buf_list); > } > > static long > xfsaild_push( > struct xfs_ail *ailp) > { > - xfs_mount_t *mp = ailp->xa_mount; > + xfs_mount_t *mp = ailp->ail_mount; > struct xfs_ail_cursor cur; > xfs_log_item_t *lip; > xfs_lsn_t lsn; > @@ -360,30 +360,30 @@ xfsaild_push( > * buffers the last time we ran, force the log first and wait for it > * before pushing again. > */ > - if (ailp->xa_log_flush && ailp->xa_last_pushed_lsn == 0 && > - (!list_empty_careful(&ailp->xa_buf_list) || > + if (ailp->ail_log_flush && ailp->ail_last_pushed_lsn == 0 && > + (!list_empty_careful(&ailp->ail_buf_list) || > xfs_ail_min_lsn(ailp))) { > - ailp->xa_log_flush = 0; > + ailp->ail_log_flush = 0; > > XFS_STATS_INC(mp, xs_push_ail_flush); > xfs_log_force(mp, XFS_LOG_SYNC); > } > > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > > - /* barrier matches the xa_target update in xfs_ail_push() */ > + /* barrier matches the ail_target update in xfs_ail_push() */ > smp_rmb(); > - target = ailp->xa_target; > - ailp->xa_target_prev = target; > + target = ailp->ail_target; > + ailp->ail_target_prev = target; > > - lip = xfs_trans_ail_cursor_first(ailp, &cur, ailp->xa_last_pushed_lsn); > + lip = xfs_trans_ail_cursor_first(ailp, &cur, ailp->ail_last_pushed_lsn); > if (!lip) { > /* > * If the AIL is empty or our push has reached the end we are > * done now. > */ > xfs_trans_ail_cursor_done(&cur); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > goto out_done; > } > > @@ -404,7 +404,7 @@ xfsaild_push( > XFS_STATS_INC(mp, xs_push_ail_success); > trace_xfs_ail_push(lip); > > - ailp->xa_last_pushed_lsn = lsn; > + ailp->ail_last_pushed_lsn = lsn; > break; > > case XFS_ITEM_FLUSHING: > @@ -423,7 +423,7 @@ xfsaild_push( > trace_xfs_ail_flushing(lip); > > flushing++; > - ailp->xa_last_pushed_lsn = lsn; > + ailp->ail_last_pushed_lsn = lsn; > break; > > case XFS_ITEM_PINNED: > @@ -431,7 +431,7 @@ xfsaild_push( > trace_xfs_ail_pinned(lip); > > stuck++; > - ailp->xa_log_flush++; > + ailp->ail_log_flush++; > break; > case XFS_ITEM_LOCKED: > XFS_STATS_INC(mp, xs_push_ail_locked); > @@ -468,10 +468,10 @@ xfsaild_push( > lsn = lip->li_lsn; > } > xfs_trans_ail_cursor_done(&cur); > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > - if (xfs_buf_delwri_submit_nowait(&ailp->xa_buf_list)) > - ailp->xa_log_flush++; > + if (xfs_buf_delwri_submit_nowait(&ailp->ail_buf_list)) > + ailp->ail_log_flush++; > > if (!count || XFS_LSN_CMP(lsn, target) >= 0) { > out_done: > @@ -481,7 +481,7 @@ xfsaild_push( > * AIL before we start the next scan from the start of the AIL. > */ > tout = 50; > - ailp->xa_last_pushed_lsn = 0; > + ailp->ail_last_pushed_lsn = 0; > } else if (((stuck + flushing) * 100) / count > 90) { > /* > * Either there is a lot of contention on the AIL or we are > @@ -494,7 +494,7 @@ xfsaild_push( > * the restart to issue a log force to unpin the stuck items. > */ > tout = 20; > - ailp->xa_last_pushed_lsn = 0; > + ailp->ail_last_pushed_lsn = 0; > } else { > /* > * Assume we have more work to do in a short while. > @@ -536,26 +536,26 @@ xfsaild( > break; > } > > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > > /* > * Idle if the AIL is empty and we are not racing with a target > * update. We check the AIL after we set the task to a sleep > - * state to guarantee that we either catch an xa_target update > + * state to guarantee that we either catch an ail_target update > * or that a wake_up resets the state to TASK_RUNNING. > * Otherwise, we run the risk of sleeping indefinitely. > * > - * The barrier matches the xa_target update in xfs_ail_push(). > + * The barrier matches the ail_target update in xfs_ail_push(). > */ > smp_rmb(); > if (!xfs_ail_min(ailp) && > - ailp->xa_target == ailp->xa_target_prev) { > - spin_unlock(&ailp->xa_lock); > + ailp->ail_target == ailp->ail_target_prev) { > + spin_unlock(&ailp->ail_lock); > freezable_schedule(); > tout = 0; > continue; > } > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > if (tout) > freezable_schedule_timeout(msecs_to_jiffies(tout)); > @@ -592,8 +592,8 @@ xfs_ail_push( > xfs_log_item_t *lip; > > lip = xfs_ail_min(ailp); > - if (!lip || XFS_FORCED_SHUTDOWN(ailp->xa_mount) || > - XFS_LSN_CMP(threshold_lsn, ailp->xa_target) <= 0) > + if (!lip || XFS_FORCED_SHUTDOWN(ailp->ail_mount) || > + XFS_LSN_CMP(threshold_lsn, ailp->ail_target) <= 0) > return; > > /* > @@ -601,10 +601,10 @@ xfs_ail_push( > * the XFS_AIL_PUSHING_BIT. > */ > smp_wmb(); > - xfs_trans_ail_copy_lsn(ailp, &ailp->xa_target, &threshold_lsn); > + xfs_trans_ail_copy_lsn(ailp, &ailp->ail_target, &threshold_lsn); > smp_wmb(); > > - wake_up_process(ailp->xa_task); > + wake_up_process(ailp->ail_task); > } > > /* > @@ -630,18 +630,18 @@ xfs_ail_push_all_sync( > struct xfs_log_item *lip; > DEFINE_WAIT(wait); > > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > while ((lip = xfs_ail_max(ailp)) != NULL) { > - prepare_to_wait(&ailp->xa_empty, &wait, TASK_UNINTERRUPTIBLE); > - ailp->xa_target = lip->li_lsn; > - wake_up_process(ailp->xa_task); > - spin_unlock(&ailp->xa_lock); > + prepare_to_wait(&ailp->ail_empty, &wait, TASK_UNINTERRUPTIBLE); > + ailp->ail_target = lip->li_lsn; > + wake_up_process(ailp->ail_task); > + spin_unlock(&ailp->ail_lock); > schedule(); > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > } > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > > - finish_wait(&ailp->xa_empty, &wait); > + finish_wait(&ailp->ail_empty, &wait); > } > > /* > @@ -672,7 +672,7 @@ xfs_trans_ail_update_bulk( > struct xfs_ail_cursor *cur, > struct xfs_log_item **log_items, > int nr_items, > - xfs_lsn_t lsn) __releases(ailp->xa_lock) > + xfs_lsn_t lsn) __releases(ailp->ail_lock) > { > xfs_log_item_t *mlip; > int mlip_changed = 0; > @@ -705,13 +705,13 @@ xfs_trans_ail_update_bulk( > xfs_ail_splice(ailp, cur, &tmp, lsn); > > if (mlip_changed) { > - if (!XFS_FORCED_SHUTDOWN(ailp->xa_mount)) > - xlog_assign_tail_lsn_locked(ailp->xa_mount); > - spin_unlock(&ailp->xa_lock); > + if (!XFS_FORCED_SHUTDOWN(ailp->ail_mount)) > + xlog_assign_tail_lsn_locked(ailp->ail_mount); > + spin_unlock(&ailp->ail_lock); > > - xfs_log_space_wake(ailp->xa_mount); > + xfs_log_space_wake(ailp->ail_mount); > } else { > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > } > } > > @@ -756,13 +756,13 @@ void > xfs_trans_ail_delete( > struct xfs_ail *ailp, > struct xfs_log_item *lip, > - int shutdown_type) __releases(ailp->xa_lock) > + int shutdown_type) __releases(ailp->ail_lock) > { > - struct xfs_mount *mp = ailp->xa_mount; > + struct xfs_mount *mp = ailp->ail_mount; > bool mlip_changed; > > if (!(lip->li_flags & XFS_LI_IN_AIL)) { > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > if (!XFS_FORCED_SHUTDOWN(mp)) { > xfs_alert_tag(mp, XFS_PTAG_AILDELETE, > "%s: attempting to delete a log item that is not in the AIL", > @@ -776,13 +776,13 @@ xfs_trans_ail_delete( > if (mlip_changed) { > if (!XFS_FORCED_SHUTDOWN(mp)) > xlog_assign_tail_lsn_locked(mp); > - if (list_empty(&ailp->xa_ail)) > - wake_up_all(&ailp->xa_empty); > + if (list_empty(&ailp->ail_head)) > + wake_up_all(&ailp->ail_empty); > } > > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > if (mlip_changed) > - xfs_log_space_wake(ailp->xa_mount); > + xfs_log_space_wake(ailp->ail_mount); > } > > int > @@ -795,16 +795,16 @@ xfs_trans_ail_init( > if (!ailp) > return -ENOMEM; > > - ailp->xa_mount = mp; > - INIT_LIST_HEAD(&ailp->xa_ail); > - INIT_LIST_HEAD(&ailp->xa_cursors); > - spin_lock_init(&ailp->xa_lock); > - INIT_LIST_HEAD(&ailp->xa_buf_list); > - init_waitqueue_head(&ailp->xa_empty); > + ailp->ail_mount = mp; > + INIT_LIST_HEAD(&ailp->ail_head); > + INIT_LIST_HEAD(&ailp->ail_cursors); > + spin_lock_init(&ailp->ail_lock); > + INIT_LIST_HEAD(&ailp->ail_buf_list); > + init_waitqueue_head(&ailp->ail_empty); > > - ailp->xa_task = kthread_run(xfsaild, ailp, "xfsaild/%s", > - ailp->xa_mount->m_fsname); > - if (IS_ERR(ailp->xa_task)) > + ailp->ail_task = kthread_run(xfsaild, ailp, "xfsaild/%s", > + ailp->ail_mount->m_fsname); > + if (IS_ERR(ailp->ail_task)) > goto out_free_ailp; > > mp->m_ail = ailp; > @@ -821,6 +821,6 @@ xfs_trans_ail_destroy( > { > struct xfs_ail *ailp = mp->m_ail; > > - kthread_stop(ailp->xa_task); > + kthread_stop(ailp->ail_task); > kmem_free(ailp); > } > diff --git a/fs/xfs/xfs_trans_buf.c b/fs/xfs/xfs_trans_buf.c > index 3ba7a96a8abd..b8871bcfe00b 100644 > --- a/fs/xfs/xfs_trans_buf.c > +++ b/fs/xfs/xfs_trans_buf.c > @@ -429,8 +429,8 @@ xfs_trans_brelse(xfs_trans_t *tp, > * If the fs has shutdown and we dropped the last reference, it may fall > * on us to release a (possibly dirty) bli if it never made it to the > * AIL (e.g., the aborted unpin already happened and didn't release it > - * due to our reference). Since we're already shutdown and need xa_lock, > - * just force remove from the AIL and release the bli here. > + * due to our reference). Since we're already shutdown and need > + * ail_lock, just force remove from the AIL and release the bli here. > */ > if (XFS_FORCED_SHUTDOWN(tp->t_mountp) && freed) { > xfs_trans_ail_remove(&bip->bli_item, SHUTDOWN_LOG_IO_ERROR); > diff --git a/fs/xfs/xfs_trans_priv.h b/fs/xfs/xfs_trans_priv.h > index b317a3644c00..be24b0c8a332 100644 > --- a/fs/xfs/xfs_trans_priv.h > +++ b/fs/xfs/xfs_trans_priv.h > @@ -65,17 +65,17 @@ struct xfs_ail_cursor { > * Eventually we need to drive the locking in here as well. > */ > struct xfs_ail { > - struct xfs_mount *xa_mount; > - struct task_struct *xa_task; > - struct list_head xa_ail; > - xfs_lsn_t xa_target; > - xfs_lsn_t xa_target_prev; > - struct list_head xa_cursors; > - spinlock_t xa_lock; > - xfs_lsn_t xa_last_pushed_lsn; > - int xa_log_flush; > - struct list_head xa_buf_list; > - wait_queue_head_t xa_empty; > + struct xfs_mount *ail_mount; > + struct task_struct *ail_task; > + struct list_head ail_head; > + xfs_lsn_t ail_target; > + xfs_lsn_t ail_target_prev; > + struct list_head ail_cursors; > + spinlock_t ail_lock; > + xfs_lsn_t ail_last_pushed_lsn; > + int ail_log_flush; > + struct list_head ail_buf_list; > + wait_queue_head_t ail_empty; > }; > > /* > @@ -84,7 +84,7 @@ struct xfs_ail { > void xfs_trans_ail_update_bulk(struct xfs_ail *ailp, > struct xfs_ail_cursor *cur, > struct xfs_log_item **log_items, int nr_items, > - xfs_lsn_t lsn) __releases(ailp->xa_lock); > + xfs_lsn_t lsn) __releases(ailp->ail_lock); > /* > * Return a pointer to the first item in the AIL. If the AIL is empty, then > * return NULL. > @@ -93,7 +93,7 @@ static inline struct xfs_log_item * > xfs_ail_min( > struct xfs_ail *ailp) > { > - return list_first_entry_or_null(&ailp->xa_ail, struct xfs_log_item, > + return list_first_entry_or_null(&ailp->ail_head, struct xfs_log_item, > li_ail); > } > > @@ -101,14 +101,14 @@ static inline void > xfs_trans_ail_update( > struct xfs_ail *ailp, > struct xfs_log_item *lip, > - xfs_lsn_t lsn) __releases(ailp->xa_lock) > + xfs_lsn_t lsn) __releases(ailp->ail_lock) > { > xfs_trans_ail_update_bulk(ailp, NULL, &lip, 1, lsn); > } > > bool xfs_ail_delete_one(struct xfs_ail *ailp, struct xfs_log_item *lip); > void xfs_trans_ail_delete(struct xfs_ail *ailp, struct xfs_log_item *lip, > - int shutdown_type) __releases(ailp->xa_lock); > + int shutdown_type) __releases(ailp->ail_lock); > > static inline void > xfs_trans_ail_remove( > @@ -117,12 +117,12 @@ xfs_trans_ail_remove( > { > struct xfs_ail *ailp = lip->li_ailp; > > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > /* xfs_trans_ail_delete() drops the AIL lock */ > if (lip->li_flags & XFS_LI_IN_AIL) > xfs_trans_ail_delete(ailp, lip, shutdown_type); > else > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > } > > void xfs_ail_push(struct xfs_ail *, xfs_lsn_t); > @@ -149,9 +149,9 @@ xfs_trans_ail_copy_lsn( > xfs_lsn_t *src) > { > ASSERT(sizeof(xfs_lsn_t) == 8); /* don't lock if it shrinks */ > - spin_lock(&ailp->xa_lock); > + spin_lock(&ailp->ail_lock); > *dst = *src; > - spin_unlock(&ailp->xa_lock); > + spin_unlock(&ailp->ail_lock); > } > #else > static inline void > @@ -172,7 +172,7 @@ xfs_clear_li_failed( > struct xfs_buf *bp = lip->li_buf; > > ASSERT(lip->li_flags & XFS_LI_IN_AIL); > - lockdep_assert_held(&lip->li_ailp->xa_lock); > + lockdep_assert_held(&lip->li_ailp->ail_lock); > > if (lip->li_flags & XFS_LI_FAILED) { > lip->li_flags &= ~XFS_LI_FAILED; > @@ -186,7 +186,7 @@ xfs_set_li_failed( > struct xfs_log_item *lip, > struct xfs_buf *bp) > { > - lockdep_assert_held(&lip->li_ailp->xa_lock); > + lockdep_assert_held(&lip->li_ailp->ail_lock); > > if (!(lip->li_flags & XFS_LI_FAILED)) { > xfs_buf_hold(bp); > -- > 2.15.1 > > -- > To unsubscribe from this list: send the line "unsubscribe linux-xfs" in > the body of a message to majordomo@vger.kernel.org > More majordomo info at http://vger.kernel.org/majordomo-info.html -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to majordomo@kvack.org. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: email@kvack.org