linux/drivers/hwspinlock/hwspinlock_core.c
<<
>>
Prefs
   1/*
   2 * Hardware spinlock framework
   3 *
   4 * Copyright (C) 2010 Texas Instruments Incorporated - http://www.ti.com
   5 *
   6 * Contact: Ohad Ben-Cohen <ohad@wizery.com>
   7 *
   8 * This program is free software; you can redistribute it and/or modify it
   9 * under the terms of the GNU General Public License version 2 as published
  10 * by the Free Software Foundation.
  11 *
  12 * This program is distributed in the hope that it will be useful,
  13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 * GNU General Public License for more details.
  16 */
  17
  18#define pr_fmt(fmt)    "%s: " fmt, __func__
  19
  20#include <linux/kernel.h>
  21#include <linux/module.h>
  22#include <linux/spinlock.h>
  23#include <linux/types.h>
  24#include <linux/err.h>
  25#include <linux/jiffies.h>
  26#include <linux/radix-tree.h>
  27#include <linux/hwspinlock.h>
  28#include <linux/pm_runtime.h>
  29#include <linux/mutex.h>
  30
  31#include "hwspinlock_internal.h"
  32
  33/* radix tree tags */
  34#define HWSPINLOCK_UNUSED       (0) /* tags an hwspinlock as unused */
  35
  36/*
  37 * A radix tree is used to maintain the available hwspinlock instances.
  38 * The tree associates hwspinlock pointers with their integer key id,
  39 * and provides easy-to-use API which makes the hwspinlock core code simple
  40 * and easy to read.
  41 *
  42 * Radix trees are quick on lookups, and reasonably efficient in terms of
  43 * storage, especially with high density usages such as this framework
  44 * requires (a continuous range of integer keys, beginning with zero, is
  45 * used as the ID's of the hwspinlock instances).
  46 *
  47 * The radix tree API supports tagging items in the tree, which this
  48 * framework uses to mark unused hwspinlock instances (see the
  49 * HWSPINLOCK_UNUSED tag above). As a result, the process of querying the
  50 * tree, looking for an unused hwspinlock instance, is now reduced to a
  51 * single radix tree API call.
  52 */
  53static RADIX_TREE(hwspinlock_tree, GFP_KERNEL);
  54
  55/*
  56 * Synchronization of access to the tree is achieved using this mutex,
  57 * as the radix-tree API requires that users provide all synchronisation.
  58 * A mutex is needed because we're using non-atomic radix tree allocations.
  59 */
  60static DEFINE_MUTEX(hwspinlock_tree_lock);
  61
  62
  63/**
  64 * __hwspin_trylock() - attempt to lock a specific hwspinlock
  65 * @hwlock: an hwspinlock which we want to trylock
  66 * @mode: controls whether local interrupts are disabled or not
  67 * @flags: a pointer where the caller's interrupt state will be saved at (if
  68 *         requested)
  69 *
  70 * This function attempts to lock an hwspinlock, and will immediately
  71 * fail if the hwspinlock is already taken.
  72 *
  73 * Upon a successful return from this function, preemption (and possibly
  74 * interrupts) is disabled, so the caller must not sleep, and is advised to
  75 * release the hwspinlock as soon as possible. This is required in order to
  76 * minimize remote cores polling on the hardware interconnect.
  77 *
  78 * The user decides whether local interrupts are disabled or not, and if yes,
  79 * whether he wants their previous state to be saved. It is up to the user
  80 * to choose the appropriate @mode of operation, exactly the same way users
  81 * should decide between spin_trylock, spin_trylock_irq and
  82 * spin_trylock_irqsave.
  83 *
  84 * Returns 0 if we successfully locked the hwspinlock or -EBUSY if
  85 * the hwspinlock was already taken.
  86 * This function will never sleep.
  87 */
  88int __hwspin_trylock(struct hwspinlock *hwlock, int mode, unsigned long *flags)
  89{
  90        int ret;
  91
  92        BUG_ON(!hwlock);
  93        BUG_ON(!flags && mode == HWLOCK_IRQSTATE);
  94
  95        /*
  96         * This spin_lock{_irq, _irqsave} serves three purposes:
  97         *
  98         * 1. Disable preemption, in order to minimize the period of time
  99         *    in which the hwspinlock is taken. This is important in order
 100         *    to minimize the possible polling on the hardware interconnect
 101         *    by a remote user of this lock.
 102         * 2. Make the hwspinlock SMP-safe (so we can take it from
 103         *    additional contexts on the local host).
 104         * 3. Ensure that in_atomic/might_sleep checks catch potential
 105         *    problems with hwspinlock usage (e.g. scheduler checks like
 106         *    'scheduling while atomic' etc.)
 107         */
 108        if (mode == HWLOCK_IRQSTATE)
 109                ret = spin_trylock_irqsave(&hwlock->lock, *flags);
 110        else if (mode == HWLOCK_IRQ)
 111                ret = spin_trylock_irq(&hwlock->lock);
 112        else
 113                ret = spin_trylock(&hwlock->lock);
 114
 115        /* is lock already taken by another context on the local cpu ? */
 116        if (!ret)
 117                return -EBUSY;
 118
 119        /* try to take the hwspinlock device */
 120        ret = hwlock->bank->ops->trylock(hwlock);
 121
 122        /* if hwlock is already taken, undo spin_trylock_* and exit */
 123        if (!ret) {
 124                if (mode == HWLOCK_IRQSTATE)
 125                        spin_unlock_irqrestore(&hwlock->lock, *flags);
 126                else if (mode == HWLOCK_IRQ)
 127                        spin_unlock_irq(&hwlock->lock);
 128                else
 129                        spin_unlock(&hwlock->lock);
 130
 131                return -EBUSY;
 132        }
 133
 134        /*
 135         * We can be sure the other core's memory operations
 136         * are observable to us only _after_ we successfully take
 137         * the hwspinlock, and we must make sure that subsequent memory
 138         * operations (both reads and writes) will not be reordered before
 139         * we actually took the hwspinlock.
 140         *
 141         * Note: the implicit memory barrier of the spinlock above is too
 142         * early, so we need this additional explicit memory barrier.
 143         */
 144        mb();
 145
 146        return 0;
 147}
 148EXPORT_SYMBOL_GPL(__hwspin_trylock);
 149
 150/**
 151 * __hwspin_lock_timeout() - lock an hwspinlock with timeout limit
 152 * @hwlock: the hwspinlock to be locked
 153 * @timeout: timeout value in msecs
 154 * @mode: mode which controls whether local interrupts are disabled or not
 155 * @flags: a pointer to where the caller's interrupt state will be saved at (if
 156 *         requested)
 157 *
 158 * This function locks the given @hwlock. If the @hwlock
 159 * is already taken, the function will busy loop waiting for it to
 160 * be released, but give up after @timeout msecs have elapsed.
 161 *
 162 * Upon a successful return from this function, preemption is disabled
 163 * (and possibly local interrupts, too), so the caller must not sleep,
 164 * and is advised to release the hwspinlock as soon as possible.
 165 * This is required in order to minimize remote cores polling on the
 166 * hardware interconnect.
 167 *
 168 * The user decides whether local interrupts are disabled or not, and if yes,
 169 * whether he wants their previous state to be saved. It is up to the user
 170 * to choose the appropriate @mode of operation, exactly the same way users
 171 * should decide between spin_lock, spin_lock_irq and spin_lock_irqsave.
 172 *
 173 * Returns 0 when the @hwlock was successfully taken, and an appropriate
 174 * error code otherwise (most notably -ETIMEDOUT if the @hwlock is still
 175 * busy after @timeout msecs). The function will never sleep.
 176 */
 177int __hwspin_lock_timeout(struct hwspinlock *hwlock, unsigned int to,
 178                                        int mode, unsigned long *flags)
 179{
 180        int ret;
 181        unsigned long expire;
 182
 183        expire = msecs_to_jiffies(to) + jiffies;
 184
 185        for (;;) {
 186                /* Try to take the hwspinlock */
 187                ret = __hwspin_trylock(hwlock, mode, flags);
 188                if (ret != -EBUSY)
 189                        break;
 190
 191                /*
 192                 * The lock is already taken, let's check if the user wants
 193                 * us to try again
 194                 */
 195                if (time_is_before_eq_jiffies(expire))
 196                        return -ETIMEDOUT;
 197
 198                /*
 199                 * Allow platform-specific relax handlers to prevent
 200                 * hogging the interconnect (no sleeping, though)
 201                 */
 202                if (hwlock->bank->ops->relax)
 203                        hwlock->bank->ops->relax(hwlock);
 204        }
 205
 206        return ret;
 207}
 208EXPORT_SYMBOL_GPL(__hwspin_lock_timeout);
 209
 210/**
 211 * __hwspin_unlock() - unlock a specific hwspinlock
 212 * @hwlock: a previously-acquired hwspinlock which we want to unlock
 213 * @mode: controls whether local interrupts needs to be restored or not
 214 * @flags: previous caller's interrupt state to restore (if requested)
 215 *
 216 * This function will unlock a specific hwspinlock, enable preemption and
 217 * (possibly) enable interrupts or restore their previous state.
 218 * @hwlock must be already locked before calling this function: it is a bug
 219 * to call unlock on a @hwlock that is already unlocked.
 220 *
 221 * The user decides whether local interrupts should be enabled or not, and
 222 * if yes, whether he wants their previous state to be restored. It is up
 223 * to the user to choose the appropriate @mode of operation, exactly the
 224 * same way users decide between spin_unlock, spin_unlock_irq and
 225 * spin_unlock_irqrestore.
 226 *
 227 * The function will never sleep.
 228 */
 229void __hwspin_unlock(struct hwspinlock *hwlock, int mode, unsigned long *flags)
 230{
 231        BUG_ON(!hwlock);
 232        BUG_ON(!flags && mode == HWLOCK_IRQSTATE);
 233
 234        /*
 235         * We must make sure that memory operations (both reads and writes),
 236         * done before unlocking the hwspinlock, will not be reordered
 237         * after the lock is released.
 238         *
 239         * That's the purpose of this explicit memory barrier.
 240         *
 241         * Note: the memory barrier induced by the spin_unlock below is too
 242         * late; the other core is going to access memory soon after it will
 243         * take the hwspinlock, and by then we want to be sure our memory
 244         * operations are already observable.
 245         */
 246        mb();
 247
 248        hwlock->bank->ops->unlock(hwlock);
 249
 250        /* Undo the spin_trylock{_irq, _irqsave} called while locking */
 251        if (mode == HWLOCK_IRQSTATE)
 252                spin_unlock_irqrestore(&hwlock->lock, *flags);
 253        else if (mode == HWLOCK_IRQ)
 254                spin_unlock_irq(&hwlock->lock);
 255        else
 256                spin_unlock(&hwlock->lock);
 257}
 258EXPORT_SYMBOL_GPL(__hwspin_unlock);
 259
 260static int hwspin_lock_register_single(struct hwspinlock *hwlock, int id)
 261{
 262        struct hwspinlock *tmp;
 263        int ret;
 264
 265        mutex_lock(&hwspinlock_tree_lock);
 266
 267        ret = radix_tree_insert(&hwspinlock_tree, id, hwlock);
 268        if (ret) {
 269                if (ret == -EEXIST)
 270                        pr_err("hwspinlock id %d already exists!\n", id);
 271                goto out;
 272        }
 273
 274        /* mark this hwspinlock as available */
 275        tmp = radix_tree_tag_set(&hwspinlock_tree, id, HWSPINLOCK_UNUSED);
 276
 277        /* self-sanity check which should never fail */
 278        WARN_ON(tmp != hwlock);
 279
 280out:
 281        mutex_unlock(&hwspinlock_tree_lock);
 282        return 0;
 283}
 284
 285static struct hwspinlock *hwspin_lock_unregister_single(unsigned int id)
 286{
 287        struct hwspinlock *hwlock = NULL;
 288        int ret;
 289
 290        mutex_lock(&hwspinlock_tree_lock);
 291
 292        /* make sure the hwspinlock is not in use (tag is set) */
 293        ret = radix_tree_tag_get(&hwspinlock_tree, id, HWSPINLOCK_UNUSED);
 294        if (ret == 0) {
 295                pr_err("hwspinlock %d still in use (or not present)\n", id);
 296                goto out;
 297        }
 298
 299        hwlock = radix_tree_delete(&hwspinlock_tree, id);
 300        if (!hwlock) {
 301                pr_err("failed to delete hwspinlock %d\n", id);
 302                goto out;
 303        }
 304
 305out:
 306        mutex_unlock(&hwspinlock_tree_lock);
 307        return hwlock;
 308}
 309
 310/**
 311 * hwspin_lock_register() - register a new hw spinlock device
 312 * @bank: the hwspinlock device, which usually provides numerous hw locks
 313 * @dev: the backing device
 314 * @ops: hwspinlock handlers for this device
 315 * @base_id: id of the first hardware spinlock in this bank
 316 * @num_locks: number of hwspinlocks provided by this device
 317 *
 318 * This function should be called from the underlying platform-specific
 319 * implementation, to register a new hwspinlock device instance.
 320 *
 321 * Should be called from a process context (might sleep)
 322 *
 323 * Returns 0 on success, or an appropriate error code on failure
 324 */
 325int hwspin_lock_register(struct hwspinlock_device *bank, struct device *dev,
 326                const struct hwspinlock_ops *ops, int base_id, int num_locks)
 327{
 328        struct hwspinlock *hwlock;
 329        int ret = 0, i;
 330
 331        if (!bank || !ops || !dev || !num_locks || !ops->trylock ||
 332                                                        !ops->unlock) {
 333                pr_err("invalid parameters\n");
 334                return -EINVAL;
 335        }
 336
 337        bank->dev = dev;
 338        bank->ops = ops;
 339        bank->base_id = base_id;
 340        bank->num_locks = num_locks;
 341
 342        for (i = 0; i < num_locks; i++) {
 343                hwlock = &bank->lock[i];
 344
 345                spin_lock_init(&hwlock->lock);
 346                hwlock->bank = bank;
 347
 348                ret = hwspin_lock_register_single(hwlock, base_id + i);
 349                if (ret)
 350                        goto reg_failed;
 351        }
 352
 353        return 0;
 354
 355reg_failed:
 356        while (--i >= 0)
 357                hwspin_lock_unregister_single(base_id + i);
 358        return ret;
 359}
 360EXPORT_SYMBOL_GPL(hwspin_lock_register);
 361
 362/**
 363 * hwspin_lock_unregister() - unregister an hw spinlock device
 364 * @bank: the hwspinlock device, which usually provides numerous hw locks
 365 *
 366 * This function should be called from the underlying platform-specific
 367 * implementation, to unregister an existing (and unused) hwspinlock.
 368lock/hw"L325"> 325int  321 * Should be called from a process context (might sleep)
 320 *
 323 * Returns 0 on success, or an appropriate error code on failure
 324 */
 325hwspin_lock_register(struct hwspinlock_device *i >= 0)
i++) {
hwspin_lock_register_single(struct hwspinlock *hwspinlock *tmp;
ret = 0, i;
 347
 342        for (i = 0;  340        bank->num_locks; i++) {
 343                hwlock = &bank->lock[i];
 330
 301<5"> 275                        hwspin_lock_unreg> 339        bank->base_id + i);
 35"> 275        i >= 0)
 334      BUSYa>i;
 284
 277        mment">/* self-sanity check which should never fail */
 346<8"> 278        WARN_ON(tmp != hwlock);
 297        }
 298
 353        return 0;
 297        }
 360EXPORT_SYMBOL_Gs="commentcode=hwspin_lock_unregister_single" c clade=hwlock" class="sref">hwlock);
 352
 362/**
&qdt">  powis goivious state to be restored. It is up
 365 *
 366 to n  * Thnal6prepares in_lon class=" registe"> 365 *
 223 227 365 *


 323 2indicturnn class="">  t"> gated)"valu)">  existing (and unused) hwspinlock.
 *  0 on(with"comment"> * to ts 0 on sucrom a process context (might sleep)
 324 */
ode=__hwsock_regquestcode=hwspin_locode=__hwsock_regquest class="sref">hwspin_lock_register(struct hwspinlock *i >= 0)
i++) {
hwspin_lock_register">bank, struct device *hwspinlock *hwlock->dev = dev;
 262        struct hwspinlock *tmp;
 288        int ret;
 298
 277 367 324 */
 3try_modulea> = EXPs="sref">dev = dev = ss="c hre"+code=bank" class="own"csref">dev =own"c"+cocref="+code=i" class="sref">i++) {
 301<                    PL" class="sref">EXPs="sref">dev = pr_e"s: canan clt > = own"cfailed to delete hwspinlock %__7hwlock);
 334                return -EINVAL;
 303        }
 284
 277powis gent"w"> edqdt2"> 324 */
 =_sync               pm_runtimea> =_syncPL" class="sref">EXPs="sref">dev = hwlock);
ret == 0) {
 348<                    PL" class="sref">EXPs="sref">dev = pr_e"s: canan clt powis anl href=failed to delete hwspinlock %__7hwlock);
 358        return ret;
 303        }
 361
 292 rk_lon class="as">&qd,>mment">/otlf-sanity check which should never fail */
 275        tmptmpradix_tree_delete(&hw href=_to">bank->bPL" class="sref">EXPOR>hwspinlock *dev,
EXPass="sref">id, HWSPINLOCK_UNUSED);
HWSPINLOCK_UNUSED);
 277        mment">/* self-sanity check which should never fail */
 278        WARN_ON(tmp != hwlock);
 298
 358        return ret;
 297        }
 361
 362/**
 363 =_id="commes="* s/**
 href=:"ae( 365 *
 365 *
 323 href=="com- href="lin> href= genrr(n existing (and unused) hwspinlock.
 325<> =_idcode=hwspin_lock_unregister> =_id class="sref">hwspin_lock_register(struct hwspinlock *i >= 0)
ret == 0) {
 300        if (!hwlock) {
 301                pr_err(< href=="string">"invalid parameters\n");
 334                return -EINVAL;
 303        }
 344
 307  _to">bank->bPL" class="sref">EXPOR>hwspinlock *EINVAL;
 303        }
 360EXPORT_SYMBOL_G> =_idcode=hwspin_lock_unregister> =_id clacde=EINVAL" class="sref">EINVAL;
 298
 362/**
 362/**
/**
 366by/a>/**

 2 namunicturn23
 223&qdtlinesynchroniz 2> = 23< existing (and unused) hwspinlock.
&qu> 363 =_id=")n existing (and unused) hwspinlock.
 317 *
 321 * Should be called from a process context (might sleep)
 323 n classlinigao nregister a="com
 285static struct hwspinlocegquestcode=hwspin_locf">hwspinlocegquestPL" cvoidcode=i" class="sref">i >= 0)
hwlock) {
 328        struct hwspinlock *hwlock;
 288        int ret;
 336
 290        mutex_lock(&hwspinlock_tree_lock);
 298
 ==  277 293        regang_lookupmptmgang_lookupmpradix_tree_delete(&spin_lock_init(&dev,
id, HWSPINLOCK_UNUSED);
 294        if (ret == 0) {
 333warn             pr_ealasean class="comment">/availabl=failed to deletclass="sref">HWSPINLOCK_UNUSED);
spin_lock_init(&(&ret;
 302                goto out;
 303        }
 347
 277   mment">/* self-sanity check which should never fail */
 278                        HWSPINLOCK_UNUSED);
 330
 292 rk_as">&qdt">  powis upnity check which should never fail */
 293        EXPOR>hwspinlock *EINVAL;
EINVAL;
spin_lock_init(&(&ret;
HWSPINLOCK_UNUSED);
 302                goto reg_failed:
 296        mutex_unlock(&hwspinlock_tree_lock);
 358f">hwspinlock *hwlock;
 359}
 360EXPORT_SYMBOL_GPLquestcode=hwspin_locf">hwspinlocegquestPL" ss="sref">hwspinlock_tree_lock);
 361
 362/**
/**
menmequested existing (and unused) hwspinlock.
 365 *
 366by/a>/**


 321 * Should be called from a process context (might sleep)
 323 n classlinigao nregister a="com
 324 */
 285static struct hwspinlocegquest_lled frocode=hwspin_locf">hwspinlocegquest_lled from " cunnigao nck_unregister_singledcode=hwspin_locid claca> */
ret == 0) {
 328        struct hwspinlock *hwlock;
 288        int ret;
ret;
 290        mutex_lock(&hwspinlock_tree_lock);
 361
 292 krnn entenis_lon class=a impls24"> 324 */
tmlookup             tmlookupPL" class="sref">radix_tree_delete(&hwspinlock_tree_lock);
 300        if (!hwlock) {
 333warn             pr_elon class=a"u doeent">/ implfailed to delete hwspinlock %edcode=hwspin_locid clacs="sref">hwspinlock_tree_lock);
 302                goto out;
 297        }
 298
 277    324 */
 278          _to">bank->bPL" class="sref">EXPOR>hwspinlock *hwspinlock_tree_lock);
 361
 292 krnn entenis_lon class=ais_n, to n4"> 324 */
 293        rep = rep =PL" class="sref">radix_tree_delete(&id, HWSPINLOCK_UNUSED);
 294        if (ret == 0) {
 333warn             pr_elon class=a"u  to lreadynin" tofailed to delete hwspinlock %edcode=hwspin_locid clacs="sref">hwspinlock_tree_lock);
 346                (&ret;
 302                goto out;
 297        }
ret;
 292 rk_as">&qdt">  powis upnity check which should never fail */
 293        EXPOR>hwspinlock *EINVAL;
 294        if (EINVAL;
 333                (&ret;
 344
reg_failed:
 296        mutex_unlock(&hwspinlock_tree_lock);
 358f">hwspinlock *hwlock;
 297        }
 360EXPORT_SYMBOL_GPLquest_lled frocode=hwspin_locf">hwspinlocegquest_lled from " ss="sref">hwspinlock_tree_lock);
 330
 362/**
hwspinlocasea="comaseani lled fro_lon class=> 362/**
 href=:"lasslled fro_lon class=aeomasea> 362/**
/**
 366 rk_> href= as"aseanigainn existing (and unused) hwspinlock.
 321 href=aent">wasmmes="* sclass= existing (and unused) hwspinlock.
 * arliis spanaeomomapde=__hwsock_regquest{_lled fro}n existing (and unused) hwspinlock.
 368lock/hw"L325"> 325i5rs/hwspin5ock/hwspinlock_core.c#L359" id54L319" class="line" name="L321"> 321 * Should be called from a process context (might sleep)
 323 * Returns 0 on success, or an appropriate error code on failure
 325(&hwspin_lock_register(struct hwspinlock *i >= 0)
i++) {
hwspin_lock_register">bank, struct device *hwspinlock_tree_lock);
 262        struct hwspinlock *tmp;
 288        int ret;
 298
 300        if (!hwlock) {
 333                pr_err(< href=="string">"invalid parameters\n");
 334                return -EINVAL;
 297        }
 297        }
device *hwspinlock *hwlock->dev = dev;
 290        mutex_lock(&hwspinlock_tree_lock);
 336
 292 krnn entenan class="commen to n4"> 324 */
 293        rep = rep =PL" class="sref">radix_tree_delete(&bank->bPL" class="sref">EXPOR>hwspinlock *dev,
 == id, HWSPINLOCK_UNUSED);
 294        if (hwlock) {
                   PL" class="sref">EXPs="sref">dev = pr_e"s:  href= gen lreadynf>(&failed to delete hwspinlock %__7hwlock);
EXPsump_stawspinlock *hwlock);
 333<3"> 293         334                return -EINVAL;
 302                goto out;
 297        }
 336
 292powis gent"t"> edqdt2"> 324 */
 293        EXPs="sref">dev = hwlock);
 294        if (EINVAL;
 302                goto out;
 361
 292 rk_enis_lon class=aas/availabl=t2"> 324 */
 275        tmprepradix_tree_delete(&bank->bPL" class="sref">EXPOR>hwspinlock *dev,
id, HWSPINLOCK_UNUSED);
HWSPINLOCK_UNUSED);
 277    324 */
 278        WARN_ON(tmp != hwlock);
 298
EXPs="sref">dev = dev = ss="c hre"+code=bank" class="own"csref">dev =own"c"+coce=hwlock" class="sref">hwlock);
 330
reg_failed:
 296        mutex_unlock(&hwspinlock_tree_lock);
 358        return ret;
 297        }
 360EXPORT_SYMBOL_Gf>(&hwspinlock_tree_lock);
 336
pr_eL_G v2string">"invalid parameters\n");
        pr_eHardwarssllss="commnterfacestring">"invalid parameters\n");
        pr_eOhad Ben-Co3"invalid parameters\n");



 /div>

The original LXR softwarssby 23LXR namunitytree" enis_experi"> 2al tersspanby valid parmailto:lxr@ockux.no">lxr@ockux.notree. /div>
lxr.ockux.no kindly hostednby valid parhttp://www.redpill-ockpro.no">Redpill Lckpro AStree" provid oper