lkml.org 
[lkml]   [2009]   [Jun]   [9]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    From
    Subject[patch 51/60] jbd2: Update locking coments

    -stable review patch. If anyone has any objections, please let us know.

    ------------------
    From: Jan Kara <jack@suse.cz>

    (cherry picked from commit 86db97c87f744364d5889ca8a4134ca2048b8f83)

    Update information about locking in JBD2 revoke code. Inconsistency in
    comments found by Lin Tan <tammy000@gmail.com>

    CC: Lin Tan <tammy000@gmail.com>
    Signed-off-by: Jan Kara <jack@suse.cz>
    Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
    Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
    ---
    fs/jbd2/revoke.c | 24 +++++++++++++++++++-----
    1 file changed, 19 insertions(+), 5 deletions(-)

    --- a/fs/jbd2/revoke.c
    +++ b/fs/jbd2/revoke.c
    @@ -55,6 +55,25 @@
    * need do nothing.
    * RevokeValid set, Revoked set:
    * buffer has been revoked.
    + *
    + * Locking rules:
    + * We keep two hash tables of revoke records. One hashtable belongs to the
    + * running transaction (is pointed to by journal->j_revoke), the other one
    + * belongs to the committing transaction. Accesses to the second hash table
    + * happen only from the kjournald and no other thread touches this table. Also
    + * journal_switch_revoke_table() which switches which hashtable belongs to the
    + * running and which to the committing transaction is called only from
    + * kjournald. Therefore we need no locks when accessing the hashtable belonging
    + * to the committing transaction.
    + *
    + * All users operating on the hash table belonging to the running transaction
    + * have a handle to the transaction. Therefore they are safe from kjournald
    + * switching hash tables under them. For operations on the lists of entries in
    + * the hash table j_revoke_lock is used.
    + *
    + * Finally, also replay code uses the hash tables but at this moment noone else
    + * can touch them (filesystem isn't mounted yet) and hence no locking is
    + * needed.
    */

    #ifndef __KERNEL__
    @@ -401,8 +420,6 @@ int jbd2_journal_revoke(handle_t *handle
    * the second time we would still have a pending revoke to cancel. So,
    * do not trust the Revoked bit on buffers unless RevokeValid is also
    * set.
    - *
    - * The caller must have the journal locked.
    */
    int jbd2_journal_cancel_revoke(handle_t *handle, struct journal_head *jh)
    {
    @@ -480,10 +497,7 @@ void jbd2_journal_switch_revoke_table(jo
    /*
    * Write revoke records to the journal for all entries in the current
    * revoke hash, deleting the entries as we go.
    - *
    - * Called with the journal lock held.
    */
    -
    void jbd2_journal_write_revoke_records(journal_t *journal,
    transaction_t *transaction)
    {



    \
     
     \ /
      Last update: 2009-06-10 06:03    [W:4.094 / U:0.008 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site