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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
22,303 | linux | 9ab4233dd08036fe34a89c7dc6f47a8bf2eb29eb | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/9ab4233dd08036fe34a89c7dc6f47a8bf2eb29eb | mm: Hold a file reference in madvise_remove
Otherwise the code races with munmap (causing a use-after-free
of the vma) or with close (causing a use-after-free of the struct
file).
The bug was introduced by commit 90ed52ebe481 ("[PATCH] holepunch: fix
mmap_sem i_mutex deadlock")
Cc: Hugh Dickins <hugh@veritas.com>
Cc... | 0 | SYSCALL_DEFINE3(madvise, unsigned long, start, size_t, len_in, int, behavior)
{
unsigned long end, tmp;
struct vm_area_struct * vma, *prev;
int unmapped_error = 0;
int error = -EINVAL;
int write;
size_t len;
#ifdef CONFIG_MEMORY_FAILURE
if (behavior == MADV_HWPOISON || behavior == MADV_SOFT_OFFLINE)
return ma... | 292,741,418,595,327,570,000,000,000,000,000,000,000 | madvise.c | 262,237,407,608,705,300,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2012-3511 | Multiple race conditions in the madvise_remove function in mm/madvise.c in the Linux kernel before 3.4.5 allow local users to cause a denial of service (use-after-free and system crash) via vectors involving a (1) munmap or (2) close system call. | https://nvd.nist.gov/vuln/detail/CVE-2012-3511 |
22,304 | linux | 9ab4233dd08036fe34a89c7dc6f47a8bf2eb29eb | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/9ab4233dd08036fe34a89c7dc6f47a8bf2eb29eb | mm: Hold a file reference in madvise_remove
Otherwise the code races with munmap (causing a use-after-free
of the vma) or with close (causing a use-after-free of the struct
file).
The bug was introduced by commit 90ed52ebe481 ("[PATCH] holepunch: fix
mmap_sem i_mutex deadlock")
Cc: Hugh Dickins <hugh@veritas.com>
Cc... | 0 | static long madvise_behavior(struct vm_area_struct * vma,
struct vm_area_struct **prev,
unsigned long start, unsigned long end, int behavior)
{
struct mm_struct * mm = vma->vm_mm;
int error = 0;
pgoff_t pgoff;
unsigned long new_flags = vma->vm_flags;
switch (behavior) {
case MADV_NORMAL:
new_flag... | 82,664,720,900,165,770,000,000,000,000,000,000,000 | madvise.c | 262,237,407,608,705,300,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2012-3511 | Multiple race conditions in the madvise_remove function in mm/madvise.c in the Linux kernel before 3.4.5 allow local users to cause a denial of service (use-after-free and system crash) via vectors involving a (1) munmap or (2) close system call. | https://nvd.nist.gov/vuln/detail/CVE-2012-3511 |
22,305 | linux | 9ab4233dd08036fe34a89c7dc6f47a8bf2eb29eb | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/9ab4233dd08036fe34a89c7dc6f47a8bf2eb29eb | mm: Hold a file reference in madvise_remove
Otherwise the code races with munmap (causing a use-after-free
of the vma) or with close (causing a use-after-free of the struct
file).
The bug was introduced by commit 90ed52ebe481 ("[PATCH] holepunch: fix
mmap_sem i_mutex deadlock")
Cc: Hugh Dickins <hugh@veritas.com>
Cc... | 0 | madvise_behavior_valid(int behavior)
{
switch (behavior) {
case MADV_DOFORK:
case MADV_DONTFORK:
case MADV_NORMAL:
case MADV_SEQUENTIAL:
case MADV_RANDOM:
case MADV_REMOVE:
case MADV_WILLNEED:
case MADV_DONTNEED:
#ifdef CONFIG_KSM
case MADV_MERGEABLE:
case MADV_UNMERGEABLE:
#endif
#ifdef CONFIG_TRANSPARENT_H... | 5,600,033,734,497,247,000,000,000,000,000,000,000 | madvise.c | 262,237,407,608,705,300,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2012-3511 | Multiple race conditions in the madvise_remove function in mm/madvise.c in the Linux kernel before 3.4.5 allow local users to cause a denial of service (use-after-free and system crash) via vectors involving a (1) munmap or (2) close system call. | https://nvd.nist.gov/vuln/detail/CVE-2012-3511 |
22,306 | linux | 9ab4233dd08036fe34a89c7dc6f47a8bf2eb29eb | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/9ab4233dd08036fe34a89c7dc6f47a8bf2eb29eb | mm: Hold a file reference in madvise_remove
Otherwise the code races with munmap (causing a use-after-free
of the vma) or with close (causing a use-after-free of the struct
file).
The bug was introduced by commit 90ed52ebe481 ("[PATCH] holepunch: fix
mmap_sem i_mutex deadlock")
Cc: Hugh Dickins <hugh@veritas.com>
Cc... | 0 | static int madvise_hwpoison(int bhv, unsigned long start, unsigned long end)
{
int ret = 0;
if (!capable(CAP_SYS_ADMIN))
return -EPERM;
for (; start < end; start += PAGE_SIZE) {
struct page *p;
int ret = get_user_pages_fast(start, 1, 0, &p);
if (ret != 1)
return ret;
if (bhv == MADV_SOFT_OFFLINE) {
... | 169,736,496,358,120,470,000,000,000,000,000,000,000 | madvise.c | 262,237,407,608,705,300,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2012-3511 | Multiple race conditions in the madvise_remove function in mm/madvise.c in the Linux kernel before 3.4.5 allow local users to cause a denial of service (use-after-free and system crash) via vectors involving a (1) munmap or (2) close system call. | https://nvd.nist.gov/vuln/detail/CVE-2012-3511 |
22,307 | linux | 9ab4233dd08036fe34a89c7dc6f47a8bf2eb29eb | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/9ab4233dd08036fe34a89c7dc6f47a8bf2eb29eb | mm: Hold a file reference in madvise_remove
Otherwise the code races with munmap (causing a use-after-free
of the vma) or with close (causing a use-after-free of the struct
file).
The bug was introduced by commit 90ed52ebe481 ("[PATCH] holepunch: fix
mmap_sem i_mutex deadlock")
Cc: Hugh Dickins <hugh@veritas.com>
Cc... | 0 | static int madvise_need_mmap_write(int behavior)
{
switch (behavior) {
case MADV_REMOVE:
case MADV_WILLNEED:
case MADV_DONTNEED:
return 0;
default:
/* be safe, default to 1. list exceptions explicitly */
return 1;
}
}
| 320,462,027,974,506,280,000,000,000,000,000,000,000 | madvise.c | 262,237,407,608,705,300,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2012-3511 | Multiple race conditions in the madvise_remove function in mm/madvise.c in the Linux kernel before 3.4.5 allow local users to cause a denial of service (use-after-free and system crash) via vectors involving a (1) munmap or (2) close system call. | https://nvd.nist.gov/vuln/detail/CVE-2012-3511 |
22,308 | linux | 9ab4233dd08036fe34a89c7dc6f47a8bf2eb29eb | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/9ab4233dd08036fe34a89c7dc6f47a8bf2eb29eb | mm: Hold a file reference in madvise_remove
Otherwise the code races with munmap (causing a use-after-free
of the vma) or with close (causing a use-after-free of the struct
file).
The bug was introduced by commit 90ed52ebe481 ("[PATCH] holepunch: fix
mmap_sem i_mutex deadlock")
Cc: Hugh Dickins <hugh@veritas.com>
Cc... | 0 | madvise_vma(struct vm_area_struct *vma, struct vm_area_struct **prev,
unsigned long start, unsigned long end, int behavior)
{
switch (behavior) {
case MADV_REMOVE:
return madvise_remove(vma, prev, start, end);
case MADV_WILLNEED:
return madvise_willneed(vma, prev, start, end);
case MADV_DONTNEED:
return mad... | 100,916,703,479,826,700,000,000,000,000,000,000,000 | madvise.c | 262,237,407,608,705,300,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2012-3511 | Multiple race conditions in the madvise_remove function in mm/madvise.c in the Linux kernel before 3.4.5 allow local users to cause a denial of service (use-after-free and system crash) via vectors involving a (1) munmap or (2) close system call. | https://nvd.nist.gov/vuln/detail/CVE-2012-3511 |
22,309 | linux | f0ec1aaf54caddd21c259aea8b2ecfbde4ee4fb9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f0ec1aaf54caddd21c259aea8b2ecfbde4ee4fb9 | [PATCH] xacct_add_tsk: fix pure theoretical ->mm use-after-free
Paranoid fix. The task can free its ->mm after the 'if (p->mm)' check.
Signed-off-by: Oleg Nesterov <oleg@tv-sign.ru>
Cc: Shailabh Nagar <nagar@watson.ibm.com>
Cc: Balbir Singh <balbir@in.ibm.com>
Cc: Jay Lan <jlan@sgi.com>
Signed-off-by: Andrew Morton <... | 0 | void acct_clear_integrals(struct task_struct *tsk)
{
tsk->acct_stimexpd = 0;
tsk->acct_rss_mem1 = 0;
tsk->acct_vm_mem1 = 0;
}
| 199,648,303,419,094,830,000,000,000,000,000,000,000 | tsacct.c | 125,401,631,378,471,580,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2012-3510 | Use-after-free vulnerability in the xacct_add_tsk function in kernel/tsacct.c in the Linux kernel before 2.6.19 allows local users to obtain potentially sensitive information from kernel memory or cause a denial of service (system crash) via a taskstats TASKSTATS_CMD_ATTR_PID command. | https://nvd.nist.gov/vuln/detail/CVE-2012-3510 |
22,310 | linux | f0ec1aaf54caddd21c259aea8b2ecfbde4ee4fb9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f0ec1aaf54caddd21c259aea8b2ecfbde4ee4fb9 | [PATCH] xacct_add_tsk: fix pure theoretical ->mm use-after-free
Paranoid fix. The task can free its ->mm after the 'if (p->mm)' check.
Signed-off-by: Oleg Nesterov <oleg@tv-sign.ru>
Cc: Shailabh Nagar <nagar@watson.ibm.com>
Cc: Balbir Singh <balbir@in.ibm.com>
Cc: Jay Lan <jlan@sgi.com>
Signed-off-by: Andrew Morton <... | 0 | void acct_update_integrals(struct task_struct *tsk)
{
if (likely(tsk->mm)) {
long delta = cputime_to_jiffies(
cputime_sub(tsk->stime, tsk->acct_stimexpd));
if (delta == 0)
return;
tsk->acct_stimexpd = tsk->stime;
tsk->acct_rss_mem1 += delta * get_mm_rss(tsk->mm);
tsk->acct_vm_mem1 += delta * tsk->mm->... | 230,956,176,137,973,770,000,000,000,000,000,000,000 | tsacct.c | 125,401,631,378,471,580,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2012-3510 | Use-after-free vulnerability in the xacct_add_tsk function in kernel/tsacct.c in the Linux kernel before 2.6.19 allows local users to obtain potentially sensitive information from kernel memory or cause a denial of service (system crash) via a taskstats TASKSTATS_CMD_ATTR_PID command. | https://nvd.nist.gov/vuln/detail/CVE-2012-3510 |
22,311 | linux | f0ec1aaf54caddd21c259aea8b2ecfbde4ee4fb9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f0ec1aaf54caddd21c259aea8b2ecfbde4ee4fb9 | [PATCH] xacct_add_tsk: fix pure theoretical ->mm use-after-free
Paranoid fix. The task can free its ->mm after the 'if (p->mm)' check.
Signed-off-by: Oleg Nesterov <oleg@tv-sign.ru>
Cc: Shailabh Nagar <nagar@watson.ibm.com>
Cc: Balbir Singh <balbir@in.ibm.com>
Cc: Jay Lan <jlan@sgi.com>
Signed-off-by: Andrew Morton <... | 0 | void bacct_add_tsk(struct taskstats *stats, struct task_struct *tsk)
{
struct timespec uptime, ts;
s64 ac_etime;
BUILD_BUG_ON(TS_COMM_LEN < TASK_COMM_LEN);
/* calculate task elapsed time in timespec */
do_posix_clock_monotonic_gettime(&uptime);
ts = timespec_sub(uptime, tsk->start_time);
/* rebase elapsed time... | 317,152,871,615,590,630,000,000,000,000,000,000,000 | tsacct.c | 125,401,631,378,471,580,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2012-3510 | Use-after-free vulnerability in the xacct_add_tsk function in kernel/tsacct.c in the Linux kernel before 2.6.19 allows local users to obtain potentially sensitive information from kernel memory or cause a denial of service (system crash) via a taskstats TASKSTATS_CMD_ATTR_PID command. | https://nvd.nist.gov/vuln/detail/CVE-2012-3510 |
22,312 | linux | 06b6a1cf6e776426766298d055bb3991957d90a7 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/06b6a1cf6e776426766298d055bb3991957d90a7 | rds: set correct msg_namelen
Jay Fenlason (fenlason@redhat.com) found a bug,
that recvfrom() on an RDS socket can return the contents of random kernel
memory to userspace if it was called with a address length larger than
sizeof(struct sockaddr_in).
rds_recvmsg() also fails to set the addr_len paramater properly befor... | 0 | void rds_clear_recv_queue(struct rds_sock *rs)
{
struct sock *sk = rds_rs_to_sk(rs);
struct rds_incoming *inc, *tmp;
unsigned long flags;
write_lock_irqsave(&rs->rs_recv_lock, flags);
list_for_each_entry_safe(inc, tmp, &rs->rs_recv_queue, i_item) {
rds_recv_rcvbuf_delta(rs, sk, inc->i_conn->c_lcong,
-... | 180,956,626,970,007,700,000,000,000,000,000,000,000 | recv.c | 196,002,549,294,029,070,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2012-3430 | The rds_recvmsg function in net/rds/recv.c in the Linux kernel before 3.0.44 does not initialize a certain structure member, which allows local users to obtain potentially sensitive information from kernel stack memory via a (1) recvfrom or (2) recvmsg system call on an RDS socket. | https://nvd.nist.gov/vuln/detail/CVE-2012-3430 |
22,313 | linux | 06b6a1cf6e776426766298d055bb3991957d90a7 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/06b6a1cf6e776426766298d055bb3991957d90a7 | rds: set correct msg_namelen
Jay Fenlason (fenlason@redhat.com) found a bug,
that recvfrom() on an RDS socket can return the contents of random kernel
memory to userspace if it was called with a address length larger than
sizeof(struct sockaddr_in).
rds_recvmsg() also fails to set the addr_len paramater properly befor... | 0 | static int rds_cmsg_recv(struct rds_incoming *inc, struct msghdr *msg)
{
int ret = 0;
if (inc->i_rdma_cookie) {
ret = put_cmsg(msg, SOL_RDS, RDS_CMSG_RDMA_DEST,
sizeof(inc->i_rdma_cookie), &inc->i_rdma_cookie);
if (ret)
return ret;
}
return 0;
}
| 286,496,354,158,010,540,000,000,000,000,000,000,000 | recv.c | 196,002,549,294,029,070,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2012-3430 | The rds_recvmsg function in net/rds/recv.c in the Linux kernel before 3.0.44 does not initialize a certain structure member, which allows local users to obtain potentially sensitive information from kernel stack memory via a (1) recvfrom or (2) recvmsg system call on an RDS socket. | https://nvd.nist.gov/vuln/detail/CVE-2012-3430 |
22,314 | linux | 06b6a1cf6e776426766298d055bb3991957d90a7 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/06b6a1cf6e776426766298d055bb3991957d90a7 | rds: set correct msg_namelen
Jay Fenlason (fenlason@redhat.com) found a bug,
that recvfrom() on an RDS socket can return the contents of random kernel
memory to userspace if it was called with a address length larger than
sizeof(struct sockaddr_in).
rds_recvmsg() also fails to set the addr_len paramater properly befor... | 0 | static void rds_inc_addref(struct rds_incoming *inc)
{
rdsdebug("addref inc %p ref %d\n", inc, atomic_read(&inc->i_refcount));
atomic_inc(&inc->i_refcount);
}
| 149,614,195,018,457,300,000,000,000,000,000,000,000 | recv.c | 196,002,549,294,029,070,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2012-3430 | The rds_recvmsg function in net/rds/recv.c in the Linux kernel before 3.0.44 does not initialize a certain structure member, which allows local users to obtain potentially sensitive information from kernel stack memory via a (1) recvfrom or (2) recvmsg system call on an RDS socket. | https://nvd.nist.gov/vuln/detail/CVE-2012-3430 |
22,315 | linux | 06b6a1cf6e776426766298d055bb3991957d90a7 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/06b6a1cf6e776426766298d055bb3991957d90a7 | rds: set correct msg_namelen
Jay Fenlason (fenlason@redhat.com) found a bug,
that recvfrom() on an RDS socket can return the contents of random kernel
memory to userspace if it was called with a address length larger than
sizeof(struct sockaddr_in).
rds_recvmsg() also fails to set the addr_len paramater properly befor... | 0 | void rds_inc_init(struct rds_incoming *inc, struct rds_connection *conn,
__be32 saddr)
{
atomic_set(&inc->i_refcount, 1);
INIT_LIST_HEAD(&inc->i_item);
inc->i_conn = conn;
inc->i_saddr = saddr;
inc->i_rdma_cookie = 0;
}
| 141,771,698,619,835,020,000,000,000,000,000,000,000 | recv.c | 196,002,549,294,029,070,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2012-3430 | The rds_recvmsg function in net/rds/recv.c in the Linux kernel before 3.0.44 does not initialize a certain structure member, which allows local users to obtain potentially sensitive information from kernel stack memory via a (1) recvfrom or (2) recvmsg system call on an RDS socket. | https://nvd.nist.gov/vuln/detail/CVE-2012-3430 |
22,316 | linux | 06b6a1cf6e776426766298d055bb3991957d90a7 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/06b6a1cf6e776426766298d055bb3991957d90a7 | rds: set correct msg_namelen
Jay Fenlason (fenlason@redhat.com) found a bug,
that recvfrom() on an RDS socket can return the contents of random kernel
memory to userspace if it was called with a address length larger than
sizeof(struct sockaddr_in).
rds_recvmsg() also fails to set the addr_len paramater properly befor... | 0 | void rds_inc_put(struct rds_incoming *inc)
{
rdsdebug("put inc %p ref %d\n", inc, atomic_read(&inc->i_refcount));
if (atomic_dec_and_test(&inc->i_refcount)) {
BUG_ON(!list_empty(&inc->i_item));
inc->i_conn->c_trans->inc_free(inc);
}
}
| 74,697,856,175,914,680,000,000,000,000,000,000,000 | recv.c | 196,002,549,294,029,070,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2012-3430 | The rds_recvmsg function in net/rds/recv.c in the Linux kernel before 3.0.44 does not initialize a certain structure member, which allows local users to obtain potentially sensitive information from kernel stack memory via a (1) recvfrom or (2) recvmsg system call on an RDS socket. | https://nvd.nist.gov/vuln/detail/CVE-2012-3430 |
22,317 | linux | 06b6a1cf6e776426766298d055bb3991957d90a7 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/06b6a1cf6e776426766298d055bb3991957d90a7 | rds: set correct msg_namelen
Jay Fenlason (fenlason@redhat.com) found a bug,
that recvfrom() on an RDS socket can return the contents of random kernel
memory to userspace if it was called with a address length larger than
sizeof(struct sockaddr_in).
rds_recvmsg() also fails to set the addr_len paramater properly befor... | 0 | static int rds_next_incoming(struct rds_sock *rs, struct rds_incoming **inc)
{
unsigned long flags;
if (!*inc) {
read_lock_irqsave(&rs->rs_recv_lock, flags);
if (!list_empty(&rs->rs_recv_queue)) {
*inc = list_entry(rs->rs_recv_queue.next,
struct rds_incoming,
i_item);
rds_inc_addref(*inc);
... | 173,650,209,038,458,580,000,000,000,000,000,000,000 | recv.c | 196,002,549,294,029,070,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2012-3430 | The rds_recvmsg function in net/rds/recv.c in the Linux kernel before 3.0.44 does not initialize a certain structure member, which allows local users to obtain potentially sensitive information from kernel stack memory via a (1) recvfrom or (2) recvmsg system call on an RDS socket. | https://nvd.nist.gov/vuln/detail/CVE-2012-3430 |
22,318 | linux | 06b6a1cf6e776426766298d055bb3991957d90a7 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/06b6a1cf6e776426766298d055bb3991957d90a7 | rds: set correct msg_namelen
Jay Fenlason (fenlason@redhat.com) found a bug,
that recvfrom() on an RDS socket can return the contents of random kernel
memory to userspace if it was called with a address length larger than
sizeof(struct sockaddr_in).
rds_recvmsg() also fails to set the addr_len paramater properly befor... | 0 | static int rds_notify_cong(struct rds_sock *rs, struct msghdr *msghdr)
{
uint64_t notify = rs->rs_cong_notify;
unsigned long flags;
int err;
err = put_cmsg(msghdr, SOL_RDS, RDS_CMSG_CONG_UPDATE,
sizeof(notify), ¬ify);
if (err)
return err;
spin_lock_irqsave(&rs->rs_lock, flags);
rs->rs_cong_notify &= ~n... | 282,879,066,490,213,150,000,000,000,000,000,000,000 | recv.c | 196,002,549,294,029,070,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2012-3430 | The rds_recvmsg function in net/rds/recv.c in the Linux kernel before 3.0.44 does not initialize a certain structure member, which allows local users to obtain potentially sensitive information from kernel stack memory via a (1) recvfrom or (2) recvmsg system call on an RDS socket. | https://nvd.nist.gov/vuln/detail/CVE-2012-3430 |
22,319 | linux | 06b6a1cf6e776426766298d055bb3991957d90a7 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/06b6a1cf6e776426766298d055bb3991957d90a7 | rds: set correct msg_namelen
Jay Fenlason (fenlason@redhat.com) found a bug,
that recvfrom() on an RDS socket can return the contents of random kernel
memory to userspace if it was called with a address length larger than
sizeof(struct sockaddr_in).
rds_recvmsg() also fails to set the addr_len paramater properly befor... | 0 | int rds_notify_queue_get(struct rds_sock *rs, struct msghdr *msghdr)
{
struct rds_notifier *notifier;
struct rds_rdma_notify cmsg = { 0 }; /* fill holes with zero */
unsigned int count = 0, max_messages = ~0U;
unsigned long flags;
LIST_HEAD(copy);
int err = 0;
/* put_cmsg copies to user space and thus may slee... | 160,188,814,754,672,640,000,000,000,000,000,000,000 | recv.c | 196,002,549,294,029,070,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2012-3430 | The rds_recvmsg function in net/rds/recv.c in the Linux kernel before 3.0.44 does not initialize a certain structure member, which allows local users to obtain potentially sensitive information from kernel stack memory via a (1) recvfrom or (2) recvmsg system call on an RDS socket. | https://nvd.nist.gov/vuln/detail/CVE-2012-3430 |
22,320 | linux | 06b6a1cf6e776426766298d055bb3991957d90a7 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/06b6a1cf6e776426766298d055bb3991957d90a7 | rds: set correct msg_namelen
Jay Fenlason (fenlason@redhat.com) found a bug,
that recvfrom() on an RDS socket can return the contents of random kernel
memory to userspace if it was called with a address length larger than
sizeof(struct sockaddr_in).
rds_recvmsg() also fails to set the addr_len paramater properly befor... | 0 | static void rds_recv_incoming_exthdrs(struct rds_incoming *inc, struct rds_sock *rs)
{
struct rds_header *hdr = &inc->i_hdr;
unsigned int pos = 0, type, len;
union {
struct rds_ext_header_version version;
struct rds_ext_header_rdma rdma;
struct rds_ext_header_rdma_dest rdma_dest;
} buffer;
while (1) {
len... | 65,192,325,032,704,050,000,000,000,000,000,000,000 | recv.c | 196,002,549,294,029,070,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2012-3430 | The rds_recvmsg function in net/rds/recv.c in the Linux kernel before 3.0.44 does not initialize a certain structure member, which allows local users to obtain potentially sensitive information from kernel stack memory via a (1) recvfrom or (2) recvmsg system call on an RDS socket. | https://nvd.nist.gov/vuln/detail/CVE-2012-3430 |
22,321 | linux | 06b6a1cf6e776426766298d055bb3991957d90a7 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/06b6a1cf6e776426766298d055bb3991957d90a7 | rds: set correct msg_namelen
Jay Fenlason (fenlason@redhat.com) found a bug,
that recvfrom() on an RDS socket can return the contents of random kernel
memory to userspace if it was called with a address length larger than
sizeof(struct sockaddr_in).
rds_recvmsg() also fails to set the addr_len paramater properly befor... | 0 | static void rds_recv_rcvbuf_delta(struct rds_sock *rs, struct sock *sk,
struct rds_cong_map *map,
int delta, __be16 port)
{
int now_congested;
if (delta == 0)
return;
rs->rs_rcv_bytes += delta;
now_congested = rs->rs_rcv_bytes > rds_sk_rcvbuf(rs);
rdsdebug("rs %p (%pI4:%u) recv bytes %d buf %d "
... | 127,162,229,149,679,690,000,000,000,000,000,000,000 | recv.c | 196,002,549,294,029,070,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2012-3430 | The rds_recvmsg function in net/rds/recv.c in the Linux kernel before 3.0.44 does not initialize a certain structure member, which allows local users to obtain potentially sensitive information from kernel stack memory via a (1) recvfrom or (2) recvmsg system call on an RDS socket. | https://nvd.nist.gov/vuln/detail/CVE-2012-3430 |
22,322 | linux | 06b6a1cf6e776426766298d055bb3991957d90a7 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/06b6a1cf6e776426766298d055bb3991957d90a7 | rds: set correct msg_namelen
Jay Fenlason (fenlason@redhat.com) found a bug,
that recvfrom() on an RDS socket can return the contents of random kernel
memory to userspace if it was called with a address length larger than
sizeof(struct sockaddr_in).
rds_recvmsg() also fails to set the addr_len paramater properly befor... | 0 | static int rds_still_queued(struct rds_sock *rs, struct rds_incoming *inc,
int drop)
{
struct sock *sk = rds_rs_to_sk(rs);
int ret = 0;
unsigned long flags;
write_lock_irqsave(&rs->rs_recv_lock, flags);
if (!list_empty(&inc->i_item)) {
ret = 1;
if (drop) {
/* XXX make sure this i_conn is reliable */... | 231,613,636,423,628,370,000,000,000,000,000,000,000 | recv.c | 196,002,549,294,029,070,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2012-3430 | The rds_recvmsg function in net/rds/recv.c in the Linux kernel before 3.0.44 does not initialize a certain structure member, which allows local users to obtain potentially sensitive information from kernel stack memory via a (1) recvfrom or (2) recvmsg system call on an RDS socket. | https://nvd.nist.gov/vuln/detail/CVE-2012-3430 |
22,448 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | void _udf_err(struct super_block *sb, const char *function,
const char *fmt, ...)
{
struct va_format vaf;
va_list args;
/* mark sb error */
if (!(sb->s_flags & MS_RDONLY))
sb->s_dirt = 1;
va_start(args, fmt);
vaf.fmt = fmt;
vaf.va = &args;
pr_err("error (device %s): %s: %pV", sb->s_id, function, &v... | 237,850,077,770,240,300,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,449 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | void _udf_warn(struct super_block *sb, const char *function,
const char *fmt, ...)
{
struct va_format vaf;
va_list args;
va_start(args, fmt);
vaf.fmt = fmt;
vaf.va = &args;
pr_warn("warning (device %s): %s: %pV", sb->s_id, function, &vaf);
va_end(args);
}
| 101,864,244,043,830,230,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,450 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static void destroy_inodecache(void)
{
kmem_cache_destroy(udf_inode_cachep);
}
| 30,587,792,492,064,593,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,451 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static void __exit exit_udf_fs(void)
{
unregister_filesystem(&udf_fstype);
destroy_inodecache();
}
| 321,981,992,962,425,700,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,452 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static int init_inodecache(void)
{
udf_inode_cachep = kmem_cache_create("udf_inode_cache",
sizeof(struct udf_inode_info),
0, (SLAB_RECLAIM_ACCOUNT |
SLAB_MEM_SPREAD),
init_once);
if (!udf_inode_cachep)
return -ENOMEM;
return 0;
}
| 263,383,575,975,868,400,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,453 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static void init_once(void *foo)
{
struct udf_inode_info *ei = (struct udf_inode_info *)foo;
ei->i_ext.i_data = NULL;
inode_init_once(&ei->vfs_inode);
}
| 42,976,509,247,187,990,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,454 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | u64 lvid_get_unique_id(struct super_block *sb)
{
struct buffer_head *bh;
struct udf_sb_info *sbi = UDF_SB(sb);
struct logicalVolIntegrityDesc *lvid;
struct logicalVolHeaderDesc *lvhd;
u64 uniqueID;
u64 ret;
bh = sbi->s_lvid_bh;
if (!bh)
return 0;
lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
lvhd =... | 186,008,906,418,885,300,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,455 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static struct inode *udf_alloc_inode(struct super_block *sb)
{
struct udf_inode_info *ei;
ei = kmem_cache_alloc(udf_inode_cachep, GFP_KERNEL);
if (!ei)
return NULL;
ei->i_unique = 0;
ei->i_lenExtents = 0;
ei->i_next_alloc_block = 0;
ei->i_next_alloc_goal = 0;
ei->i_strat4096 = 0;
init_rwsem(&ei->i_data_sem)... | 161,471,227,663,105,980,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,456 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static int udf_check_anchor_block(struct super_block *sb, sector_t block,
struct kernel_lb_addr *fileset)
{
struct buffer_head *bh;
uint16_t ident;
int ret;
if (UDF_QUERY_FLAG(sb, UDF_FLAG_VARCONV) &&
udf_fixed_to_variable(block) >=
sb->s_bdev->bd_inode->i_size >> sb->s_blocksize_bits)
return 0;
... | 300,017,454,066,830,750,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,457 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static void udf_close_lvid(struct super_block *sb)
{
struct udf_sb_info *sbi = UDF_SB(sb);
struct buffer_head *bh = sbi->s_lvid_bh;
struct logicalVolIntegrityDesc *lvid;
struct logicalVolIntegrityDescImpUse *lvidiu;
if (!bh)
return;
mutex_lock(&sbi->s_alloc_mutex);
lvid = (struct logicalVolIntegrityDesc *)bh... | 196,633,470,207,345,830,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,458 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | int udf_compute_nr_groups(struct super_block *sb, u32 partition)
{
struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
return DIV_ROUND_UP(map->s_partition_len +
(sizeof(struct spaceBitmapDesc) << 3),
sb->s_blocksize * 8);
}
| 329,726,807,976,737,040,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,459 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static unsigned int udf_count_free(struct super_block *sb)
{
unsigned int accum = 0;
struct udf_sb_info *sbi;
struct udf_part_map *map;
sbi = UDF_SB(sb);
if (sbi->s_lvid_bh) {
struct logicalVolIntegrityDesc *lvid =
(struct logicalVolIntegrityDesc *)
sbi->s_lvid_bh->b_data;
if (le32_to_cpu(lvid->numOfPar... | 178,580,782,556,421,400,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,460 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static unsigned int udf_count_free_bitmap(struct super_block *sb,
struct udf_bitmap *bitmap)
{
struct buffer_head *bh = NULL;
unsigned int accum = 0;
int index;
int block = 0, newblock;
struct kernel_lb_addr loc;
uint32_t bytes;
uint8_t *ptr;
uint16_t ident;
struct spaceBitmapDesc *bm;
loc.logicalBloc... | 254,388,138,873,666,160,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,461 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static unsigned int udf_count_free_table(struct super_block *sb,
struct inode *table)
{
unsigned int accum = 0;
uint32_t elen;
struct kernel_lb_addr eloc;
int8_t etype;
struct extent_position epos;
mutex_lock(&UDF_SB(sb)->s_alloc_mutex);
epos.block = UDF_I(table)->i_location;
epos.offset = sizeof(struct ... | 67,303,891,928,367,670,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,462 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static void udf_destroy_inode(struct inode *inode)
{
call_rcu(&inode->i_rcu, udf_i_callback);
}
| 308,496,809,364,754,200,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,463 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static int udf_fill_partdesc_info(struct super_block *sb,
struct partitionDesc *p, int p_index)
{
struct udf_part_map *map;
struct udf_sb_info *sbi = UDF_SB(sb);
struct partitionHeaderDesc *phd;
map = &sbi->s_partmaps[p_index];
map->s_partition_len = le32_to_cpu(p->partitionLength); /* blocks */
map->s_partit... | 188,627,740,529,588,780,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,464 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static int udf_find_fileset(struct super_block *sb,
struct kernel_lb_addr *fileset,
struct kernel_lb_addr *root)
{
struct buffer_head *bh = NULL;
long lastblock;
uint16_t ident;
struct udf_sb_info *sbi;
if (fileset->logicalBlockNum != 0xFFFFFFFF ||
fileset->partitionReferenceNum != 0xFFFF) {
... | 151,792,770,543,846,670,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,465 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | struct inode *udf_find_metadata_inode_efe(struct super_block *sb,
u32 meta_file_loc, u32 partition_num)
{
struct kernel_lb_addr addr;
struct inode *metadata_fe;
addr.logicalBlockNum = meta_file_loc;
addr.partitionReferenceNum = partition_num;
metadata_fe = udf_iget(sb, &addr);
if (metadata_fe == NULL)
u... | 169,974,905,262,780,450,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,466 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static void udf_find_vat_block(struct super_block *sb, int p_index,
int type1_index, sector_t start_block)
{
struct udf_sb_info *sbi = UDF_SB(sb);
struct udf_part_map *map = &sbi->s_partmaps[p_index];
sector_t vat_block;
struct kernel_lb_addr ino;
/*
* VAT file entry is in the last recorded block. Som... | 270,952,408,952,089,450,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,467 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static void udf_free_partition(struct udf_part_map *map)
{
int i;
struct udf_meta_data *mdata;
if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE)
iput(map->s_uspace.s_table);
if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
iput(map->s_fspace.s_table);
if (map->s_partition_flags & UDF_PART_FLAG_... | 51,333,398,338,164,300,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,468 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static void udf_i_callback(struct rcu_head *head)
{
struct inode *inode = container_of(head, struct inode, i_rcu);
kmem_cache_free(udf_inode_cachep, UDF_I(inode));
}
| 262,090,846,843,413,530,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,469 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static void udf_load_fileset(struct super_block *sb, struct buffer_head *bh,
struct kernel_lb_addr *root)
{
struct fileSetDesc *fset;
fset = (struct fileSetDesc *)bh->b_data;
*root = lelb_to_cpu(fset->rootDirectoryICB.extLocation);
UDF_SB(sb)->s_serial_number = le16_to_cpu(fset->descTag.tagSerialNum);
... | 307,370,952,548,016,750,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,470 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static void udf_load_logicalvolint(struct super_block *sb, struct kernel_extent_ad loc)
{
struct buffer_head *bh = NULL;
uint16_t ident;
struct udf_sb_info *sbi = UDF_SB(sb);
struct logicalVolIntegrityDesc *lvid;
while (loc.extLength > 0 &&
(bh = udf_read_tagged(sb, loc.extLocation,
loc.extLocati... | 159,304,948,476,331,150,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,471 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static int udf_load_metadata_files(struct super_block *sb, int partition)
{
struct udf_sb_info *sbi = UDF_SB(sb);
struct udf_part_map *map;
struct udf_meta_data *mdata;
struct kernel_lb_addr addr;
map = &sbi->s_partmaps[partition];
mdata = &map->s_type_specific.s_metadata;
/* metadata address */
udf_debug("Me... | 39,143,929,533,945,950,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,472 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static int udf_load_partdesc(struct super_block *sb, sector_t block)
{
struct buffer_head *bh;
struct partitionDesc *p;
struct udf_part_map *map;
struct udf_sb_info *sbi = UDF_SB(sb);
int i, type1_idx;
uint16_t partitionNumber;
uint16_t ident;
int ret = 0;
bh = udf_read_tagged(sb, block, block, &ident);
if (... | 29,897,716,411,593,640,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,473 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static int udf_load_sequence(struct super_block *sb, struct buffer_head *bh,
struct kernel_lb_addr *fileset)
{
struct anchorVolDescPtr *anchor;
long main_s, main_e, reserve_s, reserve_e;
anchor = (struct anchorVolDescPtr *)bh->b_data;
/* Locate the main sequence */
main_s = le32_to_cpu(anchor->mainVolDes... | 158,458,070,503,808,850,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,474 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static struct dentry *udf_mount(struct file_system_type *fs_type,
int flags, const char *dev_name, void *data)
{
return mount_bdev(fs_type, flags, dev_name, data, udf_fill_super);
}
| 140,760,595,338,284,580,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,475 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static void udf_open_lvid(struct super_block *sb)
{
struct udf_sb_info *sbi = UDF_SB(sb);
struct buffer_head *bh = sbi->s_lvid_bh;
struct logicalVolIntegrityDesc *lvid;
struct logicalVolIntegrityDescImpUse *lvidiu;
if (!bh)
return;
mutex_lock(&sbi->s_alloc_mutex);
lvid = (struct logicalVolIntegrityDesc *)bh-... | 205,307,458,400,070,160,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,476 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static int udf_parse_options(char *options, struct udf_options *uopt,
bool remount)
{
char *p;
int option;
uopt->novrs = 0;
uopt->partition = 0xFFFF;
uopt->session = 0xFFFFFFFF;
uopt->lastblock = 0;
uopt->anchor = 0;
uopt->volume = 0xFFFFFFFF;
uopt->rootdir = 0xFFFFFFFF;
uopt->fileset = 0xFFFFFFFF;
... | 136,374,679,979,093,220,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,477 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static noinline int udf_process_sequence(struct super_block *sb, long block,
long lastblock, struct kernel_lb_addr *fileset)
{
struct buffer_head *bh = NULL;
struct udf_vds_record vds[VDS_POS_LENGTH];
struct udf_vds_record *curr;
struct generic_desc *gd;
struct volDescPtr *vdp;
int done = 0;
uint32_t vdsn;
... | 144,735,046,797,409,210,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,478 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static void udf_put_super(struct super_block *sb)
{
int i;
struct udf_sb_info *sbi;
sbi = UDF_SB(sb);
if (sbi->s_vat_inode)
iput(sbi->s_vat_inode);
if (sbi->s_partitions)
for (i = 0; i < sbi->s_partitions; i++)
udf_free_partition(&sbi->s_partmaps[i]);
#ifdef CONFIG_UDF_NLS
if (UDF_QUERY_FLAG(sb, UDF_FLAG... | 18,034,813,864,370,486,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,479 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static int udf_remount_fs(struct super_block *sb, int *flags, char *options)
{
struct udf_options uopt;
struct udf_sb_info *sbi = UDF_SB(sb);
int error = 0;
uopt.flags = sbi->s_flags;
uopt.uid = sbi->s_uid;
uopt.gid = sbi->s_gid;
uopt.umask = sbi->s_umask;
uopt.fmode = sbi->s_fmode;
uopt.dmode = sbi->s_dm... | 319,540,908,116,049,700,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,480 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static struct udf_bitmap *udf_sb_alloc_bitmap(struct super_block *sb, u32 index)
{
struct udf_bitmap *bitmap;
int nr_groups;
int size;
nr_groups = udf_compute_nr_groups(sb, index);
size = sizeof(struct udf_bitmap) +
(sizeof(struct buffer_head *) * nr_groups);
if (size <= PAGE_SIZE)
bitmap = kzalloc(size, GF... | 17,037,728,839,670,278,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,481 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static int udf_sb_alloc_partition_maps(struct super_block *sb, u32 count)
{
struct udf_sb_info *sbi = UDF_SB(sb);
sbi->s_partmaps = kcalloc(count, sizeof(struct udf_part_map),
GFP_KERNEL);
if (!sbi->s_partmaps) {
udf_err(sb, "Unable to allocate space for %d partition maps\n",
count);
sbi->s_partitions ... | 318,517,524,623,496,150,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,482 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static void udf_sb_free_bitmap(struct udf_bitmap *bitmap)
{
int i;
int nr_groups = bitmap->s_nr_groups;
int size = sizeof(struct udf_bitmap) + (sizeof(struct buffer_head *) *
nr_groups);
for (i = 0; i < nr_groups; i++)
if (bitmap->s_block_bitmap[i])
brelse(bitmap->s_block_bitmap[i]);
if (size <= PAGE_... | 254,603,664,553,936,600,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,483 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | struct logicalVolIntegrityDescImpUse *udf_sb_lvidiu(struct udf_sb_info *sbi)
{
struct logicalVolIntegrityDesc *lvid =
(struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
__u32 number_of_partitions = le32_to_cpu(lvid->numOfPartitions);
__u32 offset = number_of_partitions * 2 *
sizeof(uint32_t)/sizeof(uint... | 125,252,437,233,982,220,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,484 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static sector_t udf_scan_anchors(struct super_block *sb, sector_t lastblock,
struct kernel_lb_addr *fileset)
{
sector_t last[6];
int i;
struct udf_sb_info *sbi = UDF_SB(sb);
int last_count = 0;
/* First try user provided anchor */
if (sbi->s_anchor) {
if (udf_check_anchor_block(sb, sbi->s_anchor, fileset)... | 46,678,329,133,364,410,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,485 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static int udf_show_options(struct seq_file *seq, struct dentry *root)
{
struct super_block *sb = root->d_sb;
struct udf_sb_info *sbi = UDF_SB(sb);
if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT))
seq_puts(seq, ",nostrict");
if (UDF_QUERY_FLAG(sb, UDF_FLAG_BLOCKSIZE_SET))
seq_printf(seq, ",bs=%lu", sb->s_blocksize);
... | 182,721,537,972,004,900,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,486 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static int udf_statfs(struct dentry *dentry, struct kstatfs *buf)
{
struct super_block *sb = dentry->d_sb;
struct udf_sb_info *sbi = UDF_SB(sb);
struct logicalVolIntegrityDescImpUse *lvidiu;
u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
if (sbi->s_lvid_bh != NULL)
lvidiu = udf_sb_lvidiu(sbi);
else
lvidiu = N... | 46,241,819,926,939,170,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,487 | linux | adee11b2085bee90bd8f4f52123ffb07882d6256 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/adee11b2085bee90bd8f4f52123ffb07882d6256 | udf: Avoid run away loop when partition table length is corrupted
Check provided length of partition table so that (possibly maliciously)
corrupted partition table cannot cause accessing data beyond current buffer.
Signed-off-by: Jan Kara <jack@suse.cz> | 0 | static int udf_sync_fs(struct super_block *sb, int wait)
{
struct udf_sb_info *sbi = UDF_SB(sb);
mutex_lock(&sbi->s_alloc_mutex);
if (sbi->s_lvid_dirty) {
/*
* Blockdevice will be synced later so we don't have to submit
* the buffer for IO
*/
mark_buffer_dirty(sbi->s_lvid_bh);
sb->s_dirt = 0;
sbi->... | 61,084,000,153,943,110,000,000,000,000,000,000,000 | super.c | 330,692,185,936,405,120,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-3400 | Heap-based buffer overflow in the udf_load_logicalvol function in fs/udf/super.c in the Linux kernel before 3.4.5 allows remote attackers to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2012-3400 |
22,488 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | SYSCALL_DEFINE1(epoll_create1, int, flags)
{
int error, fd;
struct eventpoll *ep = NULL;
struct file *file;
/* Check the EPOLL_* constant for consistency. */
BUILD_BUG_ON(EPOLL_CLOEXEC != O_CLOEXEC);
if (flags & ~EPOLL_CLOEXEC)
return -EINVAL;
/*
* Create the internal data structure ("struct eventpoll").
... | 288,254,773,111,247,950,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,489 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | SYSCALL_DEFINE1(epoll_create, int, size)
{
if (size <= 0)
return -EINVAL;
return sys_epoll_create1(0);
}
| 333,960,607,660,211,570,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,490 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | SYSCALL_DEFINE4(epoll_wait, int, epfd, struct epoll_event __user *, events,
int, maxevents, int, timeout)
{
int error;
struct file *file;
struct eventpoll *ep;
/* The maximum number of event must be greater than zero */
if (maxevents <= 0 || maxevents > EP_MAX_EVENTS)
return -EINVAL;
/* Verify that the area... | 330,939,114,104,854,700,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,491 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static void clear_tfile_check_list(void)
{
struct file *file;
/* first clear the tfile_check_list */
while (!list_empty(&tfile_check_list)) {
file = list_first_entry(&tfile_check_list, struct file,
f_tfile_llink);
list_del_init(&file->f_tfile_llink);
}
INIT_LIST_HEAD(&tfile_check_list);
}
| 13,526,476,178,114,800,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,492 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static int ep_alloc(struct eventpoll **pep)
{
int error;
struct user_struct *user;
struct eventpoll *ep;
user = get_current_user();
error = -ENOMEM;
ep = kzalloc(sizeof(*ep), GFP_KERNEL);
if (unlikely(!ep))
goto free_uid;
spin_lock_init(&ep->lock);
mutex_init(&ep->mtx);
init_waitqueue_head(&ep->wq);
init... | 93,763,008,718,870,140,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,493 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static int ep_call_nested(struct nested_calls *ncalls, int max_nests,
int (*nproc)(void *, void *, int), void *priv,
void *cookie, void *ctx)
{
int error, call_nests = 0;
unsigned long flags;
struct list_head *lsthead = &ncalls->tasks_call_list;
struct nested_call_node *tncur;
struct nested_call_node tno... | 1,143,511,647,341,460,300,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,494 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static inline int ep_cmp_ffd(struct epoll_filefd *p1,
struct epoll_filefd *p2)
{
return (p1->file > p2->file ? +1:
(p1->file < p2->file ? -1 : p1->fd - p2->fd));
}
| 78,286,324,356,407,140,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,495 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static unsigned int ep_eventpoll_poll(struct file *file, poll_table *wait)
{
int pollflags;
struct eventpoll *ep = file->private_data;
/* Insert inside our poll wait queue */
poll_wait(file, &ep->poll_wait, wait);
/*
* Proceed to find out if wanted events are really available inside
* the ready list. This ne... | 30,120,779,865,479,083,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,496 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static inline int ep_events_available(struct eventpoll *ep)
{
return !list_empty(&ep->rdllist) || ep->ovflist != EP_UNACTIVE_PTR;
}
| 141,252,588,036,347,020,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,497 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static struct epitem *ep_find(struct eventpoll *ep, struct file *file, int fd)
{
int kcmp;
struct rb_node *rbp;
struct epitem *epi, *epir = NULL;
struct epoll_filefd ffd;
ep_set_ffd(&ffd, file, fd);
for (rbp = ep->rbr.rb_node; rbp; ) {
epi = rb_entry(rbp, struct epitem, rbn);
kcmp = ep_cmp_ffd(&ffd, &epi->ff... | 14,647,374,154,094,242,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,498 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static void ep_free(struct eventpoll *ep)
{
struct rb_node *rbp;
struct epitem *epi;
/* We need to release all tasks waiting for these file */
if (waitqueue_active(&ep->poll_wait))
ep_poll_safewake(&ep->poll_wait);
/*
* We need to lock this because we could be hit by
* eventpoll_release_file() while we're ... | 195,568,252,316,096,800,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,499 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static int ep_insert(struct eventpoll *ep, struct epoll_event *event,
struct file *tfile, int fd)
{
int error, revents, pwake = 0;
unsigned long flags;
long user_watches;
struct epitem *epi;
struct ep_pqueue epq;
user_watches = atomic_long_read(&ep->user->epoll_watches);
if (unlikely(user_watches >= max_... | 101,558,086,719,784,230,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,500 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static inline int ep_is_linked(struct list_head *p)
{
return !list_empty(p);
}
| 76,676,337,662,800,200,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,501 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static inline struct epitem *ep_item_from_epqueue(poll_table *p)
{
return container_of(p, struct ep_pqueue, pt)->epi;
}
| 325,700,427,597,309,070,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,502 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static inline struct epitem *ep_item_from_wait(wait_queue_t *p)
{
return container_of(p, struct eppoll_entry, wait)->base;
}
| 338,080,754,443,371,170,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,503 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static int ep_loop_check(struct eventpoll *ep, struct file *file)
{
int ret;
struct eventpoll *ep_cur, *ep_next;
ret = ep_call_nested(&poll_loop_ncalls, EP_MAX_NESTS,
ep_loop_check_proc, file, ep, current);
/* clear visited list */
list_for_each_entry_safe(ep_cur, ep_next, &visited_list,
visited_l... | 282,879,633,704,987,100,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,504 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static int ep_loop_check_proc(void *priv, void *cookie, int call_nests)
{
int error = 0;
struct file *file = priv;
struct eventpoll *ep = file->private_data;
struct eventpoll *ep_tovisit;
struct rb_node *rbp;
struct epitem *epi;
mutex_lock_nested(&ep->mtx, call_nests + 1);
ep->visited = 1;
list_add(&ep->visit... | 81,824,327,792,640,630,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,505 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static int ep_modify(struct eventpoll *ep, struct epitem *epi, struct epoll_event *event)
{
int pwake = 0;
unsigned int revents;
poll_table pt;
init_poll_funcptr(&pt, NULL);
/*
* Set the new event interest mask before calling f_op->poll();
* otherwise we might miss an event that happens between the
* f_op-... | 324,479,847,468,642,840,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,506 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static void ep_nested_calls_init(struct nested_calls *ncalls)
{
INIT_LIST_HEAD(&ncalls->tasks_call_list);
spin_lock_init(&ncalls->lock);
}
| 82,181,235,550,190,090,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,507 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static inline int ep_op_has_event(int op)
{
return op != EPOLL_CTL_DEL;
}
| 129,033,530,012,869,650,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,508 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static int ep_poll_callback(wait_queue_t *wait, unsigned mode, int sync, void *key)
{
int pwake = 0;
unsigned long flags;
struct epitem *epi = ep_item_from_wait(wait);
struct eventpoll *ep = epi->ep;
if ((unsigned long)key & POLLFREE) {
ep_pwq_from_wait(wait)->whead = NULL;
/*
* whead = NULL above can race... | 209,133,610,377,234,200,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,509 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static int ep_poll_readyevents_proc(void *priv, void *cookie, int call_nests)
{
return ep_scan_ready_list(priv, ep_read_events_proc, NULL, call_nests + 1);
}
| 126,451,134,806,611,830,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,510 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static void ep_poll_safewake(wait_queue_head_t *wq)
{
int this_cpu = get_cpu();
ep_call_nested(&poll_safewake_ncalls, EP_MAX_NESTS,
ep_poll_wakeup_proc, NULL, wq, (void *) (long) this_cpu);
put_cpu();
}
| 178,419,219,648,342,200,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,511 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static int ep_poll_wakeup_proc(void *priv, void *cookie, int call_nests)
{
ep_wake_up_nested((wait_queue_head_t *) cookie, POLLIN,
1 + call_nests);
return 0;
}
| 152,175,426,248,533,640,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,512 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static void ep_ptable_queue_proc(struct file *file, wait_queue_head_t *whead,
poll_table *pt)
{
struct epitem *epi = ep_item_from_epqueue(pt);
struct eppoll_entry *pwq;
if (epi->nwait >= 0 && (pwq = kmem_cache_alloc(pwq_cache, GFP_KERNEL))) {
init_waitqueue_func_entry(&pwq->wait, ep_poll_callback);
pwq->wh... | 52,922,819,852,138,890,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,513 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static inline struct eppoll_entry *ep_pwq_from_wait(wait_queue_t *p)
{
return container_of(p, struct eppoll_entry, wait);
}
| 108,320,575,902,969,470,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,514 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static void ep_rbtree_insert(struct eventpoll *ep, struct epitem *epi)
{
int kcmp;
struct rb_node **p = &ep->rbr.rb_node, *parent = NULL;
struct epitem *epic;
while (*p) {
parent = *p;
epic = rb_entry(parent, struct epitem, rbn);
kcmp = ep_cmp_ffd(&epi->ffd, &epic->ffd);
if (kcmp > 0)
p = &parent->rb_ri... | 80,531,003,194,638,880,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,515 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static int ep_read_events_proc(struct eventpoll *ep, struct list_head *head,
void *priv)
{
struct epitem *epi, *tmp;
poll_table pt;
init_poll_funcptr(&pt, NULL);
list_for_each_entry_safe(epi, tmp, head, rdllink) {
pt._key = epi->event.events;
if (epi->ffd.file->f_op->poll(epi->ffd.file, &pt) &
... | 15,833,972,837,906,542,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,516 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static void ep_remove_wait_queue(struct eppoll_entry *pwq)
{
wait_queue_head_t *whead;
rcu_read_lock();
/* If it is cleared by POLLFREE, it should be rcu-safe */
whead = rcu_dereference(pwq->whead);
if (whead)
remove_wait_queue(whead, &pwq->wait);
rcu_read_unlock();
}
| 235,665,346,937,677,600,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,517 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static int ep_scan_ready_list(struct eventpoll *ep,
int (*sproc)(struct eventpoll *,
struct list_head *, void *),
void *priv,
int depth)
{
int error, pwake = 0;
unsigned long flags;
struct epitem *epi, *nepi;
LIST_HEAD(txlist);
/*
* We need to lock this because we could be hit... | 300,938,027,029,403,550,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,518 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static int ep_send_events_proc(struct eventpoll *ep, struct list_head *head,
void *priv)
{
struct ep_send_events_data *esed = priv;
int eventcnt;
unsigned int revents;
struct epitem *epi;
struct epoll_event __user *uevent;
poll_table pt;
init_poll_funcptr(&pt, NULL);
/*
* We can loop without lock ... | 246,104,205,480,293,850,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,519 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static inline void ep_set_ffd(struct epoll_filefd *ffd,
struct file *file, int fd)
{
ffd->file = file;
ffd->fd = fd;
}
| 309,843,354,895,038,430,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,520 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static inline struct timespec ep_set_mstimeout(long ms)
{
struct timespec now, ts = {
.tv_sec = ms / MSEC_PER_SEC,
.tv_nsec = NSEC_PER_MSEC * (ms % MSEC_PER_SEC),
};
ktime_get_ts(&now);
return timespec_add_safe(now, ts);
}
| 307,847,754,515,951,900,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,521 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static void ep_unregister_pollwait(struct eventpoll *ep, struct epitem *epi)
{
struct list_head *lsthead = &epi->pwqlist;
struct eppoll_entry *pwq;
while (!list_empty(lsthead)) {
pwq = list_first_entry(lsthead, struct eppoll_entry, llink);
list_del(&pwq->llink);
ep_remove_wait_queue(pwq);
kmem_cache_free(p... | 15,643,527,229,886,608,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,522 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static inline void ep_wake_up_nested(wait_queue_head_t *wqueue,
unsigned long events, int subclass)
{
unsigned long flags;
spin_lock_irqsave_nested(&wqueue->lock, flags, subclass);
wake_up_locked_poll(wqueue, events);
spin_unlock_irqrestore(&wqueue->lock, flags);
}
| 181,588,478,491,142,940,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,523 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static inline void ep_wake_up_nested(wait_queue_head_t *wqueue,
unsigned long events, int subclass)
{
wake_up_poll(wqueue, events);
}
| 185,242,785,531,531,440,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,524 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static int __init eventpoll_init(void)
{
struct sysinfo si;
si_meminfo(&si);
/*
* Allows top 4% of lomem to be allocated for epoll watches (per user).
*/
max_user_watches = (((si.totalram - si.totalhigh) / 25) << PAGE_SHIFT) /
EP_ITEM_COST;
BUG_ON(max_user_watches < 0);
/*
* Initialize the structure use... | 312,638,717,726,812,270,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,525 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | void eventpoll_release_file(struct file *file)
{
struct list_head *lsthead = &file->f_ep_links;
struct eventpoll *ep;
struct epitem *epi;
/*
* We don't want to get "file->f_lock" because it is not
* necessary. It is not necessary because we're in the "struct file"
* cleanup path, and this means that no one i... | 274,302,915,614,933,130,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,526 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static inline int is_file_epoll(struct file *f)
{
return f->f_op == &eventpoll_fops;
}
| 172,264,202,825,913,100,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
22,527 | linux | 13d518074a952d33d47c428419693f63389547e9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/13d518074a952d33d47c428419693f63389547e9 | epoll: clear the tfile_check_list on -ELOOP
An epoll_ctl(,EPOLL_CTL_ADD,,) operation can return '-ELOOP' to prevent
circular epoll dependencies from being created. However, in that case we
do not properly clear the 'tfile_check_list'. Thus, add a call to
clear_tfile_check_list() for the -ELOOP case.
Signed-off-by: ... | 0 | static int path_count_inc(int nests)
{
/* Allow an arbitrary number of depth 1 paths */
if (nests == 0)
return 0;
if (++path_count[nests] > path_limits[nests])
return -1;
return 0;
}
| 240,986,918,002,479,050,000,000,000,000,000,000,000 | eventpoll.c | 305,502,646,873,515,640,000,000,000,000,000,000,000 | [] | CVE-2012-3375 | The epoll_ctl system call in fs/eventpoll.c in the Linux kernel before 3.2.24 does not properly handle ELOOP errors in EPOLL_CTL_ADD operations, which allows local users to cause a denial of service (file-descriptor consumption and system crash) via a crafted application that attempts to create a circular epoll depende... | https://nvd.nist.gov/vuln/detail/CVE-2012-3375 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.