LXR linux/fs/reiserfs/lock.c

   1// SPDX-License-Identifier: GPL-2.0
   2#include "reiserfs.h"
   3#include <linux/mutex.h>
   4
   5/*
   6 * The previous reiserfs locking scheme was heavily based on
   7 * the tricky properties of the Bkl:
   8 *
   9 * - it was acquired recursively by a same task
  10 * - the performances relied on the release-while-schedule() property
  11 *
  12 * Now that we replace it by a mutex, we still want to keep the same
  13 * recursive property to avoid big changes in the code structure.
  14 * We use our own lock_owner here because the owner field on a mutex
  15 * is only available in SMP or mutex debugging, also we only need this field
  16 * for this mutex, no need for a system wide mutex facility.
  17 *
  18 * Also this lock is often released before a call that could block because
  19 * reiserfs performances were partially based on the release while schedule()
  20 * property of the Bkl.
  21 */
  22void reiserfs_write_lock(struct super_block *s)
  23{
  24        struct reiserfs_sb_info *sb_i = REISERFS_SB(s);
  25
  26        if (sb_i->lock_owner != current) {
  27                mutex_lock(&sb_i->lock);
  28                sb_i->lock_owner = current;
  29        }
  30
  31        /* No need to protect it, only the current task touches it */
  32        sb_i->lock_depth++;
  33}
  34
  35void reiserfs_write_unlock(struct super_block *s)
  36{
  37        struct reiserfs_sb_info *sb_i = REISERFS_SB(s);
  38
  39        /*
  40         * Are we unlocking without even holding the lock?
  41         * Such a situation must raise a BUG() if we don't want
  42         * to corrupt the data.
  43         */
  44        BUG_ON(sb_i->lock_owner != current);
  45
  46        if (--sb_i->lock_depth == -1) {
  47                sb_i->lock_owner = NULL;
  48                mutex_unlock(&sb_i->lock);
  49        }
  50}
  51
  52int __must_check reiserfs_write_unlock_nested(struct super_block *s)
  53{
  54        struct reiserfs_sb_info *sb_i = REISERFS_SB(s);
  55        int depth;
  56
  57        /* this can happen when the lock isn't always held */
  58        if (sb_i->lock_owner != current)
  59                return -1;
  60
  61        depth = sb_i->lock_depth;
  62
  63        sb_i->lock_depth = -1;
  64        sb_i->lock_owner = NULL;
  65        mutex_unlock(&sb_i->lock);
  66
  67        return depth;
  68}
  69
  70void reiserfs_write_lock_nested(struct super_block *s, int depth)
  71{
  72        struct reiserfs_sb_info *sb_i = REISERFS_SB(s);
  73
  74        /* this can happen when the lock isn't always held */
  75        if (depth == -1)
  76                return;
  77
  78        mutex_lock(&sb_i->lock);
  79        sb_i->lock_owner = current;
  80        sb_i->lock_depth = depth;
  81}
  82
  83/*
  84 * Utility function to force a BUG if it is called without the superblock
  85 * write lock held.  caller is the string printed just before calling BUG()
  86 */
  87void reiserfs_check_lock_depth(struct super_block *sb, char *caller)
  88{
  89        struct reiserfs_sb_info *sb_i = REISERFS_SB(sb);
  90
  91        WARN_ON(sb_i->lock_depth < 0);
  92}
  93
  94#ifdef CONFIG_REISERFS_CHECK
  95void reiserfs_lock_check_recursive(struct super_block *sb)
  96{
  97        struct reiserfs_sb_info *sb_i = REISERFS_SB(sb);
  98
  99        WARN_ONCE((sb_i->lock_depth > 0), "Unwanted recursive reiserfs lock!\n");
 100}
 101#endif
 102