idx int64 | project string | commit_id string | project_url string | commit_url string | commit_message string | target int64 | func string | func_hash float64 | file_name string | file_hash float64 | cwe list | cve string | cve_desc string | nvd_url string |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
27,017 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | u64 get_jiffies_64(void)
{
unsigned long seq;
u64 ret;
do {
seq = read_seqbegin(&xtime_lock);
ret = jiffies_64;
} while (read_seqretry(&xtime_lock, seq));
return ret;
}
| 150,148,807,039,043,260,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,018 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | void getnstimeofday(struct timespec *tv)
{
struct timeval x;
do_gettimeofday(&x);
tv->tv_sec = x.tv_sec;
tv->tv_nsec = x.tv_usec * NSEC_PER_USEC;
}
| 331,082,288,956,074,700,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,019 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | u64 jiffies_64_to_clock_t(u64 x)
{
#if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
# if HZ < USER_HZ
x = div_u64(x * USER_HZ, HZ);
# elif HZ > USER_HZ
x = div_u64(x, HZ / USER_HZ);
# else
/* Nothing to do */
# endif
#else
/*
* There are better ways that don't overflow early,
* but even this doesn't overflow in ... | 248,157,775,371,749,100,000,000,000,000,000,000,000 | time.c | 199,712,675,933,862,720,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,020 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | clock_t jiffies_to_clock_t(long x)
{
#if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
# if HZ < USER_HZ
return x * (USER_HZ / HZ);
# else
return x / (HZ / USER_HZ);
# endif
#else
return div_u64((u64)x * TICK_NSEC, NSEC_PER_SEC / USER_HZ);
#endif
}
| 2,155,150,114,417,953,200,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,021 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | unsigned int inline jiffies_to_msecs(const unsigned long j)
{
#if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
return (MSEC_PER_SEC / HZ) * j;
#elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
return (j + (HZ / MSEC_PER_SEC) - 1)/(HZ / MSEC_PER_SEC);
#else
# if BITS_PER_LONG == 32
return ((u64)HZ_TO_MSEC_MUL32 * j) >> H... | 88,911,237,913,732,410,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,022 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | unsigned int inline jiffies_to_usecs(const unsigned long j)
{
#if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
return (USEC_PER_SEC / HZ) * j;
#elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
return (j + (HZ / USEC_PER_SEC) - 1)/(HZ / USEC_PER_SEC);
#else
# if BITS_PER_LONG == 32
return ((u64)HZ_TO_USEC_MUL32 * j) >> H... | 240,771,873,819,511,470,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,023 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | mktime(const unsigned int year0, const unsigned int mon0,
const unsigned int day, const unsigned int hour,
const unsigned int min, const unsigned int sec)
{
unsigned int mon = mon0, year = year0;
/* 1..12 -> 11,12,1..10 */
if (0 >= (int) (mon -= 2)) {
mon += 12; /* Puts Feb last since it has leap da... | 47,200,616,308,506,020,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,024 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | unsigned long msecs_to_jiffies(const unsigned int m)
{
/*
* Negative value, means infinite timeout:
*/
if ((int)m < 0)
return MAX_JIFFY_OFFSET;
#if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
/*
* HZ is equal to or smaller than 1000, and 1000 is a nice
* round multiple of HZ, divide with the factor between... | 295,520,401,915,115,370,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,025 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | struct timeval ns_to_timeval(const s64 nsec)
{
struct timespec ts = ns_to_timespec(nsec);
struct timeval tv;
tv.tv_sec = ts.tv_sec;
tv.tv_usec = (suseconds_t) ts.tv_nsec / 1000;
return tv;
}
| 41,390,641,401,519,625,000,000,000,000,000,000,000 | time.c | 199,712,675,933,862,720,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,026 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | u64 nsec_to_clock_t(u64 x)
{
#if (NSEC_PER_SEC % USER_HZ) == 0
return div_u64(x, NSEC_PER_SEC / USER_HZ);
#elif (USER_HZ % 512) == 0
return div_u64(x * USER_HZ / 512, NSEC_PER_SEC / 512);
#else
/*
* max relative error 5.7e-8 (1.8s per year) for USER_HZ <= 1024,
* overflow after 64.99 years.
... | 288,315,454,776,846,700,000,000,000,000,000,000,000 | time.c | 199,712,675,933,862,720,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,027 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | void set_normalized_timespec(struct timespec *ts, time_t sec, long nsec)
{
while (nsec >= NSEC_PER_SEC) {
nsec -= NSEC_PER_SEC;
++sec;
}
while (nsec < 0) {
nsec += NSEC_PER_SEC;
--sec;
}
ts->tv_sec = sec;
ts->tv_nsec = nsec;
}
| 156,198,460,291,791,820,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,028 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | asmlinkage long sys_adjtimex(struct timex __user *txc_p)
{
struct timex txc; /* Local copy of parameter */
int ret;
/* Copy the user data space into the kernel copy
* structure. But bear in mind that the structures
* may change
*/
if(copy_from_user(&txc, txc_p, sizeof(struct timex)))
return -EFAULT;
ret ... | 172,630,904,115,971,030,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,029 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | asmlinkage long sys_gettimeofday(struct timeval __user *tv,
struct timezone __user *tz)
{
if (likely(tv != NULL)) {
struct timeval ktv;
do_gettimeofday(&ktv);
if (copy_to_user(tv, &ktv, sizeof(ktv)))
return -EFAULT;
}
if (unlikely(tz != NULL)) {
if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
retur... | 9,805,368,391,599,786,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,030 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | asmlinkage long sys_settimeofday(struct timeval __user *tv,
struct timezone __user *tz)
{
struct timeval user_tv;
struct timespec new_ts;
struct timezone new_tz;
if (tv) {
if (copy_from_user(&user_tv, tv, sizeof(*tv)))
return -EFAULT;
new_ts.tv_sec = user_tv.tv_sec;
new_ts.tv_nsec = user_tv.tv_usec * ... | 28,252,320,041,974,855,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,031 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | asmlinkage long sys_stime(time_t __user *tptr)
{
struct timespec tv;
int err;
if (get_user(tv.tv_sec, tptr))
return -EFAULT;
tv.tv_nsec = 0;
err = security_settime(&tv, NULL);
if (err)
return err;
do_settimeofday(&tv);
return 0;
}
| 230,179,655,868,173,770,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,032 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | asmlinkage long sys_time(time_t __user * tloc)
{
time_t i = get_seconds();
if (tloc) {
if (put_user(i,tloc))
i = -EFAULT;
}
return i;
}
| 215,533,537,065,520,570,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,033 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | timespec_to_jiffies(const struct timespec *value)
{
unsigned long sec = value->tv_sec;
long nsec = value->tv_nsec + TICK_NSEC - 1;
if (sec >= MAX_SEC_IN_JIFFIES){
sec = MAX_SEC_IN_JIFFIES;
nsec = 0;
}
return (((u64)sec * SEC_CONVERSION) +
(((u64)nsec * NSEC_CONVERSION) >>
(NSEC_JIFFIE_SC - SEC_JIFFIE_SC)... | 86,028,142,337,092,620,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,034 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | struct timespec timespec_trunc(struct timespec t, unsigned gran)
{
/*
* Division is pretty slow so avoid it for common cases.
* Currently current_kernel_time() never returns better than
* jiffies resolution. Exploit that.
*/
if (gran <= jiffies_to_usecs(1) * 1000) {
/* nothing */
} else if (gran == 1000000... | 65,219,234,082,119,385,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,035 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | timeval_to_jiffies(const struct timeval *value)
{
unsigned long sec = value->tv_sec;
long usec = value->tv_usec;
if (sec >= MAX_SEC_IN_JIFFIES){
sec = MAX_SEC_IN_JIFFIES;
usec = 0;
}
return (((u64)sec * SEC_CONVERSION) +
(((u64)usec * USEC_CONVERSION + USEC_ROUND) >>
(USEC_JIFFIE_SC - SEC_JIFFIE_SC))) >>... | 325,665,079,285,843,200,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,036 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | unsigned long usecs_to_jiffies(const unsigned int u)
{
if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
return MAX_JIFFY_OFFSET;
#if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ);
#elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
return u * (HZ / USEC_PER_SEC);
#els... | 190,328,791,346,903,350,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,037 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static inline void warp_clock(void)
{
write_seqlock_irq(&xtime_lock);
wall_to_monotonic.tv_sec -= sys_tz.tz_minuteswest * 60;
xtime.tv_sec += sys_tz.tz_minuteswest * 60;
update_xtime_cache(0);
write_sequnlock_irq(&xtime_lock);
clock_was_set();
}
| 333,432,669,839,257,250,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,038 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | u64 current_tick_length(void)
{
return tick_length;
}
| 284,595,485,290,507,940,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,039 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static void notify_cmos_timer(void)
{
if (!no_sync_cmos_clock)
mod_timer(&sync_cmos_timer, jiffies + 1);
}
| 211,847,234,361,881,260,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,040 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static inline void notify_cmos_timer(void) { }
| 259,656,127,646,233,040,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,041 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | void ntp_clear(void)
{
time_adjust = 0; /* stop active adjtime() */
time_status |= STA_UNSYNC;
time_maxerror = NTP_PHASE_LIMIT;
time_esterror = NTP_PHASE_LIMIT;
ntp_update_frequency();
tick_length = tick_length_base;
time_offset = 0;
}
| 320,662,311,522,491,200,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,042 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static void ntp_update_frequency(void)
{
u64 second_length = (u64)(tick_usec * NSEC_PER_USEC * USER_HZ)
<< TICK_LENGTH_SHIFT;
second_length += (s64)ntp_tick_adj << TICK_LENGTH_SHIFT;
second_length += (s64)time_freq << (TICK_LENGTH_SHIFT - SHIFT_NSEC);
tick_length_base = second_length;
tick_nsec = div_u64(sec... | 246,149,138,847,852,140,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,043 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | void second_overflow(void)
{
long time_adj;
/* Bump the maxerror field */
time_maxerror += MAXFREQ >> SHIFT_USEC;
if (time_maxerror > NTP_PHASE_LIMIT) {
time_maxerror = NTP_PHASE_LIMIT;
time_status |= STA_UNSYNC;
}
/*
* Leap second processing. If in leap-insert state at the end of the
* day, the system ... | 131,686,814,057,090,980,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,044 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static inline void ClearSlabDebug(struct page *page)
{
page->flags &= ~SLABDEBUG;
}
| 205,339,680,312,779,670,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,045 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static inline void ClearSlabFrozen(struct page *page)
{
page->flags &= ~FROZEN;
}
| 228,380,163,141,991,060,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,046 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static inline void SetSlabDebug(struct page *page)
{
page->flags |= SLABDEBUG;
}
| 217,671,982,773,917,600,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,047 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static inline void SetSlabFrozen(struct page *page)
{
page->flags |= FROZEN;
}
| 136,573,580,525,074,500,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,048 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static inline int SlabDebug(struct page *page)
{
return page->flags & SLABDEBUG;
}
| 249,015,903,241,730,520,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,049 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static inline int SlabFrozen(struct page *page)
{
return page->flags & FROZEN;
}
| 318,362,073,917,144,020,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,050 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static void __free_slab(struct kmem_cache *s, struct page *page)
{
int order = compound_order(page);
int pages = 1 << order;
if (unlikely(SlabDebug(page))) {
void *p;
slab_pad_check(s, page);
for_each_object(p, s, page_address(page),
page->objects)
check_object(s, page, p, 0);
ClearSlabDebug(page)... | 24,700,864,702,762,340,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,051 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | void *__kmalloc(size_t size, gfp_t flags)
{
struct kmem_cache *s;
if (unlikely(size > PAGE_SIZE))
return kmalloc_large(size, flags);
s = get_slab(size, flags);
if (unlikely(ZERO_OR_NULL_PTR(s)))
return s;
return slab_alloc(s, flags, -1, __builtin_return_address(0));
}
| 95,089,299,055,839,960,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,052 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | void *__kmalloc_node(size_t size, gfp_t flags, int node)
{
struct kmem_cache *s;
if (unlikely(size > PAGE_SIZE))
return kmalloc_large_node(size, flags, node);
s = get_slab(size, flags);
if (unlikely(ZERO_OR_NULL_PTR(s)))
return s;
return slab_alloc(s, flags, node, __builtin_return_address(0));
}
| 314,445,973,258,384,370,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,053 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | void *__kmalloc_node_track_caller(size_t size, gfp_t gfpflags,
int node, void *caller)
{
struct kmem_cache *s;
if (unlikely(size > PAGE_SIZE))
return kmalloc_large_node(size, gfpflags, node);
s = get_slab(size, gfpflags);
if (unlikely(ZERO_OR_NULL_PTR(s)))
return s;
return slab_alloc(s, gfpflags, node... | 191,876,238,423,853,480,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,054 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | void *__kmalloc_track_caller(size_t size, gfp_t gfpflags, void *caller)
{
struct kmem_cache *s;
if (unlikely(size > PAGE_SIZE))
return kmalloc_large(size, gfpflags);
s = get_slab(size, gfpflags);
if (unlikely(ZERO_OR_NULL_PTR(s)))
return s;
return slab_alloc(s, gfpflags, -1, caller);
}
| 234,628,766,050,581,700,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,055 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static void *__slab_alloc(struct kmem_cache *s,
gfp_t gfpflags, int node, void *addr, struct kmem_cache_cpu *c)
{
void **object;
struct page *new;
/* We handle __GFP_ZERO in the caller */
gfpflags &= ~__GFP_ZERO;
if (!c->page)
goto new_slab;
slab_lock(c->page);
if (unlikely(!node_match(c, node)))
goto a... | 312,908,530,670,528,860,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,056 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static void __slab_free(struct kmem_cache *s, struct page *page,
void *x, void *addr, unsigned int offset)
{
void *prior;
void **object = (void *)x;
struct kmem_cache_cpu *c;
c = get_cpu_slab(s, raw_smp_processor_id());
stat(c, FREE_SLOWPATH);
slab_lock(page);
if (unlikely(SlabDebug(page)))
goto debug;
... | 268,915,113,426,382,050,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,057 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static inline void add_full(struct kmem_cache_node *n, struct page *page) {}
| 192,103,307,677,958,850,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,058 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static int add_location(struct loc_track *t, struct kmem_cache *s,
const struct track *track)
{
long start, end, pos;
struct location *l;
void *caddr;
unsigned long age = jiffies - track->when;
start = -1;
end = t->count;
for ( ; ; ) {
pos = start + (end - start + 1) / 2;
/*
* There is nothing at "... | 59,616,567,696,303,680,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,059 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static void add_partial(struct kmem_cache_node *n,
struct page *page, int tail)
{
spin_lock(&n->list_lock);
n->nr_partial++;
if (tail)
list_add_tail(&page->lru, &n->partial);
else
list_add(&page->lru, &n->partial);
spin_unlock(&n->list_lock);
}
| 182,482,721,226,948,400,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,060 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static ssize_t aliases_show(struct kmem_cache *s, char *buf)
{
return sprintf(buf, "%d\n", s->refcount - 1);
}
| 141,128,181,523,913,170,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,061 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static ssize_t align_show(struct kmem_cache *s, char *buf)
{
return sprintf(buf, "%d\n", s->align);
}
| 145,965,461,768,287,650,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,062 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static ssize_t alloc_calls_show(struct kmem_cache *s, char *buf)
{
if (!(s->flags & SLAB_STORE_USER))
return -ENOSYS;
return list_locations(s, buf, TRACK_ALLOC);
}
| 183,164,112,301,562,200,000,000,000,000,000,000,000 | slub.c | 315,878,014,198,803,570,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,063 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static int alloc_debug_processing(struct kmem_cache *s, struct page *page,
void *object, void *addr)
{
if (!check_slab(s, page))
goto bad;
if (!on_freelist(s, page, object)) {
object_err(s, page, object, "Object already allocated");
goto bad;
}
if (!check_valid_pointer(s, page, object)) {
object_err... | 187,113,943,519,369,650,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,064 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static inline int alloc_debug_processing(struct kmem_cache *s,
struct page *page, void *object, void *addr) { return 0; }
| 58,191,942,721,875,350,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,065 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static inline int alloc_kmem_cache_cpus(struct kmem_cache *s, gfp_t flags)
{
init_kmem_cache_cpu(s, &s->cpu_slab);
return 1;
}
| 101,163,646,426,940,270,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,066 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static struct page *allocate_slab(struct kmem_cache *s, gfp_t flags, int node)
{
struct page *page;
struct kmem_cache_order_objects oo = s->oo;
flags |= s->allocflags;
page = alloc_slab_page(flags | __GFP_NOWARN | __GFP_NORETRY, node,
oo);
if (unlikely(!page)) {
oo = s->min;
/*
* Allocation may h... | 274,464,121,623,968,030,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,067 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static int any_slab_objects(struct kmem_cache *s)
{
int node;
for_each_online_node(node) {
struct kmem_cache_node *n = get_node(s, node);
if (!n)
continue;
if (atomic_read(&n->total_objects))
return 1;
}
return 0;
}
| 144,019,039,733,244,690,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,068 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static ssize_t cache_dma_show(struct kmem_cache *s, char *buf)
{
return sprintf(buf, "%d\n", !!(s->flags & SLAB_CACHE_DMA));
}
| 300,445,438,070,489,430,000,000,000,000,000,000,000 | slub.c | 315,878,014,198,803,570,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,069 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static unsigned long calculate_alignment(unsigned long flags,
unsigned long align, unsigned long size)
{
/*
* If the user wants hardware cache aligned objects then follow that
* suggestion if the object is sufficiently large.
*
* The hardware cache alignment cannot override the specified
* alignment though... | 301,009,642,051,884,400,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,070 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static inline int calculate_order(int size)
{
int order;
int min_objects;
int fraction;
/*
* Attempt to find best configuration for a slab. This
* works by first attempting to generate a layout with
* the best configuration and backing off gradually.
*
* First we reduce the acceptable waste in a slab. Th... | 56,102,680,055,630,760,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,071 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static int calculate_sizes(struct kmem_cache *s, int forced_order)
{
unsigned long flags = s->flags;
unsigned long size = s->objsize;
unsigned long align = s->align;
int order;
/*
* Round up object size to the next word boundary. We can only
* place the free pointer at word boundaries and this determines
* ... | 164,211,296,182,254,900,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,072 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static u8 *check_bytes(u8 *start, unsigned int value, unsigned int bytes)
{
while (bytes) {
if (*start != (u8)value)
return start;
start++;
bytes--;
}
return NULL;
}
| 326,948,540,312,575,660,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,073 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static int check_bytes_and_report(struct kmem_cache *s, struct page *page,
u8 *object, char *what,
u8 *start, unsigned int value, unsigned int bytes)
{
u8 *fault;
u8 *end;
fault = check_bytes(start, value, bytes);
if (!fault)
return 1;
end = start + bytes;
while (end > fault && end[-1] == value)
end--... | 212,582,031,792,749,500,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,074 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static int check_object(struct kmem_cache *s, struct page *page,
void *object, int active)
{
u8 *p = object;
u8 *endobject = object + s->objsize;
if (s->flags & SLAB_RED_ZONE) {
unsigned int red =
active ? SLUB_RED_ACTIVE : SLUB_RED_INACTIVE;
if (!check_bytes_and_report(s, page, object, "Redzone",
e... | 72,449,987,962,888,930,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,075 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static inline int check_object(struct kmem_cache *s, struct page *page,
void *object, int active) { return 1; }
| 32,434,674,979,062,880,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,076 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static int check_pad_bytes(struct kmem_cache *s, struct page *page, u8 *p)
{
unsigned long off = s->inuse; /* The end of info */
if (s->offset)
/* Freepointer is placed after the object. */
off += sizeof(void *);
if (s->flags & SLAB_STORE_USER)
/* We also have user information there */
off += 2 * sizeof(st... | 91,669,314,826,860,970,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,077 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static int check_slab(struct kmem_cache *s, struct page *page)
{
int maxobj;
VM_BUG_ON(!irqs_disabled());
if (!PageSlab(page)) {
slab_err(s, page, "Not a valid slab page");
return 0;
}
maxobj = (PAGE_SIZE << compound_order(page)) / s->size;
if (page->objects > maxobj) {
slab_err(s, page, "objects %u > ma... | 311,158,037,545,661,520,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,078 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static inline int check_valid_pointer(struct kmem_cache *s,
struct page *page, const void *object)
{
void *base;
if (!object)
return 1;
base = page_address(page);
if (object < base || object >= base + page->objects * s->size ||
(object - base) % s->size) {
return 0;
}
return 1;
}
| 97,749,570,969,247,760,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,079 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static int count_free(struct page *page)
{
return page->objects - page->inuse;
}
| 124,598,548,383,798,820,000,000,000,000,000,000,000 | slub.c | 315,878,014,198,803,570,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,080 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static int count_inuse(struct page *page)
{
return page->inuse;
}
| 307,982,561,159,532,130,000,000,000,000,000,000,000 | slub.c | 315,878,014,198,803,570,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,081 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static unsigned long count_partial(struct kmem_cache_node *n,
int (*get_count)(struct page *))
{
unsigned long flags;
unsigned long x = 0;
struct page *page;
spin_lock_irqsave(&n->list_lock, flags);
list_for_each_entry(page, &n->partial, lru)
x += get_count(page);
spin_unlock_irqrestore(&n->list_lock, fla... | 137,577,046,554,875,240,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,082 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static int count_total(struct page *page)
{
return page->objects;
}
| 163,791,693,584,582,120,000,000,000,000,000,000,000 | slub.c | 315,878,014,198,803,570,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,083 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static ssize_t cpu_slabs_show(struct kmem_cache *s, char *buf)
{
return show_slab_objects(s, buf, SO_CPU);
}
| 121,270,823,262,500,800,000,000,000,000,000,000,000 | slub.c | 315,878,014,198,803,570,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,084 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static struct kmem_cache *create_kmalloc_cache(struct kmem_cache *s,
const char *name, int size, gfp_t gfp_flags)
{
unsigned int flags = 0;
if (gfp_flags & SLUB_DMA)
flags = SLAB_CACHE_DMA;
down_write(&slub_lock);
if (!kmem_cache_open(s, gfp_flags, name, size, ARCH_KMALLOC_MINALIGN,
flags, NULL))
go... | 61,230,003,509,869,550,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,085 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static char *create_unique_id(struct kmem_cache *s)
{
char *name = kmalloc(ID_STR_LENGTH, GFP_KERNEL);
char *p = name;
BUG_ON(!name);
*p++ = ':';
/*
* First flags affecting slabcache operations. We will only
* get here for aliasable slabs so we do not need to support
* too many flags. The flags here must c... | 21,461,094,492,380,444,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,086 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static ssize_t ctor_show(struct kmem_cache *s, char *buf)
{
if (s->ctor) {
int n = sprint_symbol(buf, (unsigned long)s->ctor);
return n + sprintf(buf + n, "\n");
}
return 0;
}
| 204,998,725,800,225,000,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,087 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static void deactivate_slab(struct kmem_cache *s, struct kmem_cache_cpu *c)
{
struct page *page = c->page;
int tail = 1;
if (page->freelist)
stat(c, DEACTIVATE_REMOTE_FREES);
/*
* Merge cpu freelist into slab freelist. Typically we get here
* because both freelists are empty. So this is unlikely
* to occur... | 173,456,089,330,543,530,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,088 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static inline void dec_slabs_node(struct kmem_cache *s, int node, int objects)
{
struct kmem_cache_node *n = get_node(s, node);
atomic_long_dec(&n->nr_slabs);
atomic_long_sub(objects, &n->total_objects);
}
| 337,528,130,502,934,880,000,000,000,000,000,000,000 | slub.c | 315,878,014,198,803,570,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,089 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static inline void dec_slabs_node(struct kmem_cache *s, int node,
int objects) {}
| 305,170,922,260,188,020,000,000,000,000,000,000,000 | slub.c | 315,878,014,198,803,570,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,090 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static ssize_t destroy_by_rcu_show(struct kmem_cache *s, char *buf)
{
return sprintf(buf, "%d\n", !!(s->flags & SLAB_DESTROY_BY_RCU));
}
| 59,276,626,524,498,590,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,091 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static void discard_slab(struct kmem_cache *s, struct page *page)
{
dec_slabs_node(s, page_to_nid(page), page->objects);
free_slab(s, page);
}
| 185,899,174,492,013,280,000,000,000,000,000,000,000 | slub.c | 315,878,014,198,803,570,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,092 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static noinline struct kmem_cache *dma_kmalloc_cache(int index, gfp_t flags)
{
struct kmem_cache *s;
char *text;
size_t realsize;
s = kmalloc_caches_dma[index];
if (s)
return s;
/* Dynamically create dma cache */
if (flags & __GFP_WAIT)
down_write(&slub_lock);
else {
if (!down_write_trylock(&slub_lock))... | 97,755,525,718,800,600,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,093 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static struct kmem_cache_node *early_kmem_cache_node_alloc(gfp_t gfpflags,
int node)
{
struct page *page;
struct kmem_cache_node *n;
unsigned long flags;
BUG_ON(kmalloc_caches->size < sizeof(struct kmem_cache_node));
page = new_slab(kmalloc_caches, gfpflags, node);
BUG_ON(!page);
if (page_to_nid(pag... | 46,316,029,155,202,180,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,094 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static void flush_all(struct kmem_cache *s)
{
#ifdef CONFIG_SMP
on_each_cpu(flush_cpu_slab, s, 1, 1);
#else
unsigned long flags;
local_irq_save(flags);
flush_cpu_slab(s);
local_irq_restore(flags);
#endif
}
| 62,296,035,103,666,410,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,095 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static inline void flush_slab(struct kmem_cache *s, struct kmem_cache_cpu *c)
{
stat(c, CPUSLAB_FLUSH);
slab_lock(c->page);
deactivate_slab(s, c);
}
| 65,657,467,094,550,280,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,096 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static ssize_t free_calls_show(struct kmem_cache *s, char *buf)
{
if (!(s->flags & SLAB_STORE_USER))
return -ENOSYS;
return list_locations(s, buf, TRACK_FREE);
}
| 303,073,426,614,860,370,000,000,000,000,000,000,000 | slub.c | 315,878,014,198,803,570,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,097 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static int free_debug_processing(struct kmem_cache *s, struct page *page,
void *object, void *addr)
{
if (!check_slab(s, page))
goto fail;
if (!check_valid_pointer(s, page, object)) {
slab_err(s, page, "Invalid object pointer 0x%p", object);
goto fail;
}
if (on_freelist(s, page, object)) {
object_er... | 126,938,835,271,329,040,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,098 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static inline int free_debug_processing(struct kmem_cache *s,
struct page *page, void *object, void *addr) { return 0; }
| 224,057,350,545,315,600,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,099 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static void free_kmem_cache_cpu(struct kmem_cache_cpu *c, int cpu)
{
if (c < per_cpu(kmem_cache_cpu, cpu) ||
c > per_cpu(kmem_cache_cpu, cpu) + NR_KMEM_CACHE_CPU) {
kfree(c);
return;
}
c->freelist = (void *)per_cpu(kmem_cache_cpu_free, cpu);
per_cpu(kmem_cache_cpu_free, cpu) = c;
}
| 12,145,398,486,338,394,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,100 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static void free_kmem_cache_cpus(struct kmem_cache *s)
{
int cpu;
for_each_online_cpu(cpu) {
struct kmem_cache_cpu *c = get_cpu_slab(s, cpu);
if (c) {
s->cpu_slab[cpu] = NULL;
free_kmem_cache_cpu(c, cpu);
}
}
}
| 306,950,310,228,472,070,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,101 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static void free_partial(struct kmem_cache *s, struct kmem_cache_node *n)
{
unsigned long flags;
struct page *page, *h;
spin_lock_irqsave(&n->list_lock, flags);
list_for_each_entry_safe(page, h, &n->partial, lru) {
if (!page->inuse) {
list_del(&page->lru);
discard_slab(s, page);
n->nr_partial--;
} els... | 158,653,065,262,368,400,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,102 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static void free_slab(struct kmem_cache *s, struct page *page)
{
if (unlikely(s->flags & SLAB_DESTROY_BY_RCU)) {
/*
* RCU free overloads the RCU head over the LRU
*/
struct rcu_head *head = (void *)&page->lru;
call_rcu(head, rcu_free_slab);
} else
__free_slab(s, page);
}
| 336,182,962,769,964,350,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,103 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static inline struct kmem_cache_cpu *get_cpu_slab(struct kmem_cache *s, int cpu)
{
#ifdef CONFIG_SMP
return s->cpu_slab[cpu];
#else
return &s->cpu_slab;
#endif
}
| 68,700,302,832,818,910,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,104 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static inline void *get_freepointer(struct kmem_cache *s, void *object)
{
return *(void **)(object + s->offset);
}
| 250,257,968,717,786,400,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,105 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static inline struct kmem_cache_node *get_node(struct kmem_cache *s, int node)
{
#ifdef CONFIG_NUMA
return s->node[node];
#else
return &s->local_node;
#endif
}
| 144,996,963,170,047,140,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,106 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static struct page *get_object_page(const void *x)
{
struct page *page = virt_to_head_page(x);
if (!PageSlab(page))
return NULL;
return page;
}
| 48,761,754,931,108,600,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,107 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static struct page *get_partial(struct kmem_cache *s, gfp_t flags, int node)
{
struct page *page;
int searchnode = (node == -1) ? numa_node_id() : node;
page = get_partial_node(get_node(s, searchnode));
if (page || (flags & __GFP_THISNODE))
return page;
return get_any_partial(s, flags);
}
| 281,242,912,789,044,800,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,108 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static struct page *get_partial_node(struct kmem_cache_node *n)
{
struct page *page;
/*
* Racy check. If we mistakenly see no partial slabs then we
* just allocate an empty slab. If we mistakenly try to get a
* partial slab and there is none available then get_partials()
* will return NULL.
*/
if (!n || !... | 257,881,854,952,759,980,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,109 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static struct kmem_cache *get_slab(size_t size, gfp_t flags)
{
int index;
if (size <= 192) {
if (!size)
return ZERO_SIZE_PTR;
index = size_index[(size - 1) / 8];
} else
index = fls(size - 1);
#ifdef CONFIG_ZONE_DMA
if (unlikely((flags & SLUB_DMA)))
return dma_kmalloc_cache(index, flags);
#endif
retu... | 15,602,385,151,682,860,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,110 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static struct track *get_track(struct kmem_cache *s, void *object,
enum track_item alloc)
{
struct track *p;
if (s->offset)
p = object + s->offset + sizeof(void *);
else
p = object + s->inuse;
return p + alloc;
}
| 25,759,716,666,126,607,000,000,000,000,000,000,000 | slub.c | 315,878,014,198,803,570,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,111 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static ssize_t hwcache_align_show(struct kmem_cache *s, char *buf)
{
return sprintf(buf, "%d\n", !!(s->flags & SLAB_HWCACHE_ALIGN));
}
| 14,177,173,731,746,038,000,000,000,000,000,000,000 | slub.c | 315,878,014,198,803,570,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,112 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static inline void inc_slabs_node(struct kmem_cache *s, int node,
int objects) {}
| 15,077,980,872,418,497,000,000,000,000,000,000,000 | slub.c | 315,878,014,198,803,570,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,113 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static void __init init_alloc_cpu(void)
{
int cpu;
for_each_online_cpu(cpu)
init_alloc_cpu_cpu(cpu);
}
| 177,786,490,724,591,170,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,114 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static inline void init_alloc_cpu(void) {}
| 325,109,774,396,141,850,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,115 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static void init_alloc_cpu_cpu(int cpu)
{
int i;
if (cpu_isset(cpu, kmem_cach_cpu_free_init_once))
return;
for (i = NR_KMEM_CACHE_CPU - 1; i >= 0; i--)
free_kmem_cache_cpu(&per_cpu(kmem_cache_cpu, cpu)[i], cpu);
cpu_set(cpu, kmem_cach_cpu_free_init_once);
}
| 303,344,084,263,730,850,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
27,116 | linux | f8bd2258e2d520dff28c855658bd24bdafb5102d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f8bd2258e2d520dff28c855658bd24bdafb5102d | remove div_long_long_rem
x86 is the only arch right now, which provides an optimized for
div_long_long_rem and it has the downside that one has to be very careful that
the divide doesn't overflow.
The API is a little akward, as the arguments for the unsigned divide are
signed. The signed version also doesn't handle ... | 0 | static void init_kmem_cache_cpu(struct kmem_cache *s,
struct kmem_cache_cpu *c)
{
c->page = NULL;
c->freelist = NULL;
c->node = 0;
c->offset = s->offset / sizeof(void *);
c->objsize = s->objsize;
#ifdef CONFIG_SLUB_STATS
memset(c->stat, 0, NR_SLUB_STAT_ITEMS * sizeof(unsigned));
#endif
}
| 311,709,638,284,378,330,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2011-3209 | The div_long_long_rem implementation in include/asm-x86/div64.h in the Linux kernel before 2.6.26 on the x86 platform allows local users to cause a denial of service (Divide Error Fault and panic) via a clock_gettime system call. | https://nvd.nist.gov/vuln/detail/CVE-2011-3209 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.