!C99Shell v. 2.0 [PHP 7 Update] [25.02.2019]!

Software: nginx/1.23.4. PHP/5.6.40-65+ubuntu20.04.1+deb.sury.org+1 

uname -a: Linux foro-restaurado-2 5.15.0-1040-oracle #46-Ubuntu SMP Fri Jul 14 21:47:21 UTC 2023
aarch64
 

uid=33(www-data) gid=33(www-data) groups=33(www-data) 

Safe-mode: OFF (not secure)

/usr/src/linux-oracle-5.13-headers-5.13.0-1018/arch/riscv/include/asm/   drwxr-xr-x
Free 83.22 GB of 96.73 GB (86.04%)
Home    Back    Forward    UPDIR    Refresh    Search    Buffer    Encoder    Tools    Proc.    FTP brute    Sec.    SQL    PHP-code    Update    Feedback    Self remove    Logout    


Viewing file:     cmpxchg.h (9.24 KB)      -rw-r--r--
Select action/file-type:
(+) | (+) | (+) | Code (+) | Session (+) | (+) | SDB (+) | (+) | (+) | (+) | (+) | (+) |
/* SPDX-License-Identifier: GPL-2.0-only */
/*
 * Copyright (C) 2014 Regents of the University of California
 */

#ifndef _ASM_RISCV_CMPXCHG_H
#define _ASM_RISCV_CMPXCHG_H

#include <linux/bug.h>

#include <asm/barrier.h>
#include <asm/fence.h>

#define __xchg_relaxed(ptr, new, size)                    \
({                                    \
    __typeof__(ptr) __ptr = (ptr);                    \
    __typeof__(new) __new = (new);                    \
    __typeof__(*(ptr)) __ret;                    \
    switch (size) {                            \
    case 4:                                \
        __asm__ __volatile__ (                    \
            "    amoswap.w %0, %2, %1\n"            \
            : "=r" (__ret), "+A" (*__ptr)            \
            : "r" (__new)                    \
            : "memory");                    \
        break;                            \
    case 8:                                \
        __asm__ __volatile__ (                    \
            "    amoswap.d %0, %2, %1\n"            \
            : "=r" (__ret), "+A" (*__ptr)            \
            : "r" (__new)                    \
            : "memory");                    \
        break;                            \
    default:                            \
        BUILD_BUG();                        \
    }                                \
    __ret;                                \
})

#define xchg_relaxed(ptr, x)                        \
({                                    \
    __typeof__(*(ptr)) _x_ = (x);                    \
    (__typeof__(*(ptr))) __xchg_relaxed((ptr),            \
                        _x_, sizeof(*(ptr)));    \
})

#define __xchg_acquire(ptr, new, size)                    \
({                                    \
    __typeof__(ptr) __ptr = (ptr);                    \
    __typeof__(new) __new = (new);                    \
    __typeof__(*(ptr)) __ret;                    \
    switch (size) {                            \
    case 4:                                \
        __asm__ __volatile__ (                    \
            "    amoswap.w %0, %2, %1\n"            \
            RISCV_ACQUIRE_BARRIER                \
            : "=r" (__ret), "+A" (*__ptr)            \
            : "r" (__new)                    \
            : "memory");                    \
        break;                            \
    case 8:                                \
        __asm__ __volatile__ (                    \
            "    amoswap.d %0, %2, %1\n"            \
            RISCV_ACQUIRE_BARRIER                \
            : "=r" (__ret), "+A" (*__ptr)            \
            : "r" (__new)                    \
            : "memory");                    \
        break;                            \
    default:                            \
        BUILD_BUG();                        \
    }                                \
    __ret;                                \
})

#define xchg_acquire(ptr, x)                        \
({                                    \
    __typeof__(*(ptr)) _x_ = (x);                    \
    (__typeof__(*(ptr))) __xchg_acquire((ptr),            \
                        _x_, sizeof(*(ptr)));    \
})

#define __xchg_release(ptr, new, size)                    \
({                                    \
    __typeof__(ptr) __ptr = (ptr);                    \
    __typeof__(new) __new = (new);                    \
    __typeof__(*(ptr)) __ret;                    \
    switch (size) {                            \
    case 4:                                \
        __asm__ __volatile__ (                    \
            RISCV_RELEASE_BARRIER                \
            "    amoswap.w %0, %2, %1\n"            \
            : "=r" (__ret), "+A" (*__ptr)            \
            : "r" (__new)                    \
            : "memory");                    \
        break;                            \
    case 8:                                \
        __asm__ __volatile__ (                    \
            RISCV_RELEASE_BARRIER                \
            "    amoswap.d %0, %2, %1\n"            \
            : "=r" (__ret), "+A" (*__ptr)            \
            : "r" (__new)                    \
            : "memory");                    \
        break;                            \
    default:                            \
        BUILD_BUG();                        \
    }                                \
    __ret;                                \
})

#define xchg_release(ptr, x)                        \
({                                    \
    __typeof__(*(ptr)) _x_ = (x);                    \
    (__typeof__(*(ptr))) __xchg_release((ptr),            \
                        _x_, sizeof(*(ptr)));    \
})

#define __xchg(ptr, new, size)                        \
({                                    \
    __typeof__(ptr) __ptr = (ptr);                    \
    __typeof__(new) __new = (new);                    \
    __typeof__(*(ptr)) __ret;                    \
    switch (size) {                            \
    case 4:                                \
        __asm__ __volatile__ (                    \
            "    amoswap.w.aqrl %0, %2, %1\n"        \
            : "=r" (__ret), "+A" (*__ptr)            \
            : "r" (__new)                    \
            : "memory");                    \
        break;                            \
    case 8:                                \
        __asm__ __volatile__ (                    \
            "    amoswap.d.aqrl %0, %2, %1\n"        \
            : "=r" (__ret), "+A" (*__ptr)            \
            : "r" (__new)                    \
            : "memory");                    \
        break;                            \
    default:                            \
        BUILD_BUG();                        \
    }                                \
    __ret;                                \
})

#define xchg(ptr, x)                            \
({                                    \
    __typeof__(*(ptr)) _x_ = (x);                    \
    (__typeof__(*(ptr))) __xchg((ptr), _x_, sizeof(*(ptr)));    \
})

#define xchg32(ptr, x)                            \
({                                    \
    BUILD_BUG_ON(sizeof(*(ptr)) != 4);                \
    xchg((ptr), (x));                        \
})

#define xchg64(ptr, x)                            \
({                                    \
    BUILD_BUG_ON(sizeof(*(ptr)) != 8);                \
    xchg((ptr), (x));                        \
})

/*
 * Atomic compare and exchange.  Compare OLD with MEM, if identical,
 * store NEW in MEM.  Return the initial value in MEM.  Success is
 * indicated by comparing RETURN with OLD.
 */
#define __cmpxchg_relaxed(ptr, old, new, size)                \
({                                    \
    __typeof__(ptr) __ptr = (ptr);                    \
    __typeof__(*(ptr)) __old = (old);                \
    __typeof__(*(ptr)) __new = (new);                \
    __typeof__(*(ptr)) __ret;                    \
    register unsigned int __rc;                    \
    switch (size) {                            \
    case 4:                                \
        __asm__ __volatile__ (                    \
            "0:    lr.w %0, %2\n"                \
            "    bne  %0, %z3, 1f\n"            \
            "    sc.w %1, %z4, %2\n"            \
            "    bnez %1, 0b\n"                \
            "1:\n"                        \
            : "=&r" (__ret), "=&r" (__rc), "+A" (*__ptr)    \
            : "rJ" ((long)__old), "rJ" (__new)        \
            : "memory");                    \
        break;                            \
    case 8:                                \
        __asm__ __volatile__ (                    \
            "0:    lr.d %0, %2\n"                \
            "    bne %0, %z3, 1f\n"            \
            "    sc.d %1, %z4, %2\n"            \
            "    bnez %1, 0b\n"                \
            "1:\n"                        \
            : "=&r" (__ret), "=&r" (__rc), "+A" (*__ptr)    \
            : "rJ" (__old), "rJ" (__new)            \
            : "memory");                    \
        break;                            \
    default:                            \
        BUILD_BUG();                        \
    }                                \
    __ret;                                \
})

#define cmpxchg_relaxed(ptr, o, n)                    \
({                                    \
    __typeof__(*(ptr)) _o_ = (o);                    \
    __typeof__(*(ptr)) _n_ = (n);                    \
    (__typeof__(*(ptr))) __cmpxchg_relaxed((ptr),            \
                    _o_, _n_, sizeof(*(ptr)));    \
})

#define __cmpxchg_acquire(ptr, old, new, size)                \
({                                    \
    __typeof__(ptr) __ptr = (ptr);                    \
    __typeof__(*(ptr)) __old = (old);                \
    __typeof__(*(ptr)) __new = (new);                \
    __typeof__(*(ptr)) __ret;                    \
    register unsigned int __rc;                    \
    switch (size) {                            \
    case 4:                                \
        __asm__ __volatile__ (                    \
            "0:    lr.w %0, %2\n"                \
            "    bne  %0, %z3, 1f\n"            \
            "    sc.w %1, %z4, %2\n"            \
            "    bnez %1, 0b\n"                \
            RISCV_ACQUIRE_BARRIER                \
            "1:\n"                        \
            : "=&r" (__ret), "=&r" (__rc), "+A" (*__ptr)    \
            : "rJ" ((long)__old), "rJ" (__new)        \
            : "memory");                    \
        break;                            \
    case 8:                                \
        __asm__ __volatile__ (                    \
            "0:    lr.d %0, %2\n"                \
            "    bne %0, %z3, 1f\n"            \
            "    sc.d %1, %z4, %2\n"            \
            "    bnez %1, 0b\n"                \
            RISCV_ACQUIRE_BARRIER                \
            "1:\n"                        \
            : "=&r" (__ret), "=&r" (__rc), "+A" (*__ptr)    \
            : "rJ" (__old), "rJ" (__new)            \
            : "memory");                    \
        break;                            \
    default:                            \
        BUILD_BUG();                        \
    }                                \
    __ret;                                \
})

#define cmpxchg_acquire(ptr, o, n)                    \
({                                    \
    __typeof__(*(ptr)) _o_ = (o);                    \
    __typeof__(*(ptr)) _n_ = (n);                    \
    (__typeof__(*(ptr))) __cmpxchg_acquire((ptr),            \
                    _o_, _n_, sizeof(*(ptr)));    \
})

#define __cmpxchg_release(ptr, old, new, size)                \
({                                    \
    __typeof__(ptr) __ptr = (ptr);                    \
    __typeof__(*(ptr)) __old = (old);                \
    __typeof__(*(ptr)) __new = (new);                \
    __typeof__(*(ptr)) __ret;                    \
    register unsigned int __rc;                    \
    switch (size) {                            \
    case 4:                                \
        __asm__ __volatile__ (                    \
            RISCV_RELEASE_BARRIER                \
            "0:    lr.w %0, %2\n"                \
            "    bne  %0, %z3, 1f\n"            \
            "    sc.w %1, %z4, %2\n"            \
            "    bnez %1, 0b\n"                \
            "1:\n"                        \
            : "=&r" (__ret), "=&r" (__rc), "+A" (*__ptr)    \
            : "rJ" ((long)__old), "rJ" (__new)        \
            : "memory");                    \
        break;                            \
    case 8:                                \
        __asm__ __volatile__ (                    \
            RISCV_RELEASE_BARRIER                \
            "0:    lr.d %0, %2\n"                \
            "    bne %0, %z3, 1f\n"            \
            "    sc.d %1, %z4, %2\n"            \
            "    bnez %1, 0b\n"                \
            "1:\n"                        \
            : "=&r" (__ret), "=&r" (__rc), "+A" (*__ptr)    \
            : "rJ" (__old), "rJ" (__new)            \
            : "memory");                    \
        break;                            \
    default:                            \
        BUILD_BUG();                        \
    }                                \
    __ret;                                \
})

#define cmpxchg_release(ptr, o, n)                    \
({                                    \
    __typeof__(*(ptr)) _o_ = (o);                    \
    __typeof__(*(ptr)) _n_ = (n);                    \
    (__typeof__(*(ptr))) __cmpxchg_release((ptr),            \
                    _o_, _n_, sizeof(*(ptr)));    \
})

#define __cmpxchg(ptr, old, new, size)                    \
({                                    \
    __typeof__(ptr) __ptr = (ptr);                    \
    __typeof__(*(ptr)) __old = (old);                \
    __typeof__(*(ptr)) __new = (new);                \
    __typeof__(*(ptr)) __ret;                    \
    register unsigned int __rc;                    \
    switch (size) {                            \
    case 4:                                \
        __asm__ __volatile__ (                    \
            "0:    lr.w %0, %2\n"                \
            "    bne  %0, %z3, 1f\n"            \
            "    sc.w.rl %1, %z4, %2\n"            \
            "    bnez %1, 0b\n"                \
            "    fence rw, rw\n"                \
            "1:\n"                        \
            : "=&r" (__ret), "=&r" (__rc), "+A" (*__ptr)    \
            : "rJ" ((long)__old), "rJ" (__new)        \
            : "memory");                    \
        break;                            \
    case 8:                                \
        __asm__ __volatile__ (                    \
            "0:    lr.d %0, %2\n"                \
            "    bne %0, %z3, 1f\n"            \
            "    sc.d.rl %1, %z4, %2\n"            \
            "    bnez %1, 0b\n"                \
            "    fence rw, rw\n"                \
            "1:\n"                        \
            : "=&r" (__ret), "=&r" (__rc), "+A" (*__ptr)    \
            : "rJ" (__old), "rJ" (__new)            \
            : "memory");                    \
        break;                            \
    default:                            \
        BUILD_BUG();                        \
    }                                \
    __ret;                                \
})

#define cmpxchg(ptr, o, n)                        \
({                                    \
    __typeof__(*(ptr)) _o_ = (o);                    \
    __typeof__(*(ptr)) _n_ = (n);                    \
    (__typeof__(*(ptr))) __cmpxchg((ptr),                \
                       _o_, _n_, sizeof(*(ptr)));    \
})

#define cmpxchg_local(ptr, o, n)                    \
    (__cmpxchg_relaxed((ptr), (o), (n), sizeof(*(ptr))))

#define cmpxchg32(ptr, o, n)                        \
({                                    \
    BUILD_BUG_ON(sizeof(*(ptr)) != 4);                \
    cmpxchg((ptr), (o), (n));                    \
})

#define cmpxchg32_local(ptr, o, n)                    \
({                                    \
    BUILD_BUG_ON(sizeof(*(ptr)) != 4);                \
    cmpxchg_relaxed((ptr), (o), (n))                \
})

#define cmpxchg64(ptr, o, n)                        \
({                                    \
    BUILD_BUG_ON(sizeof(*(ptr)) != 8);                \
    cmpxchg((ptr), (o), (n));                    \
})

#define cmpxchg64_local(ptr, o, n)                    \
({                                    \
    BUILD_BUG_ON(sizeof(*(ptr)) != 8);                \
    cmpxchg_relaxed((ptr), (o), (n));                \
})

#endif /* _ASM_RISCV_CMPXCHG_H */

:: Command execute ::

Enter:
 
Select:
 

:: Search ::
  - regexp 

:: Upload ::
 
[ Read-Only ]

:: Make Dir ::
 
[ Read-Only ]
:: Make File ::
 
[ Read-Only ]

:: Go Dir ::
 
:: Go File ::
 

--[ c99shell v. 2.0 [PHP 7 Update] [25.02.2019] maintained by HackingTool | HackingTool | Generation time: 0.015 ]--