deardaniel/secdata-raw huggingface dataset:
CVE: CVE-2024-27085
Published: 2024-03-15
Description: Discourse is an open source platform for community discussion. In affected versions users that are allowed to invite others can inject arbitrarily large data in parameters used in the invite route. The problem has been patched in the latest version of Discourse. Users are advised to upgrade. Users unable to upgrade should disable invites or restrict access to them using the `invite allowed groups` site setting. 
CVSS Score: 6.5 (MEDIUM)
CWE: CWE-400
References: https://github.com/discourse/discourse/commit/62ea382247c1f87361d186392c45ca74c83be295; https://github.com/discourse/discourse/security/advisories/GHSA-cvp5-h7p8-mjj6; https://github.com/discourse/discourse/commit/62ea382247c1f87361d186392c45ca74c83be295
CVE: CVE-2024-27100
Published: 2024-03-15
Description: Discourse is an open source platform for community discussion. In affected versions the endpoints for suspending users, silencing users and exporting CSV files weren't enforcing limits on the sizes of the parameters that they accept. This could lead to excessive resource consumption which could render an instance inoperable. A site could be disrupted by either a malicious moderator on the same site or a malicious staff member on another site in the same multisite cluster. This issue is patched in the latest stable, beta and tests-passed versions of Discourse. Users are advised to upgrade. There are no known workarounds for this vulnerability.
CVSS Score: 6.5 (MEDIUM)
CWE: CWE-400
References: https://github.com/discourse/discourse/commit/8cade1e825e90a66f440e820992d43c6905f4b47; https://github.com/discourse/discourse/security/advisories/GHSA-xq4v-qg27-gxgc; https://github.com/discourse/discourse/commit/8cade1e825e90a66f440e820992d43c6905f4b47
CVE: CVE-2024-27351
Published: 2024-03-15
Description: In Django 3.2 before 3.2.25, 4.2 before 4.2.11, and 5.0 before 5.0.3, the django.utils.text.Truncator.words() method (with html=True) and the truncatewords_html template filter are subject to a potential regular expression denial-of-service attack via a crafted string. NOTE: this issue exists because of an incomplete fix for CVE-2019-14232 and CVE-2023-43665.
CVSS Score: 5.3 (MEDIUM)
CWE: CWE-1333
References: http://www.openwall.com/lists/oss-security/2024/03/04/1; https://docs.djangoproject.com/en/5.0/releases/security/; https://groups.google.com/forum/#%21forum/django-announce
CVE: CVE-2024-27920
Published: 2024-03-15
Description: projectdiscovery/nuclei is a fast and customisable vulnerability scanner based on simple YAML based DSL. A significant security oversight was identified in Nuclei v3, involving the execution of unsigned code templates through workflows. This vulnerability specifically affects users utilizing custom workflows, potentially allowing the execution of malicious code on the user's system. This advisory outlines the impacted users, provides details on the security patch, and suggests mitigation strategies. The vulnerability is addressed in Nuclei v3.2.0. Users are strongly recommended to update to this version to mitigate the security risk. Users should refrain from using custom workflows if unable to upgrade immediately. Only trusted, verified workflows should be executed.
CVSS Score: 7.4 (HIGH)
CWE: CWE-78
References: https://docs.projectdiscovery.io/templates/protocols/code; https://docs.projectdiscovery.io/templates/reference/template-signing; https://docs.projectdiscovery.io/templates/workflows/overview
CVE: CVE-2024-28242
Published: 2024-03-15
Description: Discourse is an open source platform for community discussion. In affected versions an attacker can learn that secret categories exist when they have backgrounds set. The issue is patched in the latest stable, beta and tests-passed version of Discourse. Users are advised to upgrade. Users unable to upgrade should temporarily remove category backgrounds.
CVSS Score: 5.3 (MEDIUM)
CWE: CWE-200
References: https://github.com/discourse/discourse/commit/b425fbc2a28341a5627928f[PII_REDACTED]12c3d39; https://github.com/discourse/discourse/security/advisories/GHSA-c7q7-7f6q-2c23; https://github.com/discourse/discourse/commit/b425fbc2a28341a5627928f[PII_REDACTED]12c3d39
CVE: CVE-2024-28253
Published: 2024-03-15
Description: OpenMetadata is a unified platform for discovery, observability, and governance powered by a central metadata repository, in-depth lineage, and seamless team collaboration. `CompiledRule::validateExpression` is also called from `PolicyRepository.prepare`. `prepare()` is called from `EntityRepository.prepareInternal()` which, in turn, gets called from `EntityResource.createOrUpdate()`. Note that even though there is an authorization check (`authorizer.authorize()`), it gets called after `prepareInternal()` gets called and therefore after the SpEL expression has been evaluated. In order to reach this method, an attacker can send a PUT request to `/api/v1/policies` which gets handled by `PolicyResource.createOrUpdate()`. This vulnerability was discovered with the help of CodeQL's Expression language injection (Spring) query and is also tracked as `GHSL-2023-252`. This issue may lead to Remote Code Execution and has been addressed in version 1.3.1. Users are advised to upgrade. There are no known workarounds for this vulnerability.
CVSS Score: 9.4 (CRITICAL)
CWE: CWE-94
References: https://codeql.github.com/codeql-query-help/java/java-spel-expression-injection; https://github.com/open-metadata/OpenMetadata/blob/b6b337e09a05101506a5faba4b45d370cc3c9fc8/openmetadata-service/src/main/java/org/openmetadata/service/jdbi3/EntityRepository.java#L693; https://github.com/open-metadata/OpenMetadata/blob/b6b337e09a05101506a5faba4b45d370cc3c9fc8/openmetadata-service/src/main/java/org/openmetadata/service/resources/EntityResource.java#L219
CVE: CVE-2024-28254
Published: 2024-03-15
Description: OpenMetadata is a unified platform for discovery, observability, and governance powered by a central metadata repository, in-depth lineage, and seamless team collaboration. The `‎AlertUtil::validateExpression` method evaluates an SpEL expression using `getValue` which by default uses the `StandardEvaluationContext`, allowing the expression to reach and interact with Java classes such as `java.lang.Runtime`, leading to Remote Code Execution. The `/api/v1/events/subscriptions/validation/condition/<expression>` endpoint passes user-controlled data `AlertUtil::validateExpession` allowing authenticated (non-admin) users to execute arbitrary system commands on the underlaying operating system. In addition, there is a missing authorization check since `Authorizer.authorize()` is never called in the affected path and, therefore, any authenticated non-admin user is able to trigger this endpoint and evaluate arbitrary SpEL expressions leading to arbitrary command execution. This vulnerability was discovered with the help of CodeQL's Expression language injection (Spring) query and is also tracked as `GHSL-2023-235`. This issue may lead to Remote Code Execution and has been addressed in version 1.2.4. Users are advised to upgrade. There are no known workarounds for this vulnerability.
CVSS Score: 8.8 (HIGH)
CWE: CWE-78
References: https://codeql.github.com/codeql-query-help/java/java-spel-expression-injection; https://github.com/open-metadata/OpenMetadata/blob/84054a85d3478e3e3795fe92daa633ec11c9d6d9/openmetadata-service/src/main/java/org/openmetadata/service/events/subscription/AlertUtil.java#L101; https://github.com/open-metadata/OpenMetadata/blob/84054a85d3478e3e3795fe92daa633ec11c9d6d9/openmetadata-service/src/main/java/org/openmetadata/service/events/subscription/AlertUtil.java#L108
CVE: CVE-2024-28255
Published: 2024-03-15
Description: OpenMetadata is a unified platform for discovery, observability, and governance powered by a central metadata repository, in-depth lineage, and seamless team collaboration. The `JwtFilter` handles the API authentication by requiring and verifying JWT tokens. When a new request comes in, the request's path is checked against this list. When the request's path contains any of the excluded endpoints the filter returns without validating the JWT. Unfortunately, an attacker may use Path Parameters to make any path contain any arbitrary strings. For example, a request to `GET /api/v1;v1%2fusers%2flogin/events/subscriptions/validation/condition/111` will match the excluded endpoint condition and therefore will be processed with no JWT validation allowing an attacker to bypass the authentication mechanism and reach any arbitrary endpoint, including the ones listed above that lead to arbitrary SpEL expression injection. This bypass will not work when the endpoint uses the `SecurityContext.getUserPrincipal()` since it will return `null` and will throw an NPE. This issue may lead to authentication bypass and has been addressed in version 1.2.4. Users are advised to upgrade. There are no known workarounds for this vulnerability. This issue is also tracked as `GHSL-2023-237`.
CVSS Score: 9.8 (CRITICAL)
CWE: CWE-287
References: https://github.com/open-metadata/OpenMetadata/blob/e2043a3f31312ebb42391d6c93a67584d798de52/openmetadata-service/src/main/java/org/openmetadata/service/security/JwtFilter.java#L111; https://github.com/open-metadata/OpenMetadata/blob/e2043a3f31312ebb42391d6c93a67584d798de52/openmetadata-service/src/main/java/org/openmetadata/service/security/JwtFilter.java#L113; https://github.com/open-metadata/OpenMetadata/security/advisories/GHSA-6wx7-qw5p-wh84
CVE: CVE-2024-28847
Published: 2024-03-15
Description: OpenMetadata is a unified platform for discovery, observability, and governance powered by a central metadata repository, in-depth lineage, and seamless team collaboration. Similarly to the GHSL-2023-250 issue, `AlertUtil::validateExpression` is also called from `EventSubscriptionRepository.prepare()`, which can lead to Remote Code Execution. `prepare()` is called from `EntityRepository.prepareInternal()` which, in turn, gets called from `EntityResource.createOrUpdate()`. Note that, even though there is an authorization check (`authorizer.authorize()`), it gets called after `prepareInternal()` gets called and, therefore, after the SpEL expression has been evaluated. In order to reach this method, an attacker can send a PUT request to `/api/v1/events/subscriptions` which gets handled by `EventSubscriptionResource.createOrUpdateEventSubscription()`. This vulnerability was discovered with the help of CodeQL's Expression language injection (Spring) query. This issue may lead to Remote Code Execution and has been addressed in version 1.2.4. Users are advised to upgrade. There are no known workarounds for this vulnerability. This issue is also tracked as `GHSL-2023-251`.
CVSS Score: 8.8 (HIGH)
CWE: CWE-94
References: https://codeql.github.com/codeql-query-help/java/java-spel-expression-injection; https://github.com/open-metadata/OpenMetadata/blob/b6b337e09a05101506a5faba4b45d370cc3c9fc8/openmetadata-service/src/main/java/org/openmetadata/service/jdbi3/EntityRepository.java#L693; https://github.com/open-metadata/OpenMetadata/blob/b6b337e09a05101506a5faba4b45d370cc3c9fc8/openmetadata-service/src/main/java/org/openmetadata/service/jdbi3/EventSubscriptionRepository.java#L69-L83
CVE: CVE-2024-28848
Published: 2024-03-15
Description: OpenMetadata is a unified platform for discovery, observability, and governance powered by a central metadata repository, in-depth lineage, and seamless team collaboration. The `‎CompiledRule::validateExpression` method evaluates an SpEL expression using an `StandardEvaluationContext`, allowing the expression to reach and interact with Java classes such as `java.lang.Runtime`, leading to Remote Code Execution. The `/api/v1/policies/validation/condition/<expression>` endpoint passes user-controlled data `CompiledRule::validateExpession` allowing authenticated (non-admin) users to execute arbitrary system commands on the underlaying operating system. In addition, there is a missing authorization check since `Authorizer.authorize()` is never called in the affected path and therefore any authenticated non-admin user is able to trigger this endpoint and evaluate arbitrary SpEL expressions leading to arbitrary command execution. This vulnerability was discovered with the help of CodeQL's Expression language injection (Spring) query and is also tracked as `GHSL-2023-236`. This issue may lead to Remote Code Execution and has been resolved in version 1.2.4. Users are advised to upgrade. There are no known workarounds for this vulnerability.
CVSS Score: 8.8 (HIGH)
CWE: CWE-94
References: https://codeql.github.com/codeql-query-help/java/java-spel-expression-injection; https://github.com/open-metadata/OpenMetadata/blob/main/openmetadata-service/src/main/java/org/openmetadata/service/security/policyevaluator/CompiledRule.java#L51; https://github.com/open-metadata/OpenMetadata/blob/main/openmetadata-service/src/main/java/org/openmetadata/service/security/policyevaluator/CompiledRule.java#L57
CVE: CVE-2021-47109
Published: 2024-03-15
Description: In the Linux kernel, the following vulnerability has been resolved:

neighbour: allow NUD_NOARP entries to be forced GCed

IFF_POINTOPOINT interfaces use NUD_NOARP entries for IPv6. It's possible to
fill up the neighbour table with enough entries that it will overflow for
valid connections after that.

This behaviour is more prevalent after commit 58956317c8de ("neighbor:
Improve garbage collection") is applied, as it prevents removal from
entries that are not NUD_FAILED, unless they are more than 5s old.
CVSS Score: 5.5 (MEDIUM)
CWE: CWE-190
References: https://git.kernel.org/stable/c/7a6b1ab7475fd6478eeaf5c9d1163e7a18125c8f; https://git.kernel.org/stable/c/d17d47da59f726dc4c87caebda3a50333d7e2fd3; https://git.kernel.org/stable/c/d99029e6aab62aef0a0251588b2867e77e83b137
CVE: CVE-2021-47110
Published: 2024-03-15
Description: In the Linux kernel, the following vulnerability has been resolved:

x86/kvm: Disable kvmclock on all CPUs on shutdown

Currenly, we disable kvmclock from machine_shutdown() hook and this
only happens for boot CPU. We need to disable it for all CPUs to
guard against memory corruption e.g. on restore from hibernate.

Note, writing '0' to kvmclock MSR doesn't clear memory location, it
just prevents hypervisor from updating the location so for the short
while after write and while CPU is still alive, the clock remains usable
and correct so we don't need to switch to some other clocksource.
CVSS Score: 7.1 (HIGH)
CWE: CWE-459
References: https://git.kernel.org/stable/c/1df2dc09926f61319116c80ee85701df33577d70; https://git.kernel.org/stable/c/3b0becf8b1ecf642a9edaf4c9628ffc641e490d6; https://git.kernel.org/stable/c/9084fe1b3572664ad276f427dce575f580c9799a
CVE: CVE-2021-47111
Published: 2024-03-15
Description: In the Linux kernel, the following vulnerability has been resolved:

xen-netback: take a reference to the RX task thread

Do this in order to prevent the task from being freed if the thread
returns (which can be triggered by the frontend) before the call to
kthread_stop done as part of the backend tear down. Not taking the
reference will lead to a use-after-free in that scenario. Such
reference was taken before but dropped as part of the rework done in
2ac061ce97f4.

Reintroduce the reference taking and add a comment this time
explaining why it's needed.

This is XSA-374 / CVE-2021-28691.
CVSS Score: 7.8 (HIGH)
CWE: CWE-416
References: https://git.kernel.org/stable/c/107866a8eb0b664675a260f1ba0655010fac1e08; https://git.kernel.org/stable/c/6b53db8c4c14b4e7256f058d202908b54a7b85b4; https://git.kernel.org/stable/c/caec9bcaeb1a5f03f2d406305355c853af10c13e
CVE: CVE-2021-47112
Published: 2024-03-15
Description: In the Linux kernel, the following vulnerability has been resolved:

x86/kvm: Teardown PV features on boot CPU as well

Various PV features (Async PF, PV EOI, steal time) work through memory
shared with hypervisor and when we restore from hibernation we must
properly teardown all these features to make sure hypervisor doesn't
write to stale locations after we jump to the previously hibernated kernel
(which can try to place anything there). For secondary CPUs the job is
already done by kvm_cpu_down_prepare(), register syscore ops to do
the same for boot CPU.
CVSS Score: 5.5 (MEDIUM)
References: https://git.kernel.org/stable/c/38b858da1c58ad46519a257764e059e663b59ff2; https://git.kernel.org/stable/c/7620a669111b52f224d006dea9e1e688e2d62c54; https://git.kernel.org/stable/c/8b79feffeca28c5459458fe78676b081e87c93a4
CVE: CVE-2021-47113
Published: 2024-03-15
Description: In the Linux kernel, the following vulnerability has been resolved:

btrfs: abort in rename_exchange if we fail to insert the second ref

Error injection stress uncovered a problem where we'd leave a dangling
inode ref if we failed during a rename_exchange.  This happens because
we insert the inode ref for one side of the rename, and then for the
other side.  If this second inode ref insert fails we'll leave the first
one dangling and leave a corrupt file system behind.  Fix this by
aborting if we did the insert for the first inode ref.
CVSS Score: 5.5 (MEDIUM)
CWE: CWE-416
References: https://git.kernel.org/stable/c/0df50d47d17401f9f140dfbe752a65e5d72f9932; https://git.kernel.org/stable/c/dc09ef3562726cd520c8338c1640872a60187af5; https://git.kernel.org/stable/c/ff8de2cec65a8c8521faade12a31b39c80e49f5b
CVE: CVE-2021-47114
Published: 2024-03-15
Description: In the Linux kernel, the following vulnerability has been resolved:

ocfs2: fix data corruption by fallocate

When fallocate punches holes out of inode size, if original isize is in
the middle of last cluster, then the part from isize to the end of the
cluster will be zeroed with buffer write, at that time isize is not yet
updated to match the new size, if writeback is kicked in, it will invoke
ocfs2_writepage()->block_write_full_page() where the pages out of inode
size will be dropped.  That will cause file corruption.  Fix this by
zero out eof blocks when extending the inode size.

Running the following command with qemu-image 4.2.1 can get a corrupted
coverted image file easily.

    qemu-img convert -p -t none -T none -f qcow2 $qcow_image \
             -O qcow2 -o compat=1.1 $qcow_image.conv

The usage of fallocate in qemu is like this, it first punches holes out
of inode size, then extend the inode size.

    fallocate(11, FALLOC_FL_KEEP_SIZE|FALLOC_FL_PUNCH_HOLE,[PII_REDACTED], 65536) = 0
    fallocate(11, 0,[PII_REDACTED], 65536) = 0

v1: https://www.spinics.net/lists/linux-fsdevel/msg193999.html
v2: https://lore.kernel.org/linux-fsdevel/[PII_REDACTED]3034.GB4112@quack2.suse.cz/T/
CVSS Score: 5.5 (MEDIUM)
References: https://git.kernel.org/stable/c/0a31dd6fd2f4e7db538fb6eb1f06973d81f8dd3b; https://git.kernel.org/stable/c/33e03adafb29eedae1bae9cdb50c1385279fcf65; https://git.kernel.org/stable/c/624fa7baa3788dc9e57840ba5b94bc22b03cda57
CVE: CVE-2021-47115
Published: 2024-03-15
Description: Rejected reason: This CVE ID has been rejected or withdrawn by its CVE Numbering Authority.
CVE: CVE-2021-47116
Published: 2024-03-15
Description: In the Linux kernel, the following vulnerability has been resolved:

ext4: fix memory leak in ext4_mb_init_backend on error path.

Fix a memory leak discovered by syzbot when a file system is corrupted
with an illegally large s_log_groups_per_flex.
CVSS Score: 5.5 (MEDIUM)
CWE: CWE-401
References: https://git.kernel.org/stable/c/04fb2baa0b147f51db065a1b13a11954abe592d0; https://git.kernel.org/stable/c/2050c6e5b161e5e25ce3c420fef58b24fa388a49; https://git.kernel.org/stable/c/a8867f4e[PII_REDACTED]c98de7a2d465aff5e4daf5
CVE: CVE-2021-47117
Published: 2024-03-15
Description: In the Linux kernel, the following vulnerability has been resolved:

ext4: fix bug on in ext4_es_cache_extent as ext4_split_extent_at failed

We got follow bug_on when run fsstress with injecting IO fault:
[[PII_REDACTED]14] kernel BUG at fs/ext4/extents_status.c:762!
[[PII_REDACTED]17] Internal error: Oops - BUG: 0 [#1] SMP
......
[[PII_REDACTED]29] Call trace:
[[PII_REDACTED]53]  ext4_es_cache_extent+0x150/0x168 [ext4]
[[PII_REDACTED]75]  ext4_cache_extents+0x64/0xe8 [ext4]
[[PII_REDACTED]68]  ext4_find_extent+0x300/0x330 [ext4]
[[PII_REDACTED]59]  ext4_ext_map_blocks+0x74/0x1178 [ext4]
[[PII_REDACTED]79]  ext4_map_blocks+0x2f4/0x5f0 [ext4]
[[PII_REDACTED]67]  ext4_mpage_readpages+0x4a8/0x7a8 [ext4]
[[PII_REDACTED]95]  ext4_readpage+0x54/0x100 [ext4]
[[PII_REDACTED]59]  generic_file_buffered_read+0x410/0xae8
[[PII_REDACTED]67]  generic_file_read_iter+0x114/0x190
[[PII_REDACTED]52]  ext4_file_read_iter+0x5c/0x140 [ext4]
[[PII_REDACTED]56]  __vfs_read+0x11c/0x188
[[PII_REDACTED]51]  vfs_read+0x94/0x150
[[PII_REDACTED]10]  ksys_read+0x74/0xf0

This patch's modification is according to Jan Kara's suggestion in:
https://patchwork.ozlabs.org/project/linux-ext4/patch/[PII_REDACTED]5[PII_REDACTED]-1-yebin10@huawei.com/
"I see. Now I understand your patch. Honestly, seeing how fragile is trying
to fix extent tree after split has failed in the middle, I would probably
go even further and make sure we fix the tree properly in case of ENOSPC
and EDQUOT (those are easily user triggerable).  Anything else indicates a
HW problem or fs corruption so I'd rather leave the extent tree as is and
don't try to fix it (which also means we will not create overlapping
extents)."
CVSS Score: 5.5 (MEDIUM)
References: https://git.kernel.org/stable/c/082cd4ec240b8734a82a89ffb890216ac98fec68; https://git.kernel.org/stable/c/48105dc98c9ca35af418746277b087cb2bc6df7c; https://git.kernel.org/stable/c/569496aa3776eea1ff0d49d0174ac1b7e861e107
CVE: CVE-2021-47119
Published: 2024-03-15
Description: In the Linux kernel, the following vulnerability has been resolved:

ext4: fix memory leak in ext4_fill_super

Buffer head references must be released before calling kill_bdev();
otherwise the buffer head (and its page referenced by b_data) will not
be freed by kill_bdev, and subsequently that bh will be leaked.

If blocksizes differ, sb_set_blocksize() will kill current buffers and
page cache by using kill_bdev(). And then super block will be reread
again but using correct blocksize this time. sb_set_blocksize() didn't
fully free superblock page and buffer head, and being busy, they were
not freed and instead leaked.

This can easily be reproduced by calling an infinite loop of:

  systemctl start <ext4_on_lvm>.mount, and
  systemctl stop <ext4_on_lvm>.mount

... since systemd creates a cgroup for each slice which it mounts, and
the bh leak get amplified by a dying memory cgroup that also never
gets freed, and memory consumption is much more easily noticed.
CVSS Score: 5.5 (MEDIUM)
CWE: CWE-401
References: https://git.kernel.org/stable/c/01d349a481f[PII_REDACTED]a[PII_REDACTED]f9159bcd; https://git.kernel.org/stable/c/1385b23396d511d5233b8b921ac3058b3f86a5e1; https://git.kernel.org/stable/c/afd09b617db3786b6ef3dc43e28fe728cfea84df
CVE: CVE-2021-47120
Published: 2024-03-15
Description: In the Linux kernel, the following vulnerability has been resolved:

HID: magicmouse: fix NULL-deref on disconnect

Commit 9d7b18668956 ("HID: magicmouse: add support for Apple Magic
Trackpad 2") added a sanity check for an Apple trackpad but returned
success instead of -ENODEV when the check failed. This means that the
remove callback will dereference the never-initialised driver data
pointer when the driver is later unbound (e.g. on USB disconnect).
CVSS Score: 5.5 (MEDIUM)
CWE: CWE-476
References: https://git.kernel.org/stable/c/368c5d45a87e1bcc7f1e98e0c255c37b7b12c5d6; https://git.kernel.org/stable/c/4b4f6cecca446abcb686c6e6c451d4f1ec1a7497; https://git.kernel.org/stable/c/9cf27473f21913a3eaf4702dd2a25415afd5f33f
CVE: CVE-2021-47121
Published: 2024-03-15
Description: In the Linux kernel, the following vulnerability has been resolved:

net: caif: fix memory leak in cfusbl_device_notify

In case of caif_enroll_dev() fail, allocated
link_support won't be assigned to the corresponding
structure. So simply free allocated pointer in case
of error.
CVSS Score: 5.5 (MEDIUM)
CWE: CWE-401
References: https://git.kernel.org/stable/c/46403c1f80b0d3f937ff9c4f5edc63bb64bc5051; https://git.kernel.org/stable/c/4d94f530cd24c85aede6e72b8923f371b45d6886; https://git.kernel.org/stable/c/7f5d86669fa4d485523ddb1d212e0a2d90bd62bb