linux-imx

/*

   lru_cache.c

​

   This file is part of DRBD by Philipp Reisner and Lars Ellenberg.

​

   Copyright (C) 2003-2008, LINBIT Information Technologies GmbH.

   Copyright (C) 2003-2008, Philipp Reisner <philipp.reisner@linbit.com>.

   Copyright (C) 2003-2008, Lars Ellenberg <lars.ellenberg@linbit.com>.

​

   drbd is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 2, or (at your option)

   any later version.

​

   drbd is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

​

   You should have received a copy of the GNU General Public License

   along with drbd; see the file COPYING.  If not, write to

   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.

​

 */

​

#include <linux/module.h>

#include <linux/bitops.h>

#include <linux/slab.h>

#include <linux/string.h> /* for memset */

#include <linux/seq_file.h> /* for seq_printf */

#include <linux/lru_cache.h>

​

MODULE_AUTHOR("Philipp Reisner <phil@linbit.com>, "

          "Lars Ellenberg <lars@linbit.com>");

MODULE_DESCRIPTION("lru_cache - Track sets of hot objects");

MODULE_LICENSE("GPL");

​

/* this is developers aid only.

 * it catches concurrent access (lack of locking on the users part) */

#define PARANOIA_ENTRY() do {       \

    BUG_ON(!lc);            \

    BUG_ON(!lc->nr_elements);   \

    BUG_ON(test_and_set_bit(__LC_PARANOIA, &lc->flags)); \

} while (0)

​

#define RETURN(x...)     do { \

    clear_bit_unlock(__LC_PARANOIA, &lc->flags); \

    return x ; } while (0)

​

/* BUG() if e is not one of the elements tracked by lc */

#define PARANOIA_LC_ELEMENT(lc, e) do { \

    struct lru_cache *lc_ = (lc);   \

    struct lc_element *e_ = (e);    \

    unsigned i = e_->lc_index;  \

    BUG_ON(i >= lc_->nr_elements);  \

    BUG_ON(lc_->lc_element[i] != e_); } while (0)

​

​

/* We need to atomically

 *  - try to grab the lock (set LC_LOCKED)

 *  - only if there is no pending transaction

 *    (neither LC_DIRTY nor LC_STARVING is set)

 * Because of PARANOIA_ENTRY() above abusing lc->flags as well,

 * it is not sufficient to just say

 *  return 0 == cmpxchg(&lc->flags, 0, LC_LOCKED);

 */

int lc_try_lock(struct lru_cache *lc)

{

    unsigned long val;

    do {

        val = cmpxchg(&lc->flags, 0, LC_LOCKED);

    } while (unlikely (val == LC_PARANOIA));

    /* Spin until no-one is inside a PARANOIA_ENTRY()/RETURN() section. */

    return 0 == val;

#if 0

    /* Alternative approach, spin in case someone enters or leaves a

     * PARANOIA_ENTRY()/RETURN() section. */

    unsigned long old, new, val;

    do {

        old = lc->flags & LC_PARANOIA;

        new = old | LC_LOCKED;

        val = cmpxchg(&lc->flags, old, new);

    } while (unlikely (val == (old ^ LC_PARANOIA)));

    return old == val;

#endif

}

​

/**

 * lc_create - prepares to track objects in an active set

 * @name: descriptive name only used in lc_seq_printf_stats and lc_seq_dump_details

 * @max_pending_changes: maximum changes to accumulate until a transaction is required

 * @e_count: number of elements allowed to be active simultaneously