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,117 | 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_node(struct kmem_cache_node *n)
{
n->nr_partial = 0;
spin_lock_init(&n->list_lock);
INIT_LIST_HEAD(&n->partial);
#ifdef CONFIG_SLUB_DEBUG
atomic_long_set(&n->nr_slabs, 0);
INIT_LIST_HEAD(&n->full);
#endif
}
| 4,373,961,937,921,008,600,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,118 | 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 init_kmem_cache_nodes(struct kmem_cache *s, gfp_t gfpflags)
{
int node;
int local_node;
if (slab_state >= UP)
local_node = page_to_nid(virt_to_page(s));
else
local_node = 0;
for_each_node_state(node, N_NORMAL_MEMORY) {
struct kmem_cache_node *n;
if (local_node == node)
n = &s->local_node;
... | 63,997,488,943,062,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,119 | 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 init_kmem_cache_nodes(struct kmem_cache *s, gfp_t gfpflags)
{
init_kmem_cache_node(&s->local_node);
return 1;
}
| 9,825,727,050,626,752,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,120 | 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_tracking(struct kmem_cache *s, void *object)
{
if (!(s->flags & SLAB_STORE_USER))
return;
set_track(s, object, TRACK_FREE, NULL);
set_track(s, object, TRACK_ALLOC, NULL);
}
| 321,284,356,218,908,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,121 | 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 kfree(const void *x)
{
struct page *page;
void *object = (void *)x;
if (unlikely(ZERO_OR_NULL_PTR(x)))
return;
page = virt_to_head_page(x);
if (unlikely(!PageSlab(page))) {
put_page(page);
return;
}
slab_free(page->slab, page, object, __builtin_return_address(0));
}
| 221,179,731,436,353,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,122 | 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 *kmalloc_large_node(size_t size, gfp_t flags, int node)
{
struct page *page = alloc_pages_node(node, flags | __GFP_COMP,
get_order(size));
if (page)
return page_address(page);
else
return NULL;
}
| 209,439,598,508,845,420,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,123 | 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 *kmem_cache_alloc(struct kmem_cache *s, gfp_t gfpflags)
{
return slab_alloc(s, gfpflags, -1, __builtin_return_address(0));
}
| 214,193,672,532,348,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,124 | 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 *kmem_cache_alloc_node(struct kmem_cache *s, gfp_t gfpflags, int node)
{
return slab_alloc(s, gfpflags, node, __builtin_return_address(0));
}
| 231,235,971,459,203,950,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,125 | 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 kmem_cache_close(struct kmem_cache *s)
{
int node;
flush_all(s);
/* Attempt to free all objects */
free_kmem_cache_cpus(s);
for_each_node_state(node, N_NORMAL_MEMORY) {
struct kmem_cache_node *n = get_node(s, node);
free_partial(s, n);
if (n->nr_partial || slabs_node(s, node))
return ... | 50,821,102,755,726,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,126 | 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 kmem_cache *kmem_cache_create(const char *name, size_t size,
size_t align, unsigned long flags,
void (*ctor)(struct kmem_cache *, void *))
{
struct kmem_cache *s;
down_write(&slub_lock);
s = find_mergeable(size, align, flags, name, ctor);
if (s) {
int cpu;
s->refcount++;
/*
* Adjust the object... | 248,749,150,851,653,220,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,127 | 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 kmem_cache_flags(unsigned long objsize,
unsigned long flags, const char *name,
void (*ctor)(struct kmem_cache *, void *))
{
/*
* Enable debugging if selected on the kernel commandline.
*/
if (slub_debug && (!slub_debug_slabs ||
strncmp(slub_debug_slabs, name, strlen(slub_debug_slabs)) ... | 301,778,903,856,386,100,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,128 | 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 unsigned long kmem_cache_flags(unsigned long objsize,
unsigned long flags, const char *name,
void (*ctor)(struct kmem_cache *, void *))
{
return flags;
}
| 133,087,794,206,097,540,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,129 | 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 kmem_cache_free(struct kmem_cache *s, void *x)
{
struct page *page;
page = virt_to_head_page(x);
slab_free(s, page, x, __builtin_return_address(0));
}
| 293,572,535,467,879,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,130 | 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 __init kmem_cache_init(void)
{
int i;
int caches = 0;
init_alloc_cpu();
#ifdef CONFIG_NUMA
/*
* Must first have the slab cache available for the allocations of the
* struct kmem_cache_node's. There is special bootstrap code in
* kmem_cache_open for slab_state == DOWN.
*/
create_kmalloc_cache(&kmallo... | 236,909,960,616,230,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,131 | 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 | const char *kmem_cache_name(struct kmem_cache *s)
{
return s->name;
}
| 203,601,120,375,050,160,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,132 | 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 kmem_cache_open(struct kmem_cache *s, gfp_t gfpflags,
const char *name, size_t size,
size_t align, unsigned long flags,
void (*ctor)(struct kmem_cache *, void *))
{
memset(s, 0, kmem_size);
s->name = name;
s->ctor = ctor;
s->objsize = size;
s->align = align;
s->flags = kmem_cache_flags(size, flag... | 2,167,415,296,324,771,300,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,133 | 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 | int kmem_cache_shrink(struct kmem_cache *s)
{
int node;
int i;
struct kmem_cache_node *n;
struct page *page;
struct page *t;
int objects = oo_objects(s->max);
struct list_head *slabs_by_inuse =
kmalloc(sizeof(struct list_head) * objects, GFP_KERNEL);
unsigned long flags;
if (!slabs_by_inuse)
return -ENOME... | 172,578,781,588,639,730,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,134 | 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 kmem_cache_size(struct kmem_cache *s)
{
return s->objsize;
}
| 4,860,120,138,356,827,500,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,135 | 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 | size_t ksize(const void *object)
{
struct page *page;
struct kmem_cache *s;
if (unlikely(object == ZERO_SIZE_PTR))
return 0;
page = virt_to_head_page(object);
if (unlikely(!PageSlab(page)))
return PAGE_SIZE << compound_order(page);
s = page->slab;
#ifdef CONFIG_SLUB_DEBUG
/*
* Debugging requires use o... | 70,583,882,279,663,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,136 | 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 list_slab_objects(struct kmem_cache *s, struct page *page,
const char *text)
{
#ifdef CONFIG_SLUB_DEBUG
void *addr = page_address(page);
void *p;
DECLARE_BITMAP(map, page->objects);
bitmap_zero(map, page->objects);
slab_err(s, page, "%s", text);
slab_lock(page);
for_each_free_object(p, s, pag... | 292,353,005,958,457,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,137 | 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 lock_and_freeze_slab(struct kmem_cache_node *n, struct page *page)
{
if (slab_trylock(page)) {
list_del(&page->lru);
n->nr_partial--;
SetSlabFrozen(page);
return 1;
}
return 0;
}
| 211,994,043,996,721,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,138 | 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 node_match(struct kmem_cache_cpu *c, int node)
{
#ifdef CONFIG_NUMA
if (node != -1 && c->node != node)
return 0;
#endif
return 1;
}
| 58,200,078,028,115,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,139 | 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 object_err(struct kmem_cache *s, struct page *page,
u8 *object, char *reason)
{
slab_bug(s, "%s", reason);
print_trailer(s, page, object);
}
| 55,607,039,173,653,890,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,140 | 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 objects_partial_show(struct kmem_cache *s, char *buf)
{
return show_slab_objects(s, buf, SO_PARTIAL|SO_OBJECTS);
}
| 261,082,106,954,969,450,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,141 | 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 on_freelist(struct kmem_cache *s, struct page *page, void *search)
{
int nr = 0;
void *fp = page->freelist;
void *object = NULL;
unsigned long max_objects;
while (fp && nr <= page->objects) {
if (fp == search)
return 1;
if (!check_valid_pointer(s, page, fp)) {
if (object) {
object_err(s, ... | 203,682,761,183,245,120,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,142 | 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_order_objects oo_make(int order,
unsigned long size)
{
struct kmem_cache_order_objects x = {
(order << 16) + (PAGE_SIZE << order) / size
};
return x;
}
| 77,490,671,857,753,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,143 | 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 oo_order(struct kmem_cache_order_objects x)
{
return x.x >> 16;
}
| 10,788,525,908,530,895,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,144 | 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 order_show(struct kmem_cache *s, char *buf)
{
return sprintf(buf, "%d\n", oo_order(s->oo));
}
| 202,836,978,687,847,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,145 | 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 order_store(struct kmem_cache *s,
const char *buf, size_t length)
{
int order = simple_strtoul(buf, NULL, 10);
if (order > slub_max_order || order < slub_min_order)
return -EINVAL;
calculate_sizes(s, order);
return length;
}
| 176,589,596,252,521,150,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,146 | 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 poison_show(struct kmem_cache *s, char *buf)
{
return sprintf(buf, "%d\n", !!(s->flags & SLAB_POISON));
}
| 179,947,438,563,125,730,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,147 | 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 poison_store(struct kmem_cache *s,
const char *buf, size_t length)
{
if (any_slab_objects(s))
return -EBUSY;
s->flags &= ~SLAB_POISON;
if (buf[0] == '1')
s->flags |= SLAB_POISON;
calculate_sizes(s, -1);
return length;
}
| 120,703,697,126,384,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,148 | 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 print_page_info(struct page *page)
{
printk(KERN_ERR "INFO: Slab 0x%p objects=%u used=%u fp=0x%p flags=0x%04lx\n",
page, page->objects, page->inuse, page->freelist, page->flags);
}
| 147,596,840,753,552,780,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,149 | 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 print_section(char *text, u8 *addr, unsigned int length)
{
int i, offset;
int newline = 1;
char ascii[17];
ascii[16] = 0;
for (i = 0; i < length; i++) {
if (newline) {
printk(KERN_ERR "%8s 0x%p: ", text, addr + i);
newline = 0;
}
printk(KERN_CONT " %02x", addr[i]);
offset = i % 16;
as... | 160,595,583,897,143,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,150 | 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 print_slabinfo_header(struct seq_file *m)
{
seq_puts(m, "slabinfo - version: 2.1\n");
seq_puts(m, "# name <active_objs> <num_objs> <objsize> "
"<objperslab> <pagesperslab>");
seq_puts(m, " : tunables <limit> <batchcount> <sharedfactor>");
seq_puts(m, " : slabdata <active_slabs> <num_slabs>... | 114,418,570,691,815,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,151 | 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 print_track(const char *s, struct track *t)
{
if (!t->addr)
return;
printk(KERN_ERR "INFO: %s in ", s);
__print_symbol("%s", (unsigned long)t->addr);
printk(" age=%lu cpu=%u pid=%d\n", jiffies - t->when, t->cpu, t->pid);
}
| 4,272,740,020,256,713,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,152 | 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 print_tracking(struct kmem_cache *s, void *object)
{
if (!(s->flags & SLAB_STORE_USER))
return;
print_track("Allocated", get_track(s, object, TRACK_ALLOC));
print_track("Freed", get_track(s, object, TRACK_FREE));
}
| 184,450,127,396,519,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,153 | 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 print_trailer(struct kmem_cache *s, struct page *page, u8 *p)
{
unsigned int off; /* Offset of last byte */
u8 *addr = page_address(page);
print_tracking(s, p);
print_page_info(page);
printk(KERN_ERR "INFO: Object 0x%p @offset=%tu fp=0x%p\n\n",
p, p - addr, get_freepointer(s, p));
if (p > addr ... | 32,164,048,954,450,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,154 | 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 process_slab(struct loc_track *t, struct kmem_cache *s,
struct page *page, enum track_item alloc)
{
void *addr = page_address(page);
DECLARE_BITMAP(map, page->objects);
void *p;
bitmap_zero(map, page->objects);
for_each_free_object(p, s, page->freelist)
set_bit(slab_index(p, s, addr), map);
for_... | 274,091,738,356,192,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,155 | 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 rcu_free_slab(struct rcu_head *h)
{
struct page *page;
page = container_of((struct list_head *)h, struct page, lru);
__free_slab(page->slab, page);
}
| 42,569,384,602,454,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,156 | 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 reclaim_account_show(struct kmem_cache *s, char *buf)
{
return sprintf(buf, "%d\n", !!(s->flags & SLAB_RECLAIM_ACCOUNT));
}
| 261,288,584,474,874,780,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,157 | 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 reclaim_account_store(struct kmem_cache *s,
const char *buf, size_t length)
{
s->flags &= ~SLAB_RECLAIM_ACCOUNT;
if (buf[0] == '1')
s->flags |= SLAB_RECLAIM_ACCOUNT;
return length;
}
| 16,955,714,568,657,623,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,158 | 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 red_zone_show(struct kmem_cache *s, char *buf)
{
return sprintf(buf, "%d\n", !!(s->flags & SLAB_RED_ZONE));
}
| 77,093,306,459,049,150,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,159 | 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 red_zone_store(struct kmem_cache *s,
const char *buf, size_t length)
{
if (any_slab_objects(s))
return -EBUSY;
s->flags &= ~SLAB_RED_ZONE;
if (buf[0] == '1')
s->flags |= SLAB_RED_ZONE;
calculate_sizes(s, -1);
return length;
}
| 162,939,281,623,045,160,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,160 | 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 remote_node_defrag_ratio_show(struct kmem_cache *s, char *buf)
{
return sprintf(buf, "%d\n", s->remote_node_defrag_ratio / 10);
}
| 152,161,585,865,225,840,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,161 | 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 remote_node_defrag_ratio_store(struct kmem_cache *s,
const char *buf, size_t length)
{
int n = simple_strtoul(buf, NULL, 10);
if (n < 100)
s->remote_node_defrag_ratio = n * 10;
return length;
}
| 48,632,954,121,079,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,162 | 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 remove_full(struct kmem_cache *s, struct page *page)
{
struct kmem_cache_node *n;
if (!(s->flags & SLAB_STORE_USER))
return;
n = get_node(s, page_to_nid(page));
spin_lock(&n->list_lock);
list_del(&page->lru);
spin_unlock(&n->list_lock);
}
| 15,423,083,465,229,034,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,163 | 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 remove_partial(struct kmem_cache *s,
struct page *page)
{
struct kmem_cache_node *n = get_node(s, page_to_nid(page));
spin_lock(&n->list_lock);
list_del(&page->lru);
n->nr_partial--;
spin_unlock(&n->list_lock);
}
| 194,187,054,169,104,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,164 | 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 resiliency_test(void)
{
u8 *p;
printk(KERN_ERR "SLUB resiliency testing\n");
printk(KERN_ERR "-----------------------\n");
printk(KERN_ERR "A. Corruption after allocation\n");
p = kzalloc(16, GFP_KERNEL);
p[16] = 0x12;
printk(KERN_ERR "\n1. kmalloc-16: Clobber Redzone/next pointer"
" 0x12->0x%p\... | 222,179,905,592,349,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,165 | 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 resiliency_test(void) {};
| 306,567,615,028,230,700,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,166 | 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 restore_bytes(struct kmem_cache *s, char *message, u8 data,
void *from, void *to)
{
slab_fix(s, "Restoring 0x%p-0x%p=0x%x\n", from, to - 1, data);
memset(from, data, to - from);
}
| 261,207,657,137,669,460,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,167 | 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 *s_next(struct seq_file *m, void *p, loff_t *pos)
{
return seq_list_next(p, &slab_caches, pos);
}
| 248,413,040,956,527,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,168 | 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 s_show(struct seq_file *m, void *p)
{
unsigned long nr_partials = 0;
unsigned long nr_slabs = 0;
unsigned long nr_inuse = 0;
unsigned long nr_objs = 0;
unsigned long nr_free = 0;
struct kmem_cache *s;
int node;
s = list_entry(p, struct kmem_cache, list);
for_each_online_node(node) {
struct kmem_... | 218,681,809,748,838,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,169 | 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 *s_start(struct seq_file *m, loff_t *pos)
{
loff_t n = *pos;
down_read(&slub_lock);
if (!n)
print_slabinfo_header(m);
return seq_list_start(&slab_caches, *pos);
}
| 171,761,864,916,390,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,170 | 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 s_stop(struct seq_file *m, void *p)
{
up_read(&slub_lock);
}
| 226,486,178,588,935,430,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,171 | 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 sanity_checks_show(struct kmem_cache *s, char *buf)
{
return sprintf(buf, "%d\n", !!(s->flags & SLAB_DEBUG_FREE));
}
| 86,487,087,785,193,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,172 | 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 sanity_checks_store(struct kmem_cache *s,
const char *buf, size_t length)
{
s->flags &= ~SLAB_DEBUG_FREE;
if (buf[0] == '1')
s->flags |= SLAB_DEBUG_FREE;
return length;
}
| 121,193,120,346,629,730,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,173 | 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 set_freepointer(struct kmem_cache *s, void *object, void *fp)
{
*(void **)(object + s->offset) = fp;
}
| 2,203,140,431,834,668,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,174 | 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 setup_object(struct kmem_cache *s, struct page *page,
void *object)
{
setup_object_debug(s, page, object);
if (unlikely(s->ctor))
s->ctor(s, object);
}
| 175,513,540,679,437,230,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,175 | 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 setup_object_debug(struct kmem_cache *s,
struct page *page, void *object) {}
| 148,161,376,341,252,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,176 | 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 __init setup_slub_debug(char *str)
{
slub_debug = DEBUG_DEFAULT_FLAGS;
if (*str++ != '=' || !*str)
/*
* No options specified. Switch on full debugging.
*/
goto out;
if (*str == ',')
/*
* No options but restriction on slabs. This means full
* debugging for slabs matching a pattern.
*/... | 181,349,954,985,885,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,177 | 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 __init setup_slub_max_order(char *str)
{
get_option(&str, &slub_max_order);
return 1;
}
| 281,036,412,719,038,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,178 | 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 __init setup_slub_min_objects(char *str)
{
get_option(&str, &slub_min_objects);
return 1;
}
| 4,794,566,668,413,894,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,179 | 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 __init setup_slub_min_order(char *str)
{
get_option(&str, &slub_min_order);
return 1;
}
| 143,631,952,149,005,460,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,180 | 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 __init setup_slub_nomerge(char *str)
{
slub_nomerge = 1;
return 1;
}
| 32,586,212,108,536,443,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,181 | 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 show_slab_objects(struct kmem_cache *s,
char *buf, unsigned long flags)
{
unsigned long total = 0;
int node;
int x;
unsigned long *nodes;
unsigned long *per_cpu;
nodes = kzalloc(2 * sizeof(unsigned long) * nr_node_ids, GFP_KERNEL);
if (!nodes)
return -ENOMEM;
per_cpu = nodes + nr_node_i... | 35,315,696,792,315,150,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,182 | 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 show_stat(struct kmem_cache *s, char *buf, enum stat_item si)
{
unsigned long sum = 0;
int cpu;
int len;
int *data = kmalloc(nr_cpu_ids * sizeof(int), GFP_KERNEL);
if (!data)
return -ENOMEM;
for_each_online_cpu(cpu) {
unsigned x = get_cpu_slab(s, cpu)->stat[si];
data[cpu] = x;
sum += x;
}
... | 274,749,072,257,341,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,183 | 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 shrink_show(struct kmem_cache *s, char *buf)
{
return 0;
}
| 49,516,516,226,385,040,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,184 | 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 shrink_store(struct kmem_cache *s,
const char *buf, size_t length)
{
if (buf[0] == '1') {
int rc = kmem_cache_shrink(s);
if (rc)
return rc;
} else
return -EINVAL;
return length;
}
| 141,149,225,159,526,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,185 | 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 __always_inline void *slab_alloc(struct kmem_cache *s,
gfp_t gfpflags, int node, void *addr)
{
void **object;
struct kmem_cache_cpu *c;
unsigned long flags;
local_irq_save(flags);
c = get_cpu_slab(s, smp_processor_id());
if (unlikely(!c->freelist || !node_match(c, node)))
object = __slab_alloc(s, gfp... | 338,333,491,990,706,630,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,186 | 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 slab_attr_show(struct kobject *kobj,
struct attribute *attr,
char *buf)
{
struct slab_attribute *attribute;
struct kmem_cache *s;
int err;
attribute = to_slab_attr(attr);
s = to_slab(kobj);
if (!attribute->show)
return -EIO;
err = attribute->show(s, buf);
return err;
}
| 194,962,457,567,510,300,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,187 | 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 slab_attr_store(struct kobject *kobj,
struct attribute *attr,
const char *buf, size_t len)
{
struct slab_attribute *attribute;
struct kmem_cache *s;
int err;
attribute = to_slab_attr(attr);
s = to_slab(kobj);
if (!attribute->store)
return -EIO;
err = attribute->store(s, buf, len);
r... | 200,458,777,300,769,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,188 | 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_bug(struct kmem_cache *s, char *fmt, ...)
{
va_list args;
char buf[100];
va_start(args, fmt);
vsnprintf(buf, sizeof(buf), fmt, args);
va_end(args);
printk(KERN_ERR "========================================"
"=====================================\n");
printk(KERN_ERR "BUG %s: %s\n", s->name, ... | 155,781,341,774,866,420,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,189 | 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 __cpuinit slab_cpuup_callback(struct notifier_block *nfb,
unsigned long action, void *hcpu)
{
long cpu = (long)hcpu;
struct kmem_cache *s;
unsigned long flags;
switch (action) {
case CPU_UP_PREPARE:
case CPU_UP_PREPARE_FROZEN:
init_alloc_cpu_cpu(cpu);
down_read(&slub_lock);
list_for_each_entry... | 116,898,772,855,634,150,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,190 | 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_err(struct kmem_cache *s, struct page *page, char *fmt, ...)
{
va_list args;
char buf[100];
va_start(args, fmt);
vsnprintf(buf, sizeof(buf), fmt, args);
va_end(args);
slab_bug(s, "%s", buf);
print_page_info(page);
dump_stack();
}
| 336,582,354,060,825,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,191 | 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_fix(struct kmem_cache *s, char *fmt, ...)
{
va_list args;
char buf[100];
va_start(args, fmt);
vsnprintf(buf, sizeof(buf), fmt, args);
va_end(args);
printk(KERN_ERR "FIX %s: %s\n", s->name, buf);
}
| 217,928,507,909,215,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,192 | 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 __always_inline void slab_free(struct kmem_cache *s,
struct page *page, void *x, void *addr)
{
void **object = (void *)x;
struct kmem_cache_cpu *c;
unsigned long flags;
local_irq_save(flags);
c = get_cpu_slab(s, smp_processor_id());
debug_check_no_locks_freed(object, c->objsize);
if (!(s->flags & SLAB... | 256,868,395,626,249,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,193 | 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 slab_index(void *p, struct kmem_cache *s, void *addr)
{
return (p - addr) / s->size;
}
| 80,778,986,826,557,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,194 | 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 | int slab_is_available(void)
{
return slab_state >= UP;
}
| 14,923,667,080,836,187,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,195 | 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 __always_inline void slab_lock(struct page *page)
{
bit_spin_lock(PG_locked, &page->flags);
}
| 122,743,097,602,537,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,196 | 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 slab_mem_going_offline_callback(void *arg)
{
struct kmem_cache *s;
down_read(&slub_lock);
list_for_each_entry(s, &slab_caches, list)
kmem_cache_shrink(s);
up_read(&slub_lock);
return 0;
}
| 258,278,224,153,375,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,197 | 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 slab_mem_going_online_callback(void *arg)
{
struct kmem_cache_node *n;
struct kmem_cache *s;
struct memory_notify *marg = arg;
int nid = marg->status_change_nid;
int ret = 0;
/*
* If the node's memory is already available, then kmem_cache_node is
* already created. Nothing to do.
*/
if (nid < 0... | 79,416,264,717,204,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,198 | 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_mem_offline_callback(void *arg)
{
struct kmem_cache_node *n;
struct kmem_cache *s;
struct memory_notify *marg = arg;
int offline_node;
offline_node = marg->status_change_nid;
/*
* If the node still has available memory. we need kmem_cache_node
* for it yet.
*/
if (offline_node < 0)
ret... | 251,402,596,485,268,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,199 | 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 slab_memory_callback(struct notifier_block *self,
unsigned long action, void *arg)
{
int ret = 0;
switch (action) {
case MEM_GOING_ONLINE:
ret = slab_mem_going_online_callback(arg);
break;
case MEM_GOING_OFFLINE:
ret = slab_mem_going_offline_callback(arg);
break;
case MEM_OFFLINE:
case MEM... | 105,960,339,015,812,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,200 | 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 slab_order(int size, int min_objects,
int max_order, int fract_leftover)
{
int order;
int rem;
int min_order = slub_min_order;
if ((PAGE_SIZE << min_order) / size > 65535)
return get_order(size * 65535) - 1;
for (order = max(min_order,
fls(min_objects * size - 1) - PAGE_SHIFT);
ord... | 301,798,653,499,799,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,201 | 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 slab_pad_check(struct kmem_cache *s, struct page *page)
{
u8 *start;
u8 *fault;
u8 *end;
int length;
int remainder;
if (!(s->flags & SLAB_POISON))
return 1;
start = page_address(page);
length = (PAGE_SIZE << compound_order(page));
end = start + length;
remainder = length % s->size;
if (!remain... | 22,796,876,467,958,886,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,202 | 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 slab_pad_check(struct kmem_cache *s, struct page *page)
{ return 1; }
| 117,223,932,062,470,500,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,203 | 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 slab_size_show(struct kmem_cache *s, char *buf)
{
return sprintf(buf, "%d\n", s->size);
}
| 289,594,059,131,474,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,204 | 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 __always_inline int slab_trylock(struct page *page)
{
int rc = 1;
rc = bit_spin_trylock(PG_locked, &page->flags);
return rc;
}
| 14,842,880,303,297,853,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,205 | 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 __always_inline void slab_unlock(struct page *page)
{
__bit_spin_unlock(PG_locked, &page->flags);
}
| 309,356,979,738,956,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,206 | 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 slab_unmergeable(struct kmem_cache *s)
{
if (slub_nomerge || (s->flags & SLUB_NEVER_MERGE))
return 1;
if (s->ctor)
return 1;
/*
* We may have set a slab to be unmergeable during bootstrap.
*/
if (s->refcount < 0)
return 1;
return 0;
}
| 10,919,480,534,795,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,207 | 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 unsigned long slabs_node(struct kmem_cache *s, int node)
{
struct kmem_cache_node *n = get_node(s, node);
return atomic_long_read(&n->nr_slabs);
}
| 325,450,153,129,133,360,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,208 | 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 unsigned long slabs_node(struct kmem_cache *s, int node)
{ return 0; }
| 88,105,229,344,177,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,209 | 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 slabs_show(struct kmem_cache *s, char *buf)
{
return show_slab_objects(s, buf, SO_ALL);
}
| 27,661,081,847,112,970,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,210 | 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 stat(struct kmem_cache_cpu *c, enum stat_item si)
{
#ifdef CONFIG_SLUB_STATS
c->stat[si]++;
#endif
}
| 47,645,200,615,389,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,211 | 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 store_user_show(struct kmem_cache *s, char *buf)
{
return sprintf(buf, "%d\n", !!(s->flags & SLAB_STORE_USER));
}
| 77,588,429,867,801,240,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,212 | 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 store_user_store(struct kmem_cache *s,
const char *buf, size_t length)
{
if (any_slab_objects(s))
return -EBUSY;
s->flags &= ~SLAB_STORE_USER;
if (buf[0] == '1')
s->flags |= SLAB_STORE_USER;
calculate_sizes(s, -1);
return length;
}
| 120,614,594,477,352,460,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,213 | 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 sysfs_add_func(struct work_struct *w)
{
struct kmem_cache *s;
down_write(&slub_lock);
list_for_each_entry(s, &slab_caches, list) {
if (s->flags & __SYSFS_ADD_DEFERRED) {
s->flags &= ~__SYSFS_ADD_DEFERRED;
sysfs_slab_add(s);
}
}
up_write(&slub_lock);
}
| 284,066,355,785,071,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,214 | 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 sysfs_slab_add(struct kmem_cache *s) { return 0; }
| 171,586,873,133,307,600,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,215 | 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 sysfs_slab_add(struct kmem_cache *s)
{
int err;
const char *name;
int unmergeable;
if (slab_state < SYSFS)
/* Defer until later */
return 0;
unmergeable = slab_unmergeable(s);
if (unmergeable) {
/*
* Slabcache can never be merged so we can use the name proper.
* This is typically the case... | 205,655,518,279,674,420,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,216 | 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 sysfs_slab_alias(struct kmem_cache *s, const char *p)
{ return 0; }
| 196,822,526,519,884,460,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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.