From d1d2d17fe95dbc0627be11cc8d29ae5cf549842f Mon Sep 17 00:00:00 2001 From: Jiantao Zhang Date: Mon, 21 Nov 2022 13:08:05 +0000 Subject: [PATCH 01/68] BACKPORT: USB: gadget: Fix use-after-free during usb config switch In the process of switching USB config from rndis to other config, if the hardware does not support the ->pullup callback, or the hardware encounters a low probability fault, both of them may cause the ->pullup callback to fail, which will then cause a system panic (use after free). The gadget drivers sometimes need to be unloaded regardless of the hardware's behavior. Analysis as follows: ======================================================================= (1) write /config/usb_gadget/g1/UDC "none" gether_disconnect+0x2c/0x1f8 rndis_disable+0x4c/0x74 composite_disconnect+0x74/0xb0 configfs_composite_disconnect+0x60/0x7c usb_gadget_disconnect+0x70/0x124 usb_gadget_unregister_driver+0xc8/0x1d8 gadget_dev_desc_UDC_store+0xec/0x1e4 (2) rm /config/usb_gadget/g1/configs/b.1/f1 rndis_deregister+0x28/0x54 rndis_free+0x44/0x7c usb_put_function+0x14/0x1c config_usb_cfg_unlink+0xc4/0xe0 configfs_unlink+0x124/0x1c8 vfs_unlink+0x114/0x1dc (3) rmdir /config/usb_gadget/g1/functions/rndis.gs4 panic+0x1fc/0x3d0 do_page_fault+0xa8/0x46c do_mem_abort+0x3c/0xac el1_sync_handler+0x40/0x78 0xffffff801138f880 rndis_close+0x28/0x34 eth_stop+0x74/0x110 dev_close_many+0x48/0x194 rollback_registered_many+0x118/0x814 unregister_netdev+0x20/0x30 gether_cleanup+0x1c/0x38 rndis_attr_release+0xc/0x14 kref_put+0x74/0xb8 configfs_rmdir+0x314/0x374 If gadget->ops->pullup() return an error, function rndis_close() will be called, then it will causes a use-after-free problem. ======================================================================= Fixes: 0a55187a1ec8 ("USB: gadget core: Issue ->disconnect() callback from usb_gadget_disconnect()") Signed-off-by: Jiantao Zhang Signed-off-by: TaoXue Link: https://lore.kernel.org/r/20221121130805.10735-1-water.zhangjiantao@huawei.com Signed-off-by: Greg Kroah-Hartman Bug: 273510696 Bug: 275027942 Change-Id: I702f324c5852d3b2448081b092fef464f8691989 (cherry picked from commit afdc12887f2b2ecf20d065a7d81ad29824155083) [ray: Resolved minor conflict in drivers/usb/gadget/udc/core.c] Signed-off-by: Ray Chi --- drivers/usb/gadget/udc/core.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/drivers/usb/gadget/udc/core.c b/drivers/usb/gadget/udc/core.c index e1e243e52a2d..7a00af1f9624 100644 --- a/drivers/usb/gadget/udc/core.c +++ b/drivers/usb/gadget/udc/core.c @@ -730,10 +730,11 @@ int usb_gadget_disconnect(struct usb_gadget *gadget) } ret = gadget->ops->pullup(gadget, 0); - if (!ret) { + if (!ret) gadget->connected = 0; + + if (gadget->udc->driver) gadget->udc->driver->disconnect(gadget); - } out: trace_usb_gadget_disconnect(gadget, ret); From aaffce1ef448015e4f946a53384686839147cf9e Mon Sep 17 00:00:00 2001 From: Pietro Borrello Date: Sun, 12 Feb 2023 18:59:59 +0000 Subject: [PATCH 02/68] UPSTREAM: HID: bigben: use spinlock to protect concurrent accesses [ Upstream commit 9fefb6201c4f8dd9f58c581b2a66e5cde2895ea2 ] bigben driver has a worker that may access data concurrently. Proct the accesses using a spinlock. Bug: 268589017 Fixes: 256a90ed9e46 ("HID: hid-bigbenff: driver for BigBen Interactive PS3OFMINIPAD gamepad") Signed-off-by: Pietro Borrello Link: https://lore.kernel.org/r/20230125-hid-unregister-leds-v4-1-7860c5763c38@diag.uniroma1.it Signed-off-by: Benjamin Tissoires Signed-off-by: Sasha Levin Signed-off-by: Lee Jones Change-Id: I8b7a34cba4c79c26f3d1912c97a83820d88bd5a4 --- drivers/hid/hid-bigbenff.c | 52 ++++++++++++++++++++++++++++++++++++-- 1 file changed, 50 insertions(+), 2 deletions(-) diff --git a/drivers/hid/hid-bigbenff.c b/drivers/hid/hid-bigbenff.c index e8b16665860d..ed3d2d7bc1dd 100644 --- a/drivers/hid/hid-bigbenff.c +++ b/drivers/hid/hid-bigbenff.c @@ -174,6 +174,7 @@ static __u8 pid0902_rdesc_fixed[] = { struct bigben_device { struct hid_device *hid; struct hid_report *report; + spinlock_t lock; bool removed; u8 led_state; /* LED1 = 1 .. LED4 = 8 */ u8 right_motor_on; /* right motor off/on 0/1 */ @@ -190,12 +191,27 @@ static void bigben_worker(struct work_struct *work) struct bigben_device *bigben = container_of(work, struct bigben_device, worker); struct hid_field *report_field = bigben->report->field[0]; + bool do_work_led = false; + bool do_work_ff = false; + u8 *buf; + u32 len; + unsigned long flags; if (bigben->removed || !report_field) return; + buf = hid_alloc_report_buf(bigben->report, GFP_KERNEL); + if (!buf) + return; + + len = hid_report_len(bigben->report); + + /* LED work */ + spin_lock_irqsave(&bigben->lock, flags); + if (bigben->work_led) { bigben->work_led = false; + do_work_led = true; report_field->value[0] = 0x01; /* 1 = led message */ report_field->value[1] = 0x08; /* reserved value, always 8 */ report_field->value[2] = bigben->led_state; @@ -204,11 +220,22 @@ static void bigben_worker(struct work_struct *work) report_field->value[5] = 0x00; /* padding */ report_field->value[6] = 0x00; /* padding */ report_field->value[7] = 0x00; /* padding */ - hid_hw_request(bigben->hid, bigben->report, HID_REQ_SET_REPORT); + hid_output_report(bigben->report, buf); } + spin_unlock_irqrestore(&bigben->lock, flags); + + if (do_work_led) { + hid_hw_raw_request(bigben->hid, bigben->report->id, buf, len, + bigben->report->type, HID_REQ_SET_REPORT); + } + + /* FF work */ + spin_lock_irqsave(&bigben->lock, flags); + if (bigben->work_ff) { bigben->work_ff = false; + do_work_ff = true; report_field->value[0] = 0x02; /* 2 = rumble effect message */ report_field->value[1] = 0x08; /* reserved value, always 8 */ report_field->value[2] = bigben->right_motor_on; @@ -217,8 +244,17 @@ static void bigben_worker(struct work_struct *work) report_field->value[5] = 0x00; /* padding */ report_field->value[6] = 0x00; /* padding */ report_field->value[7] = 0x00; /* padding */ - hid_hw_request(bigben->hid, bigben->report, HID_REQ_SET_REPORT); + hid_output_report(bigben->report, buf); } + + spin_unlock_irqrestore(&bigben->lock, flags); + + if (do_work_ff) { + hid_hw_raw_request(bigben->hid, bigben->report->id, buf, len, + bigben->report->type, HID_REQ_SET_REPORT); + } + + kfree(buf); } static int hid_bigben_play_effect(struct input_dev *dev, void *data, @@ -228,6 +264,7 @@ static int hid_bigben_play_effect(struct input_dev *dev, void *data, struct bigben_device *bigben = hid_get_drvdata(hid); u8 right_motor_on; u8 left_motor_force; + unsigned long flags; if (!bigben) { hid_err(hid, "no device data\n"); @@ -242,9 +279,12 @@ static int hid_bigben_play_effect(struct input_dev *dev, void *data, if (right_motor_on != bigben->right_motor_on || left_motor_force != bigben->left_motor_force) { + spin_lock_irqsave(&bigben->lock, flags); bigben->right_motor_on = right_motor_on; bigben->left_motor_force = left_motor_force; bigben->work_ff = true; + spin_unlock_irqrestore(&bigben->lock, flags); + schedule_work(&bigben->worker); } @@ -259,6 +299,7 @@ static void bigben_set_led(struct led_classdev *led, struct bigben_device *bigben = hid_get_drvdata(hid); int n; bool work; + unsigned long flags; if (!bigben) { hid_err(hid, "no device data\n"); @@ -267,6 +308,7 @@ static void bigben_set_led(struct led_classdev *led, for (n = 0; n < NUM_LEDS; n++) { if (led == bigben->leds[n]) { + spin_lock_irqsave(&bigben->lock, flags); if (value == LED_OFF) { work = (bigben->led_state & BIT(n)); bigben->led_state &= ~BIT(n); @@ -274,6 +316,7 @@ static void bigben_set_led(struct led_classdev *led, work = !(bigben->led_state & BIT(n)); bigben->led_state |= BIT(n); } + spin_unlock_irqrestore(&bigben->lock, flags); if (work) { bigben->work_led = true; @@ -307,8 +350,12 @@ static enum led_brightness bigben_get_led(struct led_classdev *led) static void bigben_remove(struct hid_device *hid) { struct bigben_device *bigben = hid_get_drvdata(hid); + unsigned long flags; + spin_lock_irqsave(&bigben->lock, flags); bigben->removed = true; + spin_unlock_irqrestore(&bigben->lock, flags); + cancel_work_sync(&bigben->worker); hid_hw_stop(hid); } @@ -362,6 +409,7 @@ static int bigben_probe(struct hid_device *hid, set_bit(FF_RUMBLE, hidinput->input->ffbit); INIT_WORK(&bigben->worker, bigben_worker); + spin_lock_init(&bigben->lock); error = input_ff_create_memless(hidinput->input, NULL, hid_bigben_play_effect); From 1bba06f3e83a3bb076f5cd9c9de9c158d556836b Mon Sep 17 00:00:00 2001 From: Pietro Borrello Date: Sun, 12 Feb 2023 19:00:00 +0000 Subject: [PATCH 03/68] UPSTREAM: HID: bigben_worker() remove unneeded check on report_field [ Upstream commit 27d2a2fd844ec7da70d19fabb482304fd1e0595b ] bigben_worker() checks report_field to be non-NULL. The check has been added in commit 918aa1ef104d ("HID: bigbenff: prevent null pointer dereference") to prevent a NULL pointer crash. However, the true root cause was a missing check for output reports, patched in commit c7bf714f8755 ("HID: check empty report_list in bigben_probe()"), where the type-confused report list_entry was overlapping with a NULL pointer, which was then causing the crash. Bug: 268589017 Fixes: 918aa1ef104d ("HID: bigbenff: prevent null pointer dereference") Signed-off-by: Pietro Borrello Link: https://lore.kernel.org/r/20230125-hid-unregister-leds-v4-2-7860c5763c38@diag.uniroma1.it Signed-off-by: Benjamin Tissoires Signed-off-by: Sasha Levin Signed-off-by: Lee Jones Change-Id: Ide36490e2e4482f6cf9af931bef052f172419e31 --- drivers/hid/hid-bigbenff.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/hid/hid-bigbenff.c b/drivers/hid/hid-bigbenff.c index ed3d2d7bc1dd..b98c5f31c184 100644 --- a/drivers/hid/hid-bigbenff.c +++ b/drivers/hid/hid-bigbenff.c @@ -197,7 +197,7 @@ static void bigben_worker(struct work_struct *work) u32 len; unsigned long flags; - if (bigben->removed || !report_field) + if (bigben->removed) return; buf = hid_alloc_report_buf(bigben->report, GFP_KERNEL); From 7fd7972fc1f6a6c05ff8fb859b5a8ed77be3dd1d Mon Sep 17 00:00:00 2001 From: Pietro Borrello Date: Sun, 12 Feb 2023 19:00:01 +0000 Subject: [PATCH 04/68] UPSTREAM: HID: bigben: use spinlock to safely schedule workers [ Upstream commit 76ca8da989c7d97a7f76c75d475fe95a584439d7 ] Use spinlocks to deal with workers introducing a wrapper bigben_schedule_work(), and several spinlock checks. Otherwise, bigben_set_led() may schedule bigben->worker after the structure has been freed, causing a use-after-free. Bug: 268589017 Fixes: 4eb1b01de5b9 ("HID: hid-bigbenff: fix race condition for scheduled work during removal") Signed-off-by: Pietro Borrello Link: https://lore.kernel.org/r/20230125-hid-unregister-leds-v4-3-7860c5763c38@diag.uniroma1.it Signed-off-by: Benjamin Tissoires Signed-off-by: Sasha Levin Signed-off-by: Lee Jones Change-Id: Ia3f47b68264f6c492597b0b0603f6822dc624f2b --- drivers/hid/hid-bigbenff.c | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/drivers/hid/hid-bigbenff.c b/drivers/hid/hid-bigbenff.c index b98c5f31c184..9d6560db762b 100644 --- a/drivers/hid/hid-bigbenff.c +++ b/drivers/hid/hid-bigbenff.c @@ -185,6 +185,15 @@ struct bigben_device { struct work_struct worker; }; +static inline void bigben_schedule_work(struct bigben_device *bigben) +{ + unsigned long flags; + + spin_lock_irqsave(&bigben->lock, flags); + if (!bigben->removed) + schedule_work(&bigben->worker); + spin_unlock_irqrestore(&bigben->lock, flags); +} static void bigben_worker(struct work_struct *work) { @@ -197,9 +206,6 @@ static void bigben_worker(struct work_struct *work) u32 len; unsigned long flags; - if (bigben->removed) - return; - buf = hid_alloc_report_buf(bigben->report, GFP_KERNEL); if (!buf) return; @@ -285,7 +291,7 @@ static int hid_bigben_play_effect(struct input_dev *dev, void *data, bigben->work_ff = true; spin_unlock_irqrestore(&bigben->lock, flags); - schedule_work(&bigben->worker); + bigben_schedule_work(bigben); } return 0; @@ -320,7 +326,7 @@ static void bigben_set_led(struct led_classdev *led, if (work) { bigben->work_led = true; - schedule_work(&bigben->worker); + bigben_schedule_work(bigben); } return; } @@ -450,7 +456,7 @@ static int bigben_probe(struct hid_device *hid, bigben->left_motor_force = 0; bigben->work_led = true; bigben->work_ff = true; - schedule_work(&bigben->worker); + bigben_schedule_work(bigben); hid_info(hid, "LED and force feedback support for BigBen gamepad\n"); From e0d8206f5d42f33854f7111ed1cb9cfc6f7820a4 Mon Sep 17 00:00:00 2001 From: Pietro Borrello Date: Sun, 12 Feb 2023 00:01:44 +0000 Subject: [PATCH 05/68] UPSTREAM: hid: bigben_probe(): validate report count [ Upstream commit b94335f899542a0da5fafc38af8edcaf90195843 ] bigben_probe() does not validate that the output report has the needed report values in the first field. A malicious device registering a report with one field and a single value causes an head OOB write in bigben_worker() when accessing report_field->value[1] to report_field->value[7]. Use hid_validate_values() which takes care of all the needed checks. Bug: 268589017 Fixes: 256a90ed9e46 ("HID: hid-bigbenff: driver for BigBen Interactive PS3OFMINIPAD gamepad") Signed-off-by: Pietro Borrello Link: https://lore.kernel.org/r/20230211-bigben-oob-v1-1-d2849688594c@diag.uniroma1.it Signed-off-by: Benjamin Tissoires Signed-off-by: Sasha Levin Signed-off-by: Lee Jones Change-Id: I575c5d4c8a63a2065752a45c47b23cf725cc57ae --- drivers/hid/hid-bigbenff.c | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/drivers/hid/hid-bigbenff.c b/drivers/hid/hid-bigbenff.c index 9d6560db762b..a02cb517b4c4 100644 --- a/drivers/hid/hid-bigbenff.c +++ b/drivers/hid/hid-bigbenff.c @@ -371,7 +371,6 @@ static int bigben_probe(struct hid_device *hid, { struct bigben_device *bigben; struct hid_input *hidinput; - struct list_head *report_list; struct led_classdev *led; char *name; size_t name_sz; @@ -396,14 +395,12 @@ static int bigben_probe(struct hid_device *hid, return error; } - report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list; - if (list_empty(report_list)) { + bigben->report = hid_validate_values(hid, HID_OUTPUT_REPORT, 0, 0, 8); + if (!bigben->report) { hid_err(hid, "no output report found\n"); error = -ENODEV; goto error_hw_stop; } - bigben->report = list_entry(report_list->next, - struct hid_report, list); if (list_empty(&hid->inputs)) { hid_err(hid, "no inputs found\n"); From 469e02cc6d3977c02378547e0e28cc537bd5d7b1 Mon Sep 17 00:00:00 2001 From: Matthias Schiffer Date: Wed, 29 Mar 2023 11:58:43 +0530 Subject: [PATCH 06/68] BACKPORT: of: base: Skip CPU nodes with "fail"/"fail-..." status Allow fully disabling CPU nodes using status = "fail". This allows a bootloader to change the number of available CPUs (for example when a common DTS is used for SoC variants with different numbers of cores) without deleting the nodes altogether, which could require additional fixups to avoid dangling phandle references. Unknown status values (everything that is not "okay"/"ok", "disabled" or "fail"/"fail-...") will continue to be interpreted like "disabled", meaning that the CPU can be enabled during boot. References: - https://www.spinics.net/lists/devicetree-spec/msg01007.html - https://github.com/devicetree-org/dt-schema/pull/61 Bug: 275500667 Change-Id: I0d0028c1d5f529c43f184556ac661c50fe026741 Link: https://lore.kernel.org/all/CAL_Jsq+1LsTBdVaODVfmB0eme2jMpNL4VgKk-OM7rQWyyF0Jbw@mail.gmail.com/ Signed-off-by: Matthias Schiffer Tested-by: Sai Prakash Ranjan Reviewed-by: Frank Rowand Link: https://lore.kernel.org/r/20211122114536.2981-1-matthias.schiffer@ew.tq-group.com Signed-off-by: Rob Herring (cherry picked from commit 4fdd0736a3b1634613d1d2eeb3328d27522052fb) Signed-off-by: Komal Bajaj --- drivers/of/base.c | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/drivers/of/base.c b/drivers/of/base.c index bcc88cbbbead..bcb37c3a13b0 100644 --- a/drivers/of/base.c +++ b/drivers/of/base.c @@ -627,6 +627,28 @@ bool of_device_is_available(const struct device_node *device) } EXPORT_SYMBOL(of_device_is_available); +/** + * __of_device_is_fail - check if a device has status "fail" or "fail-..." + * + * @device: Node to check status for, with locks already held + * + * Return: True if the status property is set to "fail" or "fail-..." (for any + * error code suffix), false otherwise + */ +static bool __of_device_is_fail(const struct device_node *device) +{ + const char *status; + + if (!device) + return false; + + status = __of_get_property(device, "status", NULL); + if (status == NULL) + return false; + + return !strcmp(status, "fail") || !strncmp(status, "fail-", 5); +} + /** * of_device_is_big_endian - check if a device has BE registers * @@ -775,6 +797,9 @@ EXPORT_SYMBOL(of_get_next_available_child); * of_get_next_cpu_node - Iterate on cpu nodes * @prev: previous child of the /cpus node, or NULL to get first * + * Unusable CPUs (those with the status property set to "fail" or "fail-...") + * will be skipped. + * * Returns a cpu node pointer with refcount incremented, use of_node_put() * on it when done. Returns NULL when prev is the last child. Decrements * the refcount of prev. @@ -796,6 +821,8 @@ struct device_node *of_get_next_cpu_node(struct device_node *prev) of_node_put(node); } for (; next; next = next->sibling) { + if (__of_device_is_fail(next)) + continue; if (!(of_node_name_eq(next, "cpu") || __of_node_is_type(next, "cpu"))) continue; From e7bfca167067d02471b615c246c7a5a6a4b0b151 Mon Sep 17 00:00:00 2001 From: Eric Biggers Date: Wed, 15 Mar 2023 11:39:02 -0700 Subject: [PATCH 07/68] BACKPORT: FROMGIT: blk-mq: release crypto keyslot before reporting I/O complete Once all I/O using a blk_crypto_key has completed, filesystems can call blk_crypto_evict_key(). However, the block layer currently doesn't call blk_crypto_put_keyslot() until the request is being freed, which happens after upper layers have been told (via bio_endio()) the I/O has completed. This causes a race condition where blk_crypto_evict_key() can see 'slot_refs != 0' without there being an actual bug. This makes __blk_crypto_evict_key() hit the 'WARN_ON_ONCE(atomic_read(&slot->slot_refs) != 0)' and return without doing anything, eventually causing a use-after-free in blk_crypto_reprogram_all_keys(). (This is a very rare bug and has only been seen when per-file keys are being used with fscrypt.) There are two options to fix this: either release the keyslot before bio_endio() is called on the request's last bio, or make __blk_crypto_evict_key() ignore slot_refs. Let's go with the first solution, since it preserves the ability to report bugs (via WARN_ON_ONCE) where a key is evicted while still in-use. Fixes: a892c8d52c02 ("block: Inline encryption support for blk-mq") Cc: stable@vger.kernel.org Reviewed-by: Nathan Huckleberry Reviewed-by: Christoph Hellwig Signed-off-by: Eric Biggers Link: https://lore.kernel.org/r/20230315183907.53675-2-ebiggers@kernel.org Signed-off-by: Jens Axboe Bug: 270098322 (cherry picked from commit 9cd1e566676bbcb8a126acd921e4e194e6339603 https://git.kernel.org/pub/scm/linux/kernel/git/axboe/linux-block.git/log/?h=for-next) Change-Id: Ic2c2426db7693a06901c7893d481471f30de03b2 Signed-off-by: Eric Biggers --- block/blk-core.c | 7 +++++++ block/blk-crypto-internal.h | 25 +++++++++++++++++++++---- block/blk-crypto.c | 24 ++++++++++++------------ block/blk-merge.c | 2 ++ block/blk-mq.c | 2 +- 5 files changed, 43 insertions(+), 17 deletions(-) diff --git a/block/blk-core.c b/block/blk-core.c index a5edfc114221..3f8c1457eadb 100644 --- a/block/blk-core.c +++ b/block/blk-core.c @@ -1450,6 +1450,13 @@ bool blk_update_request(struct request *req, blk_status_t error, req->q->integrity.profile->complete_fn(req, nr_bytes); #endif + /* + * Upper layers may call blk_crypto_evict_key() anytime after the last + * bio_endio(). Therefore, the keyslot must be released before that. + */ + if (blk_crypto_rq_has_keyslot(req) && nr_bytes >= blk_rq_bytes(req)) + __blk_crypto_rq_put_keyslot(req); + if (unlikely(error && !blk_rq_is_passthrough(req) && !(req->rq_flags & RQF_QUIET))) print_req_error(req, error, __func__); diff --git a/block/blk-crypto-internal.h b/block/blk-crypto-internal.h index 0d36aae538d7..8e0834557620 100644 --- a/block/blk-crypto-internal.h +++ b/block/blk-crypto-internal.h @@ -60,6 +60,11 @@ static inline bool blk_crypto_rq_is_encrypted(struct request *rq) return rq->crypt_ctx; } +static inline bool blk_crypto_rq_has_keyslot(struct request *rq) +{ + return rq->crypt_keyslot; +} + #else /* CONFIG_BLK_INLINE_ENCRYPTION */ static inline bool bio_crypt_rq_ctx_compatible(struct request *rq, @@ -93,6 +98,11 @@ static inline bool blk_crypto_rq_is_encrypted(struct request *rq) return false; } +static inline bool blk_crypto_rq_has_keyslot(struct request *rq) +{ + return false; +} + #endif /* CONFIG_BLK_INLINE_ENCRYPTION */ void __bio_crypt_advance(struct bio *bio, unsigned int bytes); @@ -127,14 +137,21 @@ static inline bool blk_crypto_bio_prep(struct bio **bio_ptr) return true; } -blk_status_t __blk_crypto_init_request(struct request *rq); -static inline blk_status_t blk_crypto_init_request(struct request *rq) +blk_status_t __blk_crypto_rq_get_keyslot(struct request *rq); +static inline blk_status_t blk_crypto_rq_get_keyslot(struct request *rq) { if (blk_crypto_rq_is_encrypted(rq)) - return __blk_crypto_init_request(rq); + return __blk_crypto_rq_get_keyslot(rq); return BLK_STS_OK; } +void __blk_crypto_rq_put_keyslot(struct request *rq); +static inline void blk_crypto_rq_put_keyslot(struct request *rq) +{ + if (blk_crypto_rq_has_keyslot(rq)) + __blk_crypto_rq_put_keyslot(rq); +} + void __blk_crypto_free_request(struct request *rq); static inline void blk_crypto_free_request(struct request *rq) { @@ -173,7 +190,7 @@ static inline blk_status_t blk_crypto_insert_cloned_request(struct request *rq) { if (blk_crypto_rq_is_encrypted(rq)) - return blk_crypto_init_request(rq); + return blk_crypto_rq_get_keyslot(rq); return BLK_STS_OK; } diff --git a/block/blk-crypto.c b/block/blk-crypto.c index 722868e016ed..84abf970c40c 100644 --- a/block/blk-crypto.c +++ b/block/blk-crypto.c @@ -217,26 +217,26 @@ static bool bio_crypt_check_alignment(struct bio *bio) return true; } -blk_status_t __blk_crypto_init_request(struct request *rq) +blk_status_t __blk_crypto_rq_get_keyslot(struct request *rq) { return blk_ksm_get_slot_for_key(rq->q->ksm, rq->crypt_ctx->bc_key, &rq->crypt_keyslot); } -/** - * __blk_crypto_free_request - Uninitialize the crypto fields of a request. - * - * @rq: The request whose crypto fields to uninitialize. - * - * Completely uninitializes the crypto fields of a request. If a keyslot has - * been programmed into some inline encryption hardware, that keyslot is - * released. The rq->crypt_ctx is also freed. - */ -void __blk_crypto_free_request(struct request *rq) +void __blk_crypto_rq_put_keyslot(struct request *rq) { blk_ksm_put_slot(rq->crypt_keyslot); + rq->crypt_keyslot = NULL; +} + +void __blk_crypto_free_request(struct request *rq) +{ + /* The keyslot, if one was needed, should have been released earlier. */ + if (WARN_ON_ONCE(rq->crypt_keyslot)) + __blk_crypto_rq_put_keyslot(rq); + mempool_free(rq->crypt_ctx, bio_crypt_ctx_pool); - blk_crypto_rq_set_defaults(rq); + rq->crypt_ctx = NULL; } /** diff --git a/block/blk-merge.c b/block/blk-merge.c index 087e422a65a8..4512ba4e0a67 100644 --- a/block/blk-merge.c +++ b/block/blk-merge.c @@ -803,6 +803,8 @@ static struct request *attempt_merge(struct request_queue *q, if (!blk_discard_mergable(req)) elv_merge_requests(q, req, next); + blk_crypto_rq_put_keyslot(next); + /* * 'next' is going away, so update stats accordingly */ diff --git a/block/blk-mq.c b/block/blk-mq.c index 5d520b187555..0c9631d42ee7 100644 --- a/block/blk-mq.c +++ b/block/blk-mq.c @@ -2247,7 +2247,7 @@ blk_qc_t blk_mq_submit_bio(struct bio *bio) blk_mq_bio_to_request(rq, bio, nr_segs); - ret = blk_crypto_init_request(rq); + ret = blk_crypto_rq_get_keyslot(rq); if (ret != BLK_STS_OK) { bio->bi_status = ret; bio_endio(bio); From b3926f1a34c6aa2b456e2e357e533cb4470d0ec6 Mon Sep 17 00:00:00 2001 From: Eric Biggers Date: Wed, 15 Mar 2023 11:39:03 -0700 Subject: [PATCH 08/68] BACKPORT: FROMGIT: blk-crypto: make blk_crypto_evict_key() return void blk_crypto_evict_key() is only called in contexts such as inode eviction where failure is not an option. So there is nothing the caller can do with errors except log them. (dm-table.c does "use" the error code, but only to pass on to upper layers, so it doesn't really count.) Just make blk_crypto_evict_key() return void and log errors itself. Cc: stable@vger.kernel.org Signed-off-by: Eric Biggers Reviewed-by: Christoph Hellwig Link: https://lore.kernel.org/r/20230315183907.53675-2-ebiggers@kernel.org Signed-off-by: Jens Axboe Bug: 270098322 (cherry picked from commit 70493a63ba04f754f7a7dd53a4fcc82700181490 https://git.kernel.org/pub/scm/linux/kernel/git/axboe/linux-block.git/log/?h=for-next) Change-Id: I8b9c7a74473e21fb740f021ac9f2fff95f986aa4 Signed-off-by: Eric Biggers --- block/blk-crypto.c | 22 ++++++++++------------ drivers/md/dm-table.c | 19 +++++-------------- include/linux/blk-crypto.h | 4 ++-- 3 files changed, 17 insertions(+), 28 deletions(-) diff --git a/block/blk-crypto.c b/block/blk-crypto.c index 84abf970c40c..26956813a7bf 100644 --- a/block/blk-crypto.c +++ b/block/blk-crypto.c @@ -13,6 +13,7 @@ #include #include #include +#include #include #include "blk-crypto-internal.h" @@ -418,20 +419,17 @@ EXPORT_SYMBOL_GPL(blk_crypto_start_using_key); * Upper layers (filesystems) must call this function to ensure that a key is * evicted from any hardware that it might have been programmed into. The key * must not be in use by any in-flight IO when this function is called. - * - * Return: 0 on success or if key is not present in the q's ksm, -err on error. */ -int blk_crypto_evict_key(struct request_queue *q, - const struct blk_crypto_key *key) +void blk_crypto_evict_key(struct request_queue *q, + const struct blk_crypto_key *key) { - if (blk_ksm_crypto_cfg_supported(q->ksm, &key->crypto_cfg)) - return blk_ksm_evict_key(q->ksm, key); + int err; - /* - * If the request queue's associated inline encryption hardware didn't - * have support for the key, then the key might have been programmed - * into the fallback keyslot manager, so try to evict from there. - */ - return blk_crypto_fallback_evict_key(key); + if (blk_ksm_crypto_cfg_supported(q->ksm, &key->crypto_cfg)) + err = blk_ksm_evict_key(q->ksm, key); + else + err = blk_crypto_fallback_evict_key(key); + if (err) + pr_warn_ratelimited("error %d evicting key\n", err); } EXPORT_SYMBOL_GPL(blk_crypto_evict_key); diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c index ade798f92817..743bdb157b3e 100644 --- a/drivers/md/dm-table.c +++ b/drivers/md/dm-table.c @@ -1221,21 +1221,12 @@ struct dm_keyslot_manager { struct mapped_device *md; }; -struct dm_keyslot_evict_args { - const struct blk_crypto_key *key; - int err; -}; - static int dm_keyslot_evict_callback(struct dm_target *ti, struct dm_dev *dev, sector_t start, sector_t len, void *data) { - struct dm_keyslot_evict_args *args = data; - int err; + const struct blk_crypto_key *key = data; - err = blk_crypto_evict_key(bdev_get_queue(dev->bdev), args->key); - if (!args->err) - args->err = err; - /* Always try to evict the key from all devices. */ + blk_crypto_evict_key(bdev_get_queue(dev->bdev), key); return 0; } @@ -1250,7 +1241,6 @@ static int dm_keyslot_evict(struct blk_keyslot_manager *ksm, struct dm_keyslot_manager, ksm); struct mapped_device *md = dksm->md; - struct dm_keyslot_evict_args args = { key }; struct dm_table *t; int srcu_idx; int i; @@ -1263,10 +1253,11 @@ static int dm_keyslot_evict(struct blk_keyslot_manager *ksm, ti = dm_table_get_target(t, i); if (!ti->type->iterate_devices) continue; - ti->type->iterate_devices(ti, dm_keyslot_evict_callback, &args); + ti->type->iterate_devices(ti, dm_keyslot_evict_callback, + (void *)key); } dm_put_live_table(md, srcu_idx); - return args.err; + return 0; } struct dm_derive_raw_secret_args { diff --git a/include/linux/blk-crypto.h b/include/linux/blk-crypto.h index c495572a3c46..d89f521d8310 100644 --- a/include/linux/blk-crypto.h +++ b/include/linux/blk-crypto.h @@ -104,8 +104,8 @@ int blk_crypto_init_key(struct blk_crypto_key *blk_key, int blk_crypto_start_using_key(const struct blk_crypto_key *key, struct request_queue *q); -int blk_crypto_evict_key(struct request_queue *q, - const struct blk_crypto_key *key); +void blk_crypto_evict_key(struct request_queue *q, + const struct blk_crypto_key *key); bool blk_crypto_config_supported(struct request_queue *q, const struct blk_crypto_config *cfg); From 0dad2818cb64e44d28bed2927463cc1c7832cb8d Mon Sep 17 00:00:00 2001 From: Eric Biggers Date: Wed, 15 Mar 2023 11:39:04 -0700 Subject: [PATCH 09/68] BACKPORT: FROMGIT: blk-crypto: make blk_crypto_evict_key() more robust If blk_crypto_evict_key() sees that the key is still in-use (due to a bug) or that ->keyslot_evict failed, it currently just returns while leaving the key linked into the keyslot management structures. However, blk_crypto_evict_key() is only called in contexts such as inode eviction where failure is not an option. So actually the caller proceeds with freeing the blk_crypto_key regardless of the return value of blk_crypto_evict_key(). These two assumptions don't match, and the result is that there can be a use-after-free in blk_crypto_reprogram_all_keys() after one of these errors occurs. (Note, these errors *shouldn't* happen; we're just talking about what happens if they do anyway.) Fix this by making blk_crypto_evict_key() unlink the key from the keyslot management structures even on failure. Also improve some comments. Fixes: 1b2628397058 ("block: Keyslot Manager for Inline Encryption") Cc: stable@vger.kernel.org Signed-off-by: Eric Biggers Reviewed-by: Christoph Hellwig Link: https://lore.kernel.org/r/20230315183907.53675-2-ebiggers@kernel.org Signed-off-by: Jens Axboe Bug: 270098322 (cherry picked from commit 5c7cb94452901a93e90c2230632e2c12a681bc92 https://git.kernel.org/pub/scm/linux/kernel/git/axboe/linux-block.git/log/?h=for-next) Change-Id: I4e8983ad7db94ea8cd422743196da8854adda552 Signed-off-by: Eric Biggers --- block/blk-crypto.c | 29 +++++++++++++++++++-------- block/keyslot-manager.c | 43 ++++++++++++++++++++--------------------- 2 files changed, 42 insertions(+), 30 deletions(-) diff --git a/block/blk-crypto.c b/block/blk-crypto.c index 26956813a7bf..ccb2dc5a3939 100644 --- a/block/blk-crypto.c +++ b/block/blk-crypto.c @@ -410,15 +410,20 @@ int blk_crypto_start_using_key(const struct blk_crypto_key *key, EXPORT_SYMBOL_GPL(blk_crypto_start_using_key); /** - * blk_crypto_evict_key() - Evict a key from any inline encryption hardware - * it may have been programmed into - * @q: The request queue who's associated inline encryption hardware this key - * might have been programmed into - * @key: The key to evict + * blk_crypto_evict_key() - Evict a blk_crypto_key from a request_queue + * @q: a request_queue on which I/O using the key may have been done + * @key: the key to evict * - * Upper layers (filesystems) must call this function to ensure that a key is - * evicted from any hardware that it might have been programmed into. The key - * must not be in use by any in-flight IO when this function is called. + * For a given request_queue, this function removes the given blk_crypto_key + * from the keyslot management structures and evicts it from any underlying + * hardware keyslot(s) or blk-crypto-fallback keyslot it may have been + * programmed into. + * + * Upper layers must call this before freeing the blk_crypto_key. It must be + * called for every request_queue the key may have been used on. The key must + * no longer be in use by any I/O when this function is called. + * + * Context: May sleep. */ void blk_crypto_evict_key(struct request_queue *q, const struct blk_crypto_key *key) @@ -429,6 +434,14 @@ void blk_crypto_evict_key(struct request_queue *q, err = blk_ksm_evict_key(q->ksm, key); else err = blk_crypto_fallback_evict_key(key); + /* + * An error can only occur here if the key failed to be evicted from a + * keyslot (due to a hardware or driver issue) or is allegedly still in + * use by I/O (due to a kernel bug). Even in these cases, the key is + * still unlinked from the keyslot management structures, and the caller + * is allowed and expected to free it right away. There's nothing + * callers can do to handle errors, so just log them and return void. + */ if (err) pr_warn_ratelimited("error %d evicting key\n", err); } diff --git a/block/keyslot-manager.c b/block/keyslot-manager.c index 7ba541f73ce8..94704774352a 100644 --- a/block/keyslot-manager.c +++ b/block/keyslot-manager.c @@ -350,25 +350,16 @@ bool blk_ksm_crypto_cfg_supported(struct blk_keyslot_manager *ksm, return true; } -/** - * blk_ksm_evict_key() - Evict a key from the lower layer device. - * @ksm: The keyslot manager to evict from - * @key: The key to evict - * - * Find the keyslot that the specified key was programmed into, and evict that - * slot from the lower layer device. The slot must not be in use by any - * in-flight IO when this function is called. - * - * Context: Process context. Takes and releases ksm->lock. - * Return: 0 on success or if there's no keyslot with the specified key, -EBUSY - * if the keyslot is still in use, or another -errno value on other - * error. +/* + * This is an internal function that evicts a key from an inline encryption + * device that can be either a real device or the blk-crypto-fallback "device". + * It is used only by blk_crypto_evict_key(); see that function for details. */ int blk_ksm_evict_key(struct blk_keyslot_manager *ksm, const struct blk_crypto_key *key) { struct blk_ksm_keyslot *slot; - int err = 0; + int err; if (blk_ksm_is_passthrough(ksm)) { if (ksm->ksm_ll_ops.keyslot_evict) { @@ -382,22 +373,30 @@ int blk_ksm_evict_key(struct blk_keyslot_manager *ksm, blk_ksm_hw_enter(ksm); slot = blk_ksm_find_keyslot(ksm, key); - if (!slot) - goto out_unlock; + if (!slot) { + /* + * Not an error, since a key not in use by I/O is not guaranteed + * to be in a keyslot. There can be more keys than keyslots. + */ + err = 0; + goto out; + } if (WARN_ON_ONCE(atomic_read(&slot->slot_refs) != 0)) { + /* BUG: key is still in use by I/O */ err = -EBUSY; - goto out_unlock; + goto out_remove; } err = ksm->ksm_ll_ops.keyslot_evict(ksm, key, blk_ksm_get_slot_idx(slot)); - if (err) - goto out_unlock; - +out_remove: + /* + * Callers free the key even on error, so unlink the key from the hash + * table and clear slot->key even on error. + */ hlist_del(&slot->hash_node); slot->key = NULL; - err = 0; -out_unlock: +out: blk_ksm_hw_exit(ksm); return err; } From 2a7aed72981a25f653be09cba5d0b4248e70268c Mon Sep 17 00:00:00 2001 From: Eric Biggers Date: Thu, 16 Mar 2023 22:47:27 +0000 Subject: [PATCH 10/68] ANDROID: dm-default-key: update for blk_crypto_evict_key() returning void blk_crypto_evict_key() now returns void, so update default_key_dtr() accordingly. Bug: 270098322 Change-Id: I6add49a8f792c51f33e7adb189a9e7ed5ff410b0 Signed-off-by: Eric Biggers --- drivers/md/dm-default-key.c | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/drivers/md/dm-default-key.c b/drivers/md/dm-default-key.c index e8e9b72d30c5..eaa83298858c 100644 --- a/drivers/md/dm-default-key.c +++ b/drivers/md/dm-default-key.c @@ -67,13 +67,9 @@ lookup_cipher(const char *cipher_string) static void default_key_dtr(struct dm_target *ti) { struct default_key_c *dkc = ti->private; - int err; if (dkc->dev) { - err = blk_crypto_evict_key(bdev_get_queue(dkc->dev->bdev), - &dkc->key); - if (err && err != -ENOKEY) - DMWARN("Failed to evict crypto key: %d", err); + blk_crypto_evict_key(bdev_get_queue(dkc->dev->bdev), &dkc->key); dm_put_device(ti, dkc->dev); } kfree_sensitive(dkc->cipher_string); From d88cd5c7f07842144cf3493b43a96cb198d76704 Mon Sep 17 00:00:00 2001 From: Todd Kjos Date: Fri, 31 Mar 2023 19:16:49 +0000 Subject: [PATCH 11/68] ANDROID: Fix kernelci break: eventfd_signal_mask redefined MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fix a merge issue where eventfd_signal_mask() was added twice which resulted in kernelci issues when !CONFIG_EVENTFD: include/linux/eventfd.h:76:19: error: redefinition of ‘eventfd_signal_mask’ Fixes: 4ef66581d7fd ("eventfd: provide a eventfd_signal_mask() helper") Signed-off-by: Todd Kjos Change-Id: Ifdd212e857c2ff76c75283e77b9978e51a96d178 --- include/linux/eventfd.h | 6 ------ 1 file changed, 6 deletions(-) diff --git a/include/linux/eventfd.h b/include/linux/eventfd.h index e8c5dd9c3dac..6cd2a92daf20 100644 --- a/include/linux/eventfd.h +++ b/include/linux/eventfd.h @@ -73,12 +73,6 @@ static inline int eventfd_signal_mask(struct eventfd_ctx *ctx, __u64 n, return -ENOSYS; } -static inline int eventfd_signal_mask(struct eventfd_ctx *ctx, __u64 n, - unsigned mask) -{ - return -ENOSYS; -} - static inline void eventfd_ctx_put(struct eventfd_ctx *ctx) { From 3ea370605ab59fa7f4c328e4341cda5b70399f44 Mon Sep 17 00:00:00 2001 From: Duoming Zhou Date: Tue, 24 Jan 2023 08:55:33 +0100 Subject: [PATCH 12/68] UPSTREAM: media: rc: Fix use-after-free bugs caused by ene_tx_irqsim() [ Upstream commit 29b0589a865b6f66d141d79b2dd1373e4e50fe17 ] When the ene device is detaching, function ene_remove() will be called. But there is no function to cancel tx_sim_timer in ene_remove(), the timer handler ene_tx_irqsim() could race with ene_remove(). As a result, the UAF bugs could happen, the process is shown below. (cleanup routine) | (timer routine) | mod_timer(&dev->tx_sim_timer, ..) ene_remove() | (wait a time) | ene_tx_irqsim() | dev->hw_lock //USE | ene_tx_sample(dev) //USE Fix by adding del_timer_sync(&dev->tx_sim_timer) in ene_remove(), The tx_sim_timer could stop before ene device is deallocated. What's more, The rc_unregister_device() and del_timer_sync() should be called first in ene_remove() and the deallocated functions such as free_irq(), release_region() and so on should be called behind them. Because the rc_unregister_device() is well synchronized. Otherwise, race conditions may happen. The situations that may lead to race conditions are shown below. Firstly, the rx receiver is disabled with ene_rx_disable() before rc_unregister_device() in ene_remove(), which means it can be enabled again if a process opens /dev/lirc0 between ene_rx_disable() and rc_unregister_device(). Secondly, the irqaction descriptor is freed by free_irq() before the rc device is unregistered, which means irqaction descriptor may be accessed again after it is deallocated. Thirdly, the timer can call ene_tx_sample() that can write to the io ports, which means the io ports could be accessed again after they are deallocated by release_region(). Therefore, the rc_unregister_device() and del_timer_sync() should be called first in ene_remove(). Suggested by: Sean Young Bug: 272747251 Fixes: 9ea53b74df9c ("V4L/DVB: STAGING: remove lirc_ene0100 driver") Signed-off-by: Duoming Zhou Signed-off-by: Sean Young Signed-off-by: Mauro Carvalho Chehab Signed-off-by: Sasha Levin Signed-off-by: Lee Jones Change-Id: I0076055ed3336b6f2ef4afe8afe68620dc6c2a0a --- drivers/media/rc/ene_ir.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/drivers/media/rc/ene_ir.c b/drivers/media/rc/ene_ir.c index 6049e5c95394..5aa3953cab82 100644 --- a/drivers/media/rc/ene_ir.c +++ b/drivers/media/rc/ene_ir.c @@ -1106,6 +1106,8 @@ static void ene_remove(struct pnp_dev *pnp_dev) struct ene_device *dev = pnp_get_drvdata(pnp_dev); unsigned long flags; + rc_unregister_device(dev->rdev); + del_timer_sync(&dev->tx_sim_timer); spin_lock_irqsave(&dev->hw_lock, flags); ene_rx_disable(dev); ene_rx_restore_hw_buffer(dev); @@ -1113,7 +1115,6 @@ static void ene_remove(struct pnp_dev *pnp_dev) free_irq(dev->irq, dev); release_region(dev->hw_io, ENE_IO_SIZE); - rc_unregister_device(dev->rdev); kfree(dev); } From b7b3a636ada7be8414ce01a6c721b6abdd8ac816 Mon Sep 17 00:00:00 2001 From: Baolin Wang Date: Thu, 2 Sep 2021 14:55:53 -0700 Subject: [PATCH 13/68] UPSTREAM: mm: memcontrol: set the correct memcg swappiness restriction Since commit c843966c556d ("mm: allow swappiness that prefers reclaiming anon over the file workingset") has expended the swappiness value to make swap to be preferred in some systems. We should also change the memcg swappiness restriction to allow memcg swap-preferred. Link: https://lkml.kernel.org/r/d77469b90c45c49953ccbc51e54a1d465bc18f70.1627626255.git.baolin.wang@linux.alibaba.com Fixes: c843966c556d ("mm: allow swappiness that prefers reclaiming anon over the file workingset") Signed-off-by: Baolin Wang Acked-by: Michal Hocko Cc: Johannes Weiner Cc: Vladimir Davydov Signed-off-by: Andrew Morton Signed-off-by: Linus Torvalds Bug: 275726149 (cherry picked from commit 37bc3cb9bbef86d1ddbbc789e55b588c8a2cac26) Change-Id: If6a46ebe5313ae0f5e75917adb6ca852c8daa6e6 Signed-off-by: Carlos Galo --- mm/memcontrol.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mm/memcontrol.c b/mm/memcontrol.c index 0501a27be6f1..645688340f71 100644 --- a/mm/memcontrol.c +++ b/mm/memcontrol.c @@ -4206,7 +4206,7 @@ static int mem_cgroup_swappiness_write(struct cgroup_subsys_state *css, { struct mem_cgroup *memcg = mem_cgroup_from_css(css); - if (val > 100) + if (val > 200) return -EINVAL; if (css->parent) From faf3626b8e34df3dfff3a99e6582a9abd24410ce Mon Sep 17 00:00:00 2001 From: Paul Lawrence Date: Thu, 23 Feb 2023 08:59:38 -0800 Subject: [PATCH 14/68] ANDROID: incremental fs: Evict inodes before freeing mount data Since evicting inodes triggers writes to the backing file, which uses the mi_owner field from the mount_info struct, make sure inodes are evicted before we free the mount_info data Test: incfs_test Bug: 270117845 Change-Id: I673b2e0e04b5adc3998caf6f22443598a30338af Signed-off-by: Paul Lawrence (cherry picked from commit 7899985277527b29c47929a6d6a89c5c89b406ad) --- fs/incfs/sysfs.c | 2 ++ fs/incfs/vfs.c | 8 +++++++- 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/fs/incfs/sysfs.c b/fs/incfs/sysfs.c index 5c7e0fd4496c..ba91c07d2887 100644 --- a/fs/incfs/sysfs.c +++ b/fs/incfs/sysfs.c @@ -34,12 +34,14 @@ DECLARE_FEATURE_FLAG(corefs); DECLARE_FEATURE_FLAG(zstd); DECLARE_FEATURE_FLAG(v2); DECLARE_FEATURE_FLAG(bugfix_throttling); +DECLARE_FEATURE_FLAG(bugfix_inode_eviction); static struct attribute *attributes[] = { &corefs_attr.attr, &zstd_attr.attr, &v2_attr.attr, &bugfix_throttling_attr.attr, + &bugfix_inode_eviction_attr.attr, NULL, }; diff --git a/fs/incfs/vfs.c b/fs/incfs/vfs.c index a0726a505e6c..f393f17435d3 100644 --- a/fs/incfs/vfs.c +++ b/fs/incfs/vfs.c @@ -1928,6 +1928,13 @@ void incfs_kill_sb(struct super_block *sb) pr_debug("incfs: unmount\n"); + /* + * We must kill the super before freeing mi, since killing the super + * triggers inode eviction, which triggers the final update of the + * backing file, which uses certain information for mi + */ + kill_anon_super(sb); + if (mi) { if (mi->mi_backing_dir_path.dentry) dinode = d_inode(mi->mi_backing_dir_path.dentry); @@ -1943,7 +1950,6 @@ void incfs_kill_sb(struct super_block *sb) incfs_free_mount_info(mi); sb->s_fs_info = NULL; } - kill_anon_super(sb); } static int show_options(struct seq_file *m, struct dentry *root) From 08ccb44bfffb80dfbbe0a1fb93f699a17f45dd0a Mon Sep 17 00:00:00 2001 From: Wei Liu Date: Mon, 3 Apr 2023 15:32:19 +0800 Subject: [PATCH 15/68] ANDROID: GKI: Update symbols to symbol list Update symbols to symbol list externed by oppo network group. 2 Added functions: [A] 'function sock* __udp4_lib_lookup(net*, __be32, __be16, __be32, __be16, int, int, udp_table*, sk_buff*)' [A] 'function sock* __udp6_lib_lookup(net*, const in6_addr*, __be16, const in6_addr*, __be16, int, int, udp_table*, sk_buff*)' 1 Added variable: [A] 'udp_table udp_table' Bug: 193384408 Change-Id: I11069764b442ce935facb5283f0b3b3494e2846c Signed-off-by: Wei Liu --- android/abi_gki_aarch64.xml | 434 +++++++++++++++++++++------------- android/abi_gki_aarch64_oplus | 3 + 2 files changed, 271 insertions(+), 166 deletions(-) diff --git a/android/abi_gki_aarch64.xml b/android/abi_gki_aarch64.xml index 291958b75232..f67fa1192d73 100644 --- a/android/abi_gki_aarch64.xml +++ b/android/abi_gki_aarch64.xml @@ -737,6 +737,8 @@ + + @@ -6956,6 +6958,7 @@ + @@ -38661,7 +38664,14 @@ - + + + + + + + + @@ -44522,7 +44532,23 @@ - + + + + + + + + + + + + + + + + + @@ -48852,6 +48878,7 @@ + @@ -53795,6 +53822,13 @@ + + + + + + + @@ -66454,6 +66488,13 @@ + + + + + + + @@ -69763,7 +69804,20 @@ - + + + + + + + + + + + + + + @@ -70665,6 +70719,7 @@ + @@ -75654,6 +75709,9 @@ + + + @@ -91202,6 +91260,7 @@ + @@ -102968,6 +103027,12 @@ + + + + + + @@ -111213,6 +111278,7 @@ + @@ -113557,6 +113623,17 @@ + + + + + + + + + + + @@ -116335,10 +116412,10 @@ - - - - + + + + @@ -121251,6 +121328,30 @@ + + + + + + + + + + + + + + + + + + + + + + + + @@ -122210,11 +122311,11 @@ - - - - - + + + + + @@ -122347,17 +122448,17 @@ - - - - - + + + + + - - - - + + + + @@ -122379,8 +122480,8 @@ - - + + @@ -122411,17 +122512,17 @@ - - + + - - - + + + - - + + @@ -122546,11 +122647,11 @@ - - - - - + + + + + @@ -122798,8 +122899,8 @@ - - + + @@ -137084,13 +137185,13 @@ - - + + - - - + + + @@ -137163,10 +137264,10 @@ - - - - + + + + @@ -137206,8 +137307,8 @@ - - + + @@ -137282,10 +137383,10 @@ - - - - + + + + @@ -137300,38 +137401,38 @@ - - - - + + + + - - - + + + - - + + - - - + + + - - - + + + - - - + + + @@ -137378,14 +137479,14 @@ - - - + + + - - - + + + @@ -137434,22 +137535,22 @@ - - - + + + - - - + + + - - + + - - + + @@ -137591,9 +137692,9 @@ - - - + + + @@ -137601,10 +137702,10 @@ - - - - + + + + @@ -137630,42 +137731,42 @@ - - - - + + + + - - - - - - + + + + + + - - - - - - + + + + + + - - - - - - + + + + + + - - + + @@ -137824,9 +137925,9 @@ - - - + + + @@ -141738,8 +141839,8 @@ - - + + @@ -146768,6 +146869,7 @@ + @@ -147183,13 +147285,13 @@ - - + + - - - + + + @@ -147358,8 +147460,8 @@ - - + + @@ -147505,55 +147607,55 @@ - - - + + + - - - - + + + + - - - - + + + + - - + + - - - + + + - - - + + + - - - - + + + + - - - - + + + + - - + + @@ -147593,7 +147695,7 @@ - + @@ -147713,10 +147815,10 @@ - - - - + + + + @@ -147927,9 +148029,9 @@ - - - + + + diff --git a/android/abi_gki_aarch64_oplus b/android/abi_gki_aarch64_oplus index eb8aba0710d9..5693bb828b42 100644 --- a/android/abi_gki_aarch64_oplus +++ b/android/abi_gki_aarch64_oplus @@ -3262,6 +3262,9 @@ ucsi_set_drvdata ucsi_unregister __udelay + __udp4_lib_lookup + __udp6_lib_lookup + udp_table ufshcd_auto_hibern8_update ufshcd_delay_us ufshcd_dme_get_attr From d55931c1cccc790de1b688afbee837019dd9065b Mon Sep 17 00:00:00 2001 From: Ye Bin Date: Tue, 6 Dec 2022 22:41:34 +0800 Subject: [PATCH 16/68] UPSTREAM: ext4: fix kernel BUG in 'ext4_write_inline_data_end()' commit 5c099c4fdc438014d5893629e70a8ba934433ee8 upstream. Syzbot report follow issue: ------------[ cut here ]------------ kernel BUG at fs/ext4/inline.c:227! invalid opcode: 0000 [#1] PREEMPT SMP KASAN CPU: 1 PID: 3629 Comm: syz-executor212 Not tainted 6.1.0-rc5-syzkaller-00018-g59d0d52c30d4 #0 Hardware name: Google Google Compute Engine/Google Compute Engine, BIOS Google 10/26/2022 RIP: 0010:ext4_write_inline_data+0x344/0x3e0 fs/ext4/inline.c:227 RSP: 0018:ffffc90003b3f368 EFLAGS: 00010293 RAX: 0000000000000000 RBX: ffff8880704e16c0 RCX: 0000000000000000 RDX: ffff888021763a80 RSI: ffffffff821e31a4 RDI: 0000000000000006 RBP: 000000000006818e R08: 0000000000000006 R09: 0000000000068199 R10: 0000000000000079 R11: 0000000000000000 R12: 000000000000000b R13: 0000000000068199 R14: ffffc90003b3f408 R15: ffff8880704e1c82 FS: 000055555723e3c0(0000) GS:ffff8880b9b00000(0000) knlGS:0000000000000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: 00007fffe8ac9080 CR3: 0000000079f81000 CR4: 0000000000350ee0 Call Trace: ext4_write_inline_data_end+0x2a3/0x12f0 fs/ext4/inline.c:768 ext4_write_end+0x242/0xdd0 fs/ext4/inode.c:1313 ext4_da_write_end+0x3ed/0xa30 fs/ext4/inode.c:3063 generic_perform_write+0x316/0x570 mm/filemap.c:3764 ext4_buffered_write_iter+0x15b/0x460 fs/ext4/file.c:285 ext4_file_write_iter+0x8bc/0x16e0 fs/ext4/file.c:700 call_write_iter include/linux/fs.h:2191 [inline] do_iter_readv_writev+0x20b/0x3b0 fs/read_write.c:735 do_iter_write+0x182/0x700 fs/read_write.c:861 vfs_iter_write+0x74/0xa0 fs/read_write.c:902 iter_file_splice_write+0x745/0xc90 fs/splice.c:686 do_splice_from fs/splice.c:764 [inline] direct_splice_actor+0x114/0x180 fs/splice.c:931 splice_direct_to_actor+0x335/0x8a0 fs/splice.c:886 do_splice_direct+0x1ab/0x280 fs/splice.c:974 do_sendfile+0xb19/0x1270 fs/read_write.c:1255 __do_sys_sendfile64 fs/read_write.c:1323 [inline] __se_sys_sendfile64 fs/read_write.c:1309 [inline] __x64_sys_sendfile64+0x1d0/0x210 fs/read_write.c:1309 do_syscall_x64 arch/x86/entry/common.c:50 [inline] do_syscall_64+0x39/0xb0 arch/x86/entry/common.c:80 entry_SYSCALL_64_after_hwframe+0x63/0xcd ---[ end trace 0000000000000000 ]--- Above issue may happens as follows: ext4_da_write_begin ext4_da_write_inline_data_begin ext4_da_convert_inline_data_to_extent ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA); ext4_da_write_end ext4_run_li_request ext4_mb_prefetch ext4_read_block_bitmap_nowait ext4_validate_block_bitmap ext4_mark_group_bitmap_corrupted(sb, block_group, EXT4_GROUP_INFO_BBITMAP_CORRUPT) percpu_counter_sub(&sbi->s_freeclusters_counter,grp->bb_free); -> sbi->s_freeclusters_counter become zero ext4_da_write_begin if (ext4_nonda_switch(inode->i_sb)) -> As freeclusters_counter is zero will return true *fsdata = (void *)FALL_BACK_TO_NONDELALLOC; ext4_write_begin ext4_da_write_end if (write_mode == FALL_BACK_TO_NONDELALLOC) ext4_write_end if (inline_data) ext4_write_inline_data_end ext4_write_inline_data BUG_ON(pos + len > EXT4_I(inode)->i_inline_size); -> As inode is already convert to extent, so 'pos + len' > inline_size -> then trigger BUG. To solve this issue, instead of checking ext4_has_inline_data() which is only cleared after data has been written back, check the EXT4_STATE_MAY_INLINE_DATA flag in ext4_write_end(). Fixes: f19d5870cbf7 ("ext4: add normal write support for inline data") Reported-by: syzbot+4faa160fa96bfba639f8@syzkaller.appspotmail.com Reported-by: Jun Nie Signed-off-by: Ye Bin Link: https://lore.kernel.org/r/20221206144134.1919987-1-yebin@huaweicloud.com Signed-off-by: Theodore Ts'o Cc: stable@kernel.org [ta: Fix conflict in if expression and use the local variable inline_data as it is initialized with ext4_has_inline_data(inode) anyway.] Signed-off-by: Tudor Ambarus Signed-off-by: Greg Kroah-Hartman Bug: 257756238 Change-Id: Ifc77db2f12db2270a2f7100e548e113dee3ee492 Signed-off-by: Tudor Ambarus --- fs/ext4/inode.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c index 961c75280eb4..b5b763c30268 100644 --- a/fs/ext4/inode.c +++ b/fs/ext4/inode.c @@ -1315,7 +1315,8 @@ static int ext4_write_end(struct file *file, trace_android_fs_datawrite_end(inode, pos, len); trace_ext4_write_end(inode, pos, len, copied); - if (inline_data) { + if (inline_data && + ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA)) { ret = ext4_write_inline_data_end(inode, pos, len, copied, page); if (ret < 0) { From 61344663df420c35b7d70ac37c28880ffea72f51 Mon Sep 17 00:00:00 2001 From: Peifeng Li Date: Tue, 11 Apr 2023 14:59:40 +0800 Subject: [PATCH 17/68] ANDROID: clear memory trylock-bit when page_locked. Clearing trylock-bit of page shrinked by shrnk_page_list in advance which avoids page in other scene with the trylock-bit. The page with trylock-bit will be added ret_pages and handled in trace_android_vh_handle_failed_page_trylock. In the progress[unlock_page, handled], the page carried with trylock-bit will cause some error-issues in other scene, so clear trylock-bit here. trace_android_vh_page_trylock_get_result will clear trylock-bit and return if page tyrlock failed in reclaim-process. Here we just want to clear trylock-bit so that ignore page_trylock_result. Fixes: 309a6bf81a20 ("ANDROID: vendor_hook: Add hook to not be stuck ro rmap lock in kswapd or direct_reclaim") Bug: 240003372 Signed-off-by: Peifeng Li Change-Id: Ifecd308573ef37a51e33856a0b3bb93cd67289ac --- mm/vmscan.c | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/mm/vmscan.c b/mm/vmscan.c index 4a11800e1b8f..f94f52e98868 100644 --- a/mm/vmscan.c +++ b/mm/vmscan.c @@ -1128,6 +1128,7 @@ static unsigned int shrink_page_list(struct list_head *page_list, LIST_HEAD(free_pages); unsigned int nr_reclaimed = 0; unsigned int pgactivate = 0; + bool page_trylock_result; memset(stat, 0, sizeof(*stat)); cond_resched(); @@ -1527,6 +1528,18 @@ activate_locked: count_memcg_page_event(page, PGACTIVATE); } keep_locked: + /* + * The page with trylock-bit will be added ret_pages and + * handled in trace_android_vh_handle_failed_page_trylock. + * In the progress[unlock_page, handled], the page carried + * with trylock-bit will cause some error-issues in other + * scene, so clear trylock-bit here. + * trace_android_vh_page_trylock_get_result will clear + * trylock-bit and return if page tyrlock failed in + * reclaim-process. Here we just want to clear trylock-bit + * so that ignore page_trylock_result. + */ + trace_android_vh_page_trylock_get_result(page, &page_trylock_result); unlock_page(page); keep: list_add(&page->lru, &ret_pages); From 3fafe0740e17185f477a3332bba443f51f15a7e7 Mon Sep 17 00:00:00 2001 From: Harry Wentland Date: Tue, 7 Sep 2021 19:40:06 -0400 Subject: [PATCH 18/68] BACKPORT: drm/amd/display: Pass display_pipe_params_st as const in DML MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit [Why] This neither needs to be on the stack nor passed by value to each function call. In fact, when building with clang it seems to break the Linux's default 1024 byte stack frame limit. [How] We can simply pass this as a const pointer. This patch fixes these Coverity IDs Addresses-Coverity-ID: 1424031: ("Big parameter passed by value") Addresses-Coverity-ID: 1423970: ("Big parameter passed by value") Addresses-Coverity-ID: 1423941: ("Big parameter passed by value") Addresses-Coverity-ID: 1451742: ("Big parameter passed by value") Addresses-Coverity-ID: 1451887: ("Big parameter passed by value") Addresses-Coverity-ID: 1454146: ("Big parameter passed by value") Addresses-Coverity-ID: 1454152: ("Big parameter passed by value") Addresses-Coverity-ID: 1454413: ("Big parameter passed by value") Addresses-Coverity-ID: 1466144: ("Big parameter passed by value") Addresses-Coverity-ID: 1487237: ("Big parameter passed by value") Bug: 254441685 Signed-off-by: Harry Wentland Fixes: 3fe617ccafd6 ("Enable '-Werror' by default for all kernel builds") Cc: Nick Desaulniers Cc: Linus Torvalds Cc: amd-gfx@lists.freedesktop.org Cc: Linux Kernel Mailing List Cc: Arnd Bergmann Cc: Leo Li Cc: Alex Deucher Cc: Christian König Cc: Xinhui Pan Cc: Nathan Chancellor Cc: Guenter Roeck Cc: llvm@lists.linux.dev Acked-by: Christian König Build-tested-by: Nathan Chancellor Reviewed-by: Leo Li Signed-off-by: Alex Deucher (cherry picked from commit 22667e6ec6b2ce9ca706e9061660b059725d009c) Signed-off-by: Lee Jones Change-Id: Ie9846bf0e5dd330cafa811afbb896f0bdb70c85d --- .../drm/amd/display/dc/dcn20/dcn20_resource.c | 2 +- .../dc/dml/dcn20/display_rq_dlg_calc_20.c | 6 +- .../dc/dml/dcn20/display_rq_dlg_calc_20.h | 4 +- .../dc/dml/dcn20/display_rq_dlg_calc_20v2.c | 6 +- .../dc/dml/dcn20/display_rq_dlg_calc_20v2.h | 4 +- .../dc/dml/dcn21/display_rq_dlg_calc_21.c | 62 ++++++++-------- .../dc/dml/dcn21/display_rq_dlg_calc_21.h | 4 +- .../dc/dml/dcn30/display_rq_dlg_calc_30.c | 72 +++++++++---------- .../dc/dml/dcn30/display_rq_dlg_calc_30.h | 4 +- .../drm/amd/display/dc/dml/display_mode_lib.h | 4 +- 10 files changed, 84 insertions(+), 84 deletions(-) diff --git a/drivers/gpu/drm/amd/display/dc/dcn20/dcn20_resource.c b/drivers/gpu/drm/amd/display/dc/dcn20/dcn20_resource.c index 53ac82693532..3346074047f7 100644 --- a/drivers/gpu/drm/amd/display/dc/dcn20/dcn20_resource.c +++ b/drivers/gpu/drm/amd/display/dc/dcn20/dcn20_resource.c @@ -3130,7 +3130,7 @@ void dcn20_calculate_dlg_params( context->bw_ctx.dml.funcs.rq_dlg_get_rq_reg(&context->bw_ctx.dml, &context->res_ctx.pipe_ctx[i].rq_regs, - pipes[pipe_idx].pipe); + &pipes[pipe_idx].pipe); pipe_idx++; } } diff --git a/drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c b/drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c index 799bae229e67..ed1625d331ae 100644 --- a/drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c +++ b/drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c @@ -768,12 +768,12 @@ static void dml20_rq_dlg_get_rq_params(struct display_mode_lib *mode_lib, void dml20_rq_dlg_get_rq_reg(struct display_mode_lib *mode_lib, display_rq_regs_st *rq_regs, - const display_pipe_params_st pipe_param) + const display_pipe_params_st *pipe_param) { display_rq_params_st rq_param = {0}; memset(rq_regs, 0, sizeof(*rq_regs)); - dml20_rq_dlg_get_rq_params(mode_lib, &rq_param, pipe_param.src); + dml20_rq_dlg_get_rq_params(mode_lib, &rq_param, pipe_param->src); extract_rq_regs(mode_lib, rq_regs, rq_param); print__rq_regs_st(mode_lib, *rq_regs); @@ -1549,7 +1549,7 @@ static void dml20_rq_dlg_get_dlg_params(struct display_mode_lib *mode_lib, void dml20_rq_dlg_get_dlg_reg(struct display_mode_lib *mode_lib, display_dlg_regs_st *dlg_regs, display_ttu_regs_st *ttu_regs, - display_e2e_pipe_params_st *e2e_pipe_param, + const display_e2e_pipe_params_st *e2e_pipe_param, const unsigned int num_pipes, const unsigned int pipe_idx, const bool cstate_en, diff --git a/drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.h b/drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.h index d0b90947f540..8b23867e97c1 100644 --- a/drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.h +++ b/drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.h @@ -43,7 +43,7 @@ struct display_mode_lib; void dml20_rq_dlg_get_rq_reg( struct display_mode_lib *mode_lib, display_rq_regs_st *rq_regs, - const display_pipe_params_st pipe_param); + const display_pipe_params_st *pipe_param); // Function: dml_rq_dlg_get_dlg_reg @@ -61,7 +61,7 @@ void dml20_rq_dlg_get_dlg_reg( struct display_mode_lib *mode_lib, display_dlg_regs_st *dlg_regs, display_ttu_regs_st *ttu_regs, - display_e2e_pipe_params_st *e2e_pipe_param, + const display_e2e_pipe_params_st *e2e_pipe_param, const unsigned int num_pipes, const unsigned int pipe_idx, const bool cstate_en, diff --git a/drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c b/drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c index 6a6d5970d1d5..b1208088a1df 100644 --- a/drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c +++ b/drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c @@ -768,12 +768,12 @@ static void dml20v2_rq_dlg_get_rq_params(struct display_mode_lib *mode_lib, void dml20v2_rq_dlg_get_rq_reg(struct display_mode_lib *mode_lib, display_rq_regs_st *rq_regs, - const display_pipe_params_st pipe_param) + const display_pipe_params_st *pipe_param) { display_rq_params_st rq_param = {0}; memset(rq_regs, 0, sizeof(*rq_regs)); - dml20v2_rq_dlg_get_rq_params(mode_lib, &rq_param, pipe_param.src); + dml20v2_rq_dlg_get_rq_params(mode_lib, &rq_param, pipe_param->src); extract_rq_regs(mode_lib, rq_regs, rq_param); print__rq_regs_st(mode_lib, *rq_regs); @@ -1550,7 +1550,7 @@ static void dml20v2_rq_dlg_get_dlg_params(struct display_mode_lib *mode_lib, void dml20v2_rq_dlg_get_dlg_reg(struct display_mode_lib *mode_lib, display_dlg_regs_st *dlg_regs, display_ttu_regs_st *ttu_regs, - display_e2e_pipe_params_st *e2e_pipe_param, + const display_e2e_pipe_params_st *e2e_pipe_param, const unsigned int num_pipes, const unsigned int pipe_idx, const bool cstate_en, diff --git a/drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.h b/drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.h index 27cf8bed9376..2b4e46ea1c3d 100644 --- a/drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.h +++ b/drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.h @@ -43,7 +43,7 @@ struct display_mode_lib; void dml20v2_rq_dlg_get_rq_reg( struct display_mode_lib *mode_lib, display_rq_regs_st *rq_regs, - const display_pipe_params_st pipe_param); + const display_pipe_params_st *pipe_param); // Function: dml_rq_dlg_get_dlg_reg @@ -61,7 +61,7 @@ void dml20v2_rq_dlg_get_dlg_reg( struct display_mode_lib *mode_lib, display_dlg_regs_st *dlg_regs, display_ttu_regs_st *ttu_regs, - display_e2e_pipe_params_st *e2e_pipe_param, + const display_e2e_pipe_params_st *e2e_pipe_param, const unsigned int num_pipes, const unsigned int pipe_idx, const bool cstate_en, diff --git a/drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c b/drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c index dc1c81a6e377..bca9406b03b3 100644 --- a/drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c +++ b/drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c @@ -694,7 +694,7 @@ static void get_surf_rq_param( display_data_rq_sizing_params_st *rq_sizing_param, display_data_rq_dlg_params_st *rq_dlg_param, display_data_rq_misc_params_st *rq_misc_param, - const display_pipe_params_st pipe_param, + const display_pipe_params_st *pipe_param, bool is_chroma) { bool mode_422 = false; @@ -706,30 +706,30 @@ static void get_surf_rq_param( // FIXME check if ppe apply for both luma and chroma in 422 case if (is_chroma) { - vp_width = pipe_param.src.viewport_width_c / ppe; - vp_height = pipe_param.src.viewport_height_c; - data_pitch = pipe_param.src.data_pitch_c; - meta_pitch = pipe_param.src.meta_pitch_c; + vp_width = pipe_param->src.viewport_width_c / ppe; + vp_height = pipe_param->src.viewport_height_c; + data_pitch = pipe_param->src.data_pitch_c; + meta_pitch = pipe_param->src.meta_pitch_c; } else { - vp_width = pipe_param.src.viewport_width / ppe; - vp_height = pipe_param.src.viewport_height; - data_pitch = pipe_param.src.data_pitch; - meta_pitch = pipe_param.src.meta_pitch; + vp_width = pipe_param->src.viewport_width / ppe; + vp_height = pipe_param->src.viewport_height; + data_pitch = pipe_param->src.data_pitch; + meta_pitch = pipe_param->src.meta_pitch; } - if (pipe_param.dest.odm_combine) { + if (pipe_param->dest.odm_combine) { unsigned int access_dir; unsigned int full_src_vp_width; unsigned int hactive_half; unsigned int src_hactive_half; - access_dir = (pipe_param.src.source_scan == dm_vert); // vp access direction: horizontal or vertical accessed - hactive_half = pipe_param.dest.hactive / 2; + access_dir = (pipe_param->src.source_scan == dm_vert); // vp access direction: horizontal or vertical accessed + hactive_half = pipe_param->dest.hactive / 2; if (is_chroma) { - full_src_vp_width = pipe_param.scale_ratio_depth.hscl_ratio_c * pipe_param.dest.full_recout_width; - src_hactive_half = pipe_param.scale_ratio_depth.hscl_ratio_c * hactive_half; + full_src_vp_width = pipe_param->scale_ratio_depth.hscl_ratio_c * pipe_param->dest.full_recout_width; + src_hactive_half = pipe_param->scale_ratio_depth.hscl_ratio_c * hactive_half; } else { - full_src_vp_width = pipe_param.scale_ratio_depth.hscl_ratio * pipe_param.dest.full_recout_width; - src_hactive_half = pipe_param.scale_ratio_depth.hscl_ratio * hactive_half; + full_src_vp_width = pipe_param->scale_ratio_depth.hscl_ratio * pipe_param->dest.full_recout_width; + src_hactive_half = pipe_param->scale_ratio_depth.hscl_ratio * hactive_half; } if (access_dir == 0) { @@ -754,7 +754,7 @@ static void get_surf_rq_param( rq_sizing_param->meta_chunk_bytes = 2048; rq_sizing_param->min_meta_chunk_bytes = 256; - if (pipe_param.src.hostvm) + if (pipe_param->src.hostvm) rq_sizing_param->mpte_group_bytes = 512; else rq_sizing_param->mpte_group_bytes = 2048; @@ -768,23 +768,23 @@ static void get_surf_rq_param( vp_height, data_pitch, meta_pitch, - pipe_param.src.source_format, - pipe_param.src.sw_mode, - pipe_param.src.macro_tile_size, - pipe_param.src.source_scan, - pipe_param.src.hostvm, + pipe_param->src.source_format, + pipe_param->src.sw_mode, + pipe_param->src.macro_tile_size, + pipe_param->src.source_scan, + pipe_param->src.hostvm, is_chroma); } static void dml_rq_dlg_get_rq_params( struct display_mode_lib *mode_lib, display_rq_params_st *rq_param, - const display_pipe_params_st pipe_param) + const display_pipe_params_st *pipe_param) { // get param for luma surface - rq_param->yuv420 = pipe_param.src.source_format == dm_420_8 - || pipe_param.src.source_format == dm_420_10; - rq_param->yuv420_10bpc = pipe_param.src.source_format == dm_420_10; + rq_param->yuv420 = pipe_param->src.source_format == dm_420_8 + || pipe_param->src.source_format == dm_420_10; + rq_param->yuv420_10bpc = pipe_param->src.source_format == dm_420_10; get_surf_rq_param( mode_lib, @@ -794,7 +794,7 @@ static void dml_rq_dlg_get_rq_params( pipe_param, 0); - if (is_dual_plane((enum source_format_class) (pipe_param.src.source_format))) { + if (is_dual_plane((enum source_format_class) (pipe_param->src.source_format))) { // get param for chroma surface get_surf_rq_param( mode_lib, @@ -806,14 +806,14 @@ static void dml_rq_dlg_get_rq_params( } // calculate how to split the det buffer space between luma and chroma - handle_det_buf_split(mode_lib, rq_param, pipe_param.src); + handle_det_buf_split(mode_lib, rq_param, pipe_param->src); print__rq_params_st(mode_lib, *rq_param); } void dml21_rq_dlg_get_rq_reg( struct display_mode_lib *mode_lib, display_rq_regs_st *rq_regs, - const display_pipe_params_st pipe_param) + const display_pipe_params_st *pipe_param) { display_rq_params_st rq_param = {0}; @@ -1658,7 +1658,7 @@ void dml21_rq_dlg_get_dlg_reg( struct display_mode_lib *mode_lib, display_dlg_regs_st *dlg_regs, display_ttu_regs_st *ttu_regs, - display_e2e_pipe_params_st *e2e_pipe_param, + const display_e2e_pipe_params_st *e2e_pipe_param, const unsigned int num_pipes, const unsigned int pipe_idx, const bool cstate_en, @@ -1696,7 +1696,7 @@ void dml21_rq_dlg_get_dlg_reg( // system parameter calculation done dml_print("DML_DLG: Calculation for pipe[%d] start\n\n", pipe_idx); - dml_rq_dlg_get_rq_params(mode_lib, &rq_param, e2e_pipe_param[pipe_idx].pipe); + dml_rq_dlg_get_rq_params(mode_lib, &rq_param, &e2e_pipe_param[pipe_idx].pipe); dml_rq_dlg_get_dlg_params( mode_lib, e2e_pipe_param, diff --git a/drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.h b/drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.h index e8f7785e3fc6..af6ad0ca9cf8 100644 --- a/drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.h +++ b/drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.h @@ -44,7 +44,7 @@ struct display_mode_lib; void dml21_rq_dlg_get_rq_reg( struct display_mode_lib *mode_lib, display_rq_regs_st *rq_regs, - const display_pipe_params_st pipe_param); + const display_pipe_params_st *pipe_param); // Function: dml_rq_dlg_get_dlg_reg // Calculate and return DLG and TTU register struct given the system setting @@ -61,7 +61,7 @@ void dml21_rq_dlg_get_dlg_reg( struct display_mode_lib *mode_lib, display_dlg_regs_st *dlg_regs, display_ttu_regs_st *ttu_regs, - display_e2e_pipe_params_st *e2e_pipe_param, + const display_e2e_pipe_params_st *e2e_pipe_param, const unsigned int num_pipes, const unsigned int pipe_idx, const bool cstate_en, diff --git a/drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c b/drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c index 58c312f80a07..f4d6acad0b6c 100644 --- a/drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c +++ b/drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c @@ -747,7 +747,7 @@ static void get_surf_rq_param(struct display_mode_lib *mode_lib, display_data_rq_sizing_params_st *rq_sizing_param, display_data_rq_dlg_params_st *rq_dlg_param, display_data_rq_misc_params_st *rq_misc_param, - const display_pipe_params_st pipe_param, + const display_pipe_params_st *pipe_param, bool is_chroma, bool is_alpha) { @@ -761,32 +761,32 @@ static void get_surf_rq_param(struct display_mode_lib *mode_lib, // FIXME check if ppe apply for both luma and chroma in 422 case if (is_chroma | is_alpha) { - vp_width = pipe_param.src.viewport_width_c / ppe; - vp_height = pipe_param.src.viewport_height_c; - data_pitch = pipe_param.src.data_pitch_c; - meta_pitch = pipe_param.src.meta_pitch_c; - surface_height = pipe_param.src.surface_height_y / 2.0; + vp_width = pipe_param->src.viewport_width_c / ppe; + vp_height = pipe_param->src.viewport_height_c; + data_pitch = pipe_param->src.data_pitch_c; + meta_pitch = pipe_param->src.meta_pitch_c; + surface_height = pipe_param->src.surface_height_y / 2.0; } else { - vp_width = pipe_param.src.viewport_width / ppe; - vp_height = pipe_param.src.viewport_height; - data_pitch = pipe_param.src.data_pitch; - meta_pitch = pipe_param.src.meta_pitch; - surface_height = pipe_param.src.surface_height_y; + vp_width = pipe_param->src.viewport_width / ppe; + vp_height = pipe_param->src.viewport_height; + data_pitch = pipe_param->src.data_pitch; + meta_pitch = pipe_param->src.meta_pitch; + surface_height = pipe_param->src.surface_height_y; } - if (pipe_param.dest.odm_combine) { + if (pipe_param->dest.odm_combine) { unsigned int access_dir = 0; unsigned int full_src_vp_width = 0; unsigned int hactive_odm = 0; unsigned int src_hactive_odm = 0; - access_dir = (pipe_param.src.source_scan == dm_vert); // vp access direction: horizontal or vertical accessed - hactive_odm = pipe_param.dest.hactive / ((unsigned int)pipe_param.dest.odm_combine*2); + access_dir = (pipe_param->src.source_scan == dm_vert); // vp access direction: horizontal or vertical accessed + hactive_odm = pipe_param->dest.hactive / ((unsigned int) pipe_param->dest.odm_combine*2); if (is_chroma) { - full_src_vp_width = pipe_param.scale_ratio_depth.hscl_ratio_c * pipe_param.dest.full_recout_width; - src_hactive_odm = pipe_param.scale_ratio_depth.hscl_ratio_c * hactive_odm; + full_src_vp_width = pipe_param->scale_ratio_depth.hscl_ratio_c * pipe_param->dest.full_recout_width; + src_hactive_odm = pipe_param->scale_ratio_depth.hscl_ratio_c * hactive_odm; } else { - full_src_vp_width = pipe_param.scale_ratio_depth.hscl_ratio * pipe_param.dest.full_recout_width; - src_hactive_odm = pipe_param.scale_ratio_depth.hscl_ratio * hactive_odm; + full_src_vp_width = pipe_param->scale_ratio_depth.hscl_ratio * pipe_param->dest.full_recout_width; + src_hactive_odm = pipe_param->scale_ratio_depth.hscl_ratio * hactive_odm; } if (access_dir == 0) { @@ -815,7 +815,7 @@ static void get_surf_rq_param(struct display_mode_lib *mode_lib, rq_sizing_param->meta_chunk_bytes = 2048; rq_sizing_param->min_meta_chunk_bytes = 256; - if (pipe_param.src.hostvm) + if (pipe_param->src.hostvm) rq_sizing_param->mpte_group_bytes = 512; else rq_sizing_param->mpte_group_bytes = 2048; @@ -828,28 +828,28 @@ static void get_surf_rq_param(struct display_mode_lib *mode_lib, vp_height, data_pitch, meta_pitch, - pipe_param.src.source_format, - pipe_param.src.sw_mode, - pipe_param.src.macro_tile_size, - pipe_param.src.source_scan, - pipe_param.src.hostvm, + pipe_param->src.source_format, + pipe_param->src.sw_mode, + pipe_param->src.macro_tile_size, + pipe_param->src.source_scan, + pipe_param->src.hostvm, is_chroma, surface_height); } static void dml_rq_dlg_get_rq_params(struct display_mode_lib *mode_lib, display_rq_params_st *rq_param, - const display_pipe_params_st pipe_param) + const display_pipe_params_st *pipe_param) { // get param for luma surface - rq_param->yuv420 = pipe_param.src.source_format == dm_420_8 - || pipe_param.src.source_format == dm_420_10 - || pipe_param.src.source_format == dm_rgbe_alpha - || pipe_param.src.source_format == dm_420_12; + rq_param->yuv420 = pipe_param->src.source_format == dm_420_8 + || pipe_param->src.source_format == dm_420_10 + || pipe_param->src.source_format == dm_rgbe_alpha + || pipe_param->src.source_format == dm_420_12; - rq_param->yuv420_10bpc = pipe_param.src.source_format == dm_420_10; + rq_param->yuv420_10bpc = pipe_param->src.source_format == dm_420_10; - rq_param->rgbe_alpha = (pipe_param.src.source_format == dm_rgbe_alpha)?1:0; + rq_param->rgbe_alpha = (pipe_param->src.source_format == dm_rgbe_alpha)?1:0; get_surf_rq_param(mode_lib, &(rq_param->sizing.rq_l), @@ -859,7 +859,7 @@ static void dml_rq_dlg_get_rq_params(struct display_mode_lib *mode_lib, 0, 0); - if (is_dual_plane((enum source_format_class)(pipe_param.src.source_format))) { + if (is_dual_plane((enum source_format_class)(pipe_param->src.source_format))) { // get param for chroma surface get_surf_rq_param(mode_lib, &(rq_param->sizing.rq_c), @@ -871,13 +871,13 @@ static void dml_rq_dlg_get_rq_params(struct display_mode_lib *mode_lib, } // calculate how to split the det buffer space between luma and chroma - handle_det_buf_split(mode_lib, rq_param, pipe_param.src); + handle_det_buf_split(mode_lib, rq_param, pipe_param->src); print__rq_params_st(mode_lib, *rq_param); } void dml30_rq_dlg_get_rq_reg(struct display_mode_lib *mode_lib, display_rq_regs_st *rq_regs, - const display_pipe_params_st pipe_param) + const display_pipe_params_st *pipe_param) { display_rq_params_st rq_param = { 0 }; @@ -1831,7 +1831,7 @@ static void dml_rq_dlg_get_dlg_params(struct display_mode_lib *mode_lib, void dml30_rq_dlg_get_dlg_reg(struct display_mode_lib *mode_lib, display_dlg_regs_st *dlg_regs, display_ttu_regs_st *ttu_regs, - display_e2e_pipe_params_st *e2e_pipe_param, + const display_e2e_pipe_params_st *e2e_pipe_param, const unsigned int num_pipes, const unsigned int pipe_idx, const bool cstate_en, @@ -1866,7 +1866,7 @@ void dml30_rq_dlg_get_dlg_reg(struct display_mode_lib *mode_lib, // system parameter calculation done dml_print("DML_DLG: Calculation for pipe[%d] start\n\n", pipe_idx); - dml_rq_dlg_get_rq_params(mode_lib, &rq_param, e2e_pipe_param[pipe_idx].pipe); + dml_rq_dlg_get_rq_params(mode_lib, &rq_param, &e2e_pipe_param[pipe_idx].pipe); dml_rq_dlg_get_dlg_params(mode_lib, e2e_pipe_param, num_pipes, diff --git a/drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.h b/drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.h index c04965cceff3..625e41f8d575 100644 --- a/drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.h +++ b/drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.h @@ -41,7 +41,7 @@ struct display_mode_lib; // See also: void dml30_rq_dlg_get_rq_reg(struct display_mode_lib *mode_lib, display_rq_regs_st *rq_regs, - const display_pipe_params_st pipe_param); + const display_pipe_params_st *pipe_param); // Function: dml_rq_dlg_get_dlg_reg // Calculate and return DLG and TTU register struct given the system setting @@ -57,7 +57,7 @@ void dml30_rq_dlg_get_rq_reg(struct display_mode_lib *mode_lib, void dml30_rq_dlg_get_dlg_reg(struct display_mode_lib *mode_lib, display_dlg_regs_st *dlg_regs, display_ttu_regs_st *ttu_regs, - display_e2e_pipe_params_st *e2e_pipe_param, + const display_e2e_pipe_params_st *e2e_pipe_param, const unsigned int num_pipes, const unsigned int pipe_idx, const bool cstate_en, diff --git a/drivers/gpu/drm/amd/display/dc/dml/display_mode_lib.h b/drivers/gpu/drm/amd/display/dc/dml/display_mode_lib.h index 6adee8a9ee56..0be31ea15f44 100644 --- a/drivers/gpu/drm/amd/display/dc/dml/display_mode_lib.h +++ b/drivers/gpu/drm/amd/display/dc/dml/display_mode_lib.h @@ -49,7 +49,7 @@ struct dml_funcs { struct display_mode_lib *mode_lib, display_dlg_regs_st *dlg_regs, display_ttu_regs_st *ttu_regs, - display_e2e_pipe_params_st *e2e_pipe_param, + const display_e2e_pipe_params_st *e2e_pipe_param, const unsigned int num_pipes, const unsigned int pipe_idx, const bool cstate_en, @@ -60,7 +60,7 @@ struct dml_funcs { void (*rq_dlg_get_rq_reg)( struct display_mode_lib *mode_lib, display_rq_regs_st *rq_regs, - const display_pipe_params_st pipe_param); + const display_pipe_params_st *pipe_param); void (*recalculate)(struct display_mode_lib *mode_lib); void (*validate)(struct display_mode_lib *mode_lib); }; From 1b3cfadf63b5d793a2480689dcf38814178c4ea6 Mon Sep 17 00:00:00 2001 From: Harry Wentland Date: Tue, 7 Sep 2021 20:22:13 -0400 Subject: [PATCH 19/68] BACKPORT: drm/amd/display: Allocate structs needed by dcn_bw_calc_rq_dlg_ttu in pipe_ctx MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit [Why & How] dcn_bw_calc_rq_dlg_ttu uses a stack frame great than 1024. To solve this we could allocate the rq_param, dlg_sys_param, and input structs dynamically. Since this function is inside a kernel_fpu_begin()/end() call we want to avoid memory allocation. Instead it's much safer to pre-allocate these on the pipe_ctx. Bug: 254441685 Signed-off-by: Harry Wentland Fixes: 3fe617ccafd6 ("Enable '-Werror' by default for all kernel builds") Cc: Nick Desaulniers Cc: Linus Torvalds Cc: amd-gfx@lists.freedesktop.org Cc: Linux Kernel Mailing List Cc: Arnd Bergmann Cc: Leo Li Cc: Alex Deucher Cc: Christian König Cc: Xinhui Pan Cc: Nathan Chancellor Cc: Guenter Roeck Cc: llvm@lists.linux.dev Acked-by: Christian König Build-tested-by: Nathan Chancellor Reviewed-by: Leo Li Signed-off-by: Alex Deucher (cherry picked from commit 1f2fcc8183e372b5d8f0e00d3e42e5d6a4a6a336) Signed-off-by: Lee Jones Change-Id: I667857207b3bdcdc8eebb87a043fc4d5bf008d4d --- .../gpu/drm/amd/display/dc/calcs/dcn_calcs.c | 51 ++++++++++--------- .../gpu/drm/amd/display/dc/inc/core_types.h | 3 ++ 2 files changed, 30 insertions(+), 24 deletions(-) diff --git a/drivers/gpu/drm/amd/display/dc/calcs/dcn_calcs.c b/drivers/gpu/drm/amd/display/dc/calcs/dcn_calcs.c index 51397b565ddf..93280dca7cd0 100644 --- a/drivers/gpu/drm/amd/display/dc/calcs/dcn_calcs.c +++ b/drivers/gpu/drm/amd/display/dc/calcs/dcn_calcs.c @@ -459,9 +459,9 @@ static void dcn_bw_calc_rq_dlg_ttu( struct _vcs_dpi_display_dlg_regs_st *dlg_regs = &pipe->dlg_regs; struct _vcs_dpi_display_ttu_regs_st *ttu_regs = &pipe->ttu_regs; struct _vcs_dpi_display_rq_regs_st *rq_regs = &pipe->rq_regs; - struct _vcs_dpi_display_rq_params_st rq_param = {0}; - struct _vcs_dpi_display_dlg_sys_params_st dlg_sys_param = {0}; - struct _vcs_dpi_display_e2e_pipe_params_st input = { { { 0 } } }; + struct _vcs_dpi_display_rq_params_st *rq_param = &pipe->dml_rq_param; + struct _vcs_dpi_display_dlg_sys_params_st *dlg_sys_param = &pipe->dml_dlg_sys_param; + struct _vcs_dpi_display_e2e_pipe_params_st *input = &pipe->dml_input; float total_active_bw = 0; float total_prefetch_bw = 0; int total_flip_bytes = 0; @@ -470,45 +470,48 @@ static void dcn_bw_calc_rq_dlg_ttu( memset(dlg_regs, 0, sizeof(*dlg_regs)); memset(ttu_regs, 0, sizeof(*ttu_regs)); memset(rq_regs, 0, sizeof(*rq_regs)); + memset(rq_param, 0, sizeof(*rq_param)); + memset(dlg_sys_param, 0, sizeof(*dlg_sys_param)); + memset(input, 0, sizeof(*input)); for (i = 0; i < number_of_planes; i++) { total_active_bw += v->read_bandwidth[i]; total_prefetch_bw += v->prefetch_bandwidth[i]; total_flip_bytes += v->total_immediate_flip_bytes[i]; } - dlg_sys_param.total_flip_bw = v->return_bw - dcn_bw_max2(total_active_bw, total_prefetch_bw); - if (dlg_sys_param.total_flip_bw < 0.0) - dlg_sys_param.total_flip_bw = 0; + dlg_sys_param->total_flip_bw = v->return_bw - dcn_bw_max2(total_active_bw, total_prefetch_bw); + if (dlg_sys_param->total_flip_bw < 0.0) + dlg_sys_param->total_flip_bw = 0; - dlg_sys_param.t_mclk_wm_us = v->dram_clock_change_watermark; - dlg_sys_param.t_sr_wm_us = v->stutter_enter_plus_exit_watermark; - dlg_sys_param.t_urg_wm_us = v->urgent_watermark; - dlg_sys_param.t_extra_us = v->urgent_extra_latency; - dlg_sys_param.deepsleep_dcfclk_mhz = v->dcf_clk_deep_sleep; - dlg_sys_param.total_flip_bytes = total_flip_bytes; + dlg_sys_param->t_mclk_wm_us = v->dram_clock_change_watermark; + dlg_sys_param->t_sr_wm_us = v->stutter_enter_plus_exit_watermark; + dlg_sys_param->t_urg_wm_us = v->urgent_watermark; + dlg_sys_param->t_extra_us = v->urgent_extra_latency; + dlg_sys_param->deepsleep_dcfclk_mhz = v->dcf_clk_deep_sleep; + dlg_sys_param->total_flip_bytes = total_flip_bytes; - pipe_ctx_to_e2e_pipe_params(pipe, &input.pipe); - input.clks_cfg.dcfclk_mhz = v->dcfclk; - input.clks_cfg.dispclk_mhz = v->dispclk; - input.clks_cfg.dppclk_mhz = v->dppclk; - input.clks_cfg.refclk_mhz = dc->res_pool->ref_clocks.dchub_ref_clock_inKhz / 1000.0; - input.clks_cfg.socclk_mhz = v->socclk; - input.clks_cfg.voltage = v->voltage_level; + pipe_ctx_to_e2e_pipe_params(pipe, &input->pipe); + input->clks_cfg.dcfclk_mhz = v->dcfclk; + input->clks_cfg.dispclk_mhz = v->dispclk; + input->clks_cfg.dppclk_mhz = v->dppclk; + input->clks_cfg.refclk_mhz = dc->res_pool->ref_clocks.dchub_ref_clock_inKhz / 1000.0; + input->clks_cfg.socclk_mhz = v->socclk; + input->clks_cfg.voltage = v->voltage_level; // dc->dml.logger = pool->base.logger; - input.dout.output_format = (v->output_format[in_idx] == dcn_bw_420) ? dm_420 : dm_444; - input.dout.output_type = (v->output[in_idx] == dcn_bw_hdmi) ? dm_hdmi : dm_dp; + input->dout.output_format = (v->output_format[in_idx] == dcn_bw_420) ? dm_420 : dm_444; + input->dout.output_type = (v->output[in_idx] == dcn_bw_hdmi) ? dm_hdmi : dm_dp; //input[in_idx].dout.output_standard; /*todo: soc->sr_enter_plus_exit_time??*/ - dlg_sys_param.t_srx_delay_us = dc->dcn_ip->dcfclk_cstate_latency / v->dcf_clk_deep_sleep; + dlg_sys_param->t_srx_delay_us = dc->dcn_ip->dcfclk_cstate_latency / v->dcf_clk_deep_sleep; - dml1_rq_dlg_get_rq_params(dml, &rq_param, input.pipe.src); + dml1_rq_dlg_get_rq_params(dml, rq_param, input.pipe.src); dml1_extract_rq_regs(dml, rq_regs, rq_param); dml1_rq_dlg_get_dlg_params( dml, dlg_regs, ttu_regs, - rq_param.dlg, + rq_param->dlg, dlg_sys_param, input, true, diff --git a/drivers/gpu/drm/amd/display/dc/inc/core_types.h b/drivers/gpu/drm/amd/display/dc/inc/core_types.h index 6e6bc66e49f0..e40a1d5d5528 100644 --- a/drivers/gpu/drm/amd/display/dc/inc/core_types.h +++ b/drivers/gpu/drm/amd/display/dc/inc/core_types.h @@ -328,6 +328,9 @@ struct pipe_ctx { struct _vcs_dpi_display_ttu_regs_st ttu_regs; struct _vcs_dpi_display_rq_regs_st rq_regs; struct _vcs_dpi_display_pipe_dest_params_st pipe_dlg_param; + struct _vcs_dpi_display_rq_params_st dml_rq_param; + struct _vcs_dpi_display_dlg_sys_params_st dml_dlg_sys_param; + struct _vcs_dpi_display_e2e_pipe_params_st dml_input; #endif union pipe_update_flags update_flags; struct dwbc *dwbc; From 3815eca894ad79cc6faadb4bb17757d1ae8d78cd Mon Sep 17 00:00:00 2001 From: Lv Ruyi Date: Sat, 9 Oct 2021 08:59:00 +0000 Subject: [PATCH 20/68] UPSTREAM: firmware: tegra: Fix error application of sizeof() to pointer Application of sizeof() to pointer yields the number of bytes of the pointer, but it should use the length of buffer in the code. Bug: 254441685 Fixes: 06c2d9a078ab ("firmware: tegra: Reduce stack usage") Reported-by: Zeal Robot Signed-off-by: Lv Ruyi Reviewed-by: Jon Hunter Tested-by: Jon Hunter Signed-off-by: Thierry Reding (cherry picked from commit 711e26c00e4c7b7cef0420c76a61e6d818e12687) Signed-off-by: Lee Jones Change-Id: Ide1f9cbc31fea6fbb1d74f7ad4bbb6bef7caa0a9 --- drivers/firmware/tegra/bpmp-debugfs.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/drivers/firmware/tegra/bpmp-debugfs.c b/drivers/firmware/tegra/bpmp-debugfs.c index 286fe1257961..fbc0d661060b 100644 --- a/drivers/firmware/tegra/bpmp-debugfs.c +++ b/drivers/firmware/tegra/bpmp-debugfs.c @@ -77,13 +77,14 @@ static const char *get_filename(struct tegra_bpmp *bpmp, const char *root_path, *filename = NULL; char *root_path_buf; size_t root_len; + size_t root_path_buf_len = 512; - root_path_buf = kzalloc(512, GFP_KERNEL); + root_path_buf = kzalloc(root_path_buf_len, GFP_KERNEL); if (!root_path_buf) goto out; root_path = dentry_path(bpmp->debugfs_mirror, root_path_buf, - sizeof(root_path_buf)); + root_path_buf_len); if (IS_ERR(root_path)) goto out; From 37b3a6153f703925678d4ca6e59c72f440ade088 Mon Sep 17 00:00:00 2001 From: Michael Ellerman Date: Fri, 27 May 2022 21:15:41 +1000 Subject: [PATCH 21/68] UPSTREAM: powerpc/64: Include cache.h directly in paca.h paca.h uses ____cacheline_aligned without directly including cache.h, where it's defined. For Book3S builds that's OK because paca.h includes lppaca.h, and it does include cache.h. But Book3E builds have been getting cache.h indirectly via printk.h, which is dicey, and in fact that include was recently removed, leading to build errors such as: ld: fs/isofs/dir.o:(.bss+0x0): multiple definition of `____cacheline_aligned'; fs/isofs/namei.o:(.bss+0x0): first defined here So include cache.h directly to fix the build error. Bug: 254441685 Fixes: 534aa1dc975a ("printk: stop including cache.h from printk.h") Reported-by: Guenter Roeck Signed-off-by: Michael Ellerman (cherry picked from commit dcf280e6f80be280ca7dd1b058f038654e4a18dd) Signed-off-by: Lee Jones Change-Id: Id94536f14e3705b90bf12f6c61f59b96de3c994a --- arch/powerpc/include/asm/paca.h | 1 + 1 file changed, 1 insertion(+) diff --git a/arch/powerpc/include/asm/paca.h b/arch/powerpc/include/asm/paca.h index 9454d29ff4b4..bf8da58c393e 100644 --- a/arch/powerpc/include/asm/paca.h +++ b/arch/powerpc/include/asm/paca.h @@ -12,6 +12,7 @@ #ifdef CONFIG_PPC64 +#include #include #include #include From f74be4424642f5ff8bd34d5711f030c45710c348 Mon Sep 17 00:00:00 2001 From: Thinh Nguyen Date: Tue, 18 Oct 2022 19:39:01 -0700 Subject: [PATCH 22/68] UPSTREAM: usb: dwc3: gadget: Don't delay End Transfer on delayed_status The gadget driver may wait on the request completion when it sets the USB_GADGET_DELAYED_STATUS. Make sure that the End Transfer command can go through if the dwc->delayed_status is set so that the request can complete. When the delayed_status is set, the Setup packet is already processed, and the next phase should be either Data or Status. It's unlikely that the host would cancel the control transfer and send a new Setup packet during End Transfer command. But if that's the case, we can try again when ep0state returns to EP0_SETUP_PHASE. Bug: 254441685 Fixes: e1ee843488d5 ("usb: dwc3: gadget: Force sending delayed status during soft disconnect") Cc: stable@vger.kernel.org Signed-off-by: Thinh Nguyen Link: https://lore.kernel.org/r/3f9f59e5d74efcbaee444cf4b30ef639cc7b124e.1666146954.git.Thinh.Nguyen@synopsys.com Signed-off-by: Greg Kroah-Hartman (cherry picked from commit 4db0fbb601361767144e712beb96704b966339f5) Signed-off-by: Lee Jones Change-Id: I308536a4d5482c838a1b75c84a1e1127e43f3b95 --- drivers/usb/dwc3/gadget.c | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/drivers/usb/dwc3/gadget.c b/drivers/usb/dwc3/gadget.c index 0ed907e7aaef..091ec8002efa 100644 --- a/drivers/usb/dwc3/gadget.c +++ b/drivers/usb/dwc3/gadget.c @@ -1683,6 +1683,16 @@ static int __dwc3_stop_active_transfer(struct dwc3_ep *dep, bool force, bool int cmd |= DWC3_DEPCMD_PARAM(dep->resource_index); memset(¶ms, 0, sizeof(params)); ret = dwc3_send_gadget_ep_cmd(dep, cmd, ¶ms); + /* + * If the End Transfer command was timed out while the device is + * not in SETUP phase, it's possible that an incoming Setup packet + * may prevent the command's completion. Let's retry when the + * ep0state returns to EP0_SETUP_PHASE. + */ + if (ret == -ETIMEDOUT && dep->dwc->ep0state != EP0_SETUP_PHASE) { + dep->flags |= DWC3_EP_DELAY_STOP; + return 0; + } WARN_ON_ONCE(ret); dep->resource_index = 0; @@ -3710,7 +3720,7 @@ void dwc3_stop_active_transfer(struct dwc3_ep *dep, bool force, * timeout. Delay issuing the End Transfer command until the Setup TRB is * prepared. */ - if (dwc->ep0state != EP0_SETUP_PHASE) { + if (dwc->ep0state != EP0_SETUP_PHASE && !dwc->delayed_status) { dep->flags |= DWC3_EP_DELAY_STOP; return; } From 8eb30a41f5017f084a530c7ace5e8bdbf90c1e9e Mon Sep 17 00:00:00 2001 From: Peter Xu Date: Wed, 2 Nov 2022 14:41:52 -0400 Subject: [PATCH 23/68] UPSTREAM: mm/shmem: use page_mapping() to detect page cache for uffd continue mfill_atomic_install_pte() checks page->mapping to detect whether one page is used in the page cache. However as pointed out by Matthew, the page can logically be a tail page rather than always the head in the case of uffd minor mode with UFFDIO_CONTINUE. It means we could wrongly install one pte with shmem thp tail page assuming it's an anonymous page. It's not that clear even for anonymous page, since normally anonymous pages also have page->mapping being setup with the anon vma. It's safe here only because the only such caller to mfill_atomic_install_pte() is always passing in a newly allocated page (mcopy_atomic_pte()), whose page->mapping is not yet setup. However that's not extremely obvious either. For either of above, use page_mapping() instead. Bug: 254441685 Link: https://lkml.kernel.org/r/Y2K+y7wnhC4vbnP2@x1n Fixes: 153132571f02 ("userfaultfd/shmem: support UFFDIO_CONTINUE for shmem") Signed-off-by: Peter Xu Reported-by: Matthew Wilcox Cc: Andrea Arcangeli Cc: Hugh Dickins Cc: Axel Rasmussen Cc: Signed-off-by: Andrew Morton (cherry picked from commit 93b0d9178743a68723babe8448981f658aebc58e) Signed-off-by: Lee Jones Change-Id: I5635ee1a81087e8022169ad1bda1e6d98fe5835f --- mm/userfaultfd.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mm/userfaultfd.c b/mm/userfaultfd.c index 80da102e4c36..fa707e50b102 100644 --- a/mm/userfaultfd.c +++ b/mm/userfaultfd.c @@ -63,7 +63,7 @@ int mfill_atomic_install_pte(struct mm_struct *dst_mm, pmd_t *dst_pmd, pte_t _dst_pte, *dst_pte; bool writable = dst_vma->vm_flags & VM_WRITE; bool vm_shared = dst_vma->vm_flags & VM_SHARED; - bool page_in_cache = page->mapping; + bool page_in_cache = page_mapping(page); spinlock_t *ptl; struct inode *inode; pgoff_t offset, max_off; From d11c3f780c87198ac9d94f954e66d651677b532a Mon Sep 17 00:00:00 2001 From: SeongJae Park Date: Mon, 7 Nov 2022 16:50:00 +0000 Subject: [PATCH 24/68] UPSTREAM: mm/damon/dbgfs: check if rm_contexts input is for a real context A user could write a name of a file under 'damon/' debugfs directory, which is not a user-created context, to 'rm_contexts' file. In the case, 'dbgfs_rm_context()' just assumes it's the valid DAMON context directory only if a file of the name exist. As a result, invalid memory access could happen as below. Fix the bug by checking if the given input is for a directory. This check can filter out non-context inputs because directories under 'damon/' debugfs directory can be created via only 'mk_contexts' file. This bug has found by syzbot[1]. [1] https://lore.kernel.org/damon/000000000000ede3ac05ec4abf8e@google.com/ Bug: 254441685 Link: https://lkml.kernel.org/r/20221107165001.5717-2-sj@kernel.org Fixes: 75c1c2b53c78 ("mm/damon/dbgfs: support multiple contexts") Signed-off-by: SeongJae Park Reported-by: syzbot+6087eafb76a94c4ac9eb@syzkaller.appspotmail.com Cc: [5.15.x] Signed-off-by: Andrew Morton (cherry picked from commit 1de09a7281edecfdba19b3a07417f6d65243ab5f) Signed-off-by: Lee Jones Change-Id: I038612db15c0a46089a5e1a52a4750fff6ba3bf6 --- mm/damon/dbgfs.c | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/mm/damon/dbgfs.c b/mm/damon/dbgfs.c index f2772fc740c0..819c337c22ff 100644 --- a/mm/damon/dbgfs.c +++ b/mm/damon/dbgfs.c @@ -785,6 +785,7 @@ out: static int dbgfs_rm_context(char *name) { struct dentry *root, *dir, **new_dirs; + struct inode *inode; struct damon_ctx **new_ctxs; int i, j; int ret = 0; @@ -800,6 +801,12 @@ static int dbgfs_rm_context(char *name) if (!dir) return -ENOENT; + inode = d_inode(dir); + if (!S_ISDIR(inode->i_mode)) { + ret = -EINVAL; + goto out_dput; + } + new_dirs = kmalloc_array(dbgfs_nr_ctxs - 1, sizeof(*dbgfs_dirs), GFP_KERNEL); if (!new_dirs) { From 8adfaec1546ce4bf3444584fdf7e96f52e71044a Mon Sep 17 00:00:00 2001 From: Mark Rutland Date: Mon, 14 Nov 2022 10:44:11 +0000 Subject: [PATCH 25/68] BACKPORT: arm64: mm: kfence: only handle translation faults Alexander noted that KFENCE only expects to handle faults from invalid page table entries (i.e. translation faults), but arm64's fault handling logic will call kfence_handle_page_fault() for other types of faults, including alignment faults caused by unaligned atomics. This has the unfortunate property of causing those other faults to be reported as "KFENCE: use-after-free", which is misleading and hinders debugging. Fix this by only forwarding unhandled translation faults to the KFENCE code, similar to what x86 does already. Alexander has verified that this passes all the tests in the KFENCE test suite and avoids bogus reports on misaligned atomics. Bug: 254441685 Link: https://lore.kernel.org/all/20221102081620.1465154-1-zhongbaisong@huawei.com/ Fixes: 840b23986344 ("arm64, kfence: enable KFENCE for ARM64") Signed-off-by: Mark Rutland Reviewed-by: Alexander Potapenko Tested-by: Alexander Potapenko Cc: Catalin Marinas Cc: Marco Elver Cc: Will Deacon Link: https://lore.kernel.org/r/20221114104411.2853040-1-mark.rutland@arm.com Signed-off-by: Will Deacon (cherry picked from commit 0bb1fbffc631064db567ccaeb9ed6b6df6342b66) Signed-off-by: Lee Jones Change-Id: I317bb3ca1db362f3a3befa2e97c76d71f1edc770 --- arch/arm64/mm/fault.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/arch/arm64/mm/fault.c b/arch/arm64/mm/fault.c index fa59cfb4696b..6c962463064b 100644 --- a/arch/arm64/mm/fault.c +++ b/arch/arm64/mm/fault.c @@ -361,6 +361,11 @@ static bool is_el1_mte_sync_tag_check_fault(unsigned int esr) return false; } +static bool is_translation_fault(unsigned long esr) +{ + return (esr & ESR_ELx_FSC_TYPE) == ESR_ELx_FSC_FAULT; +} + static void __do_kernel_fault(unsigned long addr, unsigned int esr, struct pt_regs *regs) { @@ -393,7 +398,8 @@ static void __do_kernel_fault(unsigned long addr, unsigned int esr, } else if (addr < PAGE_SIZE) { msg = "NULL pointer dereference"; } else { - if (kfence_handle_page_fault(addr, esr & ESR_ELx_WNR, regs)) + if (is_translation_fault(esr) && + kfence_handle_page_fault(addr, esr & ESR_ELx_WNR, regs)) return; msg = "paging request"; From 9a595405c4ab45f276bb82531745ee6d5317a946 Mon Sep 17 00:00:00 2001 From: Charan Teja Kalla Date: Tue, 8 Nov 2022 10:46:22 +0530 Subject: [PATCH 26/68] UPSTREAM: mm/page_exit: fix kernel doc warning in page_ext_put() Fix the below compiler warnings reported with 'make W=1 mm/'. mm/page_ext.c:178: warning: Function parameter or member 'page_ext' not described in 'page_ext_put'. Bug: 254441685 [quic_pkondeti@quicinc.com: better patch title] Link: https://lkml.kernel.org/r/1667884582-2465-1-git-send-email-quic_charante@quicinc.com Fixes: b1d5488a252dc9 ("mm: fix use-after free of page_ext after race with memory-offline") Signed-off-by: Charan Teja Kalla Reported-by: Vlastimil Babka Tested-by: Vlastimil Babka Cc: Pavan Kondeti Signed-off-by: Andrew Morton (cherry picked from commit ed86b74874f839f0e579bdf92ea0a5aabdfabebb) Signed-off-by: Lee Jones Change-Id: Ia1facd5591e04a41d03f9c9a65ea2ef506db2b3f --- mm/page_ext.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mm/page_ext.c b/mm/page_ext.c index e5b56394e2b4..fca6a09cdcfe 100644 --- a/mm/page_ext.c +++ b/mm/page_ext.c @@ -148,7 +148,7 @@ struct page_ext *page_ext_get(struct page *page) /** * page_ext_put() - Working with page extended information is done. - * @page_ext - Page extended information received from page_ext_get(). + * @page_ext: Page extended information received from page_ext_get(). * * The page extended information of the page may not be valid after this * function is called. From 73c8565a9eb474481b15a7b2ab4dbf955f8a4c6e Mon Sep 17 00:00:00 2001 From: Damien Le Moal Date: Thu, 24 Nov 2022 11:12:07 +0900 Subject: [PATCH 27/68] UPSTREAM: block: mq-deadline: Fix dd_finish_request() for zoned devices dd_finish_request() tests if the per prio fifo_list is not empty to determine if request dispatching must be restarted for handling blocked write requests to zoned devices with a call to blk_mq_sched_mark_restart_hctx(). While simple, this implementation has 2 problems: 1) Only the priority level of the completed request is considered. However, writes to a zone may be blocked due to other writes to the same zone using a different priority level. While this is unlikely to happen in practice, as writing a zone with different IO priorirites does not make sense, nothing in the code prevents this from happening. 2) The use of list_empty() is dangerous as dd_finish_request() does not take dd->lock and may run concurrently with the insert and dispatch code. Fix these 2 problems by testing the write fifo list of all priority levels using the new helper dd_has_write_work(), and by testing each fifo list using list_empty_careful(). Bug: 254441685 Fixes: c807ab520fc3 ("block/mq-deadline: Add I/O priority support") Cc: Signed-off-by: Damien Le Moal Reviewed-by: Johannes Thumshirn Link: https://lore.kernel.org/r/20221124021208.242541-2-damien.lemoal@opensource.wdc.com Signed-off-by: Jens Axboe (cherry picked from commit 2820e5d0820ac4daedff1272616a53d9c7682fd2) Signed-off-by: Lee Jones Change-Id: I0b56fae549938312d0c8fda1bc193e3a47e4fff4 --- block/mq-deadline-main.c | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-) diff --git a/block/mq-deadline-main.c b/block/mq-deadline-main.c index cdcf72e72d98..560752ad8677 100644 --- a/block/mq-deadline-main.c +++ b/block/mq-deadline-main.c @@ -793,6 +793,18 @@ static void dd_prepare_request(struct request *rq) rq->elv.priv[0] = NULL; } +static bool dd_has_write_work(struct blk_mq_hw_ctx *hctx) +{ + struct deadline_data *dd = hctx->queue->elevator->elevator_data; + enum dd_prio p; + + for (p = 0; p <= DD_PRIO_MAX; p++) + if (!list_empty_careful(&dd->per_prio[p].fifo_list[DD_WRITE])) + return true; + + return false; +} + /* * Callback from inside blk_mq_free_request(). * @@ -816,7 +828,6 @@ static void dd_finish_request(struct request *rq) struct dd_blkcg *blkcg = rq->elv.priv[0]; const u8 ioprio_class = dd_rq_ioclass(rq); const enum dd_prio prio = ioprio_class_to_prio[ioprio_class]; - struct dd_per_prio *per_prio = &dd->per_prio[prio]; dd_count(dd, completed, prio); ddcg_count(blkcg, completed, ioprio_class); @@ -826,9 +837,10 @@ static void dd_finish_request(struct request *rq) spin_lock_irqsave(&dd->zone_lock, flags); blk_req_zone_write_unlock(rq); - if (!list_empty(&per_prio->fifo_list[DD_WRITE])) - blk_mq_sched_mark_restart_hctx(rq->mq_hctx); spin_unlock_irqrestore(&dd->zone_lock, flags); + + if (dd_has_write_work(rq->mq_hctx)) + blk_mq_sched_mark_restart_hctx(rq->mq_hctx); } } From 2f9858326dea00b90551eff8d1822cf218007ab9 Mon Sep 17 00:00:00 2001 From: Yang Shen Date: Tue, 22 Nov 2022 17:03:55 +0800 Subject: [PATCH 28/68] UPSTREAM: coresight: trbe: remove cpuhp instance node before remove cpuhp state cpuhp_state_add_instance() and cpuhp_state_remove_instance() should be used in pairs. Or there will lead to the warn on cpuhp_remove_multi_state() since the cpuhp_step list is not empty. The following is the error log with 'rmmod coresight-trbe': Error: Removing state 215 which has instances left. Call trace: __cpuhp_remove_state_cpuslocked+0x144/0x160 __cpuhp_remove_state+0xac/0x100 arm_trbe_device_remove+0x2c/0x60 [coresight_trbe] platform_remove+0x34/0x70 device_remove+0x54/0x90 device_release_driver_internal+0x1e4/0x250 driver_detach+0x5c/0xb0 bus_remove_driver+0x64/0xc0 driver_unregister+0x3c/0x70 platform_driver_unregister+0x20/0x30 arm_trbe_exit+0x1c/0x658 [coresight_trbe] __arm64_sys_delete_module+0x1ac/0x24c invoke_syscall+0x50/0x120 el0_svc_common.constprop.0+0x58/0x1a0 do_el0_svc+0x38/0xd0 el0_svc+0x2c/0xc0 el0t_64_sync_handler+0x1ac/0x1b0 el0t_64_sync+0x19c/0x1a0 ---[ end trace 0000000000000000 ]--- Bug: 254441685 Fixes: 3fbf7f011f24 ("coresight: sink: Add TRBE driver") Reviewed-by: Anshuman Khandual Signed-off-by: Yang Shen Signed-off-by: Suzuki K Poulose Link: https://lore.kernel.org/r/20221122090355.23533-1-shenyang39@huawei.com (cherry picked from commit 20ee8c223f792947378196307d8e707c9cdc2d61) Signed-off-by: Lee Jones Change-Id: Ie0a1bece2f5a1c54291c11cef3afb23aedcd0750 --- drivers/hwtracing/coresight/coresight-trbe.c | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/hwtracing/coresight/coresight-trbe.c b/drivers/hwtracing/coresight/coresight-trbe.c index 7dddb85b9059..fac63d092c7b 100644 --- a/drivers/hwtracing/coresight/coresight-trbe.c +++ b/drivers/hwtracing/coresight/coresight-trbe.c @@ -1030,6 +1030,7 @@ static int arm_trbe_probe_cpuhp(struct trbe_drvdata *drvdata) static void arm_trbe_remove_cpuhp(struct trbe_drvdata *drvdata) { + cpuhp_state_remove_instance(drvdata->trbe_online, &drvdata->hotplug_node); cpuhp_remove_multi_state(drvdata->trbe_online); } From 391c34feedcff11a5639a636ebbd72226d9cf407 Mon Sep 17 00:00:00 2001 From: Sean Christopherson Date: Wed, 30 Nov 2022 23:09:01 +0000 Subject: [PATCH 29/68] UPSTREAM: KVM: arm64: Free hypervisor allocations if vector slot init fails Teardown hypervisor mode if vector slot setup fails in order to avoid leaking any allocations done by init_hyp_mode(). Bug: 254441685 Fixes: b881cdce77b4 ("KVM: arm64: Allocate hyp vectors statically") Signed-off-by: Sean Christopherson Message-Id: <20221130230934.1014142-18-seanjc@google.com> Signed-off-by: Paolo Bonzini (cherry picked from commit 6baaeda878445dc7b9e86f614ac39bf137c385af) Signed-off-by: Lee Jones Change-Id: Id20a219325d0ae7882b7e910f460fc8b5c05f839 --- arch/arm64/kvm/arm.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/arch/arm64/kvm/arm.c b/arch/arm64/kvm/arm.c index 67c20d4d6ade..0470ebad9bdb 100644 --- a/arch/arm64/kvm/arm.c +++ b/arch/arm64/kvm/arm.c @@ -2098,18 +2098,18 @@ int kvm_arch_init(void *opaque) err = kvm_init_vector_slots(); if (err) { kvm_err("Cannot initialise vector slots\n"); - goto out_err; + goto out_hyp; } err = init_subsystems(); if (err) - goto out_hyp; + goto out_subs; if (!in_hyp_mode) { err = finalize_hyp_mode(); if (err) { kvm_err("Failed to finalize Hyp protection\n"); - goto out_hyp; + goto out_subs; } } @@ -2123,8 +2123,9 @@ int kvm_arch_init(void *opaque) return 0; -out_hyp: +out_subs: hyp_cpu_pm_exit(); +out_hyp: if (!in_hyp_mode) teardown_hyp_mode(); out_err: From 43390f1621406d56277757a6602cd148b9a5024f Mon Sep 17 00:00:00 2001 From: James Houghton Date: Wed, 4 Jan 2023 23:19:10 +0000 Subject: [PATCH 30/68] BACKPORT: hugetlb: unshare some PMDs when splitting VMAs PMD sharing can only be done in PUD_SIZE-aligned pieces of VMAs; however, it is possible that HugeTLB VMAs are split without unsharing the PMDs first. Without this fix, it is possible to hit the uffd-wp-related WARN_ON_ONCE in hugetlb_change_protection [1]. The key there is that hugetlb_unshare_all_pmds will not attempt to unshare PMDs in non-PUD_SIZE-aligned sections of the VMA. It might seem ideal to unshare in hugetlb_vm_op_open, but we need to unshare in both the new and old VMAs, so unsharing in hugetlb_vm_op_split seems natural. [1]: https://lore.kernel.org/linux-mm/CADrL8HVeOkj0QH5VZZbRzybNE8CG-tEGFshnA+bG9nMgcWtBSg@mail.gmail.com/ Bug: 254441685 Link: https://lkml.kernel.org/r/20230104231910.1464197-1-jthoughton@google.com Fixes: 6dfeaff93be1 ("hugetlb/userfaultfd: unshare all pmds for hugetlbfs when register wp") Signed-off-by: James Houghton Reviewed-by: Mike Kravetz Acked-by: Peter Xu Cc: Axel Rasmussen Cc: Muchun Song Cc: Signed-off-by: Andrew Morton (cherry picked from commit b30c14cd61025eeea2f2e8569606cd167ba9ad2d) Signed-off-by: Lee Jones Change-Id: Ic7b61e7fd00369f17d26164c187a148d09ffd9ae --- mm/hugetlb.c | 45 ++++++++++++++++++++++++++++++++++++--------- 1 file changed, 36 insertions(+), 9 deletions(-) diff --git a/mm/hugetlb.c b/mm/hugetlb.c index 7be2c9241cee..a4682bbdf352 100644 --- a/mm/hugetlb.c +++ b/mm/hugetlb.c @@ -78,6 +78,9 @@ DEFINE_SPINLOCK(hugetlb_lock); static int num_fault_mutexes; struct mutex *hugetlb_fault_mutex_table ____cacheline_aligned_in_smp; +static void hugetlb_unshare_pmds(struct vm_area_struct *vma, + unsigned long start, unsigned long end); + static inline bool PageHugeFreed(struct page *head) { return page_private(head + 4) == -1UL; @@ -3698,6 +3701,25 @@ static int hugetlb_vm_op_split(struct vm_area_struct *vma, unsigned long addr) { if (addr & ~(huge_page_mask(hstate_vma(vma)))) return -EINVAL; + + /* + * PMD sharing is only possible for PUD_SIZE-aligned address ranges + * in HugeTLB VMAs. If we will lose PUD_SIZE alignment due to this + * split, unshare PMDs in the PUD_SIZE interval surrounding addr now. + */ + if (addr & ~PUD_MASK) { + /* + * hugetlb_vm_op_split is called right before we attempt to + * split the VMA. We will need to unshare PMDs in the old and + * new VMAs, so let's unshare before we split. + */ + unsigned long floor = addr & PUD_MASK; + unsigned long ceil = floor + PUD_SIZE; + + if (floor >= vma->vm_start && ceil <= vma->vm_end) + hugetlb_unshare_pmds(vma, floor, ceil); + } + return 0; } @@ -5756,26 +5778,21 @@ void move_hugetlb_state(struct page *oldpage, struct page *newpage, int reason) } } -/* - * This function will unconditionally remove all the shared pmd pgtable entries - * within the specific vma for a hugetlbfs memory range. - */ -void hugetlb_unshare_all_pmds(struct vm_area_struct *vma) +static void hugetlb_unshare_pmds(struct vm_area_struct *vma, + unsigned long start, + unsigned long end) { struct hstate *h = hstate_vma(vma); unsigned long sz = huge_page_size(h); struct mm_struct *mm = vma->vm_mm; struct mmu_notifier_range range; - unsigned long address, start, end; + unsigned long address; spinlock_t *ptl; pte_t *ptep; if (!(vma->vm_flags & VM_MAYSHARE)) return; - start = ALIGN(vma->vm_start, PUD_SIZE); - end = ALIGN_DOWN(vma->vm_end, PUD_SIZE); - if (start >= end) return; @@ -5808,6 +5825,16 @@ void hugetlb_unshare_all_pmds(struct vm_area_struct *vma) mmu_notifier_invalidate_range_end(&range); } +/* + * This function will unconditionally remove all the shared pmd pgtable entries + * within the specific vma for a hugetlbfs memory range. + */ +void hugetlb_unshare_all_pmds(struct vm_area_struct *vma) +{ + hugetlb_unshare_pmds(vma, ALIGN(vma->vm_start, PUD_SIZE), + ALIGN_DOWN(vma->vm_end, PUD_SIZE)); +} + #ifdef CONFIG_CMA static bool cma_reserve_called __initdata; From 1b307b685cca4f0fc72b69b5f86f4fbdf532780b Mon Sep 17 00:00:00 2001 From: Pratham Pratap Date: Wed, 25 Jan 2023 12:57:25 +0530 Subject: [PATCH 31/68] UPSTREAM: usb: gadget: f_uac2: Fix incorrect increment of bNumEndpoints Currently connect/disconnect of USB cable calls afunc_bind and eventually increments the bNumEndpoints. Performing multiple plugin/plugout will increment bNumEndpoints incorrectly, and on the next plug-in it leads to invalid configuration of descriptor and hence enumeration fails. Fix this by resetting the value of bNumEndpoints to 1 on every afunc_bind call. Bug: 254441685 Fixes: 40c73b30546e ("usb: gadget: f_uac2: add adaptive sync support for capture") Cc: stable Signed-off-by: Pratham Pratap Signed-off-by: Prashanth K Link: https://lore.kernel.org/r/1674631645-28888-1-git-send-email-quic_prashk@quicinc.com Signed-off-by: Greg Kroah-Hartman (cherry picked from commit 2fa89458af9993fab8054daf827f38881e2ad473) Signed-off-by: Lee Jones Change-Id: Ibbc0b098b7fc4d2d8e07dc4aa9be2917dc57bd64 --- drivers/usb/gadget/function/f_uac2.c | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/usb/gadget/function/f_uac2.c b/drivers/usb/gadget/function/f_uac2.c index 91affe8babb8..3f4edfa73250 100644 --- a/drivers/usb/gadget/function/f_uac2.c +++ b/drivers/usb/gadget/function/f_uac2.c @@ -1097,6 +1097,7 @@ afunc_bind(struct usb_configuration *cfg, struct usb_function *fn) } std_as_out_if0_desc.bInterfaceNumber = ret; std_as_out_if1_desc.bInterfaceNumber = ret; + std_as_out_if1_desc.bNumEndpoints = 1; uac2->as_out_intf = ret; uac2->as_out_alt = 0; From 6f485880624b7f1c919780ad992c09ab0c5d64c3 Mon Sep 17 00:00:00 2001 From: Sandeep Dhavale Date: Wed, 8 Feb 2023 17:33:22 +0800 Subject: [PATCH 32/68] BACKPORT: erofs: add per-cpu threads for decompression as an option Using per-cpu thread pool we can reduce the scheduling latency compared to workqueue implementation. With this patch scheduling latency and variation is reduced as per-cpu threads are high priority kthread_workers. The results were evaluated on arm64 Android devices running 5.10 kernel. The table below shows resulting improvements of total scheduling latency for the same app launch benchmark runs with 50 iterations. Scheduling latency is the latency between when the task (workqueue kworker vs kthread_worker) became eligible to run to when it actually started running. +-------------------------+-----------+----------------+---------+ | | workqueue | kthread_worker | diff | +-------------------------+-----------+----------------+---------+ | Average (us) | 15253 | 2914 | -80.89% | | Median (us) | 14001 | 2912 | -79.20% | | Minimum (us) | 3117 | 1027 | -67.05% | | Maximum (us) | 30170 | 3805 | -87.39% | | Standard deviation (us) | 7166 | 359 | | +-------------------------+-----------+----------------+---------+ Background: Boot times and cold app launch benchmarks are very important to the Android ecosystem as they directly translate to responsiveness from user point of view. While EROFS provides a lot of important features like space savings, we saw some performance penalty in cold app launch benchmarks in few scenarios. Analysis showed that the significant variance was coming from the scheduling cost while decompression cost was more or less the same. Having per-cpu thread pool we can see from the above table that this variation is reduced by ~80% on average. This problem was discussed at LPC 2022. Link to LPC 2022 slides and talk at [1] [1] https://lpc.events/event/16/contributions/1338/ [ Gao Xiang: At least, we have to add this until WQ_UNBOUND workqueue issue [2] on many arm64 devices is resolved. ] [2] https://lore.kernel.org/r/CAJkfWY490-m6wNubkxiTPsW59sfsQs37Wey279LmiRxKt7aQYg@mail.gmail.com Bug: 271636421 Bug: 278520205 Test: launch_cvd Change-Id: I9dce2bfd6f40ec6a210161b80cee7c0417b4edb3 Signed-off-by: Sandeep Dhavale Signed-off-by: Gao Xiang Link: https://lore.kernel.org/r/20230208093322.75816-1-hsiangkao@linux.alibaba.com (cherry picked from commit 3fffb589b9a6e331e39cb75373ee7691acd7b109) [dhavale: Fixed minor conflict as upstream now has zdata.h folded in zdata.c] Signed-off-by: Sandeep Dhavale (cherry picked from commit 566a7f6c6b3f5f13b766fe749bbdb45918b029ac) [dhavale: Fixed minor conflicts in Kconfig and zdata.c] (cherry picked from commit 2de95f5d183c2174c9380a902919c8e59e380293) --- fs/erofs/Kconfig | 17 +++++ fs/erofs/zdata.c | 185 ++++++++++++++++++++++++++++++++++++++++++----- fs/erofs/zdata.h | 2 + 3 files changed, 186 insertions(+), 18 deletions(-) diff --git a/fs/erofs/Kconfig b/fs/erofs/Kconfig index 858b3339f381..662660852397 100644 --- a/fs/erofs/Kconfig +++ b/fs/erofs/Kconfig @@ -76,3 +76,20 @@ config EROFS_FS_ZIP If you don't want to enable compression feature, say N. +config EROFS_FS_PCPU_KTHREAD + bool "EROFS per-cpu decompression kthread workers" + depends on EROFS_FS_ZIP + help + Saying Y here enables per-CPU kthread workers pool to carry out + async decompression for low latencies on some architectures. + + If unsure, say N. + +config EROFS_FS_PCPU_KTHREAD_HIPRI + bool "EROFS high priority per-CPU kthread workers" + depends on EROFS_FS_ZIP && EROFS_FS_PCPU_KTHREAD + help + This permits EROFS to configure per-CPU kthread workers to run + at higher priority. + + If unsure, say N. diff --git a/fs/erofs/zdata.c b/fs/erofs/zdata.c index 7596db389201..9a7318251445 100644 --- a/fs/erofs/zdata.c +++ b/fs/erofs/zdata.c @@ -7,7 +7,7 @@ #include "zdata.h" #include "compress.h" #include - +#include #include /* @@ -125,24 +125,128 @@ typedef tagptr1_t compressed_page_t; static struct workqueue_struct *z_erofs_workqueue __read_mostly; -void z_erofs_exit_zip_subsystem(void) +#ifdef CONFIG_EROFS_FS_PCPU_KTHREAD +static struct kthread_worker __rcu **z_erofs_pcpu_workers; + +static void erofs_destroy_percpu_workers(void) { - destroy_workqueue(z_erofs_workqueue); - z_erofs_destroy_pcluster_pool(); + struct kthread_worker *worker; + unsigned int cpu; + + for_each_possible_cpu(cpu) { + worker = rcu_dereference_protected( + z_erofs_pcpu_workers[cpu], 1); + rcu_assign_pointer(z_erofs_pcpu_workers[cpu], NULL); + if (worker) + kthread_destroy_worker(worker); + } + kfree(z_erofs_pcpu_workers); } -static inline int z_erofs_init_workqueue(void) +static struct kthread_worker *erofs_init_percpu_worker(int cpu) { - const unsigned int onlinecpus = num_possible_cpus(); + struct kthread_worker *worker = + kthread_create_worker_on_cpu(cpu, 0, "erofs_worker/%u", cpu); - /* - * no need to spawn too many threads, limiting threads could minimum - * scheduling overhead, perhaps per-CPU threads should be better? - */ - z_erofs_workqueue = alloc_workqueue("erofs_unzipd", - WQ_UNBOUND | WQ_HIGHPRI, - onlinecpus + onlinecpus / 4); - return z_erofs_workqueue ? 0 : -ENOMEM; + if (IS_ERR(worker)) + return worker; + if (IS_ENABLED(CONFIG_EROFS_FS_PCPU_KTHREAD_HIPRI)) + sched_set_fifo_low(worker->task); + else + sched_set_normal(worker->task, 0); + return worker; +} + +static int erofs_init_percpu_workers(void) +{ + struct kthread_worker *worker; + unsigned int cpu; + + z_erofs_pcpu_workers = kcalloc(num_possible_cpus(), + sizeof(struct kthread_worker *), GFP_ATOMIC); + if (!z_erofs_pcpu_workers) + return -ENOMEM; + + for_each_online_cpu(cpu) { /* could miss cpu{off,on}line? */ + worker = erofs_init_percpu_worker(cpu); + if (!IS_ERR(worker)) + rcu_assign_pointer(z_erofs_pcpu_workers[cpu], worker); + } + return 0; +} +#else +static inline void erofs_destroy_percpu_workers(void) {} +static inline int erofs_init_percpu_workers(void) { return 0; } +#endif + +#if defined(CONFIG_HOTPLUG_CPU) && defined(CONFIG_EROFS_FS_PCPU_KTHREAD) +static DEFINE_SPINLOCK(z_erofs_pcpu_worker_lock); +static enum cpuhp_state erofs_cpuhp_state; + +static int erofs_cpu_online(unsigned int cpu) +{ + struct kthread_worker *worker, *old; + + worker = erofs_init_percpu_worker(cpu); + if (IS_ERR(worker)) + return PTR_ERR(worker); + + spin_lock(&z_erofs_pcpu_worker_lock); + old = rcu_dereference_protected(z_erofs_pcpu_workers[cpu], + lockdep_is_held(&z_erofs_pcpu_worker_lock)); + if (!old) + rcu_assign_pointer(z_erofs_pcpu_workers[cpu], worker); + spin_unlock(&z_erofs_pcpu_worker_lock); + if (old) + kthread_destroy_worker(worker); + return 0; +} + +static int erofs_cpu_offline(unsigned int cpu) +{ + struct kthread_worker *worker; + + spin_lock(&z_erofs_pcpu_worker_lock); + worker = rcu_dereference_protected(z_erofs_pcpu_workers[cpu], + lockdep_is_held(&z_erofs_pcpu_worker_lock)); + rcu_assign_pointer(z_erofs_pcpu_workers[cpu], NULL); + spin_unlock(&z_erofs_pcpu_worker_lock); + + synchronize_rcu(); + if (worker) + kthread_destroy_worker(worker); + return 0; +} + +static int erofs_cpu_hotplug_init(void) +{ + int state; + + state = cpuhp_setup_state_nocalls(CPUHP_AP_ONLINE_DYN, + "fs/erofs:online", erofs_cpu_online, erofs_cpu_offline); + if (state < 0) + return state; + + erofs_cpuhp_state = state; + return 0; +} + +static void erofs_cpu_hotplug_destroy(void) +{ + if (erofs_cpuhp_state) + cpuhp_remove_state_nocalls(erofs_cpuhp_state); +} +#else /* !CONFIG_HOTPLUG_CPU || !CONFIG_EROFS_FS_PCPU_KTHREAD */ +static inline int erofs_cpu_hotplug_init(void) { return 0; } +static inline void erofs_cpu_hotplug_destroy(void) {} +#endif + +void z_erofs_exit_zip_subsystem(void) +{ + erofs_cpu_hotplug_destroy(); + erofs_destroy_percpu_workers(); + destroy_workqueue(z_erofs_workqueue); + z_erofs_destroy_pcluster_pool(); } int __init z_erofs_init_zip_subsystem(void) @@ -150,10 +254,29 @@ int __init z_erofs_init_zip_subsystem(void) int err = z_erofs_create_pcluster_pool(); if (err) - return err; - err = z_erofs_init_workqueue(); + goto out_error_pcluster_pool; + + z_erofs_workqueue = alloc_workqueue("erofs_worker", + WQ_UNBOUND | WQ_HIGHPRI, num_possible_cpus()); + if (!z_erofs_workqueue) + goto out_error_workqueue_init; + + err = erofs_init_percpu_workers(); if (err) - z_erofs_destroy_pcluster_pool(); + goto out_error_pcpu_worker; + + err = erofs_cpu_hotplug_init(); + if (err < 0) + goto out_error_cpuhp_init; + return err; + +out_error_cpuhp_init: + erofs_destroy_percpu_workers(); +out_error_pcpu_worker: + destroy_workqueue(z_erofs_workqueue); +out_error_workqueue_init: + z_erofs_destroy_pcluster_pool(); +out_error_pcluster_pool: return err; } @@ -782,6 +905,12 @@ err_out: } static void z_erofs_decompressqueue_work(struct work_struct *work); +#ifdef CONFIG_EROFS_FS_PCPU_KTHREAD +static void z_erofs_decompressqueue_kthread_work(struct kthread_work *work) +{ + z_erofs_decompressqueue_work((struct work_struct *)work); +} +#endif static void z_erofs_decompress_kickoff(struct z_erofs_decompressqueue *io, bool sync, int bios) { @@ -799,7 +928,22 @@ static void z_erofs_decompress_kickoff(struct z_erofs_decompressqueue *io, return; /* Use workqueue and sync decompression for atomic contexts only */ if (in_atomic() || irqs_disabled()) { +#ifdef CONFIG_EROFS_FS_PCPU_KTHREAD + struct kthread_worker *worker; + + rcu_read_lock(); + worker = rcu_dereference( + z_erofs_pcpu_workers[raw_smp_processor_id()]); + if (!worker) { + INIT_WORK(&io->u.work, z_erofs_decompressqueue_work); + queue_work(z_erofs_workqueue, &io->u.work); + } else { + kthread_queue_work(worker, &io->u.kthread_work); + } + rcu_read_unlock(); +#else queue_work(z_erofs_workqueue, &io->u.work); +#endif sbi->ctx.readahead_sync_decompress = true; return; } @@ -1207,7 +1351,12 @@ jobqueue_init(struct super_block *sb, *fg = true; goto fg_out; } +#ifdef CONFIG_EROFS_FS_PCPU_KTHREAD + kthread_init_work(&q->u.kthread_work, + z_erofs_decompressqueue_kthread_work); +#else INIT_WORK(&q->u.work, z_erofs_decompressqueue_work); +#endif } else { fg_out: q = fgq; @@ -1348,7 +1497,7 @@ submit_bio_retry: /* * although background is preferred, no one is pending for submission. - * don't issue workqueue for decompression but drop it directly instead. + * don't issue decompression but drop it directly instead. */ if (!*force_fg && !nr_bios) { kvfree(q[JQ_SUBMIT]); diff --git a/fs/erofs/zdata.h b/fs/erofs/zdata.h index 60bf396164ec..f2118ce60e46 100644 --- a/fs/erofs/zdata.h +++ b/fs/erofs/zdata.h @@ -7,6 +7,7 @@ #ifndef __EROFS_FS_ZDATA_H #define __EROFS_FS_ZDATA_H +#include #include "internal.h" #include "zpvec.h" @@ -92,6 +93,7 @@ struct z_erofs_decompressqueue { union { struct completion done; struct work_struct work; + struct kthread_work kthread_work; } u; }; From 76e536328f69114bf4e08d65554924b483b01224 Mon Sep 17 00:00:00 2001 From: Dan Carpenter Date: Thu, 16 Feb 2023 15:13:04 +0300 Subject: [PATCH 33/68] UPSTREAM: erofs: fix an error code in z_erofs_init_zip_subsystem() Return -ENOMEM if alloc_workqueue() fails. Don't return success. Fixes: d8a650adf429 ("erofs: add per-cpu threads for decompression as an option") Bug: 271636421 Bug: 278520205 Tests: launch_cvd Change-Id: I49dcf8094655db47ac71ae8967b5402373fc7adc Signed-off-by: Dan Carpenter Reviewed-by: Gao Xiang Link: https://lore.kernel.org/r/Y+4d0FRsUq8jPoOu@kili Signed-off-by: Gao Xiang (cherry picked from commit 8d1b80a79452630f157bf634ae9cfcd9f4eed161) Signed-off-by: Sandeep Dhavale (cherry picked from commit 5004cc655730355d681b333ff5eafd62a4ee02f2) (cherry picked from commit b7f5039f59d8bee886f584c65ca30f14be4b642c) --- fs/erofs/zdata.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/fs/erofs/zdata.c b/fs/erofs/zdata.c index 9a7318251445..d4eb0e96b9ac 100644 --- a/fs/erofs/zdata.c +++ b/fs/erofs/zdata.c @@ -258,8 +258,10 @@ int __init z_erofs_init_zip_subsystem(void) z_erofs_workqueue = alloc_workqueue("erofs_worker", WQ_UNBOUND | WQ_HIGHPRI, num_possible_cpus()); - if (!z_erofs_workqueue) + if (!z_erofs_workqueue) { + err = -ENOMEM; goto out_error_workqueue_init; + } err = erofs_init_percpu_workers(); if (err) From 4078681792c3fc0b0e896ee0b53909a5f3595c48 Mon Sep 17 00:00:00 2001 From: Sandeep Dhavale Date: Wed, 1 Mar 2023 19:03:41 +0000 Subject: [PATCH 34/68] ANDROID: Enable percpu high priority kthreads for erofs This change enables 2 configs CONFIG_EROFS_FS_PCPU_KTHREAD CONFIG_EROFS_FS_PCPU_KTHREAD_HIPRI With these changes scheduling latency is reduced by ~80% Bug: 271636421 Bug: 278520205 Tests: launch_cvd Change-Id: I91076edd3c7dcbb3497ca0accf98af28c43f4ffb Signed-off-by: Sandeep Dhavale (cherry picked from commit f8e756a6f7019d6c367844ecc449e052c2173f93) (cherry picked from commit ff1fcec189e004540d2abc41bc20102b126e4d7f) --- arch/arm64/configs/gki_defconfig | 2 ++ arch/x86/configs/gki_defconfig | 2 ++ 2 files changed, 4 insertions(+) diff --git a/arch/arm64/configs/gki_defconfig b/arch/arm64/configs/gki_defconfig index d6adcfbd974d..d82e363ddff8 100644 --- a/arch/arm64/configs/gki_defconfig +++ b/arch/arm64/configs/gki_defconfig @@ -591,6 +591,8 @@ CONFIG_PSTORE_CONSOLE=y CONFIG_PSTORE_PMSG=y CONFIG_PSTORE_RAM=y CONFIG_EROFS_FS=y +CONFIG_EROFS_FS_PCPU_KTHREAD=y +CONFIG_EROFS_FS_PCPU_KTHREAD_HIPRI=y CONFIG_NLS_CODEPAGE_437=y CONFIG_NLS_CODEPAGE_737=y CONFIG_NLS_CODEPAGE_775=y diff --git a/arch/x86/configs/gki_defconfig b/arch/x86/configs/gki_defconfig index 8c486248e3dd..63419263e5ac 100644 --- a/arch/x86/configs/gki_defconfig +++ b/arch/x86/configs/gki_defconfig @@ -523,6 +523,8 @@ CONFIG_PSTORE_CONSOLE=y CONFIG_PSTORE_PMSG=y CONFIG_PSTORE_RAM=y CONFIG_EROFS_FS=y +CONFIG_EROFS_FS_PCPU_KTHREAD=y +CONFIG_EROFS_FS_PCPU_KTHREAD_HIPRI=y CONFIG_NLS_CODEPAGE_437=y CONFIG_NLS_CODEPAGE_737=y CONFIG_NLS_CODEPAGE_775=y From 7b7cd1158649be7a6488bcecb0009ea6e8d54f98 Mon Sep 17 00:00:00 2001 From: Chao Yu Date: Sun, 20 Mar 2022 23:11:17 +0800 Subject: [PATCH 35/68] BACKPORT: f2fs: check pinfile in gc_data_segment() in advance In order to skip migrating section which contains data of pinned file in advance. Bug: 278486610 Signed-off-by: Chao Yu Signed-off-by: Jaegeuk Kim Signed-off-by: Chao Yu (cherry picked from commit 3c4b4e198e7723f00c0f3a078144173fd591d6d8) Change-Id: Ia5d0fa83376afd60cb9dec1ef2e377fedfd905f5 --- fs/f2fs/gc.c | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c index 63f7a7238442..00a69b555daf 100644 --- a/fs/f2fs/gc.c +++ b/fs/f2fs/gc.c @@ -1476,6 +1476,13 @@ next_step: if (IS_ERR(inode) || is_bad_inode(inode)) continue; + if (is_inode_flag_set(inode, FI_PIN_FILE) && + gc_type == FG_GC) { + f2fs_pin_file_control(inode, true); + iput(inode); + return submitted; + } + if (!f2fs_down_write_trylock( &F2FS_I(inode)->i_gc_rwsem[WRITE])) { iput(inode); From 7771fe887f137d6a1340922ffe0ce65fa44cf8eb Mon Sep 17 00:00:00 2001 From: Chao Yu Date: Fri, 6 May 2022 18:30:31 +0800 Subject: [PATCH 36/68] BACKPORT: f2fs: give priority to select unpinned section for foreground GC Previously, during foreground GC, if victims contain data of pinned file, it will fail migration of the data, and meanwhile i_gc_failures of that pinned file may increase, and when it exceeds threshold, GC will unpin the file, result in breaking pinfile's semantics. In order to mitigate such condition, let's record and skip section which has pinned file's data and give priority to select unpinned one. Bug: 278486610 Signed-off-by: Chao Yu Signed-off-by: Jaegeuk Kim Signed-off-by: Chao Yu (cherry picked from commit 8f84484a0696aa9be41e8e5c1f299f3b5788e5ad) Change-Id: I5477ba502254e3109c01e118301c99f6332c1da5 --- fs/f2fs/gc.c | 85 +++++++++++++++++++++++++++++++++++++++-------- fs/f2fs/segment.c | 8 +++++ fs/f2fs/segment.h | 3 ++ 3 files changed, 82 insertions(+), 14 deletions(-) diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c index 00a69b555daf..71f969a8023f 100644 --- a/fs/f2fs/gc.c +++ b/fs/f2fs/gc.c @@ -627,6 +627,54 @@ static void release_victim_entry(struct f2fs_sb_info *sbi) f2fs_bug_on(sbi, !list_empty(&am->victim_list)); } +static bool f2fs_pin_section(struct f2fs_sb_info *sbi, unsigned int segno) +{ + struct dirty_seglist_info *dirty_i = DIRTY_I(sbi); + unsigned int secno = GET_SEC_FROM_SEG(sbi, segno); + + if (!dirty_i->enable_pin_section) + return false; + if (!test_and_set_bit(secno, dirty_i->pinned_secmap)) + dirty_i->pinned_secmap_cnt++; + return true; +} + +static bool f2fs_pinned_section_exists(struct dirty_seglist_info *dirty_i) +{ + return dirty_i->pinned_secmap_cnt; +} + +static bool f2fs_section_is_pinned(struct dirty_seglist_info *dirty_i, + unsigned int secno) +{ + return dirty_i->enable_pin_section && + f2fs_pinned_section_exists(dirty_i) && + test_bit(secno, dirty_i->pinned_secmap); +} + +static void f2fs_unpin_all_sections(struct f2fs_sb_info *sbi, bool enable) +{ + unsigned int bitmap_size = f2fs_bitmap_size(MAIN_SECS(sbi)); + + if (f2fs_pinned_section_exists(DIRTY_I(sbi))) { + memset(DIRTY_I(sbi)->pinned_secmap, 0, bitmap_size); + DIRTY_I(sbi)->pinned_secmap_cnt = 0; + } + DIRTY_I(sbi)->enable_pin_section = enable; +} + +static int f2fs_gc_pinned_control(struct inode *inode, int gc_type, + unsigned int segno) +{ + if (!f2fs_is_pinned_file(inode)) + return 0; + if (gc_type != FG_GC) + return -EBUSY; + if (!f2fs_pin_section(F2FS_I_SB(inode), segno)) + f2fs_pin_file_control(inode, true); + return -EAGAIN; +} + /* * This function is called from two paths. * One is garbage collection and the other is SSR segment selection. @@ -768,6 +816,9 @@ retry: if (gc_type == BG_GC && test_bit(secno, dirty_i->victim_secmap)) goto next; + if (gc_type == FG_GC && f2fs_section_is_pinned(dirty_i, secno)) + goto next; + if (is_atgc) { add_victim_entry(sbi, &p, segno); goto next; @@ -1196,12 +1247,9 @@ static int move_data_block(struct inode *inode, block_t bidx, goto out; } - if (f2fs_is_pinned_file(inode)) { - if (gc_type == FG_GC) - f2fs_pin_file_control(inode, true); - err = -EAGAIN; + err = f2fs_gc_pinned_control(inode, gc_type, segno); + if (err) goto out; - } set_new_dnode(&dn, inode, NULL, NULL, 0); err = f2fs_get_dnode_of_data(&dn, bidx, LOOKUP_NODE); @@ -1346,12 +1394,9 @@ static int move_data_page(struct inode *inode, block_t bidx, int gc_type, err = -EAGAIN; goto out; } - if (f2fs_is_pinned_file(inode)) { - if (gc_type == FG_GC) - f2fs_pin_file_control(inode, true); - err = -EAGAIN; + err = f2fs_gc_pinned_control(inode, gc_type, segno); + if (err) goto out; - } if (gc_type == BG_GC) { if (PageWriteback(page)) { @@ -1472,13 +1517,14 @@ next_step: ofs_in_node = le16_to_cpu(entry->ofs_in_node); if (phase == 3) { + int err; + inode = f2fs_iget(sb, dni.ino); if (IS_ERR(inode) || is_bad_inode(inode)) continue; - if (is_inode_flag_set(inode, FI_PIN_FILE) && - gc_type == FG_GC) { - f2fs_pin_file_control(inode, true); + err = f2fs_gc_pinned_control(inode, gc_type, segno); + if (err == -EAGAIN) { iput(inode); return submitted; } @@ -1763,9 +1809,17 @@ gc_more: ret = -EINVAL; goto stop; } +retry: ret = __get_victim(sbi, &segno, gc_type); - if (ret) + if (ret) { + /* allow to search victim from sections has pinned data */ + if (ret == -ENODATA && gc_type == FG_GC && + f2fs_pinned_section_exists(DIRTY_I(sbi))) { + f2fs_unpin_all_sections(sbi, false); + goto retry; + } goto stop; + } seg_freed = do_garbage_collect(sbi, segno, &gc_list, gc_type, force); if (gc_type == FG_GC && @@ -1816,6 +1870,9 @@ stop: SIT_I(sbi)->last_victim[ALLOC_NEXT] = 0; SIT_I(sbi)->last_victim[FLUSH_DEVICE] = init_segno; + if (gc_type == FG_GC) + f2fs_unpin_all_sections(sbi, true); + trace_f2fs_gc_end(sbi->sb, ret, total_freed, sec_freed, get_pages(sbi, F2FS_DIRTY_NODES), get_pages(sbi, F2FS_DIRTY_DENTS), diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c index a02220f208a0..e01387477f04 100644 --- a/fs/f2fs/segment.c +++ b/fs/f2fs/segment.c @@ -4713,6 +4713,13 @@ static int init_victim_secmap(struct f2fs_sb_info *sbi) dirty_i->victim_secmap = f2fs_kvzalloc(sbi, bitmap_size, GFP_KERNEL); if (!dirty_i->victim_secmap) return -ENOMEM; + + dirty_i->pinned_secmap = f2fs_kvzalloc(sbi, bitmap_size, GFP_KERNEL); + if (!dirty_i->pinned_secmap) + return -ENOMEM; + + dirty_i->pinned_secmap_cnt = 0; + dirty_i->enable_pin_section = true; return 0; } @@ -5301,6 +5308,7 @@ static void destroy_victim_secmap(struct f2fs_sb_info *sbi) { struct dirty_seglist_info *dirty_i = DIRTY_I(sbi); + kvfree(dirty_i->pinned_secmap); kvfree(dirty_i->victim_secmap); } diff --git a/fs/f2fs/segment.h b/fs/f2fs/segment.h index d31eb2f2019c..d7e8eaddc2ec 100644 --- a/fs/f2fs/segment.h +++ b/fs/f2fs/segment.h @@ -295,6 +295,9 @@ struct dirty_seglist_info { struct mutex seglist_lock; /* lock for segment bitmaps */ int nr_dirty[NR_DIRTY_TYPE]; /* # of dirty segments */ unsigned long *victim_secmap; /* background GC victims */ + unsigned long *pinned_secmap; /* pinned victims from foreground GC */ + unsigned int pinned_secmap_cnt; /* count of victims which has pinned data */ + bool enable_pin_section; /* enable pinning section */ }; /* victim selection function for cleaning and SSR */ From 8c9c56dbe5284f8680f15ccc1c77435532181108 Mon Sep 17 00:00:00 2001 From: Wesley Cheng Date: Mon, 6 Mar 2023 12:05:57 -0800 Subject: [PATCH 37/68] FROMGIT: usb: dwc3: gadget: Add 1ms delay after end transfer command without IOC Previously, there was a 100uS delay inserted after issuing an end transfer command for specific controller revisions. This was due to the fact that there was a GUCTL2 bit field which enabled synchronous completion of the end transfer command once the CMDACT bit was cleared in the DEPCMD register. Since this bit does not exist for all controller revisions and the current implementation heavily relies on utizling the EndTransfer command completion interrupt, add the delay back in for uses where the interrupt on completion bit is not set, and increase the duration to 1ms for the controller to complete the command. An issue was seen where the USB request buffer was unmapped while the DWC3 controller was still accessing the TRB. However, it was confirmed that the end transfer command was successfully submitted. (no end transfer timeout) In situations, such as dwc3_gadget_soft_disconnect() and __dwc3_gadget_ep_disable(), the dwc3_remove_request() is utilized, which will issue the end transfer command, and follow up with dwc3_gadget_giveback(). At least for the USB ep disable path, it is required for any pending and started requests to be completed and returned to the function driver in the same context of the disable call. Without the GUCTL2 bit, it is not ensured that the end transfer is completed before the buffers are unmapped. Fixes: cf2f8b63f7f1 ("usb: dwc3: gadget: Remove END_TRANSFER delay") Cc: stable Signed-off-by: Wesley Cheng Acked-by: Thinh Nguyen Link: https://lore.kernel.org/r/20230306200557.29387-1-quic_wcheng@quicinc.com Signed-off-by: Greg Kroah-Hartman Bug: 271815733 Bug: 279141860 Change-Id: I9e06d4810e7052717c7b8e16facd7b765b1ce414 (cherry picked from commit d8a2bb4eb75866275b5cf7de2e593ac3449643e2 https://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb.git usb-linus) Signed-off-by: Wesley Cheng (cherry picked from commit 35a0e36ee86b9328e6d4e7b353638df730d7bb2e) --- drivers/usb/dwc3/gadget.c | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/drivers/usb/dwc3/gadget.c b/drivers/usb/dwc3/gadget.c index 091ec8002efa..7224cb6e6b78 100644 --- a/drivers/usb/dwc3/gadget.c +++ b/drivers/usb/dwc3/gadget.c @@ -1673,6 +1673,7 @@ static int __dwc3_gadget_get_frame(struct dwc3 *dwc) */ static int __dwc3_stop_active_transfer(struct dwc3_ep *dep, bool force, bool interrupt) { + struct dwc3 *dwc = dep->dwc; struct dwc3_gadget_ep_cmd_params params; u32 cmd; int ret; @@ -1696,10 +1697,13 @@ static int __dwc3_stop_active_transfer(struct dwc3_ep *dep, bool force, bool int WARN_ON_ONCE(ret); dep->resource_index = 0; - if (!interrupt) + if (!interrupt) { + if (!DWC3_IP_IS(DWC3) || DWC3_VER_IS_PRIOR(DWC3, 310A)) + mdelay(1); dep->flags &= ~DWC3_EP_TRANSFER_STARTED; - else if (!ret) + } else if (!ret) { dep->flags |= DWC3_EP_END_TRANSFER_PENDING; + } return ret; } @@ -3749,7 +3753,11 @@ void dwc3_stop_active_transfer(struct dwc3_ep *dep, bool force, * enabled, the EndTransfer command will have completed upon * returning from this function. * - * This mode is NOT available on the DWC_usb31 IP. + * This mode is NOT available on the DWC_usb31 IP. In this + * case, if the IOC bit is not set, then delay by 1ms + * after issuing the EndTransfer command. This allows for the + * controller to handle the command completely before DWC3 + * remove requests attempts to unmap USB request buffers. */ __dwc3_stop_active_transfer(dep, force, interrupt); } From 5bbc750d9eb8a5f275e4df5a23ff1c96ae890b58 Mon Sep 17 00:00:00 2001 From: Hans de Goede Date: Fri, 9 Apr 2021 15:40:31 +0200 Subject: [PATCH 38/68] UPSTREAM: usb: typec: Add typec_port_register_altmodes() This can be used by Type-C controller drivers which use a standard usb-connector fwnode, with altmodes sub-node, to describe the available altmodes. Note there are is no devicetree bindings documentation for the altmodes node, this is deliberate. ATM the fwnodes used to register the altmodes are only used internally to pass platform info from a drivers/platform/x86 driver to the type-c subsystem. When a devicetree user of this functionally comes up and the dt-bindings have been hashed out the internal use can be adjusted to match the dt-bindings. Currently the typec_port_register_altmodes() function expects an "altmodes" child fwnode on port->dev with this "altmodes" fwnode having child fwnodes itself with each child containing 2 integer properties: 1. A "svid" property, which sets the id of the altmode, e.g. displayport altmode has a svid of 0xff01. 2. A "vdo" property, typically used as a bitmask describing the capabilities of the altmode, the bits in the vdo are specified in the specification of the altmode. Bug: 279314285 Reviewed-by: Heikki Krogerus Signed-off-by: Hans de Goede Link: https://lore.kernel.org/r/20210409134033.105834-2-hdegoede@redhat.com Signed-off-by: Greg Kroah-Hartman Change-Id: Ib78f0b67b985751a32b6f42e79c7976f5515f6b2 Signed-off-by: yubing.zhang (cherry picked from commit 7b458a4c5d7302947556e12c83cfe4da769665d0) Signed-off-by: Kever Yang --- drivers/usb/typec/class.c | 54 +++++++++++++++++++++++++++++++++++++++ include/linux/usb/typec.h | 6 +++++ 2 files changed, 60 insertions(+) diff --git a/drivers/usb/typec/class.c b/drivers/usb/typec/class.c index 4375aa843000..50247e9f3016 100644 --- a/drivers/usb/typec/class.c +++ b/drivers/usb/typec/class.c @@ -1984,6 +1984,60 @@ typec_port_register_altmode(struct typec_port *port, } EXPORT_SYMBOL_GPL(typec_port_register_altmode); +void typec_port_register_altmodes(struct typec_port *port, + const struct typec_altmode_ops *ops, void *drvdata, + struct typec_altmode **altmodes, size_t n) +{ + struct fwnode_handle *altmodes_node, *child; + struct typec_altmode_desc desc; + struct typec_altmode *alt; + size_t index = 0; + u32 svid, vdo; + int ret; + + altmodes_node = device_get_named_child_node(&port->dev, "altmodes"); + if (!altmodes_node) + return; /* No altmodes specified */ + + fwnode_for_each_child_node(altmodes_node, child) { + ret = fwnode_property_read_u32(child, "svid", &svid); + if (ret) { + dev_err(&port->dev, "Error reading svid for altmode %s\n", + fwnode_get_name(child)); + continue; + } + + ret = fwnode_property_read_u32(child, "vdo", &vdo); + if (ret) { + dev_err(&port->dev, "Error reading vdo for altmode %s\n", + fwnode_get_name(child)); + continue; + } + + if (index >= n) { + dev_err(&port->dev, "Error not enough space for altmode %s\n", + fwnode_get_name(child)); + continue; + } + + desc.svid = svid; + desc.vdo = vdo; + desc.mode = index + 1; + alt = typec_port_register_altmode(port, &desc); + if (IS_ERR(alt)) { + dev_err(&port->dev, "Error registering altmode %s\n", + fwnode_get_name(child)); + continue; + } + + alt->ops = ops; + typec_altmode_set_drvdata(alt, drvdata); + altmodes[index] = alt; + index++; + } +} +EXPORT_SYMBOL_GPL(typec_port_register_altmodes); + /** * typec_register_port - Register a USB Type-C Port * @parent: Parent device diff --git a/include/linux/usb/typec.h b/include/linux/usb/typec.h index b2e2c302caa6..88594260074d 100644 --- a/include/linux/usb/typec.h +++ b/include/linux/usb/typec.h @@ -18,6 +18,7 @@ struct typec_partner; struct typec_cable; struct typec_plug; struct typec_port; +struct typec_altmode_ops; struct fwnode_handle; struct device; @@ -139,6 +140,11 @@ struct typec_altmode struct typec_altmode *typec_port_register_altmode(struct typec_port *port, const struct typec_altmode_desc *desc); + +void typec_port_register_altmodes(struct typec_port *port, + const struct typec_altmode_ops *ops, void *drvdata, + struct typec_altmode **altmodes, size_t n); + void typec_unregister_altmode(struct typec_altmode *altmode); struct typec_port *typec_altmode2port(struct typec_altmode *alt); From 7513f3e148e2b247ed49cbb8c4cac2ed5b72460d Mon Sep 17 00:00:00 2001 From: Hans de Goede Date: Fri, 9 Apr 2021 15:40:32 +0200 Subject: [PATCH 39/68] UPSTREAM: usb: typec: tcpm: Add support for altmodes Add support for altmodes described in the usb-connector fwnode associated with the Type-C controller by calling the new typec_port_register_altmodes_from_fwnode() helper for this. Bug: 279314285 Reviewed-by: Heikki Krogerus Signed-off-by: Hans de Goede Link: https://lore.kernel.org/r/20210409134033.105834-3-hdegoede@redhat.com Signed-off-by: Greg Kroah-Hartman Change-Id: I0d7de11b08f1c297e78c7f4cbea90b6d85f8abe5 Signed-off-by: yubing.zhang (cherry picked from commit 55d8b34772e0728a224198ba605eed8cfc570aa0) Signed-off-by: Kever Yang --- drivers/usb/typec/tcpm/tcpm.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/drivers/usb/typec/tcpm/tcpm.c b/drivers/usb/typec/tcpm/tcpm.c index dc0d3a48894a..b15a461bec34 100644 --- a/drivers/usb/typec/tcpm/tcpm.c +++ b/drivers/usb/typec/tcpm/tcpm.c @@ -6521,6 +6521,10 @@ struct tcpm_port *tcpm_register_port(struct device *dev, struct tcpc_dev *tcpc) goto out_role_sw_put; } + typec_port_register_altmodes(port->typec_port, + &tcpm_altmode_ops, port, + port->port_altmode, ALTMODE_DISCOVERY_MAX); + mutex_lock(&port->lock); tcpm_init(port); mutex_unlock(&port->lock); From 004c4693705a2e3c52257929809fc387a36733b9 Mon Sep 17 00:00:00 2001 From: Mike Snitzer Date: Thu, 4 Aug 2022 14:53:07 -0400 Subject: [PATCH 40/68] UPSTREAM: dm verity: remove WQ_CPU_INTENSIVE flag since using WQ_UNBOUND The documentation [1] says that WQ_CPU_INTENSIVE is "meaningless" for unbound wq. So remove WQ_CPU_INTENSIVE from the verify_wq allocation. 1. https://www.kernel.org/doc/html/latest/core-api/workqueue.html#flags Suggested-by: Maksym Planeta Signed-off-by: Mike Snitzer Bug: 233247259 (cherry picked from commit 43fa47cb116daa48f731fa5c00d781200addb2ae) Signed-off-by: Nathan Huckleberry (cherry picked from https://android-review.googlesource.com/q/commit:407f5e1a1ddada4de7085798973bbf9135e3bfc5) Merged-In: I13c8916a24274d586a5f462541345d149c602ca3 Bug: 279521578 Change-Id: Ic4d07ccdbd017c4f89e3de5805c9e733a3df9de6 --- drivers/md/dm-verity-target.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/md/dm-verity-target.c b/drivers/md/dm-verity-target.c index 1c8038c665ec..0d4596f100bf 100644 --- a/drivers/md/dm-verity-target.c +++ b/drivers/md/dm-verity-target.c @@ -1220,7 +1220,7 @@ static int verity_ctr(struct dm_target *ti, unsigned argc, char **argv) } /* WQ_UNBOUND greatly improves performance when running on ramdisk */ - v->verify_wq = alloc_workqueue("kverityd", WQ_CPU_INTENSIVE | WQ_MEM_RECLAIM | WQ_UNBOUND, num_online_cpus()); + v->verify_wq = alloc_workqueue("kverityd", WQ_MEM_RECLAIM | WQ_UNBOUND, num_online_cpus()); if (!v->verify_wq) { ti->error = "Cannot allocate workqueue"; r = -ENOMEM; From 3de420d372f0b81505b5d32f605681b38baddc18 Mon Sep 17 00:00:00 2001 From: Nathan Huckleberry Date: Tue, 30 Aug 2022 18:44:44 +0000 Subject: [PATCH 41/68] BACKPORT: dm verity: enable WQ_HIGHPRI on verify_wq WQ_HIGHPRI increases throughput and decreases disk latency when using dm-verity. This is important in Android for camera startup speed. The following tests were run by doing 60 seconds of random reads using a dm-verity device backed by two ramdisks. Without WQ_HIGHPRI lat (usec): min=13, max=3947, avg=69.53, stdev=50.55 READ: bw=51.1MiB/s (53.6MB/s), 51.1MiB/s-51.1MiB/s (53.6MB/s-53.6MB/s) With WQ_HIGHPRI: lat (usec): min=13, max=7854, avg=31.15, stdev=30.42 READ: bw=116MiB/s (121MB/s), 116MiB/s-116MiB/s (121MB/s-121MB/s) Further testing was done by measuring how long it takes to open a camera on an Android device. Without WQ_HIGHPRI Total verity work queue wait times (ms): 880.960, 789.517, 898.852 With WQ_HIGHPRI: Total verity work queue wait times (ms): 528.824, 439.191, 433.300 The average time to open the camera is reduced by 350ms (or 40-50%). Signed-off-by: Nathan Huckleberry Signed-off-by: Mike Snitzer Bug: 233247259 (cherry picked from commit afd41fff9c73ccc3757e94ad727d2a9ac4d7f6cb) [nhuck: Resolved minor conflict in drivers/md/dm-verity-target.c ] (cherry picked from https://android-review.googlesource.com/q/commit:fd4631f8568f5bf16ac5c8b0686d40fad6e4e047) Merged-In: I7d600c924b4a3e793b9a26c2852139683061a831 Bug: 279521578 Change-Id: Ib858d388aa24e4a625085804c097ad66aa179a14 --- drivers/md/dm-verity-target.c | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/drivers/md/dm-verity-target.c b/drivers/md/dm-verity-target.c index 0d4596f100bf..a43c2f78a848 100644 --- a/drivers/md/dm-verity-target.c +++ b/drivers/md/dm-verity-target.c @@ -993,6 +993,7 @@ static int verity_ctr(struct dm_target *ti, unsigned argc, char **argv) struct dm_verity_sig_opts verify_args = {0}; struct dm_arg_set as; unsigned int num; + unsigned int wq_flags; unsigned long long num_ll; int r; int i; @@ -1220,7 +1221,18 @@ static int verity_ctr(struct dm_target *ti, unsigned argc, char **argv) } /* WQ_UNBOUND greatly improves performance when running on ramdisk */ - v->verify_wq = alloc_workqueue("kverityd", WQ_MEM_RECLAIM | WQ_UNBOUND, num_online_cpus()); + wq_flags = WQ_MEM_RECLAIM | WQ_UNBOUND; + /* + * Using WQ_HIGHPRI improves throughput and completion latency by + * reducing wait times when reading from a dm-verity device. + * + * Also as required for the "try_verify_in_tasklet" feature: WQ_HIGHPRI + * allows verify_wq to preempt softirq since verification in tasklet + * will fall-back to using it for error handling (or if the bufio cache + * doesn't have required hashes). + */ + wq_flags |= WQ_HIGHPRI; + v->verify_wq = alloc_workqueue("kverityd", wq_flags, num_online_cpus()); if (!v->verify_wq) { ti->error = "Cannot allocate workqueue"; r = -ENOMEM; From 306223f885fa9cf355deeb84be0e6594cf4a1680 Mon Sep 17 00:00:00 2001 From: Nathan Huckleberry Date: Wed, 1 Feb 2023 17:23:48 -0800 Subject: [PATCH 42/68] UPSTREAM: dm verity: stop using WQ_UNBOUND for verify_wq Setting WQ_UNBOUND increases scheduler latency on ARM64. This is likely due to the asymmetric architecture of ARM64 processors. I've been unable to reproduce the results that claim WQ_UNBOUND gives a performance boost on x86-64. This flag is causing performance issues for multiple subsystems within Android. Notably, the same slowdown exists for decompression with EROFS. | open-prebuilt-camera | WQ_UNBOUND | ~WQ_UNBOUND | |-----------------------|------------|---------------| | verity wait time (us) | 11746 | 119 (-98%) | | erofs wait time (us) | 357805 | 174205 (-51%) | | sha256 ramdisk random read | WQ_UNBOUND | ~WQ_UNBOUND | |----------------------------|-----------=---|-------------| | arm64 (accelerated) | bw=42.4MiB/s | bw=212MiB/s | | arm64 (generic) | bw=16.5MiB/s | bw=48MiB/s | | x86_64 (generic) | bw=233MiB/s | bw=230MiB/s | Using a alloc_workqueue() @max_active arg of num_online_cpus() only made sense with WQ_UNBOUND. Switch the @max_active arg to 0 (aka default, which is 256 per-cpu). Also, eliminate 'wq_flags' since it really doesn't serve a purpose. Cc: Sami Tolvanen Cc: Eric Biggers Signed-off-by: Nathan Huckleberry Reviewed-by: Mikulas Patocka Signed-off-by: Mike Snitzer Bug: 233247259 (cherry picked from commit c25da5b7baf1d243e6612ba2b97e2a2c4a1376f6) (cherry picked from https://android-review.googlesource.com/q/commit:0b8c60f03740004a9693d63a2d31618b00469107) Merged-In: Iea437fcfaa978a1389a57ef4d4adcb976d89089c Bug: 279521578 Change-Id: Iecdc2ef25cc59ca53bfe3bca775f93cfda57f9d7 --- drivers/md/dm-verity-target.c | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/drivers/md/dm-verity-target.c b/drivers/md/dm-verity-target.c index a43c2f78a848..fb1902f2b60a 100644 --- a/drivers/md/dm-verity-target.c +++ b/drivers/md/dm-verity-target.c @@ -993,7 +993,6 @@ static int verity_ctr(struct dm_target *ti, unsigned argc, char **argv) struct dm_verity_sig_opts verify_args = {0}; struct dm_arg_set as; unsigned int num; - unsigned int wq_flags; unsigned long long num_ll; int r; int i; @@ -1220,8 +1219,6 @@ static int verity_ctr(struct dm_target *ti, unsigned argc, char **argv) goto bad; } - /* WQ_UNBOUND greatly improves performance when running on ramdisk */ - wq_flags = WQ_MEM_RECLAIM | WQ_UNBOUND; /* * Using WQ_HIGHPRI improves throughput and completion latency by * reducing wait times when reading from a dm-verity device. @@ -1231,8 +1228,7 @@ static int verity_ctr(struct dm_target *ti, unsigned argc, char **argv) * will fall-back to using it for error handling (or if the bufio cache * doesn't have required hashes). */ - wq_flags |= WQ_HIGHPRI; - v->verify_wq = alloc_workqueue("kverityd", wq_flags, num_online_cpus()); + v->verify_wq = alloc_workqueue("kverityd", WQ_MEM_RECLAIM | WQ_HIGHPRI, 0); if (!v->verify_wq) { ti->error = "Cannot allocate workqueue"; r = -ENOMEM; From 2e61d90c44df342d2493ef407ada126ee8c8cb61 Mon Sep 17 00:00:00 2001 From: Carlos Llamas Date: Wed, 26 Apr 2023 02:16:25 +0000 Subject: [PATCH 43/68] ANDROID: fix use of plain integer as NULL pointer This patch fixes the following sparse issues: drivers/android/binder.c:1373:70: sparse: sparse: Using plain integer as NULL pointer drivers/android/binder.c:2508:41: sparse: sparse: Using plain integer as NULL pointer Fixes: e107ea9e4dd1 ("ANDROID: vendor_hooks: Add hooks for binder proc transaction") Reported-by: kernel test robot Link: https://lore.kernel.org/oe-kbuild-all/202304150607.IuUhkfxB-lkp@intel.com/ Cc: zhengding chen Change-Id: I272b3239e2d81bfdd28d1fe412f2c3d0731ec50f Signed-off-by: Carlos Llamas --- drivers/android/binder.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/drivers/android/binder.c b/drivers/android/binder.c index 16e0ba315abf..66152cc321a9 100644 --- a/drivers/android/binder.c +++ b/drivers/android/binder.c @@ -1399,7 +1399,8 @@ err_no_ref: */ static void binder_free_ref(struct binder_ref *ref) { - trace_android_vh_binder_del_ref(ref->proc ? ref->proc->tsk : 0, ref->data.desc); + trace_android_vh_binder_del_ref(ref->proc ? ref->proc->tsk : NULL, + ref->data.desc); if (ref->node) binder_free_node(ref->node); kfree(ref->death); @@ -2871,7 +2872,8 @@ static int binder_proc_transaction(struct binder_transaction *t, thread = binder_select_thread_ilocked(proc); trace_android_vh_binder_proc_transaction(current, proc->tsk, - thread ? thread->task : 0, node->debug_id, t->code, pending_async); + thread ? thread->task : NULL, node->debug_id, t->code, + pending_async); if (thread) { binder_transaction_priority(thread->task, t, node_prio, From 49652e1bbd0a2da40de02dd06bbb865fdd70fa4e Mon Sep 17 00:00:00 2001 From: Tudor Ambarus Date: Wed, 19 Apr 2023 06:46:08 +0000 Subject: [PATCH 44/68] UPSTREAM: Revert "ext4: fix use-after-free in ext4_xattr_set_entry" This reverts commit bb8592efcf8ef2f62947745d3182ea05b5256a15 which is commit 67d7d8ad99beccd9fe92d585b87f1760dc9018e3 upstream. The order in which patches are queued to stable matters. This patch has a logical dependency on commit 310c097c2bdbea253d6ee4e064f3e65580ef93ac upstream, and failing to queue the latter results in a null-ptr-deref reported at the Link below. In order to avoid conflicts on stable, revert the commit just so that we can queue its prerequisite patch first and then queue the same after. Link: https://syzkaller.appspot.com/bug?extid=d5ebf56f3b1268136afd Signed-off-by: Tudor Ambarus Signed-off-by: Greg Kroah-Hartman Bug: 253759004 Change-Id: I0e09ac2e68c2b21834ccd620c79f73fadc420170 (cherry picked from commit 9400206d9d5eebc0317da4151364ade32d28944f) Signed-off-by: Tudor Ambarus --- fs/ext4/xattr.c | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/fs/ext4/xattr.c b/fs/ext4/xattr.c index b80ad5a7b05c..3c570ea4d0a6 100644 --- a/fs/ext4/xattr.c +++ b/fs/ext4/xattr.c @@ -2182,9 +2182,8 @@ int ext4_xattr_ibody_find(struct inode *inode, struct ext4_xattr_info *i, struct ext4_inode *raw_inode; int error; - if (!EXT4_INODE_HAS_XATTR_SPACE(inode)) + if (EXT4_I(inode)->i_extra_isize == 0) return 0; - raw_inode = ext4_raw_inode(&is->iloc); header = IHDR(inode, raw_inode); is->s.base = is->s.first = IFIRST(header); @@ -2212,9 +2211,8 @@ int ext4_xattr_ibody_inline_set(handle_t *handle, struct inode *inode, struct ext4_xattr_search *s = &is->s; int error; - if (!EXT4_INODE_HAS_XATTR_SPACE(inode)) + if (EXT4_I(inode)->i_extra_isize == 0) return -ENOSPC; - error = ext4_xattr_set_entry(i, s, handle, inode, false /* is_block */); if (error) return error; From 3acba5c435917699725890bbc55e96a961b92178 Mon Sep 17 00:00:00 2001 From: Ritesh Harjani Date: Wed, 19 Apr 2023 06:46:09 +0000 Subject: [PATCH 45/68] UPSTREAM: ext4: remove duplicate definition of ext4_xattr_ibody_inline_set() [ Upstream commit 310c097c2bdbea253d6ee4e064f3e65580ef93ac ] ext4_xattr_ibody_inline_set() & ext4_xattr_ibody_set() have the exact same definition. Hence remove ext4_xattr_ibody_inline_set() and all its call references. Convert the callers of it to call ext4_xattr_ibody_set() instead. [ Modified to preserve ext4_xattr_ibody_set() and remove ext4_xattr_ibody_inline_set() instead. -- TYT ] Signed-off-by: Ritesh Harjani Link: https://lore.kernel.org/r/fd566b799bbbbe9b668eb5eecde5b5e319e3694f.1622685482.git.riteshh@linux.ibm.com Signed-off-by: Theodore Ts'o Signed-off-by: Tudor Ambarus Signed-off-by: Greg Kroah-Hartman Bug: 253759004 Change-Id: Iaf02894c4f88d79d85ed00363fc83d4b3ba8c575 Signed-off-by: Tudor Ambarus --- fs/ext4/inline.c | 11 +++++------ fs/ext4/xattr.c | 26 +------------------------- fs/ext4/xattr.h | 6 +++--- 3 files changed, 9 insertions(+), 34 deletions(-) diff --git a/fs/ext4/inline.c b/fs/ext4/inline.c index cd575062787a..0121484a41d9 100644 --- a/fs/ext4/inline.c +++ b/fs/ext4/inline.c @@ -208,7 +208,7 @@ out: /* * write the buffer to the inline inode. * If 'create' is set, we don't need to do the extra copy in the xattr - * value since it is already handled by ext4_xattr_ibody_inline_set. + * value since it is already handled by ext4_xattr_ibody_set. * That saves us one memcpy. */ static void ext4_write_inline_data(struct inode *inode, struct ext4_iloc *iloc, @@ -290,7 +290,7 @@ static int ext4_create_inline_data(handle_t *handle, BUG_ON(!is.s.not_found); - error = ext4_xattr_ibody_inline_set(handle, inode, &i, &is); + error = ext4_xattr_ibody_set(handle, inode, &i, &is); if (error) { if (error == -ENOSPC) ext4_clear_inode_state(inode, @@ -362,7 +362,7 @@ static int ext4_update_inline_data(handle_t *handle, struct inode *inode, i.value = value; i.value_len = len; - error = ext4_xattr_ibody_inline_set(handle, inode, &i, &is); + error = ext4_xattr_ibody_set(handle, inode, &i, &is); if (error) goto out; @@ -435,7 +435,7 @@ static int ext4_destroy_inline_data_nolock(handle_t *handle, if (error) goto out; - error = ext4_xattr_ibody_inline_set(handle, inode, &i, &is); + error = ext4_xattr_ibody_set(handle, inode, &i, &is); if (error) goto out; @@ -1950,8 +1950,7 @@ int ext4_inline_data_truncate(struct inode *inode, int *has_inline) i.value = value; i.value_len = i_size > EXT4_MIN_INLINE_DATA_SIZE ? i_size - EXT4_MIN_INLINE_DATA_SIZE : 0; - err = ext4_xattr_ibody_inline_set(handle, inode, - &i, &is); + err = ext4_xattr_ibody_set(handle, inode, &i, &is); if (err) goto out_error; } diff --git a/fs/ext4/xattr.c b/fs/ext4/xattr.c index 3c570ea4d0a6..9cca06a7e9dd 100644 --- a/fs/ext4/xattr.c +++ b/fs/ext4/xattr.c @@ -2203,31 +2203,7 @@ int ext4_xattr_ibody_find(struct inode *inode, struct ext4_xattr_info *i, return 0; } -int ext4_xattr_ibody_inline_set(handle_t *handle, struct inode *inode, - struct ext4_xattr_info *i, - struct ext4_xattr_ibody_find *is) -{ - struct ext4_xattr_ibody_header *header; - struct ext4_xattr_search *s = &is->s; - int error; - - if (EXT4_I(inode)->i_extra_isize == 0) - return -ENOSPC; - error = ext4_xattr_set_entry(i, s, handle, inode, false /* is_block */); - if (error) - return error; - header = IHDR(inode, ext4_raw_inode(&is->iloc)); - if (!IS_LAST_ENTRY(s->first)) { - header->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC); - ext4_set_inode_state(inode, EXT4_STATE_XATTR); - } else { - header->h_magic = cpu_to_le32(0); - ext4_clear_inode_state(inode, EXT4_STATE_XATTR); - } - return 0; -} - -static int ext4_xattr_ibody_set(handle_t *handle, struct inode *inode, +int ext4_xattr_ibody_set(handle_t *handle, struct inode *inode, struct ext4_xattr_info *i, struct ext4_xattr_ibody_find *is) { diff --git a/fs/ext4/xattr.h b/fs/ext4/xattr.h index b357872ab83b..e5e36bd11f05 100644 --- a/fs/ext4/xattr.h +++ b/fs/ext4/xattr.h @@ -200,9 +200,9 @@ extern int ext4_xattr_ibody_find(struct inode *inode, struct ext4_xattr_info *i, extern int ext4_xattr_ibody_get(struct inode *inode, int name_index, const char *name, void *buffer, size_t buffer_size); -extern int ext4_xattr_ibody_inline_set(handle_t *handle, struct inode *inode, - struct ext4_xattr_info *i, - struct ext4_xattr_ibody_find *is); +extern int ext4_xattr_ibody_set(handle_t *handle, struct inode *inode, + struct ext4_xattr_info *i, + struct ext4_xattr_ibody_find *is); extern struct mb_cache *ext4_xattr_create_cache(void); extern void ext4_xattr_destroy_cache(struct mb_cache *); From 4d2352ab07ad3dd1f16fd79e50e2815c8daf135f Mon Sep 17 00:00:00 2001 From: Baokun Li Date: Wed, 19 Apr 2023 06:46:10 +0000 Subject: [PATCH 46/68] UPSTREAM: ext4: fix use-after-free in ext4_xattr_set_entry [ Upstream commit 67d7d8ad99beccd9fe92d585b87f1760dc9018e3 ] Hulk Robot reported a issue: ================================================================== BUG: KASAN: use-after-free in ext4_xattr_set_entry+0x18ab/0x3500 Write of size 4105 at addr ffff8881675ef5f4 by task syz-executor.0/7092 CPU: 1 PID: 7092 Comm: syz-executor.0 Not tainted 4.19.90-dirty #17 Call Trace: [...] memcpy+0x34/0x50 mm/kasan/kasan.c:303 ext4_xattr_set_entry+0x18ab/0x3500 fs/ext4/xattr.c:1747 ext4_xattr_ibody_inline_set+0x86/0x2a0 fs/ext4/xattr.c:2205 ext4_xattr_set_handle+0x940/0x1300 fs/ext4/xattr.c:2386 ext4_xattr_set+0x1da/0x300 fs/ext4/xattr.c:2498 __vfs_setxattr+0x112/0x170 fs/xattr.c:149 __vfs_setxattr_noperm+0x11b/0x2a0 fs/xattr.c:180 __vfs_setxattr_locked+0x17b/0x250 fs/xattr.c:238 vfs_setxattr+0xed/0x270 fs/xattr.c:255 setxattr+0x235/0x330 fs/xattr.c:520 path_setxattr+0x176/0x190 fs/xattr.c:539 __do_sys_lsetxattr fs/xattr.c:561 [inline] __se_sys_lsetxattr fs/xattr.c:557 [inline] __x64_sys_lsetxattr+0xc2/0x160 fs/xattr.c:557 do_syscall_64+0xdf/0x530 arch/x86/entry/common.c:298 entry_SYSCALL_64_after_hwframe+0x44/0xa9 RIP: 0033:0x459fe9 RSP: 002b:00007fa5e54b4c08 EFLAGS: 00000246 ORIG_RAX: 00000000000000bd RAX: ffffffffffffffda RBX: 000000000051bf60 RCX: 0000000000459fe9 RDX: 00000000200003c0 RSI: 0000000020000180 RDI: 0000000020000140 RBP: 000000000051bf60 R08: 0000000000000001 R09: 0000000000000000 R10: 0000000000001009 R11: 0000000000000246 R12: 0000000000000000 R13: 00007ffc73c93fc0 R14: 000000000051bf60 R15: 00007fa5e54b4d80 [...] ================================================================== Above issue may happen as follows: ------------------------------------- ext4_xattr_set ext4_xattr_set_handle ext4_xattr_ibody_find >> s->end < s->base >> no EXT4_STATE_XATTR >> xattr_check_inode is not executed ext4_xattr_ibody_set ext4_xattr_set_entry >> size_t min_offs = s->end - s->base >> UAF in memcpy we can easily reproduce this problem with the following commands: mkfs.ext4 -F /dev/sda mount -o debug_want_extra_isize=128 /dev/sda /mnt touch /mnt/file setfattr -n user.cat -v `seq -s z 4096|tr -d '[:digit:]'` /mnt/file In ext4_xattr_ibody_find, we have the following assignment logic: header = IHDR(inode, raw_inode) = raw_inode + EXT4_GOOD_OLD_INODE_SIZE + i_extra_isize is->s.base = IFIRST(header) = header + sizeof(struct ext4_xattr_ibody_header) is->s.end = raw_inode + s_inode_size In ext4_xattr_set_entry min_offs = s->end - s->base = s_inode_size - EXT4_GOOD_OLD_INODE_SIZE - i_extra_isize - sizeof(struct ext4_xattr_ibody_header) last = s->first free = min_offs - ((void *)last - s->base) - sizeof(__u32) = s_inode_size - EXT4_GOOD_OLD_INODE_SIZE - i_extra_isize - sizeof(struct ext4_xattr_ibody_header) - sizeof(__u32) In the calculation formula, all values except s_inode_size and i_extra_size are fixed values. When i_extra_size is the maximum value s_inode_size - EXT4_GOOD_OLD_INODE_SIZE, min_offs is -4 and free is -8. The value overflows. As a result, the preceding issue is triggered when memcpy is executed. Therefore, when finding xattr or setting xattr, check whether there is space for storing xattr in the inode to resolve this issue. Cc: stable@kernel.org Reported-by: Hulk Robot Signed-off-by: Baokun Li Reviewed-by: Ritesh Harjani (IBM) Reviewed-by: Jan Kara Link: https://lore.kernel.org/r/20220616021358.2504451-3-libaokun1@huawei.com Signed-off-by: Theodore Ts'o Signed-off-by: Tudor Ambarus Signed-off-by: Greg Kroah-Hartman Bug: 253759004 Change-Id: Ib0e74eb2b13884e6ee773748b62cd8a0bcfab3f3 Signed-off-by: Tudor Ambarus --- fs/ext4/xattr.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/fs/ext4/xattr.c b/fs/ext4/xattr.c index 9cca06a7e9dd..6fee044fd158 100644 --- a/fs/ext4/xattr.c +++ b/fs/ext4/xattr.c @@ -2182,8 +2182,9 @@ int ext4_xattr_ibody_find(struct inode *inode, struct ext4_xattr_info *i, struct ext4_inode *raw_inode; int error; - if (EXT4_I(inode)->i_extra_isize == 0) + if (!EXT4_INODE_HAS_XATTR_SPACE(inode)) return 0; + raw_inode = ext4_raw_inode(&is->iloc); header = IHDR(inode, raw_inode); is->s.base = is->s.first = IFIRST(header); @@ -2211,8 +2212,9 @@ int ext4_xattr_ibody_set(handle_t *handle, struct inode *inode, struct ext4_xattr_search *s = &is->s; int error; - if (EXT4_I(inode)->i_extra_isize == 0) + if (!EXT4_INODE_HAS_XATTR_SPACE(inode)) return -ENOSPC; + error = ext4_xattr_set_entry(i, s, handle, inode, false /* is_block */); if (error) return error; From e2ed7e5048bf80da1604616be758e25fdefab33f Mon Sep 17 00:00:00 2001 From: Daeho Jeong Date: Tue, 15 Mar 2022 21:14:14 -0700 Subject: [PATCH 47/68] BACKPORT: f2fs: introduce gc_urgent_mid mode We need a mid level of gc urgent mode to do GC forcibly in a period of given gc_urgent_sleep_time, but not like using greedy GC approach and switching to SSR mode such as gc urgent high mode. This can be used for more aggressive periodic storage clean up. Signed-off-by: Daeho Jeong Signed-off-by: Jaegeuk Kim BUG: 279706487 Change-Id: I52405f36fcbc0b9ffae1abba3b215ba8506ef6a1 (cherry picked from commit d98af5f4552058a5c22030641ef79cee92c61f54) [Dylan: Resolved minor conflict in fs/f2fs/gc.c ] Signed-off-by: Dylan Chang --- Documentation/ABI/testing/sysfs-fs-f2fs | 17 +++++++++++------ fs/f2fs/debug.c | 4 +++- fs/f2fs/f2fs.h | 4 ++++ fs/f2fs/gc.c | 3 ++- fs/f2fs/sysfs.c | 7 +++++++ 5 files changed, 27 insertions(+), 8 deletions(-) diff --git a/Documentation/ABI/testing/sysfs-fs-f2fs b/Documentation/ABI/testing/sysfs-fs-f2fs index 75f4bbb06c4d..020284afa78d 100644 --- a/Documentation/ABI/testing/sysfs-fs-f2fs +++ b/Documentation/ABI/testing/sysfs-fs-f2fs @@ -271,11 +271,16 @@ Description: Shows current reserved blocks in system, it may be temporarily What: /sys/fs/f2fs//gc_urgent Date: August 2017 Contact: "Jaegeuk Kim" -Description: Do background GC agressively when set. When gc_urgent = 1, - background thread starts to do GC by given gc_urgent_sleep_time - interval. When gc_urgent = 2, F2FS will lower the bar of - checking idle in order to process outstanding discard commands - and GC a little bit aggressively. It is set to 0 by default. +Description: Do background GC aggressively when set. Set to 0 by default. + gc urgent high(1): does GC forcibly in a period of given + gc_urgent_sleep_time and ignores I/O idling check. uses greedy + GC approach and turns SSR mode on. + gc urgent low(2): lowers the bar of checking I/O idling in + order to process outstanding discard commands and GC a + little bit aggressively. uses cost benefit GC approach. + gc urgent mid(3): does GC forcibly in a period of given + gc_urgent_sleep_time and executes a mid level of I/O idling check. + uses cost benefit GC approach. What: /sys/fs/f2fs//gc_urgent_sleep_time Date: August 2017 @@ -506,7 +511,7 @@ Date: July 2021 Contact: "Daeho Jeong" Description: Show how many segments have been reclaimed by GC during a specific GC mode (0: GC normal, 1: GC idle CB, 2: GC idle greedy, - 3: GC idle AT, 4: GC urgent high, 5: GC urgent low) + 3: GC idle AT, 4: GC urgent high, 5: GC urgent low 6: GC urgent mid) You can re-initialize this value to "0". What: /sys/fs/f2fs//gc_segment_mode diff --git a/fs/f2fs/debug.c b/fs/f2fs/debug.c index f33e64acaf2b..a549f7b192d1 100644 --- a/fs/f2fs/debug.c +++ b/fs/f2fs/debug.c @@ -469,12 +469,14 @@ static int stat_show(struct seq_file *s, void *v) si->node_segs, si->bg_node_segs); seq_printf(s, " - Reclaimed segs : Normal (%d), Idle CB (%d), " "Idle Greedy (%d), Idle AT (%d), " - "Urgent High (%d), Urgent Low (%d)\n", + "Urgent High (%d), Urgent Mid (%d), " + "Urgent Low (%d)\n", si->sbi->gc_reclaimed_segs[GC_NORMAL], si->sbi->gc_reclaimed_segs[GC_IDLE_CB], si->sbi->gc_reclaimed_segs[GC_IDLE_GREEDY], si->sbi->gc_reclaimed_segs[GC_IDLE_AT], si->sbi->gc_reclaimed_segs[GC_URGENT_HIGH], + si->sbi->gc_reclaimed_segs[GC_URGENT_MID], si->sbi->gc_reclaimed_segs[GC_URGENT_LOW]); seq_printf(s, "Try to move %d blocks (BG: %d)\n", si->tot_blks, si->bg_data_blks + si->bg_node_blks); diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h index 2e13419f93e8..1e53d000490c 100644 --- a/fs/f2fs/f2fs.h +++ b/fs/f2fs/f2fs.h @@ -1286,6 +1286,7 @@ enum { GC_IDLE_AT, GC_URGENT_HIGH, GC_URGENT_LOW, + GC_URGENT_MID, MAX_GC_MODE, }; @@ -2754,6 +2755,9 @@ static inline bool is_idle(struct f2fs_sb_info *sbi, int type) if (is_inflight_io(sbi, type)) return false; + if (sbi->gc_mode == GC_URGENT_MID) + return true; + if (sbi->gc_mode == GC_URGENT_LOW && (type == DISCARD_TIME || type == GC_TIME)) return true; diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c index 71f969a8023f..2861b99704ff 100644 --- a/fs/f2fs/gc.c +++ b/fs/f2fs/gc.c @@ -90,7 +90,8 @@ static int gc_thread_func(void *data) * invalidated soon after by user update or deletion. * So, I'd like to wait some time to collect dirty segments. */ - if (sbi->gc_mode == GC_URGENT_HIGH) { + if (sbi->gc_mode == GC_URGENT_HIGH || + sbi->gc_mode == GC_URGENT_MID) { wait_ms = gc_th->urgent_sleep_time; f2fs_down_write(&sbi->gc_lock); goto do_gc; diff --git a/fs/f2fs/sysfs.c b/fs/f2fs/sysfs.c index a095919c55ad..07cdf2eef064 100644 --- a/fs/f2fs/sysfs.c +++ b/fs/f2fs/sysfs.c @@ -466,6 +466,13 @@ out: } } else if (t == 2) { sbi->gc_mode = GC_URGENT_LOW; + } else if (t == 3) { + sbi->gc_mode = GC_URGENT_MID; + if (sbi->gc_thread) { + sbi->gc_thread->gc_wake = 1; + wake_up_interruptible_all( + &sbi->gc_thread->gc_wait_queue_head); + } } else { return -EINVAL; } From 00499a5f22b015db989eb07ea02f731143946f7b Mon Sep 17 00:00:00 2001 From: Giuliano Procida Date: Wed, 3 May 2023 09:23:05 +0100 Subject: [PATCH 48/68] ANDROID: GKI: reorder symbols within ABI files This matches the extract_symbols ordering. Bug: 280431338 Change-Id: Iec287562393379fa6cf93be9a617deb09ed427fa Signed-off-by: Giuliano Procida --- android/abi_gki_aarch64_asus | 2 +- android/abi_gki_aarch64_exynos | 8 +- android/abi_gki_aarch64_galaxy | 7146 +++++++++++------------ android/abi_gki_aarch64_generic | 8 +- android/abi_gki_aarch64_lenovo | 10 +- android/abi_gki_aarch64_mtk | 6 +- android/abi_gki_aarch64_oplus | 78 +- android/abi_gki_aarch64_qcom | 10 +- android/abi_gki_aarch64_transsion | 110 +- android/abi_gki_aarch64_type_visibility | 2 +- android/abi_gki_aarch64_vivo | 6 +- android/abi_gki_aarch64_xiaomi | 130 +- 12 files changed, 3758 insertions(+), 3758 deletions(-) diff --git a/android/abi_gki_aarch64_asus b/android/abi_gki_aarch64_asus index a44e7e67e0e4..0c3159dcda6f 100644 --- a/android/abi_gki_aarch64_asus +++ b/android/abi_gki_aarch64_asus @@ -265,8 +265,8 @@ up_read up_write vfree vfs_fsync_range -vmalloc __vmalloc +vmalloc vsnprintf vzalloc __wait_on_buffer diff --git a/android/abi_gki_aarch64_exynos b/android/abi_gki_aarch64_exynos index 0b37ab51884c..5f0526297f1c 100644 --- a/android/abi_gki_aarch64_exynos +++ b/android/abi_gki_aarch64_exynos @@ -73,9 +73,9 @@ blocking_notifier_call_chain blocking_notifier_chain_register blocking_notifier_chain_unregister - bpf_trace_run1 bpf_trace_run10 bpf_trace_run12 + bpf_trace_run1 bpf_trace_run2 bpf_trace_run3 bpf_trace_run4 @@ -1044,9 +1044,9 @@ is_dma_buf_file is_vmalloc_addr iterate_fd - jiffies jiffies_64_to_clock_t jiffies64_to_msecs + jiffies jiffies_to_msecs jiffies_to_usecs kasan_flag_enabled @@ -1167,8 +1167,8 @@ memory_read_from_buffer memparse memremap - memset memset64 + memset __memset_io memstart_addr memunmap @@ -1262,8 +1262,8 @@ nla_find nla_memcpy __nla_parse - nla_put nla_put_64bit + nla_put nla_put_nohdr nla_reserve __nla_validate diff --git a/android/abi_gki_aarch64_galaxy b/android/abi_gki_aarch64_galaxy index 7ba5f74f973a..6b921ab3a901 100644 --- a/android/abi_gki_aarch64_galaxy +++ b/android/abi_gki_aarch64_galaxy @@ -1,121 +1,1948 @@ [abi_symbol_list] - PDE_DATA - __ClearPageMovable - __SetPageMovable - ___pskb_trim - ___ratelimit + access_process_vm + ack_all_badblocks + activate_task + add_cpu + add_device_randomness + add_memory + add_memory_subsection + add_taint + add_timer + add_timer_on + add_uevent_var + add_wait_queue + adjust_managed_page_count + alarm_cancel + alarm_init + alarm_start + alarm_start_relative + alarmtimer_get_rtcdev + alarm_try_to_cancel + alloc_anon_inode + alloc_chrdev_region __alloc_disk_node + alloc_etherdev_mqs + alloc_io_pgtable_ops + alloc_netdev_mqs + alloc_page_buffers + alloc_pages_exact __alloc_pages_nodemask __alloc_percpu __alloc_percpu_gfp __alloc_skb + alloc_skb_with_frags + alloc_workqueue + all_vm_events + amba_bustype + amba_driver_register + amba_driver_unregister + amba_release_regions + amba_request_regions + android_debug_per_cpu_symbol + android_debug_symbol + android_rvh_probe_register + anon_inode_getfd + anon_inode_getfile __arch_clear_user __arch_copy_from_user __arch_copy_in_user __arch_copy_to_user + arch_timer_read_counter + argv_free + argv_split + arm64_const_caps_ready + arm64_use_ng_mappings __arm_smccc_hvc __arm_smccc_smc + async_schedule_node + async_schedule_node_domain + async_synchronize_full_domain + _atomic_dec_and_lock + atomic_notifier_call_chain + atomic_notifier_chain_register + atomic_notifier_chain_unregister + autoremove_wake_function + available_idle_cpu + backlight_device_get_by_type + backlight_device_register + backlight_device_set_brightness + backlight_device_unregister + badblocks_clear + badblocks_exit + badblocks_init + badblocks_set + badblocks_show + badblocks_store + balloon_aops + balloon_page_alloc + balloon_page_dequeue + balloon_page_enqueue + bcmp + bdev_check_media_change + bdevname + bdev_read_only + bdget_disk + bd_link_disk_holder + bdput + bd_set_nr_sectors + bd_unlink_disk_holder + bgpio_init + bin2hex + bio_add_page + bio_alloc_bioset + bio_associate_blkg + bio_chain + bio_clone_blkg_association + bio_endio + bio_init + bio_put + bioset_exit + bioset_init + bitmap_allocate_region __bitmap_andnot __bitmap_clear __bitmap_complement + bitmap_find_next_zero_area_off + bitmap_from_arr32 __bitmap_or + bitmap_parse + bitmap_parselist + bitmap_parselist_user + bitmap_print_to_pagebuf + bitmap_release_region __bitmap_set + bitmap_to_arr32 __bitmap_weight __bitmap_xor - __blk_mq_debugfs_rq_show - __blk_mq_end_request - __blk_rq_map_sg + bitmap_zalloc + blk_alloc_queue + blkcg_activate_policy + blkcg_deactivate_policy + blkcg_policy_register + blkcg_policy_unregister + blkcg_root + blk_cleanup_queue + blkdev_fsync + blkdev_get_by_dev + blkdev_get_by_path __blkdev_issue_discard + blkdev_issue_flush __blkdev_issue_zeroout + blkdev_put + blk_execute_rq + blk_execute_rq_nowait + blk_finish_plug + blk_freeze_queue_start + blk_get_queue + blk_get_request + blkg_lookup_slowpath + blk_mq_alloc_request + blk_mq_alloc_request_hctx + blk_mq_alloc_tag_set + blk_mq_complete_request + blk_mq_complete_request_remote + __blk_mq_debugfs_rq_show + blk_mq_debugfs_rq_show + blk_mq_delay_kick_requeue_list + __blk_mq_end_request + blk_mq_end_request + blk_mq_free_request + blk_mq_free_tag_set + blk_mq_freeze_queue + blk_mq_freeze_queue_wait + blk_mq_freeze_queue_wait_timeout + blk_mq_init_queue + blk_mq_map_queues + blk_mq_pci_map_queues + blk_mq_quiesce_queue + blk_mq_requeue_request + blk_mq_rq_cpu + blk_mq_run_hw_queues + blk_mq_sched_request_inserted + blk_mq_sched_try_insert_merge + blk_mq_sched_try_merge + blk_mq_start_request + blk_mq_start_stopped_hw_queues + blk_mq_stop_hw_queue + blk_mq_tagset_busy_iter + blk_mq_tagset_wait_completed_request + blk_mq_tag_to_rq + blk_mq_unfreeze_queue + blk_mq_unique_tag + blk_mq_unquiesce_queue + blk_mq_update_nr_hw_queues + blk_mq_virtio_map_queues + blk_poll + blk_put_queue + blk_put_request + blk_queue_alignment_offset + blk_queue_bounce_limit + blk_queue_can_use_dma_map_merging + blk_queue_chunk_sectors + blk_queue_dma_alignment + blk_queue_flag_clear + blk_queue_flag_set + blk_queue_flag_test_and_set + blk_queue_io_min + blk_queue_io_opt + blk_queue_logical_block_size + blk_queue_max_discard_sectors + blk_queue_max_discard_segments + blk_queue_max_hw_sectors + blk_queue_max_segments + blk_queue_max_segment_size + blk_queue_max_write_zeroes_sectors + blk_queue_physical_block_size + blk_queue_rq_timeout + blk_queue_split + blk_queue_virt_boundary + blk_queue_write_cache + blk_register_region + blk_rq_map_kern + __blk_rq_map_sg + blk_rq_map_user + blk_rq_map_user_iov + blk_rq_unmap_user + blk_set_queue_dying + blk_set_stacking_limits + blk_start_plug + blk_status_to_errno + blk_sync_queue + blk_unregister_region + blk_update_request + blk_verify_command + blocking_notifier_call_chain + blocking_notifier_chain_register + blocking_notifier_chain_unregister + bmap + bpf_dispatcher_xdp_func + bpf_prog_add + bpf_prog_put + bpf_prog_sub + bpf_stats_enabled_key + bpf_trace_run10 + bpf_trace_run11 + bpf_trace_run12 + bpf_trace_run1 + bpf_trace_run2 + bpf_trace_run3 + bpf_trace_run4 + bpf_trace_run5 + bpf_trace_run6 + bpf_trace_run7 + bpf_trace_run8 + bpf_trace_run9 + bpf_warn_invalid_xdp_action + bsearch + bt_err + bt_info + build_skb + bus_find_device + bus_for_each_dev + bus_for_each_drv + bus_register + bus_register_notifier + bus_set_iommu + bus_unregister + bus_unregister_notifier + cache_line_size + call_netdevice_notifiers + call_rcu + call_rcu_tasks + call_rcu_tasks_trace + call_srcu + cancel_delayed_work + cancel_delayed_work_sync + cancel_work_sync + capable + cdc_ncm_bind_common + cdc_ncm_change_mtu + cdc_ncm_fill_tx_frame + cdc_ncm_rx_verify_ndp16 + cdc_ncm_rx_verify_nth16 + cdc_ncm_select_altsetting + cdc_ncm_unbind + cdc_parse_cdc_header + cdev_add + cdev_alloc + cdev_del + cdev_device_add + cdev_device_del + cdev_init + cec_allocate_adapter + cec_delete_adapter + cec_received_msg_ts + cec_register_adapter + cec_s_log_addrs + cec_s_phys_addr + cec_s_phys_addr_from_edid + cec_transmit_attempt_done_ts + cec_transmit_done_ts + cec_unregister_adapter __cfi_slowpath + cgroup_path_ns + cgroup_taskset_first + cgroup_taskset_next __check_object_size + check_preempt_curr + check_zeroed_user __class_create + class_create_file_ns + class_destroy + class_find_device + class_for_each_device + class_interface_unregister __class_register + class_remove_file_ns + class_unregister + cleancache_register_ops + cleanup_srcu_struct + clear_page + __ClearPageMovable + clk_bulk_disable + clk_bulk_enable + clk_bulk_get_all + clk_bulk_prepare + clk_bulk_put_all + clk_bulk_unprepare __clk_determine_rate + clk_disable + clk_enable + clk_fixed_factor_ops + clk_fixed_rate_ops + clk_get __clk_get_hw __clk_get_name + clk_get_parent + clk_get_rate + clk_hw_get_flags + clk_hw_get_name + clk_hw_get_num_parents + clk_hw_get_parent + clk_hw_get_parent_by_index + clk_hw_get_rate + clk_hw_is_enabled + clk_hw_is_prepared + clk_hw_register __clk_hw_register_divider + clk_hw_register_fixed_factor __clk_hw_register_gate __clk_hw_register_mux + clk_hw_round_rate + clk_hw_set_rate_range + clk_hw_unregister + clk_hw_unregister_divider + clk_hw_unregister_fixed_factor + clk_hw_unregister_gate + clk_hw_unregister_mux __clk_is_enabled __clk_mux_determine_rate_closest + clk_notifier_register + clk_notifier_unregister + clk_prepare + clk_put + clk_register + clk_register_clkdev + clk_register_fixed_factor + clk_register_fixed_rate + clk_register_gate + clk_round_rate + clk_set_parent + clk_set_rate + clk_sync_state + clk_unprepare + clk_unregister + clockevents_config_and_register + clocks_calc_mult_shift __clocksource_register_scale __close_fd + cma_alloc + cma_for_each_area + cma_get_name + cma_release + compat_alloc_user_space + compat_only_sysfs_link_entry_to_kobj + compat_ptr_ioctl + complete + complete_all + complete_and_exit + completion_done + component_add + component_bind_all + component_del + component_master_add_with_match + component_master_del + component_match_add_release + component_unbind_all + cond_synchronize_rcu + config_ep_by_speed + configfs_register_subsystem + configfs_unregister_subsystem + config_group_init + config_group_init_type_name + config_item_get + config_item_put + console_drivers + console_printk + console_stop + console_suspend_enabled + console_trylock + console_unlock __const_udelay + consume_skb + contig_page_data + _copy_from_iter + _copy_from_iter_full + copy_from_kernel_nofault + copy_page + _copy_to_iter __cpu_active_mask - __cpu_online_mask - __cpu_possible_mask - __cpu_present_mask + cpu_all_bits + cpu_bit_bitmap + cpufreq_add_update_util_hook + cpufreq_cpu_get + cpufreq_cpu_get_raw + cpufreq_cpu_put + cpufreq_disable_fast_switch + cpufreq_driver_fast_switch + cpufreq_driver_resolve_freq __cpufreq_driver_target + cpufreq_enable_boost_support + cpufreq_enable_fast_switch + cpufreq_freq_attr_scaling_available_freqs + cpufreq_freq_attr_scaling_boost_freqs + cpufreq_freq_transition_begin + cpufreq_freq_transition_end + cpufreq_frequency_table_verify + cpufreq_generic_attr + cpufreq_generic_frequency_table_verify + cpufreq_generic_get + cpufreq_generic_suspend + cpufreq_get_driver_data + cpufreq_get_policy + cpufreq_policy_transition_delay_us + cpufreq_quick_get + cpufreq_quick_get_max + cpufreq_register_driver + cpufreq_register_governor + cpufreq_register_notifier + cpufreq_remove_update_util_hook + cpufreq_table_index_unsorted + cpufreq_this_cpu_can_update + cpufreq_unregister_driver + cpufreq_unregister_notifier + cpufreq_update_policy + cpu_hotplug_disable + cpu_hotplug_enable __cpuhp_remove_state __cpuhp_setup_state __cpuhp_setup_state_cpuslocked __cpuhp_state_add_instance __cpuhp_state_remove_instance + cpuhp_tasks_frozen + cpu_hwcap_keys + cpu_hwcaps + cpuidle_governor_latency_req + cpuidle_register_governor + cpu_irqtime + cpu_is_hotpluggable + cpu_latency_qos_add_request + cpu_latency_qos_remove_request + cpu_latency_qos_request_active + cpu_latency_qos_update_request + cpumask_any_but + cpumask_next + cpumask_next_and + cpumask_next_wrap + cpu_number + __cpu_online_mask + cpu_pm_register_notifier + cpu_pm_unregister_notifier + __cpu_possible_mask + __cpu_present_mask + cpupri_find_fitness + cpu_scale + cpus_read_lock + cpus_read_unlock + cpu_subsys + cpu_topology + crc16 + crc32_le + crc8 + crc8_populate_msb + create_function_device + crypto_aead_encrypt + crypto_aead_setauthsize + crypto_aead_setkey + crypto_alloc_aead + crypto_alloc_base + crypto_alloc_shash + crypto_alloc_skcipher + crypto_cipher_encrypt_one + crypto_cipher_setkey + crypto_comp_compress + crypto_comp_decompress + crypto_destroy_tfm + crypto_has_alg + crypto_register_alg + crypto_register_rngs + crypto_register_scomp + crypto_shash_digest + crypto_shash_final + crypto_shash_setkey + crypto_shash_update + crypto_skcipher_decrypt + crypto_skcipher_encrypt + crypto_skcipher_setkey + crypto_unregister_alg + crypto_unregister_rngs + crypto_unregister_scomp + css_next_child + css_next_descendant_pre + csum_ipv6_magic + csum_partial + csum_tcpudp_nofold + _ctype + current_time + current_work + d_add + d_alloc_name + dapm_pinctrl_event + dapm_regulator_event + datagram_poll + d_delete + deactivate_task + debugfs_attr_read + debugfs_attr_write + debugfs_create_atomic_t + debugfs_create_blob + debugfs_create_bool + debugfs_create_dir + debugfs_create_file + debugfs_create_file_unsafe + debugfs_create_regset32 + debugfs_create_size_t + debugfs_create_symlink + debugfs_create_u16 + debugfs_create_u32 + debugfs_create_u64 + debugfs_create_u8 + debugfs_create_ulong + debugfs_create_x32 + debugfs_create_x64 + debugfs_create_x8 + debugfs_file_get + debugfs_file_put + debugfs_lookup + debugfs_print_regs32 + debugfs_remove + dec_zone_page_state + default_llseek + deferred_free + delayed_work_timer_fn + del_gendisk + del_timer + del_timer_sync + desc_to_gpio + destroy_workqueue + _dev_alert + dev_alloc_name + dev_close + dev_coredumpm + dev_coredumpv + _dev_crit + dev_driver_string + _dev_emerg + _dev_err + dev_err_probe + devfreq_add_device + devfreq_add_governor + devfreq_cooling_unregister + devfreq_get_devfreq_by_phandle + devfreq_monitor_resume + devfreq_monitor_start + devfreq_monitor_stop + devfreq_monitor_suspend + devfreq_recommended_opp + devfreq_register_opp_notifier + devfreq_remove_device + devfreq_remove_governor + devfreq_resume_device + devfreq_suspend_device + devfreq_unregister_opp_notifier + devfreq_update_interval + dev_fwnode __dev_get_by_index + dev_get_by_index + dev_get_by_name + dev_get_regmap + dev_get_stats + device_add + device_add_disk + device_add_groups + device_attach + device_bind_driver + device_create + device_create_bin_file + device_create_file + device_create_with_groups + device_del + device_destroy + device_find_child + device_for_each_child + device_get_child_node_count + device_get_dma_attr + device_get_mac_address + device_get_match_data + device_get_named_child_node + device_get_next_child_node + device_initialize + device_init_wakeup + device_link_add + device_link_del + device_match_fwnode + device_match_name + device_match_of_node + device_property_present + device_property_read_string + device_property_read_string_array + device_property_read_u16_array + device_property_read_u32_array + device_property_read_u8_array + device_register + device_release_driver + device_remove_bin_file + device_remove_file + device_remove_file_self + device_remove_groups + device_set_wakeup_capable + device_set_wakeup_enable + device_show_bool + device_show_int + device_store_bool + device_store_int + device_unregister + device_wakeup_disable + device_wakeup_enable + _dev_info __dev_kfree_skb_any + devm_add_action __devm_alloc_percpu + devm_backlight_device_register + devm_backlight_device_unregister + devm_blk_ksm_init + devm_clk_bulk_get + devm_clk_bulk_get_all + devm_clk_bulk_get_optional + devm_clk_get + devm_clk_get_optional + devm_clk_hw_register + devm_clk_hw_register_clkdev + devm_clk_put + devm_clk_register + dev_mc_sync_multiple + dev_mc_unsync + devm_devfreq_add_device + devm_devfreq_register_notifier + devm_devfreq_unregister_notifier + devm_device_add_group + devm_device_add_groups + devm_device_remove_group __devm_drm_dev_alloc + devm_drm_panel_bridge_add_typed + devm_extcon_dev_allocate + devm_extcon_dev_register + devm_extcon_dev_unregister + devm_extcon_register_notifier + devm_free_irq + devm_free_percpu + devm_gen_pool_create + devm_get_clk_from_child + devm_gpiochip_add_data_with_key + devm_gpiod_get + devm_gpiod_get_array + devm_gpiod_get_index + devm_gpiod_get_optional + devm_gpiod_put_array + devm_gpio_free + devm_gpio_request + devm_gpio_request_one + devm_hwrng_register + devm_hwspin_lock_register + devm_i2c_new_dummy_device + devm_iio_channel_get + devm_iio_device_alloc __devm_iio_device_register + devm_input_allocate_device + devm_ioremap + devm_ioremap_resource + devm_ioremap_wc + devm_iounmap __devm_irq_alloc_descs + devm_kasprintf + devm_kfree + devm_kmalloc + devm_kmemdup + devm_kstrdup + devm_kstrdup_const + devm_kvasprintf + devm_led_classdev_register_ext + devm_mbox_controller_register + devm_memremap + devm_mfd_add_devices + devm_nvmem_cell_get + devm_nvmem_device_get + devm_nvmem_register + devm_of_clk_add_hw_provider + devm_of_icc_get + devm_of_iomap __devm_of_phy_provider_register + devm_of_platform_populate + devm_of_pwm_get + devm_pci_alloc_host_bridge + devm_phy_create + devm_phy_get + devm_phy_put + devm_pinctrl_get + devm_pinctrl_put + devm_pinctrl_register + devm_pinctrl_register_and_init + devm_platform_get_and_ioremap_resource + devm_platform_ioremap_resource + devm_platform_ioremap_resource_byname + devm_power_supply_register + devm_pwm_put + devm_regmap_add_irq_chip + devm_regmap_del_irq_chip + devm_regmap_field_alloc __devm_regmap_init __devm_regmap_init_i2c __devm_regmap_init_mmio_clk __devm_regmap_init_spi + devm_regulator_bulk_get + devm_regulator_get + devm_regulator_get_exclusive + devm_regulator_get_optional + devm_regulator_put + devm_regulator_register + devm_regulator_register_notifier __devm_release_region + devm_request_any_context_irq __devm_request_region + devm_request_threaded_irq + devm_reset_control_array_get __devm_reset_control_get + devm_reset_controller_register + devm_rtc_allocate_device + devm_rtc_device_register + devm_snd_dmaengine_pcm_register + devm_snd_soc_register_card + devm_snd_soc_register_component __devm_spi_alloc_controller + devm_spi_register_controller + devm_thermal_of_cooling_device_register + devm_thermal_zone_of_sensor_register + devm_thermal_zone_of_sensor_unregister + devm_usb_get_phy + devm_usb_get_phy_by_node + devm_usb_get_phy_by_phandle + devm_watchdog_register_device + _dev_notice + dev_open + dev_pm_clear_wake_irq + dev_pm_domain_attach + dev_pm_domain_attach_by_name + dev_pm_domain_detach + dev_pm_genpd_add_notifier + dev_pm_genpd_remove_notifier + dev_pm_genpd_set_next_wakeup + dev_pm_genpd_set_performance_state + dev_pm_opp_add + dev_pm_opp_adjust_voltage + dev_pm_opp_disable + dev_pm_opp_enable + dev_pm_opp_find_freq_ceil + dev_pm_opp_find_freq_ceil_by_volt + dev_pm_opp_find_freq_exact + dev_pm_opp_find_freq_floor + dev_pm_opp_free_cpufreq_table + dev_pm_opp_get_freq + dev_pm_opp_get_level + dev_pm_opp_get_max_transition_latency + dev_pm_opp_get_opp_count + dev_pm_opp_get_opp_table + dev_pm_opp_get_sharing_cpus + dev_pm_opp_get_suspend_opp_freq + dev_pm_opp_get_voltage + dev_pm_opp_init_cpufreq_table + dev_pm_opp_of_add_table + dev_pm_opp_of_cpumask_add_table + dev_pm_opp_of_cpumask_remove_table + dev_pm_opp_of_find_icc_paths + dev_pm_opp_of_get_sharing_cpus + dev_pm_opp_of_register_em + dev_pm_opp_of_remove_table + dev_pm_opp_put + dev_pm_opp_put_clkname + dev_pm_opp_put_opp_table + dev_pm_opp_put_regulators + dev_pm_opp_register_notifier + dev_pm_opp_remove_all_dynamic + dev_pm_opp_set_bw + dev_pm_opp_set_clkname + dev_pm_opp_set_rate + dev_pm_opp_set_regulators + dev_pm_opp_set_sharing_cpus + dev_pm_opp_set_supported_hw + dev_pm_opp_unregister_notifier + dev_pm_qos_add_notifier + dev_pm_qos_add_request + dev_pm_qos_expose_latency_tolerance + dev_pm_qos_hide_latency_tolerance + dev_pm_qos_read_value + dev_pm_qos_remove_notifier + dev_pm_qos_remove_request + dev_pm_qos_update_request + dev_pm_qos_update_user_latency_tolerance + dev_pm_set_dedicated_wake_irq + dev_printk + dev_printk_emit + dev_queue_xmit + devres_add + devres_alloc_node + devres_free + devres_release + dev_set_mtu + dev_set_name + dev_uc_sync_multiple + dev_uc_unsync + _dev_warn + disable_irq + disable_irq_nosync + disable_percpu_irq + disk_end_io_acct + disk_start_io_acct + divider_get_val + divider_recalc_rate + divider_ro_round_rate_parent + divider_round_rate_parent + dma_alloc_attrs + dma_async_device_register + dma_async_device_unregister + dma_async_tx_descriptor_init + dma_buf_attach + dma_buf_begin_cpu_access + dma_buf_begin_cpu_access_partial + dma_buf_detach + dma_buf_dynamic_attach + dma_buf_end_cpu_access + dma_buf_end_cpu_access_partial + dma_buf_export + dma_buf_fd + dma_buf_get + dma_buf_get_flags + dma_buf_map_attachment + dma_buf_mmap + dma_buf_move_notify + dmabuf_page_pool_alloc + dmabuf_page_pool_create + dmabuf_page_pool_destroy + dmabuf_page_pool_free + dma_buf_pin + dma_buf_put + dma_buf_unmap_attachment + dma_buf_unpin + dma_buf_vmap + dma_buf_vunmap + dma_contiguous_default_area + dmaengine_unmap_put + dma_fence_add_callback + dma_fence_array_create + dma_fence_array_ops + dma_fence_context_alloc + dma_fence_default_wait + dma_fence_enable_sw_signaling + dma_fence_free + dma_fence_get_status + dma_fence_get_stub + dma_fence_init + dma_fence_match_context + dma_fence_release + dma_fence_remove_callback + dma_fence_signal + dma_fence_signal_locked + dma_fence_wait_any_timeout + dma_fence_wait_timeout + dma_free_attrs + dma_get_merge_boundary + dma_get_required_mask + dma_get_sgtable_attrs + dma_get_slave_caps + dma_get_slave_channel + dma_heap_add + dma_heap_buffer_alloc + dma_heap_buffer_free + dma_heap_find + dma_heap_get_dev + dma_heap_get_drvdata + dma_heap_get_name + dma_heap_put + d_make_root + dmam_alloc_attrs + dma_map_page_attrs + dma_map_resource + dma_map_sg_attrs + dma_max_mapping_size + dmam_free_coherent + dma_mmap_attrs + dmam_pool_create + dma_pool_alloc + dma_pool_create + dma_pool_destroy + dma_pool_free + dma_release_channel + dma_request_chan __dma_request_channel + dma_resv_add_excl_fence + dma_resv_add_shared_fence + dma_resv_fini + dma_resv_get_fences_rcu + dma_resv_init + dma_resv_reserve_shared + dma_resv_test_signaled_rcu + dma_resv_wait_timeout_rcu + dma_set_coherent_mask + dma_set_mask + dma_sync_sg_for_cpu + dma_sync_sg_for_device + dma_sync_single_for_cpu + dma_sync_single_for_device + dma_unmap_page_attrs + dma_unmap_resource + dma_unmap_sg_attrs + do_exit __do_once_done __do_once_start + do_SAK + do_trace_rcu_torture_read + do_wait_intr + do_wait_intr_irq + down + downgrade_write + down_interruptible + down_read + down_read_killable + down_read_trylock + down_timeout + down_trylock + down_write + d_path + dput + drain_workqueue + driver_attach + driver_create_file + driver_find_device + driver_register + driver_remove_file + driver_unregister + drm_add_edid_modes + drm_add_modes_noedid + drm_atomic_add_affected_connectors + drm_atomic_add_affected_planes + drm_atomic_commit + drm_atomic_get_connector_state + drm_atomic_get_crtc_state + drm_atomic_get_new_connector_for_encoder + drm_atomic_get_plane_state + drm_atomic_get_private_obj_state + drm_atomic_helper_bridge_destroy_state + drm_atomic_helper_bridge_duplicate_state + drm_atomic_helper_bridge_reset + drm_atomic_helper_check + drm_atomic_helper_check_modeset + drm_atomic_helper_check_planes + drm_atomic_helper_check_plane_state + drm_atomic_helper_cleanup_planes + drm_atomic_helper_commit + drm_atomic_helper_commit_cleanup_done + drm_atomic_helper_commit_duplicated_state + drm_atomic_helper_commit_hw_done + drm_atomic_helper_commit_modeset_disables + drm_atomic_helper_commit_modeset_enables + drm_atomic_helper_commit_planes + drm_atomic_helper_commit_tail __drm_atomic_helper_connector_destroy_state + drm_atomic_helper_connector_destroy_state __drm_atomic_helper_connector_duplicate_state + drm_atomic_helper_connector_duplicate_state __drm_atomic_helper_connector_reset + drm_atomic_helper_connector_reset __drm_atomic_helper_crtc_destroy_state + drm_atomic_helper_crtc_destroy_state __drm_atomic_helper_crtc_duplicate_state + drm_atomic_helper_crtc_duplicate_state __drm_atomic_helper_crtc_reset + drm_atomic_helper_crtc_reset + drm_atomic_helper_damage_merged + drm_atomic_helper_dirtyfb + drm_atomic_helper_disable_plane + drm_atomic_helper_disable_planes_on_crtc + drm_atomic_helper_duplicate_state + drm_atomic_helper_fake_vblank + drm_atomic_helper_page_flip __drm_atomic_helper_plane_destroy_state + drm_atomic_helper_plane_destroy_state __drm_atomic_helper_plane_duplicate_state + drm_atomic_helper_plane_duplicate_state + drm_atomic_helper_plane_reset + drm_atomic_helper_prepare_planes __drm_atomic_helper_private_obj_duplicate_state + drm_atomic_helper_set_config + drm_atomic_helper_setup_commit + drm_atomic_helper_shutdown + drm_atomic_helper_swap_state + drm_atomic_helper_update_legacy_modeset_state + drm_atomic_helper_update_plane + drm_atomic_helper_wait_for_dependencies + drm_atomic_helper_wait_for_fences + drm_atomic_helper_wait_for_flip_done + drm_atomic_helper_wait_for_vblanks + drm_atomic_normalize_zpos + drm_atomic_private_obj_fini + drm_atomic_private_obj_init + drm_atomic_set_crtc_for_connector + drm_atomic_set_crtc_for_plane + drm_atomic_set_fb_for_plane + drm_atomic_set_fence_for_plane + drm_atomic_set_mode_for_crtc + drm_atomic_state_alloc + drm_atomic_state_clear + drm_atomic_state_default_clear + drm_atomic_state_default_release __drm_atomic_state_free + drm_atomic_state_init + drm_bridge_add + drm_bridge_attach + drm_bridge_chain_disable + drm_bridge_chain_enable + drm_bridge_chain_mode_set + drm_bridge_chain_post_disable + drm_bridge_chain_pre_enable + drm_bridge_hpd_notify + drm_bridge_remove + drm_client_init + drm_client_modeset_commit_locked + drm_client_register + drm_compat_ioctl + drm_connector_attach_dp_subconnector_property + drm_connector_attach_edid_property + drm_connector_attach_encoder + drm_connector_cleanup + drm_connector_has_possible_encoder + drm_connector_init + drm_connector_init_with_ddc + drm_connector_list_iter_begin + drm_connector_list_iter_end + drm_connector_list_iter_next + drm_connector_register + drm_connector_set_tile_property + drm_connector_unregister + drm_connector_update_edid_property + drm_crtc_arm_vblank_event + drm_crtc_cleanup + drm_crtc_enable_color_mgmt + drm_crtc_from_index + drm_crtc_handle_vblank + drm_crtc_helper_set_config + drm_crtc_helper_set_mode + drm_crtc_init + drm_crtc_init_with_planes + drm_crtc_send_vblank_event + drm_crtc_set_max_vblank_count + drm_crtc_vblank_count + drm_crtc_vblank_count_and_time + drm_crtc_vblank_get + drm_crtc_vblank_helper_get_vblank_timestamp + drm_crtc_vblank_off + drm_crtc_vblank_on + drm_crtc_vblank_put + drm_crtc_vblank_reset + drm_crtc_wait_one_vblank + drm_cvt_mode __drm_dbg __drm_debug + drm_debugfs_create_files + drm_detect_hdmi_monitor + drm_detect_monitor_audio + drm_dev_alloc + drm_dev_dbg + drm_dev_enter + drm_dev_exit + drm_dev_get + drm_dev_printk + drm_dev_put + drm_dev_register + drm_dev_set_unique + drm_dev_unplug + drm_dev_unregister + drm_display_mode_to_videomode + drm_do_get_edid + drm_dp_atomic_find_vcpi_slots + drm_dp_atomic_release_vcpi_slots + drm_dp_aux_init + drm_dp_aux_register + drm_dp_aux_unregister + drm_dp_bw_code_to_link_rate + drm_dp_calc_pbn_mode + drm_dp_channel_eq_ok + drm_dp_check_act_status + drm_dp_clock_recovery_ok + drm_dp_dpcd_read + drm_dp_dpcd_read_link_status + drm_dp_dpcd_write + drm_dp_find_vcpi_slots + drm_dp_get_adjust_request_pre_emphasis + drm_dp_get_adjust_request_voltage + drm_dp_get_edid_quirks + drm_dp_link_rate_to_bw_code + drm_dp_link_train_channel_eq_delay + drm_dp_link_train_clock_recovery_delay + drm_dp_mst_allocate_vcpi + drm_dp_mst_deallocate_vcpi + drm_dp_mst_detect_port + drm_dp_mst_get_edid + drm_dp_mst_get_port_malloc + drm_dp_mst_hpd_irq + drm_dp_mst_put_port_malloc + drm_dp_mst_reset_vcpi_slots + drm_dp_mst_topology_mgr_destroy + drm_dp_mst_topology_mgr_init + drm_dp_mst_topology_mgr_set_mst + drm_dp_send_power_updown_phy + drm_dp_set_subconnector_property + drm_dp_update_payload_part1 + drm_dp_update_payload_part2 + drm_edid_block_valid + drm_edid_duplicate + drm_edid_get_monitor_name + drm_edid_header_is_valid + drm_edid_is_valid + drm_edid_to_sad + drm_edid_to_speaker_allocation + drm_encoder_cleanup + drm_encoder_init __drm_err + drm_event_cancel_free + drm_event_reserve_init + drm_event_reserve_init_locked + drm_fb_cma_get_gem_obj + drm_flip_work_cleanup + drm_flip_work_commit + drm_flip_work_init + drm_flip_work_queue + drm_format_info + drm_framebuffer_cleanup + drm_framebuffer_init + drm_framebuffer_lookup + drm_framebuffer_remove + drm_framebuffer_unregister_private + drm_gem_cma_dumb_create_internal + drm_gem_cma_free_object + drm_gem_cma_mmap + drm_gem_cma_prime_get_sg_table + drm_gem_cma_prime_import_sg_table + drm_gem_cma_prime_mmap + drm_gem_cma_prime_vmap + drm_gem_cma_prime_vunmap + drm_gem_cma_vm_ops + drm_gem_create_mmap_offset + drm_gem_dmabuf_mmap + drm_gem_dmabuf_release + drm_gem_dmabuf_vmap + drm_gem_dmabuf_vunmap + drm_gem_fb_create + drm_gem_fb_create_handle + drm_gem_fb_destroy + drm_gem_fb_get_obj + drm_gem_fb_prepare_fb + drm_gem_free_mmap_offset + drm_gem_get_pages + drm_gem_handle_create + drm_gem_lock_reservations + drm_gem_map_attach + drm_gem_map_detach + drm_gem_map_dma_buf + drm_gem_mmap + drm_gem_mmap_obj + drm_gem_object_free + drm_gem_object_init + drm_gem_object_lookup + drm_gem_object_put_locked + drm_gem_object_release + drm_gem_prime_export + drm_gem_prime_fd_to_handle + drm_gem_prime_handle_to_fd + drm_gem_prime_import + drm_gem_prime_import_dev + drm_gem_prime_mmap + drm_gem_private_object_init + drm_gem_put_pages + drm_gem_shmem_create + drm_gem_shmem_free_object + drm_gem_shmem_get_sg_table + drm_gem_shmem_mmap + drm_gem_shmem_pin + drm_gem_shmem_print_info + drm_gem_shmem_unpin + drm_gem_shmem_vmap + drm_gem_shmem_vunmap + drm_gem_unlock_reservations + drm_gem_unmap_dma_buf + drm_gem_vm_close + drm_gem_vm_open + drm_get_connector_status_name + drm_get_edid + drm_get_format_info + drm_get_format_name + drm_handle_vblank + drm_hdmi_avi_infoframe_from_display_mode + drm_helper_connector_dpms + drm_helper_disable_unused_functions + drm_helper_force_disable_all + drm_helper_hpd_irq_event + drm_helper_mode_fill_fb_struct + drm_helper_probe_single_connector_modes + drm_helper_resume_force_mode + drm_ioctl + drm_irq_install + drm_irq_uninstall + drm_is_current_master + drm_kms_helper_hotplug_event + drm_kms_helper_is_poll_worker + drm_kms_helper_poll_disable + drm_kms_helper_poll_enable + drm_kms_helper_poll_fini + drm_kms_helper_poll_init + drm_match_cea_mode + drmm_kmalloc + drm_mm_init + drm_mm_insert_node_in_range + drmm_mode_config_init + drm_mm_print + drm_mm_remove_node + drm_mm_takedown + drm_mode_config_cleanup + drm_mode_config_helper_resume + drm_mode_config_helper_suspend + drm_mode_config_reset + drm_mode_convert_to_umode + drm_mode_convert_umode + drm_mode_copy + drm_mode_create + drm_mode_create_dp_colorspace_property + drm_mode_create_scaling_mode_property + drm_mode_create_tile_group + drm_mode_crtc_set_gamma_size + drm_mode_debug_printmodeline + drm_mode_destroy + drm_mode_duplicate + drm_mode_equal + drm_mode_equal_no_clocks + drm_mode_get_tile_group + drm_mode_is_420_only + drm_mode_match + drm_mode_object_find + drm_mode_object_get + drm_mode_object_put + drm_mode_probed_add + drm_modeset_acquire_fini + drm_modeset_acquire_init + drm_modeset_backoff + drm_mode_set_crtcinfo + drm_modeset_drop_locks + drm_modeset_lock + drm_modeset_lock_all + drm_modeset_lock_all_ctx + drm_modeset_lock_init + drm_mode_set_name + drm_modeset_unlock + drm_modeset_unlock_all + drm_mode_sort + drm_mode_vrefresh + drm_need_swiotlb + drm_object_attach_property + drm_object_property_set_value + drm_of_component_match_add + drm_of_find_possible_crtcs + drm_open + drm_panel_add + drm_panel_disable + drm_panel_enable + drm_panel_get_modes + drm_panel_init + drm_panel_prepare + drm_panel_remove + drm_panel_unprepare + drm_plane_cleanup + drm_plane_create_alpha_property + drm_plane_create_blend_mode_property + drm_plane_create_rotation_property + drm_plane_create_zpos_property + drm_plane_enable_fb_damage_clips + drm_poll + drm_prime_gem_destroy + drm_prime_pages_to_sg + drm_prime_sg_to_page_addr_arrays + drm_printf __drm_printfn_coredump __drm_printfn_info __drm_printfn_seq_file + drm_property_blob_get + drm_property_blob_put + drm_property_create + drm_property_create_bitmask + drm_property_create_blob + drm_property_create_bool + drm_property_create_enum + drm_property_create_range + drm_property_create_signed_range + drm_property_lookup_blob + drm_property_replace_blob + drm_puts __drm_puts_coredump __drm_puts_seq_file + drm_read + drm_rect_calc_hscale + drm_rect_calc_vscale + drm_rect_clip_scaled + drm_rect_intersect + drm_release + drm_rotation_simplify + drm_send_event + drm_send_event_locked + drm_set_preferred_mode + drm_simple_encoder_init + drm_state_dump + drm_syncobj_add_point + drm_syncobj_create + drm_syncobj_find + drm_syncobj_find_fence + drm_syncobj_free + drm_syncobj_get_fd + drm_syncobj_get_handle + drm_syncobj_replace_fence + drm_sysfs_hotplug_event + drm_universal_plane_init + drm_vblank_init + drm_vma_node_allow + drm_vma_node_is_allowed + drm_vma_node_revoke + drm_wait_one_vblank + drm_writeback_connector_init + drm_writeback_queue_job + drm_writeback_signal_completion + dst_release + dump_align + dump_backtrace + dump_emit + dump_stack + dup_iter + dwc3_send_gadget_ep_cmd + dwc3_stop_active_transfer + dw_handle_msi_irq + dw_pcie_host_init + dw_pcie_msi_init + dw_pcie_own_conf_map_bus + dw_pcie_read + dw_pcie_setup_rc + dw_pcie_write __dynamic_dev_dbg __dynamic_pr_debug + edac_device_add_device + edac_device_alloc_ctl_info + edac_device_alloc_index + edac_device_del_device + edac_device_free_ctl_info + edac_device_handle_ce_count + edac_device_handle_ue_count + efi + efi_tpm_final_log_size + elevator_alloc + elv_bio_merge_ok + elv_rb_add + elv_rb_del + elv_rb_find + elv_rb_former_request + elv_rb_latter_request + elv_register + elv_rqhash_add + elv_rqhash_del + elv_unregister + emergency_restart + enable_irq + enable_percpu_irq + eth_commit_mac_addr_change + ether_setup + eth_mac_addr + eth_platform_get_mac_address + eth_prepare_mac_addr_change __ethtool_get_link_ksettings + ethtool_op_get_link + ethtool_op_get_ts_info + ethtool_virtdev_set_link_ksettings + eth_type_trans + eth_validate_addr + eventfd_ctx_fdget + eventfd_ctx_fileget + eventfd_ctx_put + eventfd_ctx_remove_wait_queue + eventfd_signal + event_triggers_call + extcon_find_edev_by_node + extcon_get_edev_by_phandle + extcon_get_edev_name + extcon_get_extcon_dev + extcon_get_property + extcon_get_state + extcon_register_notifier + extcon_set_property + extcon_set_property_capability + extcon_set_state_sync + extcon_unregister_notifier + fasync_helper __fdget + fd_install + fget + file_path + file_ra_state_init + filp_close + filp_open_block + find_get_pid + find_last_bit + find_next_bit + find_next_zero_bit + find_snd_usb_substream + find_task_by_vpid + find_vma + find_vpid + finish_wait + firmware_request_nowarn + fixed_phy_register + fixed_phy_unregister + fixed_size_llseek + flow_keys_basic_dissector + flush_dcache_page + flush_delayed_work __flush_icache_range + flush_signals + flush_work + flush_workqueue + fput + frame_vector_create + frame_vector_destroy + frame_vector_to_pages + free_buffer_head + free_io_pgtable_ops + free_irq + free_netdev __free_pages + free_pages + free_pages_exact + free_percpu + free_percpu_irq + freezing_slow_path + freq_qos_add_request + freq_qos_remove_request + freq_qos_update_request + freq_scale + fs_bio_set + fsync_bdev + ftrace_dump + full_name_hash + fwnode_find_reference + fwnode_get_name + fwnode_get_named_child_node + fwnode_get_next_child_node + fwnode_gpiod_get_index + fwnode_handle_get + fwnode_handle_put + fwnode_property_present + fwnode_property_read_string + fwnode_property_read_u32_array + fwnode_usb_role_switch_get + gcd + generic_delete_inode + generic_device_group + generic_file_llseek + generic_file_read_iter + generic_handle_irq + generic_iommu_put_resv_regions + generic_mii_ioctl + generic_perform_write + generic_write_checks + genlmsg_put + genl_notify + genl_register_family + genl_unregister_family __genphy_config_aneg + genphy_read_status + genphy_resume + genphy_soft_reset + genphy_suspend + gen_pool_add_owner + gen_pool_alloc_algo_owner + gen_pool_avail + gen_pool_best_fit + gen_pool_create + gen_pool_destroy + gen_pool_dma_alloc_align + gen_pool_dma_zalloc_align + gen_pool_first_fit_align + gen_pool_first_fit_order_align + gen_pool_free_owner + gen_pool_has_addr + gen_pool_set_algo + gen_pool_size + gen_pool_virt_to_phys + getboottime64 + get_cpu_device + get_cpu_idle_time + get_cpu_idle_time_us + get_cpu_iowait_time_us + get_device + get_device_system_crosststamp __get_free_pages + get_governor_parent_kobj + get_next_ino + get_option + get_options + get_pid_task + get_random_bytes + get_random_bytes_arch + get_random_u32 + get_random_u64 + get_sg_io_hdr + get_state_synchronize_rcu __get_task_comm + get_task_exe_file + get_task_mm + get_task_pid + get_thermal_instance + get_tree_single + get_unmapped_area + get_unused_fd_flags + get_user_pages + get_user_pages_fast + get_user_pages_remote + get_vaddr_frames + get_zeroed_page + gfp_zone + gic_nonsecure_priorities + glob_match + gnss_allocate_device + gnss_deregister_device + gnss_insert_raw + gnss_put_device + gnss_register_device + gov_attr_set_get + gov_attr_set_init + gov_attr_set_put + governor_sysfs_ops + gpiochip_add_data_with_key + gpiochip_add_pin_range + gpiochip_find + gpiochip_generic_config + gpiochip_generic_free + gpiochip_generic_request + gpiochip_get_data + gpiochip_irqchip_add_key + gpiochip_line_is_valid + gpiochip_lock_as_irq + gpiochip_populate_parent_fwspec_fourcell + gpiochip_remove + gpiochip_set_nested_irqchip + gpiochip_unlock_as_irq + gpiod_cansleep + gpiod_count + gpiod_direction_input + gpiod_direction_output + gpiod_direction_output_raw + gpiod_get_optional + gpiod_get_raw_value + gpiod_get_raw_value_cansleep + gpiod_get_value + gpiod_get_value_cansleep + gpiod_set_consumer_name + gpiod_set_debounce + gpiod_set_raw_value + gpiod_set_raw_value_cansleep + gpiod_set_value + gpiod_set_value_cansleep + gpiod_to_chip + gpiod_to_irq + gpio_free + gpio_free_array + gpio_request + gpio_request_one + gpio_to_desc + gro_cells_destroy + gro_cells_init + gro_cells_receive + gs_alloc_req + gserial_alloc_line + gserial_connect + gserial_disconnect + gserial_free_line + gserial_resume + gserial_suspend + gs_free_req + guid_gen + handle_bad_irq + handle_edge_irq + handle_fasteoi_ack_irq + handle_fasteoi_irq + handle_level_irq + handle_nested_irq + handle_simple_irq + handle_sysrq + hash_digest_size + hashlen_string + have_governor_per_policy + hci_alloc_dev + hci_free_dev + hci_recv_frame + hci_register_dev + hci_unregister_dev + hdmi_audio_infoframe_init + hdmi_audio_infoframe_pack + hdmi_avi_infoframe_init + hdmi_avi_infoframe_pack + hdmi_infoframe_pack + hex2bin + hex_dump_to_buffer + hex_to_bin + hid_hw_close + hid_hw_open + hid_hw_start + hid_hw_stop + hid_open_report __hid_register_driver + hid_report_raw_event __hid_request + hid_unregister_driver + hmm_range_fault + hrtimer_active + hrtimer_cancel + hrtimer_forward __hrtimer_get_remaining + hrtimer_init + hrtimer_init_sleeper + hrtimer_sleeper_start_expires + hrtimer_start_range_ns + hrtimer_try_to_cancel + hvc_alloc + hvc_instantiate + hvc_kick + hvc_poll + hvc_remove __hvc_resize + hwrng_register + hwrng_unregister + hwspin_lock_free + hwspin_lock_request_specific __hwspin_lock_timeout __hwspin_unlock + hypervisor_kobj + i2c_adapter_type + i2c_add_adapter + i2c_add_numbered_adapter + i2c_bit_add_bus + i2c_bit_add_numbered_bus + i2c_bus_type + i2c_client_type + i2c_del_adapter + i2c_del_driver + i2c_for_each_dev + i2c_generic_scl_recovery + i2c_get_adapter + i2c_get_device_id + i2c_get_dma_safe_msg_buf + i2c_match_id + i2c_new_ancillary_device + i2c_new_client_device + i2c_new_dummy_device + i2c_new_scanned_device + i2c_parse_fw_timings + i2c_put_adapter + i2c_put_dma_safe_msg_buf + i2c_recover_bus + i2c_register_driver + i2c_smbus_read_byte + i2c_smbus_read_byte_data + i2c_smbus_read_i2c_block_data + i2c_smbus_read_word_data + i2c_smbus_write_byte + i2c_smbus_write_byte_data + i2c_smbus_write_i2c_block_data + i2c_smbus_write_word_data __i2c_smbus_xfer + i2c_smbus_xfer __i2c_transfer + i2c_transfer + i2c_transfer_buffer_flags + i2c_unregister_device + i2c_verify_adapter + i2c_verify_client + icc_disable + icc_enable + icc_get + icc_link_create + icc_node_add + icc_node_create + icc_node_del + icc_node_destroy + icc_nodes_remove + icc_provider_add + icc_provider_del + icc_put + icc_set_bw + icc_set_tag + icc_std_aggregate + icc_sync_state + ida_alloc_range + ida_destroy + ida_free + idr_alloc + idr_alloc_cyclic + idr_alloc_u32 + idr_destroy + idr_find + idr_for_each + idr_get_next + idr_preload + idr_remove + idr_replace + ieee802154_alloc_hw + ieee802154_free_hw + ieee802154_register_hw + ieee802154_rx_irqsafe + ieee802154_unregister_hw + ieee802154_wake_queue + ieee802154_xmit_complete + iio_buffer_init + iio_buffer_put + iio_channel_get + iio_channel_get_all + iio_channel_release + iio_device_alloc + iio_device_attach_buffer + iio_device_free __iio_device_register + iio_device_unregister + iio_push_to_buffers + iio_read_channel_processed + iio_read_channel_raw + import_iovec + in4_pton + in6_dev_finish_destroy + in6_pton + in_aton + inc_zone_page_state + in_egroup_p + inet_proto_csum_replace4 + init_dummy_netdev + init_iova_domain + init_net + init_on_free + init_pid_ns + init_pseudo __init_rwsem + init_srcu_struct __init_swait_queue_head + init_task + init_timer_key + init_uts_ns + init_wait_entry __init_waitqueue_head + input_alloc_absinfo + input_allocate_device + input_close_device + input_event + input_ff_create + input_ff_create_memless + input_ff_destroy + input_free_device + input_mt_assign_slots + input_mt_destroy_slots + input_mt_drop_unused + input_mt_init_slots + input_mt_report_finger_count + input_mt_report_pointer_emulation + input_mt_report_slot_state + input_mt_sync_frame + input_open_device + input_register_device + input_register_handle + input_register_handler + input_set_abs_params + input_set_capability + input_set_timestamp + input_unregister_device + input_unregister_handle + input_unregister_handler + interval_tree_insert + interval_tree_iter_first + interval_tree_iter_next + interval_tree_remove + int_pow + int_sqrt + invalidate_bdev + invalidate_mapping_pages + iomem_resource + iommu_alloc_resv_region + iommu_attach_device + iommu_attach_group + iommu_aux_attach_device + iommu_aux_detach_device + iommu_aux_get_pasid + iommu_detach_device + iommu_detach_group + iommu_dev_enable_feature + iommu_dev_feature_enabled + iommu_device_register + iommu_device_sysfs_add + iommu_device_sysfs_remove + iommu_device_unlink + iommu_device_unregister + iommu_dma_enable_best_fit_algo + iommu_dma_get_resv_regions + iommu_dma_reserve_iova + iommu_domain_alloc + iommu_domain_free + iommu_domain_get_attr + iommu_domain_set_attr + iommu_fwspec_add_ids + iommu_fwspec_free + iommu_get_dma_cookie + iommu_get_domain_for_dev + iommu_get_msi_cookie + iommu_group_alloc + iommu_group_for_each_dev + iommu_group_get + iommu_group_get_iommudata + iommu_group_put + iommu_group_ref_get + iommu_group_set_iommudata + iommu_group_set_name + iommu_iova_to_phys + iommu_map + iommu_map_sg + iommu_present + iommu_put_dma_cookie + iommu_register_device_fault_handler + iommu_report_device_fault + iommu_set_fault_handler + iommu_unmap + iommu_unregister_device_fault_handler __ioread32_copy __ioremap + io_schedule_timeout + iounmap + iov_iter_bvec + iov_iter_kvec __iowrite32_copy + ip_compute_csum + ipi_desc_get + ip_send_check + iput __ipv6_addr_type + ipv6_ext_hdr + ipv6_find_hdr + ipv6_skip_exthdr __irq_alloc_descs + irq_chip_ack_parent + irq_chip_disable_parent + irq_chip_enable_parent + irq_chip_eoi_parent + irq_chip_get_parent_state + irq_chip_mask_parent + irq_chip_retrigger_hierarchy + irq_chip_set_affinity_parent + irq_chip_set_parent_state + irq_chip_set_type_parent + irq_chip_set_vcpu_affinity_parent + irq_chip_set_wake_parent + irq_chip_unmask_parent + irq_create_fwspec_mapping + irq_create_mapping_affinity + irq_create_of_mapping + irq_dispose_mapping __irq_domain_add + irq_domain_add_simple + irq_domain_alloc_irqs_parent + irq_domain_create_hierarchy + irq_domain_free_irqs_common + irq_domain_free_irqs_parent + irq_domain_get_irq_data + irq_domain_remove + irq_domain_set_hwirq_and_chip + irq_domain_set_info + irq_domain_simple_ops + irq_domain_update_bus_token + irq_domain_xlate_onecell + irq_domain_xlate_onetwocell + irq_domain_xlate_twocell + irq_find_mapping + irq_find_matching_fwspec + irq_get_irqchip_state + irq_get_irq_data + irq_modify_status + irq_of_parse_and_map + irq_set_affinity_hint + irq_set_affinity_notifier + irq_set_chained_handler_and_data + irq_set_chip + irq_set_chip_and_handler_name + irq_set_chip_data __irq_set_handler + irq_set_handler_data + irq_set_irqchip_state + irq_set_irq_type + irq_set_irq_wake + irq_set_parent + irq_to_desc + irq_work_queue + irq_work_queue_on + irq_work_sync + is_dma_buf_file + is_vmalloc_addr + iwe_stream_add_event + iwe_stream_add_point + iwe_stream_add_value + jiffies_64_to_clock_t + jiffies64_to_msecs + jiffies + jiffies_to_msecs + jiffies_to_usecs + kasan_flag_enabled + kasprintf + kernel_bind + kernel_connect + kernel_cpustat + kernel_getsockname + kernel_kobj + kernel_power_off + kernel_recvmsg + kernel_restart + kernel_sendmsg + kernel_sigaction + kernfs_find_and_get_ns + kernfs_notify + kernfs_path_from_node + kernfs_put + kern_mount + kern_path + kern_unmount __kfifo_alloc __kfifo_free __kfifo_in @@ -123,109 +1950,1767 @@ __kfifo_out __kfifo_out_peek __kfifo_to_user + kfree + kfree_const + kfree_sensitive __kfree_skb + kfree_skb + kick_all_cpus_sync + kill_anon_super + kill_fasync + kill_litter_super + kimage_vaddr + kimage_voffset + kiocb_set_cancel_fn __kmalloc + kmalloc_caches + kmalloc_order + kmalloc_order_trace + kmem_cache_alloc + kmem_cache_alloc_trace + kmem_cache_create + kmem_cache_create_usercopy + kmem_cache_destroy + kmem_cache_free + kmemdup + kmemdup_nul + kmsg_dump_get_line + kmsg_dump_rewind + kobject_add + kobject_create_and_add + kobject_del + kobject_get + kobject_init + kobject_init_and_add + kobject_put + kobject_set_name + kobject_uevent + kobject_uevent_env + kobj_sysfs_ops + krealloc + kset_create_and_add + kset_unregister + ksize + ksoftirqd + kstat + kstat_irqs_cpu + kstat_irqs_usr + kstrdup + kstrdup_const + kstrdup_quotable_cmdline + kstrndup + kstrtobool + kstrtobool_from_user + kstrtoint + kstrtoint_from_user + kstrtol_from_user + kstrtoll + kstrtos16 + kstrtos8 + kstrtos8_from_user + kstrtou16 + kstrtou16_from_user + kstrtou8 + kstrtou8_from_user + kstrtouint + kstrtouint_from_user + kstrtoul_from_user + kstrtoull + kstrtoull_from_user + ksys_sync_helper + kthread_bind + kthread_bind_mask + kthread_blkcg + kthread_cancel_delayed_work_sync + kthread_cancel_work_sync + kthread_create_on_node + kthread_create_worker + kthread_delayed_work_timer_fn + kthread_destroy_worker + kthread_flush_work + kthread_flush_worker __kthread_init_worker + kthread_mod_delayed_work + kthread_park + kthread_parkme + kthread_queue_delayed_work + kthread_queue_work + kthread_should_park + kthread_should_stop + kthread_stop + kthread_unpark + kthread_unuse_mm + kthread_use_mm + kthread_worker_fn + ktime_add_safe + ktime_get + ktime_get_coarse_with_offset + ktime_get_mono_fast_ns + ktime_get_raw + ktime_get_raw_ts64 + ktime_get_real_seconds + ktime_get_real_ts64 + ktime_get_seconds + ktime_get_ts64 + ktime_get_with_offset + kvasprintf + kvfree + kvfree_call_rcu + kvmalloc_node + led_classdev_flash_register_ext + led_classdev_flash_unregister + led_classdev_register_ext + led_classdev_unregister + led_trigger_event + led_trigger_register_simple + led_trigger_unregister_simple __list_add_valid __list_del_entry_valid + list_sort + llist_add_batch + llist_reverse_order __local_bh_enable_ip __lock_page + lock_sock_nested + log_abnormal_wakeup_reason + log_buf_addr_get + log_buf_len_get __log_post_read_mmio __log_read_mmio + log_threaded_irq_wakeup_reason __log_write_mmio + loops_per_jiffy + lzo1x_1_compress + lzo1x_decompress_safe + lzorle1x_1_compress + mac_pton + match_string + mbox_chan_received_data + mbox_chan_txdone + mbox_client_txdone + mbox_controller_register + mbox_controller_unregister + mbox_free_channel + mbox_request_channel + mbox_send_message + mdiobus_alloc_size + mdiobus_free + mdiobus_read __mdiobus_register + mdiobus_unregister + mdiobus_write + media_device_cleanup + media_device_init __media_device_register + media_device_unregister + media_entity_pads_init + memblock_end_of_DRAM + memblock_free __memcat_p + memchr + memchr_inv + memcmp + memcpy __memcpy_fromio __memcpy_toio + memdup_user + memdup_user_nul + memmove + memory_block_size_bytes + memory_read_from_buffer + memparse + mempool_alloc + mempool_alloc_slab + mempool_create + mempool_create_node + mempool_destroy + mempool_exit + mempool_free + mempool_free_slab + mempool_init + mempool_kfree + mempool_kmalloc + memremap + memset64 + memset __memset_io + memstart_addr + memunmap + mfd_add_devices + mfd_remove_devices + migrate_swap + mii_check_media + mii_ethtool_get_link_ksettings + mii_ethtool_gset + mii_ethtool_set_link_ksettings + mii_link_ok + mii_nway_restart + mipi_dsi_attach + mipi_dsi_compression_mode + mipi_dsi_create_packet + mipi_dsi_dcs_read + mipi_dsi_dcs_set_column_address + mipi_dsi_dcs_set_display_brightness + mipi_dsi_dcs_set_page_address + mipi_dsi_dcs_set_tear_off + mipi_dsi_dcs_write_buffer + mipi_dsi_detach + mipi_dsi_device_register_full + mipi_dsi_device_unregister + mipi_dsi_driver_register_full + mipi_dsi_driver_unregister + mipi_dsi_host_register + mipi_dsi_host_unregister + mipi_dsi_packet_format_is_long + mipi_dsi_picture_parameter_set + misc_deregister + misc_register + mktime64 + mmc_add_host + mmc_alloc_host + mmc_app_cmd + mmc_calc_max_discard + mmc_can_erase + mmc_can_gpio_cd + mmc_can_secure_erase_trim + mmc_can_trim __mmc_claim_host + mmc_cmdq_disable + mmc_cmdq_enable + mmc_cqe_post_req + mmc_cqe_recovery + mmc_cqe_request_done + mmc_cqe_start_req + mmc_detect_card_removed + mmc_detect_change + mmc_erase + mmc_erase_group_aligned + mmc_flush_cache + mmc_free_host + mmc_get_card + mmc_get_ext_csd + mmc_gpiod_request_cd + mmc_gpiod_request_cd_irq + mmc_gpiod_request_ro + mmc_gpio_get_cd + mmc_gpio_get_ro + mmc_hw_reset + mmc_of_parse + mmc_of_parse_voltage + mmc_put_card + mmc_register_driver + mmc_regulator_get_supply + mmc_regulator_set_ocr + mmc_regulator_set_vqmmc + mmc_release_host + mmc_remove_host + mmc_request_done + mmc_retune_pause + mmc_retune_release + mmc_retune_unpause + mmc_run_bkops + mmc_sanitize __mmc_send_status + mmc_send_status + mmc_send_tuning + mmc_set_data_timeout + mmc_start_request + mmc_switch + mmc_unregister_driver + mmc_wait_for_cmd + mmc_wait_for_req __mmdrop + mmput + mm_trace_rss_stat + mmu_interval_notifier_insert + mmu_interval_notifier_remove + mmu_interval_read_begin + mmu_notifier_synchronize + mod_delayed_work_on + mod_node_page_state + mod_timer __module_get + module_layout + module_put __msecs_to_jiffies + msleep + msleep_interruptible __mutex_init + mutex_is_locked + mutex_lock + mutex_lock_interruptible + mutex_trylock + mutex_trylock_recursive + mutex_unlock + names_cachep + name_to_dev_t __napi_alloc_skb + napi_complete_done + napi_consume_skb + napi_disable + napi_gro_flush + napi_gro_receive __napi_schedule + napi_schedule_prep __ndelay __netdev_alloc_skb + netdev_change_features + netdev_err + netdev_increment_features + netdev_info + netdev_lower_state_changed + netdev_master_upper_dev_link + netdev_notify_peers + netdev_pick_tx + netdev_rx_handler_register + netdev_rx_handler_unregister + netdev_state_change + netdev_update_features + netdev_upper_dev_link + netdev_upper_dev_unlink + netdev_warn + netif_carrier_off + netif_carrier_on + netif_device_attach + netif_device_detach + netif_napi_add __netif_napi_del + netif_receive_skb + netif_receive_skb_list + netif_rx + netif_rx_ni + netif_schedule_queue + netif_set_real_num_rx_queues + netif_set_real_num_tx_queues __netif_set_xps_queue + netif_stacked_transfer_operstate + netif_tx_stop_all_queues + netif_tx_wake_queue + netlink_ack + netlink_broadcast + netlink_capable + netlink_has_listeners __netlink_kernel_create + netlink_kernel_release + netlink_register_notifier + netlink_unicast + netlink_unregister_notifier + net_namespace_list + net_ratelimit + new_inode __next_zones_zonelist + nf_conntrack_destroy + nla_append + nla_find + nla_memcpy __nla_parse + nla_put_64bit + nla_put + nla_put_nohdr + nla_reserve_64bit + nla_reserve + nla_strlcpy __nla_validate __nlmsg_put + no_llseek + nonseekable_open + noop_llseek + no_seek_end_llseek + nr_cpu_ids + nr_ipi_get + nr_irqs + ns_capable + nsecs_to_jiffies + nsec_to_clock_t + ns_to_timespec64 __num_online_cpus + nvdimm_bus_register + nvdimm_bus_unregister + nvdimm_pmem_region_create + nvmem_cell_get + nvmem_cell_put + nvmem_cell_read + nvmem_cell_read_u32 + nvmem_cell_write + nvmem_device_put + nvmem_device_read + nvmem_device_write + of_address_to_resource + of_alias_get_highest_id + of_alias_get_id + of_clk_add_hw_provider + of_clk_add_provider + of_clk_del_provider + of_clk_get + of_clk_get_by_name + of_clk_get_from_provider + of_clk_get_parent_count + of_clk_get_parent_name + of_clk_hw_onecell_get + of_clk_hw_simple_get + of_clk_set_defaults + of_clk_src_onecell_get + of_clk_src_simple_get + of_count_phandle_with_args + of_cpufreq_cooling_register + of_cpu_node_to_id + of_css + of_devfreq_cooling_register + of_devfreq_cooling_register_power + of_device_get_match_data + of_device_is_available + of_device_is_compatible + of_device_modalias + of_device_request_module + of_device_uevent_modalias + of_dma_configure_id + of_dma_controller_free + of_dma_controller_register + of_dma_is_coherent + of_drm_find_bridge + of_drm_find_panel + of_find_all_nodes + of_find_compatible_node + of_find_device_by_node + of_find_i2c_adapter_by_node + of_find_i2c_device_by_node + of_find_matching_node_and_match + of_find_mipi_dsi_host_by_node + of_find_node_by_name + of_find_node_by_phandle + of_find_node_by_type + of_find_node_opts_by_path + of_find_node_with_property + of_find_property + of_fwnode_ops + of_genpd_add_provider_onecell + of_genpd_add_provider_simple + of_genpd_del_provider + of_get_address + of_get_child_by_name + of_get_compatible_child + of_get_cpu_node + of_get_dma_window + of_get_named_gpio_flags + of_get_next_available_child + of_get_next_child + of_get_next_parent + of_get_parent + of_get_property + of_get_regulator_init_data + of_graph_get_endpoint_by_regs + of_graph_get_next_endpoint + of_graph_get_port_parent + of_graph_get_remote_endpoint + of_graph_get_remote_node + of_graph_get_remote_port + of_graph_get_remote_port_parent + of_graph_is_present + of_graph_parse_endpoint + of_hwspin_lock_get_id + of_i2c_get_board_info + of_icc_get + of_icc_xlate_onecell + of_iomap + of_irq_find_parent + of_irq_get + of_irq_get_byname + of_irq_parse_one + of_machine_is_compatible + of_match_device + of_match_node + of_modalias_node + of_n_addr_cells + of_node_name_eq + of_n_size_cells + of_nvmem_device_get + of_parse_phandle + of_parse_phandle_with_args + of_parse_phandle_with_fixed_args + of_phandle_iterator_init + of_phandle_iterator_next + of_phy_simple_xlate + of_platform_depopulate + of_platform_device_create + of_platform_device_destroy + of_platform_populate + of_property_count_elems_of_size + of_property_match_string + of_property_read_string + of_property_read_string_helper + of_property_read_u32_index + of_property_read_u64 + of_property_read_u64_index + of_property_read_variable_u16_array + of_property_read_variable_u32_array + of_property_read_variable_u64_array + of_property_read_variable_u8_array + of_prop_next_string + of_prop_next_u32 + of_pwm_xlate_with_flags + of_reserved_mem_device_init_by_idx + of_reserved_mem_device_release + of_reserved_mem_lookup + of_reset_control_array_get __of_reset_control_get + of_root + of_thermal_get_ntrips + of_thermal_get_trip_points + of_thermal_is_trip_valid + of_translate_address + of_usb_get_phy_mode + of_usb_host_tpl_support + on_each_cpu + oops_in_progress + orderly_poweroff + overflowuid + page_endio + page_mapping + page_reporting_register + page_reporting_unregister + panic + panic_notifier_list + panic_timeout + param_array_ops + param_get_int + param_get_string + param_get_uint + param_get_ullong + param_ops_bint + param_ops_bool + param_ops_byte + param_ops_charp + param_ops_hexint + param_ops_int + param_ops_long + param_ops_short + param_ops_string + param_ops_uint + param_ops_ullong + param_ops_ulong + param_ops_ushort + param_set_bool + param_set_copystring + param_set_int + param_set_uint + part_end_io_acct + part_start_io_acct + passthru_features_check + path_put + pause_cpus + pci_alloc_irq_vectors_affinity + pci_assign_resource + pci_assign_unassigned_bus_resources + pcibios_resource_to_bus + pci_bus_resource_n + pci_bus_type + pci_clear_master + pci_d3cold_disable + pci_device_group + pci_device_is_present + pci_dev_present + pci_dev_put + pci_disable_device + pci_disable_msi + pcie_aspm_enabled + pcie_bandwidth_available + pcie_capability_read_word + pcie_capability_write_word + pcie_get_mps + pcie_get_speed_cap + pci_enable_atomic_ops_to_root + pci_enable_device + pci_enable_device_mem + pci_enable_msi + pci_enable_wake + pci_find_bus + pci_find_capability + pci_find_ext_capability + pci_find_next_capability + pci_free_irq + pci_free_irq_vectors + pci_generic_config_read + pci_generic_config_write + pci_get_device + pci_get_domain_bus_and_slot + pci_get_slot + pci_host_probe + pci_intx + pci_iomap + pci_iomap_range + pci_ioremap_bar + pci_irq_get_affinity + pci_irq_vector + pci_load_and_free_saved_state + pci_load_saved_state + pci_map_rom + pci_match_id + pcim_enable_device + pci_msi_create_irq_domain + pci_msi_mask_irq + pci_msi_unmask_irq + pci_msix_vec_count + pci_read_config_byte + pci_read_config_dword + pci_read_config_word __pci_register_driver - __per_cpu_offset + pci_release_region + pci_release_regions + pci_release_resource + pci_release_selected_regions + pci_request_irq + pci_request_region + pci_request_regions + pci_request_selected_regions + pci_rescan_bus + pci_resize_resource + pci_restore_msi_state + pci_restore_state + pci_save_state + pci_select_bars + pci_set_master + pci_set_mwi + pci_set_power_state + pci_store_saved_state + pci_unmap_rom + pci_unregister_driver + pci_wake_from_d3 + pci_walk_bus + pci_write_config_byte + pci_write_config_dword + pci_write_config_word + PDE_DATA __percpu_down_read + percpu_down_write __percpu_init_rwsem + __per_cpu_offset + per_cpu_ptr_to_phys + percpu_ref_exit + percpu_ref_init + percpu_ref_is_zero + percpu_ref_kill_and_confirm + percpu_ref_switch_to_atomic_sync + percpu_ref_switch_to_percpu + percpu_up_write + perf_aux_output_begin + perf_aux_output_end + perf_aux_output_flag + perf_event_addr_filters_sync + perf_event_create_kernel_counter + perf_event_disable + perf_event_enable + perf_event_pause + perf_event_read_local + perf_event_read_value + perf_event_release_kernel + perf_event_update_userpage + perf_get_aux + perf_pmu_migrate_context + perf_pmu_register + perf_pmu_unregister + perf_trace_buf_alloc + perf_trace_run_bpf_submit + pfn_valid + phy_attached_info + phy_calibrate + phy_configure + phy_connect + phy_connect_direct + phy_disconnect + phy_do_ioctl_running + phy_drivers_register + phy_drivers_unregister + phy_ethtool_get_link_ksettings + phy_ethtool_nway_reset + phy_ethtool_set_link_ksettings + phy_ethtool_set_wol + phy_exit + phy_find_first + phy_get_pause + phy_init + phy_init_hw + phy_mii_ioctl + phy_pm_runtime_get_sync + phy_pm_runtime_put_sync + phy_power_off + phy_power_on + phy_print_status + phy_register_fixup_for_uid + phy_save_page + phy_set_mode_ext + phy_start + phy_stop + phy_unregister_fixup_for_uid + pick_highest_pushable_task + pid_nr_ns + pid_task + pinconf_generic_dt_free_map + pinconf_generic_dt_node_to_map + pinctrl_add_gpio_range + pinctrl_dev_get_drvdata + pinctrl_enable + pinctrl_force_default + pinctrl_force_sleep + pinctrl_get + pinctrl_lookup_state + pinctrl_pm_select_default_state + pinctrl_pm_select_idle_state + pinctrl_pm_select_sleep_state + pinctrl_put + pinctrl_remove_gpio_range + pinctrl_select_default_state + pinctrl_select_state + pinctrl_utils_free_map + pin_get_name + pin_user_pages + pin_user_pages_fast + pin_user_pages_remote + pipe_lock + pipe_unlock + pktgen_xfrm_outer_mode_output + platform_add_devices + platform_bus_type + platform_device_add + platform_device_add_data + platform_device_add_properties + platform_device_add_resources + platform_device_alloc + platform_device_del + platform_device_put + platform_device_register + platform_device_register_full + platform_device_unregister __platform_driver_probe __platform_driver_register + platform_driver_unregister + platform_find_device_by_driver + platform_get_irq + platform_get_irq_byname + platform_get_irq_byname_optional + platform_get_irq_optional + platform_get_resource + platform_get_resource_byname + platform_irq_count __platform_register_drivers + pm_clk_add + pm_clk_create + pm_clk_destroy + pm_clk_resume + pm_clk_suspend + pm_generic_resume + pm_generic_runtime_resume + pm_generic_runtime_suspend + pm_generic_suspend + pm_genpd_add_subdomain + pm_genpd_init + pm_genpd_remove + pm_genpd_remove_subdomain + pm_power_off __pm_relax + pm_relax + pm_runtime_allow + pm_runtime_autosuspend_expiration + pm_runtime_barrier __pm_runtime_disable + pm_runtime_enable + pm_runtime_forbid + pm_runtime_force_resume + pm_runtime_force_suspend + pm_runtime_get_if_active __pm_runtime_idle + pm_runtime_irq_safe + pm_runtime_no_callbacks __pm_runtime_resume + pm_runtime_set_autosuspend_delay __pm_runtime_set_status __pm_runtime_suspend __pm_runtime_use_autosuspend __pm_stay_awake + pm_stay_awake + pm_suspend_global_flags + pm_system_wakeup + pm_wakeup_dev_event + pm_wakeup_ws_event + policy_has_boost_freq + power_supply_changed + power_supply_get_by_name + power_supply_get_by_phandle_array + power_supply_get_drvdata + power_supply_get_property + power_supply_is_system_supplied + power_supply_put + power_supply_register + power_supply_reg_notifier + power_supply_set_property + power_supply_unregister + power_supply_unreg_notifier + prandom_bytes + prandom_u32 + preempt_schedule + preempt_schedule_notrace + prepare_to_wait + prepare_to_wait_event + print_hex_dump + printk + printk_deferred __printk_ratelimit + printk_timed_ratelimit + proc_create + proc_create_data + proc_create_single_data + proc_dointvec + proc_dointvec_minmax + proc_dostring + proc_douintvec_minmax + proc_mkdir + proc_mkdir_data + proc_remove + proc_set_size + proc_set_user + proc_symlink + proto_register + proto_unregister + ps2_begin_command + ps2_cmd_aborted + ps2_command + ps2_drain + ps2_end_command + ps2_handle_ack + ps2_handle_response + ps2_init + ps2_sendbyte + ps2_sliced_command + pskb_expand_head __pskb_pull_tail + ___pskb_trim + pstore_register + pstore_unregister + public_key_verify_signature + put_device + put_disk + put_iova_domain __put_page + put_pid + put_sg_io_hdr __put_task_struct + put_tty_driver + put_unused_fd + put_vaddr_frames + pwm_apply_state + pwmchip_add + pwmchip_remove + pwm_get_chip_data + pwm_set_chip_data + qcom_smem_state_get + qcom_smem_state_register + qcom_smem_state_unregister + qcom_smem_state_update_bits + qdisc_reset + queue_delayed_work_on + queue_work_on + radix_tree_delete + radix_tree_insert + radix_tree_iter_delete + radix_tree_iter_resume + radix_tree_lookup + radix_tree_maybe_preload + radix_tree_next_chunk + radix_tree_tagged + ___ratelimit + rational_best_approximation + raw_notifier_call_chain + raw_notifier_chain_register + raw_notifier_chain_unregister + _raw_read_lock + _raw_read_lock_bh + _raw_read_lock_irq + _raw_read_lock_irqsave + _raw_read_unlock + _raw_read_unlock_bh + _raw_read_unlock_irq + _raw_read_unlock_irqrestore + _raw_spin_lock + _raw_spin_lock_bh + _raw_spin_lock_irq + _raw_spin_lock_irqsave + _raw_spin_trylock + _raw_spin_trylock_bh + _raw_spin_unlock + _raw_spin_unlock_bh + _raw_spin_unlock_irq + _raw_spin_unlock_irqrestore + _raw_write_lock + _raw_write_lock_bh + _raw_write_lock_irq + _raw_write_lock_irqsave + _raw_write_unlock + _raw_write_unlock_bh + _raw_write_unlock_irq + _raw_write_unlock_irqrestore + rb_erase __rb_erase_color + rb_first + rb_first_postorder __rb_insert_augmented + rb_insert_color + rb_last + rb_next + rb_next_postorder + rb_prev + rb_replace_node + rcu_barrier + rcu_barrier_tasks + rcu_barrier_tasks_trace + rcu_bind_current_to_nocb + rcu_cpu_stall_suppress + rcu_cpu_stall_suppress_at_boot + rcu_expedite_gp + rcu_force_quiescent_state + rcu_fwd_progress_check + rcu_get_gp_kthreads_prio + rcu_get_gp_seq + rcu_gp_is_expedited + rcu_gp_is_normal + rcu_gp_set_torture_wait + rcu_inkernel_boot_has_ended + rcu_is_watching + rcu_jiffies_till_stall_check __rcu_read_lock __rcu_read_unlock + rcu_read_unlock_trace_special + rcutorture_get_gp_data + rcu_unexpedite_gp + rcuwait_wake_up + rdev_get_drvdata + rdev_get_id + reboot_mode + reciprocal_value + refcount_dec_and_lock + refcount_dec_and_mutex_lock + refcount_dec_not_one + refcount_warn_saturate + refresh_frequency_limits __refrigerator + regcache_cache_bypass + regcache_cache_only + regcache_drop_region + regcache_mark_dirty + regcache_sync + regcache_sync_region + register_blkdev __register_chrdev + register_chrdev_region + register_console + register_die_notifier + register_filesystem + register_ftrace_export + register_inet6addr_notifier + register_inetaddr_notifier + register_kernel_break_hook + register_kprobe + register_kretprobe + register_memory_notifier + register_module_notifier + register_netdev + register_netdevice + register_netdevice_notifier + register_netevent_notifier + register_net_sysctl + register_oom_notifier + register_pernet_device + register_pernet_subsys + register_pm_notifier + register_reboot_notifier + register_restart_handler __register_rpmsg_driver + register_shrinker + register_syscore_ops + register_sysctl + register_sysctl_table + register_virtio_device + register_virtio_driver + register_vmap_purge_notifier + regmap_add_irq_chip + regmap_async_complete + regmap_bulk_read + regmap_bulk_write + regmap_check_range_table + regmap_del_irq_chip + regmap_exit + regmap_field_read + regmap_field_update_bits_base + regmap_get_device __regmap_init + regmap_irq_get_domain + regmap_irq_get_virq + regmap_mmio_detach_clk + regmap_multi_reg_write + regmap_multi_reg_write_bypassed + regmap_raw_read + regmap_raw_write + regmap_raw_write_async + regmap_read + regmap_register_patch + regmap_update_bits_base + regmap_write + regulator_allow_bypass + regulator_bulk_disable + regulator_bulk_enable + regulator_bulk_get + regulator_count_voltages + regulator_disable + regulator_disable_deferred + regulator_disable_regmap + regulator_enable + regulator_enable_regmap + regulator_force_disable + regulator_get + regulator_get_current_limit + regulator_get_drvdata + regulator_get_mode + regulator_get_optional + regulator_get_voltage + regulator_get_voltage_rdev + regulator_get_voltage_sel_regmap + regulator_is_enabled + regulator_is_enabled_regmap + regulator_is_supported_voltage + regulator_list_voltage_linear + regulator_list_voltage_linear_range + regulator_list_voltage_table + regulator_map_voltage_ascend + regulator_map_voltage_linear + regulator_notifier_call_chain + regulator_put + regulator_register + regulator_register_notifier + regulator_set_current_limit + regulator_set_load + regulator_set_mode + regulator_set_voltage + regulator_set_voltage_sel_regmap + regulator_unregister + regulator_unregister_notifier + release_firmware + release_pages __release_region + release_sock + remap_pfn_range + remap_vmalloc_range + remove_cpu + remove_memory_subsection + remove_proc_entry + remove_wait_queue + report_iommu_fault + request_any_context_irq + request_firmware + request_firmware_direct + request_firmware_into_buf + request_firmware_nowait __request_module __request_percpu_irq __request_region + request_threaded_irq + resched_curr + reservation_ww_class + reset_control_assert + reset_control_deassert + reset_control_put + reset_control_reset + resume_cpus + return_address + revalidate_disk_size + rfkill_alloc + rfkill_destroy + rfkill_find_type + rfkill_init_sw_state + rfkill_register + rfkill_set_sw_state + rfkill_unregister + rhashtable_destroy + rhashtable_init + rhashtable_insert_slow __rht_bucket_nested + rht_bucket_nested + rht_bucket_nested_insert + rndis_deregister + rndis_free_response + rndis_get_next_response + rndis_msg_parser + rndis_register + rndis_set_host_mac + rndis_set_param_dev + rndis_set_param_medium + rndis_set_param_vendor + rndis_signal_connect + rndis_uninit + root_task_group + round_jiffies_relative + round_jiffies_up + rpmsg_get_signals + rpmsg_poll + rpmsg_register_device + rpmsg_send + rpmsg_set_signals + rpmsg_trysend + rpmsg_unregister_device + rproc_add + rproc_add_subdev + rproc_alloc + rproc_boot + rproc_coredump_add_custom_segment + rproc_coredump_add_segment + rproc_coredump_set_elf_info + rproc_coredump_using_sections + rproc_del + rproc_elf_get_boot_addr + rproc_free + rproc_get_by_child + rproc_get_by_phandle + rproc_put + rproc_remove_subdev + rproc_report_crash + rproc_shutdown + rps_needed + rtc_class_close + rtc_class_open + rtc_read_time __rtc_register_device + rtc_set_time + rtc_time64_to_tm + rtc_tm_to_time64 + rtc_update_irq + rtc_valid_tm + rtc_year_days + rt_mutex_lock + rt_mutex_trylock + rt_mutex_unlock + rtnl_is_locked + rtnl_link_register + rtnl_link_unregister + rtnl_lock + rtnl_register_module + rtnl_trylock + rtnl_unicast + rtnl_unlock + rtnl_unregister + runqueues + sb800_prefetch + sbitmap_queue_min_shallow_depth + sched_clock + sched_feat_keys + sched_feat_names + sched_setattr + sched_setattr_nocheck + sched_set_fifo + sched_set_fifo_low + sched_set_normal + sched_setscheduler + sched_setscheduler_nocheck + sched_show_task + sched_trace_cfs_rq_avg + sched_trace_cfs_rq_cpu + sched_trace_cfs_rq_path + sched_trace_rd_span + sched_trace_rq_avg_dl + sched_trace_rq_avg_irq + sched_trace_rq_avg_rt + sched_trace_rq_cpu + sched_uclamp_used + schedule + schedule_hrtimeout + schedule_timeout + schedule_timeout_interruptible + schedule_timeout_uninterruptible + scnprintf + scsi_autopm_get_device + scsi_autopm_put_device + scsi_block_requests + scsi_block_when_processing_errors + scsi_command_size_tbl + scsi_compat_ioctl + scsi_device_get + scsi_device_put + scsi_device_quiesce + scsi_dma_unmap + scsi_eh_ready_devs __scsi_execute + scsi_ioctl + scsi_ioctl_block_when_processing_errors __scsi_iterate_devices + scsi_normalize_sense __scsi_print_sense + scsi_print_sense_hdr + scsi_register_interface + scsi_remove_device + scsi_unblock_requests + sdev_prefix_printk __sdhci_add_host + sdhci_add_host + sdhci_cleanup_host + sdhci_cqe_disable + sdhci_cqe_enable + sdhci_cqe_irq + sdhci_enable_clk + sdhci_get_property + sdhci_pltfm_free + sdhci_pltfm_init + sdhci_remove_host + sdhci_reset + sdhci_set_bus_width + sdhci_set_power_noreg + sdhci_setup_host + sdio_claim_host + sdio_disable_func + sdio_enable_func + sdio_f0_readb + sdio_f0_writeb + sdio_get_host_pm_caps + sdio_memcpy_fromio + sdio_memcpy_toio + sdio_readsb + sdio_register_driver + sdio_release_host + sdio_set_block_size + sdio_set_host_pm_flags + sdio_signal_irq + sdio_unregister_driver + sdio_writesb + securityfs_create_dir + securityfs_create_file + securityfs_remove + send_sig_info + seq_buf_printf + seq_file_path + seq_hex_dump + seq_list_next + seq_list_start + seq_lseek + seq_open __seq_open_private + seq_printf + seq_putc + seq_puts + seq_read + seq_release + seq_release_private + seq_vprintf + seq_write + serdev_device_close + serdev_device_open + serdev_device_set_baudrate + serdev_device_set_flow_control + serdev_device_wait_until_sent + serdev_device_write + serdev_device_write_wakeup + serio_close + serio_interrupt + serio_open + serio_reconnect __serio_register_driver __serio_register_port + serio_rescan + serio_unregister_child_port + serio_unregister_driver + serio_unregister_port + set_blocksize + set_capacity_revalidate_and_notify + set_cpus_allowed_ptr + set_disk_ro + set_freezable + set_normalized_timespec64 + set_page_dirty + set_page_dirty_lock + __SetPageMovable + set_task_cpu + set_user_nice + sg_alloc_table + sg_alloc_table_from_pages + sg_free_table + sg_init_one + sg_init_table + sgl_alloc + sgl_free + sg_miter_next + sg_miter_start + sg_miter_stop + sg_nents_for_len + sg_next __sg_page_iter_dma_next __sg_page_iter_next __sg_page_iter_start + sg_pcopy_from_buffer + sg_pcopy_to_buffer + sg_scsi_ioctl + sg_zero_buffer + shmem_truncate_range + show_rcu_gp_kthreads + show_regs + sigprocmask + si_mem_available + si_meminfo + simple_attr_open + simple_attr_read + simple_attr_release + simple_attr_write + simple_dir_inode_operations + simple_dir_operations + simple_open + simple_read_from_buffer + simple_statfs + simple_strtol + simple_strtoll + simple_strtoul + simple_strtoull + simple_write_to_buffer + single_open + single_open_size + single_release + si_swapinfo + sk_alloc + skb_add_rx_frag + skb_append_pagefrags + skb_checksum + skb_clone + skb_coalesce_rx_frag + skb_copy + skb_copy_bits + skb_copy_datagram_iter + skb_copy_expand + skb_copy_ubufs + skb_dequeue + skb_dequeue_tail + skb_ensure_writable __skb_ext_put __skb_flow_dissect + skb_free_datagram __skb_get_hash __skb_gso_segment __skb_pad + skb_page_frag_refill + skb_partial_csum_set + skb_pull + skb_push + skb_put + skb_queue_head + skb_queue_purge + skb_queue_tail + skb_realloc_headroom + skb_recv_datagram + skb_set_owner_w + skb_store_bits + skb_to_sgvec + skb_trim + skb_tstamp_tx + skb_unlink + sk_free + skip_spaces + smpboot_register_percpu_thread + smpboot_unregister_percpu_thread + smp_call_function + smp_call_function_any + smp_call_function_many + smp_call_function_single + smp_call_function_single_async + smp_call_on_cpu + snd_card_disconnect + snd_card_free + snd_card_new + snd_card_register + snd_card_rw_proc_new + snd_component_add + snd_compr_stop_error + snd_ctl_add + _snd_ctl_add_follower + snd_ctl_add_vmaster_hook + snd_ctl_apply_vmaster_followers + snd_ctl_boolean_mono_info + snd_ctl_boolean_stereo_info + snd_ctl_enum_info + snd_ctl_find_id + snd_ctl_make_virtual_master + snd_ctl_new1 + snd_ctl_notify + snd_ctl_remove + snd_ctl_remove_id + snd_ctl_sync_vmaster + snd_device_disconnect + snd_device_free + snd_device_new + snd_dma_alloc_pages + snd_dmaengine_pcm_prepare_slave_config + snd_dma_free_pages + snd_hwdep_new + snd_info_create_card_entry + snd_info_create_module_entry + snd_info_free_entry + snd_info_register + snd_interval_refine + snd_jack_new + snd_jack_report + snd_jack_set_key + snd_pci_quirk_lookup + snd_pcm_add_chmap_ctls + snd_pcm_alt_chmaps + snd_pcm_create_iec958_consumer_hw_params + snd_pcm_format_physical_width + snd_pcm_format_width + snd_pcm_hw_constraint_eld + snd_pcm_hw_constraint_integer + snd_pcm_hw_constraint_list + snd_pcm_hw_constraint_minmax + snd_pcm_hw_constraint_msbits + snd_pcm_hw_constraint_step + snd_pcm_hw_limit_rates + snd_pcm_hw_rule_add + snd_pcm_lib_default_mmap + snd_pcm_lib_free_pages + snd_pcm_lib_ioctl + snd_pcm_lib_malloc_pages + snd_pcm_lib_preallocate_free_for_all + snd_pcm_lib_preallocate_pages + snd_pcm_new + snd_pcm_period_elapsed + snd_pcm_rate_range_to_bits + snd_pcm_set_managed_buffer_all + snd_pcm_set_ops + snd_pcm_set_sync + snd_pcm_std_chmaps + snd_pcm_stream_lock + _snd_pcm_stream_lock_irqsave + snd_pcm_stream_unlock + snd_pcm_stream_unlock_irqrestore + snd_soc_add_card_controls + snd_soc_add_component_controls + snd_soc_add_dai_controls + snd_soc_bytes_info_ext + snd_soc_bytes_tlv_callback + snd_soc_card_get_kcontrol + snd_soc_card_jack_new + snd_soc_component_async_complete + snd_soc_component_disable_pin + snd_soc_component_exit_regmap + snd_soc_component_force_enable_pin + snd_soc_component_init_regmap + snd_soc_component_read + snd_soc_component_set_jack + snd_soc_component_set_pll + snd_soc_component_set_sysclk + snd_soc_component_update_bits + snd_soc_component_update_bits_async + snd_soc_component_write + snd_soc_dai_get_channel_map + snd_soc_dai_link_set_capabilities + snd_soc_dai_set_bclk_ratio + snd_soc_dai_set_channel_map + snd_soc_dai_set_fmt + snd_soc_dai_set_pll + snd_soc_dai_set_sysclk + snd_soc_dai_set_tdm_slot + snd_soc_dapm_add_routes + snd_soc_dapm_disable_pin + snd_soc_dapm_disable_pin_unlocked + snd_soc_dapm_enable_pin + snd_soc_dapm_force_enable_pin + snd_soc_dapm_force_enable_pin_unlocked + snd_soc_dapm_get_enum_double + snd_soc_dapm_get_pin_status + snd_soc_dapm_get_pin_switch + snd_soc_dapm_get_volsw + snd_soc_dapm_ignore_suspend + snd_soc_dapm_info_pin_switch + snd_soc_dapm_kcontrol_dapm + snd_soc_dapm_kcontrol_widget + snd_soc_dapm_mixer_update_power + snd_soc_dapm_mux_update_power + snd_soc_dapm_new_control + snd_soc_dapm_new_controls + snd_soc_dapm_new_widgets + snd_soc_dapm_put_enum_double + snd_soc_dapm_put_pin_switch + snd_soc_dapm_put_volsw + snd_soc_dapm_sync + snd_soc_dapm_sync_unlocked + snd_soc_dapm_weak_routes + snd_soc_find_dai + snd_soc_get_enum_double + snd_soc_get_pcm_runtime + snd_soc_get_volsw + snd_soc_get_volsw_range + snd_soc_get_volsw_sx + snd_soc_get_xr_sx + snd_soc_info_enum_double + snd_soc_info_multi_ext + snd_soc_info_volsw + snd_soc_info_volsw_range + snd_soc_info_volsw_sx + snd_soc_info_xr_sx + snd_soc_jack_add_gpios + snd_soc_jack_report + snd_soc_lookup_component + snd_soc_new_compress + snd_soc_of_get_dai_link_codecs + snd_soc_of_get_dai_name + snd_soc_of_parse_audio_routing + snd_soc_of_parse_audio_simple_widgets + snd_soc_of_parse_aux_devs + snd_soc_of_parse_card_name + snd_soc_of_parse_daifmt + snd_soc_of_parse_node_prefix + snd_soc_of_parse_tdm_slot + snd_soc_of_put_dai_link_codecs + snd_soc_params_to_bclk + snd_soc_params_to_frame_size + snd_soc_pm_ops + snd_soc_put_enum_double + snd_soc_put_volsw + snd_soc_put_volsw_range + snd_soc_put_volsw_sx + snd_soc_put_xr_sx + snd_soc_register_card + snd_soc_register_component + snd_soc_rtdcom_lookup + snd_soc_runtime_calc_hw + snd_soc_runtime_set_dai_fmt + snd_soc_set_runtime_hwparams + snd_soc_tplg_component_load + snd_soc_tplg_component_remove + snd_soc_tplg_widget_bind_event + snd_soc_unregister_card + snd_soc_unregister_component + snd_usb_enable_audio_stream + snd_vendor_set_ops + snprintf + soc_device_register + soc_device_unregister + sock_alloc_send_skb + sock_create_kern + sock_gettstamp + sock_init_data + sock_i_uid + sock_no_accept + sock_no_listen + sock_no_mmap + sock_no_sendpage + sock_no_shutdown + sock_no_socketpair + sock_queue_rcv_skb + sock_register + sock_release + sock_setsockopt + sock_unregister + sock_wfree + softnet_data + sort __spi_alloc_controller + spi_bus_lock + spi_bus_type + spi_bus_unlock + spi_controller_resume + spi_controller_suspend + spi_delay_exec + spi_finalize_current_message + spi_finalize_current_transfer + spi_get_next_queued_message + spi_register_controller __spi_register_driver + spi_setup + spi_sync + spi_sync_locked + spi_unregister_controller __splice_from_pipe + split_page + spmi_controller_add + spmi_controller_alloc + spmi_controller_remove __spmi_driver_register + spmi_ext_register_read + spmi_ext_register_readl + spmi_ext_register_write + spmi_ext_register_writel + spmi_register_read + spmi_register_write + spmi_register_zero_write + sprintf + sprint_symbol + sprint_symbol_no_offset + srcu_barrier + srcu_batches_completed + srcu_init_notifier_head + srcu_notifier_call_chain + srcu_notifier_chain_register + srcu_notifier_chain_unregister __srcu_read_lock __srcu_read_unlock + srcutorture_get_gp_data + srcu_torture_stats_print + sscanf __stack_chk_fail __stack_chk_guard + stack_trace_print + stack_trace_save + stack_trace_save_regs + stack_trace_save_tsk + static_key_disable + static_key_disable_cpuslocked + static_key_slow_dec + static_key_slow_inc + stop_machine + stop_one_cpu_nowait + stpcpy + strcasecmp + strcat + strchr + strchrnul + strcmp + strcpy + strcspn + stream_open + strim + string_get_size + strlcat + strlcpy + strlen + strncasecmp + strncat + strnchr + strncmp + strncpy + strncpy_from_user + strndup_user + strnlen + strnstr + strpbrk + strrchr + strreplace + strscpy + strsep + strspn + strstr + submit_bh + submit_bio + submit_bio_wait + subsys_system_register __sw_hweight16 __sw_hweight32 __sw_hweight64 __sw_hweight8 + swiotlb_nr_tbl + sync_blockdev + sync_file_create + sync_file_get_fence + synchronize_irq + synchronize_net + synchronize_rcu + synchronize_rcu_expedited + synchronize_rcu_tasks + synchronize_rcu_tasks_trace + synchronize_srcu + synchronize_srcu_expedited + syscon_node_to_regmap + syscon_regmap_lookup_by_phandle + sysctl_sched_features + sysctl_sched_latency + sysctl_vals + sysfs_add_file_to_group + sysfs_add_link_to_group + sysfs_create_bin_file + sysfs_create_file_ns + sysfs_create_files + sysfs_create_group + sysfs_create_groups + sysfs_create_link + sysfs_emit + sysfs_emit_at __sysfs_match_string + sysfs_notify + sysfs_remove_bin_file + sysfs_remove_file_from_group + sysfs_remove_file_ns + sysfs_remove_files + sysfs_remove_group + sysfs_remove_groups + sysfs_remove_link + sysfs_remove_link_from_group + sysfs_streq + sysfs_update_group + sysrq_mask + system_freezable_wq + system_freezing_cnt + system_highpri_wq + system_long_wq + system_power_efficient_wq + system_state + system_unbound_wq + system_wq + sys_tz + task_active_pid_ns + task_groups + __tasklet_hi_schedule + tasklet_init + tasklet_kill + __tasklet_schedule + tasklet_setup + tasklist_lock + task_may_not_preempt __task_pid_nr_ns __task_rq_lock - __tasklet_hi_schedule - __tasklet_schedule + task_rq_lock + tcpci_get_tcpm_port + tcpci_irq + tcpci_register_port + tcpci_unregister_port + tcpm_cc_change + tcpm_is_toggling + tcpm_pd_hard_reset + tcpm_pd_receive + tcpm_pd_transmit_complete + tcpm_sink_frs + tcpm_sourcing_vbus + tcpm_update_sink_capabilities + tcpm_vbus_change + tcp_register_congestion_control + tcp_reno_cong_avoid + tcp_reno_ssthresh + tcp_reno_undo_cwnd + tcp_slow_start + tcp_unregister_congestion_control + thermal_cdev_update + thermal_cooling_device_register + thermal_cooling_device_unregister + thermal_of_cooling_device_register + thermal_pressure + thermal_zone_device_disable + thermal_zone_device_enable + thermal_zone_device_is_enabled + thermal_zone_device_register + thermal_zone_device_unregister + thermal_zone_device_update + thermal_zone_get_slope + thermal_zone_get_temp + thermal_zone_get_zone_by_name + thermal_zone_of_sensor_register + thermal_zone_of_sensor_unregister + thread_group_cputime_adjusted + tick_nohz_get_idle_calls_cpu + tick_nohz_get_sleep_length + time64_to_tm + timecounter_init + timecounter_read + timer_unstable_counter_workaround + topology_set_thermal_pressure + _totalram_pages + total_swapcache_pages + _trace_android_vh_record_pcpu_rwsem_starttime __trace_bprintk __trace_bputs - __trace_printk + trace_clock_local + trace_event_buffer_commit + trace_event_buffer_reserve + trace_event_ignore_this_pid + trace_event_raw_init + trace_event_reg + trace_handle_return __traceiter_android_rvh_account_irq __traceiter_android_rvh_build_perf_domains __traceiter_android_rvh_can_migrate_task @@ -233,8 +3718,8 @@ __traceiter_android_rvh_cpu_cgroup_attach __traceiter_android_rvh_cpu_cgroup_can_attach __traceiter_android_rvh_cpu_cgroup_online - __traceiter_android_rvh_cpu_overutilized __traceiter_android_rvh_cpufreq_transition + __traceiter_android_rvh_cpu_overutilized __traceiter_android_rvh_dequeue_task __traceiter_android_rvh_die_kernel_fault __traceiter_android_rvh_do_mem_abort @@ -346,6 +3831,7 @@ __traceiter_kfree_skb __traceiter_sched_util_est_se_tp __traceiter_xdp_exception + trace_output_call __tracepoint_android_rvh_account_irq __tracepoint_android_rvh_arm64_serror_panic __tracepoint_android_rvh_bad_mode @@ -355,8 +3841,8 @@ __tracepoint_android_rvh_cpu_cgroup_attach __tracepoint_android_rvh_cpu_cgroup_can_attach __tracepoint_android_rvh_cpu_cgroup_online - __tracepoint_android_rvh_cpu_overutilized __tracepoint_android_rvh_cpufreq_transition + __tracepoint_android_rvh_cpu_overutilized __tracepoint_android_rvh_dequeue_task __tracepoint_android_rvh_dequeue_task_idle __tracepoint_android_rvh_die_kernel_fault @@ -501,6 +3987,9 @@ __tracepoint_pelt_irq_tp __tracepoint_pelt_rt_tp __tracepoint_pelt_se_tp + tracepoint_probe_register + tracepoint_probe_register_prio + tracepoint_probe_unregister __tracepoint_rwmmio_post_read __tracepoint_rwmmio_read __tracepoint_rwmmio_write @@ -513,3523 +4002,14 @@ __tracepoint_workqueue_execute_end __tracepoint_workqueue_execute_start __tracepoint_xdp_exception - __tty_alloc_driver - __tty_insert_flip_char - __udelay - __uio_register_device - __unregister_chrdev - __update_load_avg_blocked_se - __usb_create_hcd - __usb_get_extra_descriptor - __usecs_to_jiffies - __v4l2_device_register_subdev_nodes - __video_register_device - __wait_rcu_gp - __wake_up - __wake_up_locked - __wake_up_locked_key - __wake_up_sync - __warn_printk - __xa_alloc - __xa_insert - __xfrm_state_destroy - _atomic_dec_and_lock - _copy_from_iter - _copy_from_iter_full - _copy_to_iter - _ctype - _dev_alert - _dev_crit - _dev_emerg - _dev_err - _dev_info - _dev_notice - _dev_warn - _raw_read_lock - _raw_read_lock_bh - _raw_read_lock_irq - _raw_read_lock_irqsave - _raw_read_unlock - _raw_read_unlock_bh - _raw_read_unlock_irq - _raw_read_unlock_irqrestore - _raw_spin_lock - _raw_spin_lock_bh - _raw_spin_lock_irq - _raw_spin_lock_irqsave - _raw_spin_trylock - _raw_spin_trylock_bh - _raw_spin_unlock - _raw_spin_unlock_bh - _raw_spin_unlock_irq - _raw_spin_unlock_irqrestore - _raw_write_lock - _raw_write_lock_bh - _raw_write_lock_irq - _raw_write_lock_irqsave - _raw_write_unlock - _raw_write_unlock_bh - _raw_write_unlock_irq - _raw_write_unlock_irqrestore - _snd_ctl_add_follower - _snd_pcm_stream_lock_irqsave - _totalram_pages - _trace_android_vh_record_pcpu_rwsem_starttime - access_process_vm - ack_all_badblocks - activate_task - add_cpu - add_device_randomness - add_memory - add_memory_subsection - add_taint - add_timer - add_timer_on - add_uevent_var - add_wait_queue - adjust_managed_page_count - alarm_cancel - alarm_init - alarm_start - alarm_start_relative - alarm_try_to_cancel - alarmtimer_get_rtcdev - all_vm_events - alloc_anon_inode - alloc_chrdev_region - alloc_etherdev_mqs - alloc_io_pgtable_ops - alloc_netdev_mqs - alloc_page_buffers - alloc_pages_exact - alloc_skb_with_frags - alloc_workqueue - amba_bustype - amba_driver_register - amba_driver_unregister - amba_release_regions - amba_request_regions - android_debug_per_cpu_symbol - android_debug_symbol - android_rvh_probe_register - anon_inode_getfd - anon_inode_getfile - arch_timer_read_counter - argv_free - argv_split - arm64_const_caps_ready - arm64_use_ng_mappings - async_schedule_node - async_schedule_node_domain - async_synchronize_full_domain - atomic_notifier_call_chain - atomic_notifier_chain_register - atomic_notifier_chain_unregister - autoremove_wake_function - available_idle_cpu - backlight_device_get_by_type - backlight_device_register - backlight_device_set_brightness - backlight_device_unregister - badblocks_clear - badblocks_exit - badblocks_init - badblocks_set - badblocks_show - badblocks_store - balloon_aops - balloon_page_alloc - balloon_page_dequeue - balloon_page_enqueue - bcmp - bd_link_disk_holder - bd_set_nr_sectors - bd_unlink_disk_holder - bdev_check_media_change - bdev_read_only - bdevname - bdget_disk - bdput - bgpio_init - bin2hex - bio_add_page - bio_alloc_bioset - bio_associate_blkg - bio_chain - bio_clone_blkg_association - bio_endio - bio_init - bio_put - bioset_exit - bioset_init - bitmap_allocate_region - bitmap_find_next_zero_area_off - bitmap_from_arr32 - bitmap_parse - bitmap_parselist - bitmap_parselist_user - bitmap_print_to_pagebuf - bitmap_release_region - bitmap_to_arr32 - bitmap_zalloc - blk_alloc_queue - blk_cleanup_queue - blk_execute_rq - blk_execute_rq_nowait - blk_finish_plug - blk_freeze_queue_start - blk_get_queue - blk_get_request - blk_mq_alloc_request - blk_mq_alloc_request_hctx - blk_mq_alloc_tag_set - blk_mq_complete_request - blk_mq_complete_request_remote - blk_mq_debugfs_rq_show - blk_mq_delay_kick_requeue_list - blk_mq_end_request - blk_mq_free_request - blk_mq_free_tag_set - blk_mq_freeze_queue - blk_mq_freeze_queue_wait - blk_mq_freeze_queue_wait_timeout - blk_mq_init_queue - blk_mq_map_queues - blk_mq_pci_map_queues - blk_mq_quiesce_queue - blk_mq_requeue_request - blk_mq_rq_cpu - blk_mq_run_hw_queues - blk_mq_sched_request_inserted - blk_mq_sched_try_insert_merge - blk_mq_sched_try_merge - blk_mq_start_request - blk_mq_start_stopped_hw_queues - blk_mq_stop_hw_queue - blk_mq_tag_to_rq - blk_mq_tagset_busy_iter - blk_mq_tagset_wait_completed_request - blk_mq_unfreeze_queue - blk_mq_unique_tag - blk_mq_unquiesce_queue - blk_mq_update_nr_hw_queues - blk_mq_virtio_map_queues - blk_poll - blk_put_queue - blk_put_request - blk_queue_alignment_offset - blk_queue_bounce_limit - blk_queue_can_use_dma_map_merging - blk_queue_chunk_sectors - blk_queue_dma_alignment - blk_queue_flag_clear - blk_queue_flag_set - blk_queue_flag_test_and_set - blk_queue_io_min - blk_queue_io_opt - blk_queue_logical_block_size - blk_queue_max_discard_sectors - blk_queue_max_discard_segments - blk_queue_max_hw_sectors - blk_queue_max_segment_size - blk_queue_max_segments - blk_queue_max_write_zeroes_sectors - blk_queue_physical_block_size - blk_queue_rq_timeout - blk_queue_split - blk_queue_virt_boundary - blk_queue_write_cache - blk_register_region - blk_rq_map_kern - blk_rq_map_user - blk_rq_map_user_iov - blk_rq_unmap_user - blk_set_queue_dying - blk_set_stacking_limits - blk_start_plug - blk_status_to_errno - blk_sync_queue - blk_unregister_region - blk_update_request - blk_verify_command - blkcg_activate_policy - blkcg_deactivate_policy - blkcg_policy_register - blkcg_policy_unregister - blkcg_root - blkdev_fsync - blkdev_get_by_dev - blkdev_get_by_path - blkdev_issue_flush - blkdev_put - blkg_lookup_slowpath - blocking_notifier_call_chain - blocking_notifier_chain_register - blocking_notifier_chain_unregister - bmap - bpf_dispatcher_xdp_func - bpf_prog_add - bpf_prog_put - bpf_prog_sub - bpf_stats_enabled_key - bpf_trace_run1 - bpf_trace_run10 - bpf_trace_run11 - bpf_trace_run12 - bpf_trace_run2 - bpf_trace_run3 - bpf_trace_run4 - bpf_trace_run5 - bpf_trace_run6 - bpf_trace_run7 - bpf_trace_run8 - bpf_trace_run9 - bpf_warn_invalid_xdp_action - bsearch - bt_err - bt_info - build_skb - bus_find_device - bus_for_each_dev - bus_for_each_drv - bus_register - bus_register_notifier - bus_set_iommu - bus_unregister - bus_unregister_notifier - cache_line_size - call_netdevice_notifiers - call_rcu - call_rcu_tasks - call_rcu_tasks_trace - call_srcu - cancel_delayed_work - cancel_delayed_work_sync - cancel_work_sync - capable - cdc_ncm_bind_common - cdc_ncm_change_mtu - cdc_ncm_fill_tx_frame - cdc_ncm_rx_verify_ndp16 - cdc_ncm_rx_verify_nth16 - cdc_ncm_select_altsetting - cdc_ncm_unbind - cdc_parse_cdc_header - cdev_add - cdev_alloc - cdev_del - cdev_device_add - cdev_device_del - cdev_init - cec_allocate_adapter - cec_delete_adapter - cec_received_msg_ts - cec_register_adapter - cec_s_log_addrs - cec_s_phys_addr - cec_s_phys_addr_from_edid - cec_transmit_attempt_done_ts - cec_transmit_done_ts - cec_unregister_adapter - cgroup_path_ns - cgroup_taskset_first - cgroup_taskset_next - check_preempt_curr - check_zeroed_user - class_create_file_ns - class_destroy - class_find_device - class_for_each_device - class_interface_unregister - class_remove_file_ns - class_unregister - cleancache_register_ops - cleanup_srcu_struct - clear_page - clk_bulk_disable - clk_bulk_enable - clk_bulk_get_all - clk_bulk_prepare - clk_bulk_put_all - clk_bulk_unprepare - clk_disable - clk_enable - clk_fixed_factor_ops - clk_fixed_rate_ops - clk_get - clk_get_parent - clk_get_rate - clk_hw_get_flags - clk_hw_get_name - clk_hw_get_num_parents - clk_hw_get_parent - clk_hw_get_parent_by_index - clk_hw_get_rate - clk_hw_is_enabled - clk_hw_is_prepared - clk_hw_register - clk_hw_register_fixed_factor - clk_hw_round_rate - clk_hw_set_rate_range - clk_hw_unregister - clk_hw_unregister_divider - clk_hw_unregister_fixed_factor - clk_hw_unregister_gate - clk_hw_unregister_mux - clk_notifier_register - clk_notifier_unregister - clk_prepare - clk_put - clk_register - clk_register_clkdev - clk_register_fixed_factor - clk_register_fixed_rate - clk_register_gate - clk_round_rate - clk_set_parent - clk_set_rate - clk_sync_state - clk_unprepare - clk_unregister - clockevents_config_and_register - clocks_calc_mult_shift - cma_alloc - cma_for_each_area - cma_get_name - cma_release - compat_alloc_user_space - compat_only_sysfs_link_entry_to_kobj - compat_ptr_ioctl - complete - complete_all - complete_and_exit - completion_done - component_add - component_bind_all - component_del - component_master_add_with_match - component_master_del - component_match_add_release - component_unbind_all - cond_synchronize_rcu - config_ep_by_speed - config_group_init - config_group_init_type_name - config_item_get - config_item_put - configfs_register_subsystem - configfs_unregister_subsystem - console_drivers - console_printk - console_stop - console_suspend_enabled - console_trylock - console_unlock - consume_skb - contig_page_data - copy_from_kernel_nofault - copy_page - cpu_all_bits - cpu_bit_bitmap - cpu_hotplug_disable - cpu_hotplug_enable - cpu_hwcap_keys - cpu_hwcaps - cpu_irqtime - cpu_is_hotpluggable - cpu_latency_qos_add_request - cpu_latency_qos_remove_request - cpu_latency_qos_request_active - cpu_latency_qos_update_request - cpu_number - cpu_pm_register_notifier - cpu_pm_unregister_notifier - cpu_scale - cpu_subsys - cpu_topology - cpufreq_add_update_util_hook - cpufreq_cpu_get - cpufreq_cpu_get_raw - cpufreq_cpu_put - cpufreq_disable_fast_switch - cpufreq_driver_fast_switch - cpufreq_driver_resolve_freq - cpufreq_enable_boost_support - cpufreq_enable_fast_switch - cpufreq_freq_attr_scaling_available_freqs - cpufreq_freq_attr_scaling_boost_freqs - cpufreq_freq_transition_begin - cpufreq_freq_transition_end - cpufreq_frequency_table_verify - cpufreq_generic_attr - cpufreq_generic_frequency_table_verify - cpufreq_generic_get - cpufreq_generic_suspend - cpufreq_get_driver_data - cpufreq_get_policy - cpufreq_policy_transition_delay_us - cpufreq_quick_get - cpufreq_quick_get_max - cpufreq_register_driver - cpufreq_register_governor - cpufreq_register_notifier - cpufreq_remove_update_util_hook - cpufreq_table_index_unsorted - cpufreq_this_cpu_can_update - cpufreq_unregister_driver - cpufreq_unregister_notifier - cpufreq_update_policy - cpuhp_tasks_frozen - cpuidle_governor_latency_req - cpuidle_register_governor - cpumask_any_but - cpumask_next - cpumask_next_and - cpumask_next_wrap - cpupri_find_fitness - cpus_read_lock - cpus_read_unlock - crc16 - crc32_le - crc8 - crc8_populate_msb - create_function_device - crypto_aead_encrypt - crypto_aead_setauthsize - crypto_aead_setkey - crypto_alloc_aead - crypto_alloc_base - crypto_alloc_shash - crypto_alloc_skcipher - crypto_cipher_encrypt_one - crypto_cipher_setkey - crypto_comp_compress - crypto_comp_decompress - crypto_destroy_tfm - crypto_has_alg - crypto_register_alg - crypto_register_rngs - crypto_register_scomp - crypto_shash_digest - crypto_shash_final - crypto_shash_setkey - crypto_shash_update - crypto_skcipher_decrypt - crypto_skcipher_encrypt - crypto_skcipher_setkey - crypto_unregister_alg - crypto_unregister_rngs - crypto_unregister_scomp - css_next_child - css_next_descendant_pre - csum_ipv6_magic - csum_partial - csum_tcpudp_nofold - current_time - current_work - d_add - d_alloc_name - d_delete - d_make_root - d_path - dapm_pinctrl_event - dapm_regulator_event - datagram_poll - deactivate_task - debugfs_attr_read - debugfs_attr_write - debugfs_create_atomic_t - debugfs_create_blob - debugfs_create_bool - debugfs_create_dir - debugfs_create_file - debugfs_create_file_unsafe - debugfs_create_regset32 - debugfs_create_size_t - debugfs_create_symlink - debugfs_create_u16 - debugfs_create_u32 - debugfs_create_u64 - debugfs_create_u8 - debugfs_create_ulong - debugfs_create_x32 - debugfs_create_x64 - debugfs_create_x8 - debugfs_file_get - debugfs_file_put - debugfs_lookup - debugfs_print_regs32 - debugfs_remove - dec_zone_page_state - default_llseek - deferred_free - del_gendisk - del_timer - del_timer_sync - delayed_work_timer_fn - desc_to_gpio - destroy_workqueue - dev_alloc_name - dev_close - dev_coredumpm - dev_coredumpv - dev_driver_string - dev_err_probe - dev_fwnode - dev_get_by_index - dev_get_by_name - dev_get_regmap - dev_get_stats - dev_mc_sync_multiple - dev_mc_unsync - dev_open - dev_pm_clear_wake_irq - dev_pm_domain_attach - dev_pm_domain_attach_by_name - dev_pm_domain_detach - dev_pm_genpd_add_notifier - dev_pm_genpd_remove_notifier - dev_pm_genpd_set_next_wakeup - dev_pm_genpd_set_performance_state - dev_pm_opp_add - dev_pm_opp_adjust_voltage - dev_pm_opp_disable - dev_pm_opp_enable - dev_pm_opp_find_freq_ceil - dev_pm_opp_find_freq_ceil_by_volt - dev_pm_opp_find_freq_exact - dev_pm_opp_find_freq_floor - dev_pm_opp_free_cpufreq_table - dev_pm_opp_get_freq - dev_pm_opp_get_level - dev_pm_opp_get_max_transition_latency - dev_pm_opp_get_opp_count - dev_pm_opp_get_opp_table - dev_pm_opp_get_sharing_cpus - dev_pm_opp_get_suspend_opp_freq - dev_pm_opp_get_voltage - dev_pm_opp_init_cpufreq_table - dev_pm_opp_of_add_table - dev_pm_opp_of_cpumask_add_table - dev_pm_opp_of_cpumask_remove_table - dev_pm_opp_of_find_icc_paths - dev_pm_opp_of_get_sharing_cpus - dev_pm_opp_of_register_em - dev_pm_opp_of_remove_table - dev_pm_opp_put - dev_pm_opp_put_clkname - dev_pm_opp_put_opp_table - dev_pm_opp_put_regulators - dev_pm_opp_register_notifier - dev_pm_opp_remove_all_dynamic - dev_pm_opp_set_bw - dev_pm_opp_set_clkname - dev_pm_opp_set_rate - dev_pm_opp_set_regulators - dev_pm_opp_set_sharing_cpus - dev_pm_opp_set_supported_hw - dev_pm_opp_unregister_notifier - dev_pm_qos_add_notifier - dev_pm_qos_add_request - dev_pm_qos_expose_latency_tolerance - dev_pm_qos_hide_latency_tolerance - dev_pm_qos_read_value - dev_pm_qos_remove_notifier - dev_pm_qos_remove_request - dev_pm_qos_update_request - dev_pm_qos_update_user_latency_tolerance - dev_pm_set_dedicated_wake_irq - dev_printk - dev_printk_emit - dev_queue_xmit - dev_set_mtu - dev_set_name - dev_uc_sync_multiple - dev_uc_unsync - devfreq_add_device - devfreq_add_governor - devfreq_cooling_unregister - devfreq_get_devfreq_by_phandle - devfreq_monitor_resume - devfreq_monitor_start - devfreq_monitor_stop - devfreq_monitor_suspend - devfreq_recommended_opp - devfreq_register_opp_notifier - devfreq_remove_device - devfreq_remove_governor - devfreq_resume_device - devfreq_suspend_device - devfreq_unregister_opp_notifier - devfreq_update_interval - device_add - device_add_disk - device_add_groups - device_attach - device_bind_driver - device_create - device_create_bin_file - device_create_file - device_create_with_groups - device_del - device_destroy - device_find_child - device_for_each_child - device_get_child_node_count - device_get_dma_attr - device_get_mac_address - device_get_match_data - device_get_named_child_node - device_get_next_child_node - device_init_wakeup - device_initialize - device_link_add - device_link_del - device_match_fwnode - device_match_name - device_match_of_node - device_property_present - device_property_read_string - device_property_read_string_array - device_property_read_u16_array - device_property_read_u32_array - device_property_read_u8_array - device_register - device_release_driver - device_remove_bin_file - device_remove_file - device_remove_file_self - device_remove_groups - device_set_wakeup_capable - device_set_wakeup_enable - device_show_bool - device_show_int - device_store_bool - device_store_int - device_unregister - device_wakeup_disable - device_wakeup_enable - devm_add_action - devm_backlight_device_register - devm_backlight_device_unregister - devm_blk_ksm_init - devm_clk_bulk_get - devm_clk_bulk_get_all - devm_clk_bulk_get_optional - devm_clk_get - devm_clk_get_optional - devm_clk_hw_register - devm_clk_hw_register_clkdev - devm_clk_put - devm_clk_register - devm_devfreq_add_device - devm_devfreq_register_notifier - devm_devfreq_unregister_notifier - devm_device_add_group - devm_device_add_groups - devm_device_remove_group - devm_drm_panel_bridge_add_typed - devm_extcon_dev_allocate - devm_extcon_dev_register - devm_extcon_dev_unregister - devm_extcon_register_notifier - devm_free_irq - devm_free_percpu - devm_gen_pool_create - devm_get_clk_from_child - devm_gpio_free - devm_gpio_request - devm_gpio_request_one - devm_gpiochip_add_data_with_key - devm_gpiod_get - devm_gpiod_get_array - devm_gpiod_get_index - devm_gpiod_get_optional - devm_gpiod_put_array - devm_hwrng_register - devm_hwspin_lock_register - devm_i2c_new_dummy_device - devm_iio_channel_get - devm_iio_device_alloc - devm_input_allocate_device - devm_ioremap - devm_ioremap_resource - devm_ioremap_wc - devm_iounmap - devm_kasprintf - devm_kfree - devm_kmalloc - devm_kmemdup - devm_kstrdup - devm_kstrdup_const - devm_kvasprintf - devm_led_classdev_register_ext - devm_mbox_controller_register - devm_memremap - devm_mfd_add_devices - devm_nvmem_cell_get - devm_nvmem_device_get - devm_nvmem_register - devm_of_clk_add_hw_provider - devm_of_icc_get - devm_of_iomap - devm_of_platform_populate - devm_of_pwm_get - devm_pci_alloc_host_bridge - devm_phy_create - devm_phy_get - devm_phy_put - devm_pinctrl_get - devm_pinctrl_put - devm_pinctrl_register - devm_pinctrl_register_and_init - devm_platform_get_and_ioremap_resource - devm_platform_ioremap_resource - devm_platform_ioremap_resource_byname - devm_power_supply_register - devm_pwm_put - devm_regmap_add_irq_chip - devm_regmap_del_irq_chip - devm_regmap_field_alloc - devm_regulator_bulk_get - devm_regulator_get - devm_regulator_get_exclusive - devm_regulator_get_optional - devm_regulator_put - devm_regulator_register - devm_regulator_register_notifier - devm_request_any_context_irq - devm_request_threaded_irq - devm_reset_control_array_get - devm_reset_controller_register - devm_rtc_allocate_device - devm_rtc_device_register - devm_snd_dmaengine_pcm_register - devm_snd_soc_register_card - devm_snd_soc_register_component - devm_spi_register_controller - devm_thermal_of_cooling_device_register - devm_thermal_zone_of_sensor_register - devm_thermal_zone_of_sensor_unregister - devm_usb_get_phy - devm_usb_get_phy_by_node - devm_usb_get_phy_by_phandle - devm_watchdog_register_device - devres_add - devres_alloc_node - devres_free - devres_release - disable_irq - disable_irq_nosync - disable_percpu_irq - disk_end_io_acct - disk_start_io_acct - divider_get_val - divider_recalc_rate - divider_ro_round_rate_parent - divider_round_rate_parent - dma_alloc_attrs - dma_async_device_register - dma_async_device_unregister - dma_async_tx_descriptor_init - dma_buf_attach - dma_buf_begin_cpu_access - dma_buf_begin_cpu_access_partial - dma_buf_detach - dma_buf_dynamic_attach - dma_buf_end_cpu_access - dma_buf_end_cpu_access_partial - dma_buf_export - dma_buf_fd - dma_buf_get - dma_buf_get_flags - dma_buf_map_attachment - dma_buf_mmap - dma_buf_move_notify - dma_buf_pin - dma_buf_put - dma_buf_unmap_attachment - dma_buf_unpin - dma_buf_vmap - dma_buf_vunmap - dma_contiguous_default_area - dma_fence_add_callback - dma_fence_array_create - dma_fence_array_ops - dma_fence_context_alloc - dma_fence_default_wait - dma_fence_enable_sw_signaling - dma_fence_free - dma_fence_get_status - dma_fence_get_stub - dma_fence_init - dma_fence_match_context - dma_fence_release - dma_fence_remove_callback - dma_fence_signal - dma_fence_signal_locked - dma_fence_wait_any_timeout - dma_fence_wait_timeout - dma_free_attrs - dma_get_merge_boundary - dma_get_required_mask - dma_get_sgtable_attrs - dma_get_slave_caps - dma_get_slave_channel - dma_heap_add - dma_heap_buffer_alloc - dma_heap_buffer_free - dma_heap_find - dma_heap_get_dev - dma_heap_get_drvdata - dma_heap_get_name - dma_heap_put - dma_map_page_attrs - dma_map_resource - dma_map_sg_attrs - dma_max_mapping_size - dma_mmap_attrs - dma_pool_alloc - dma_pool_create - dma_pool_destroy - dma_pool_free - dma_release_channel - dma_request_chan - dma_resv_add_excl_fence - dma_resv_add_shared_fence - dma_resv_fini - dma_resv_get_fences_rcu - dma_resv_init - dma_resv_reserve_shared - dma_resv_test_signaled_rcu - dma_resv_wait_timeout_rcu - dma_set_coherent_mask - dma_set_mask - dma_sync_sg_for_cpu - dma_sync_sg_for_device - dma_sync_single_for_cpu - dma_sync_single_for_device - dma_unmap_page_attrs - dma_unmap_resource - dma_unmap_sg_attrs - dmabuf_page_pool_alloc - dmabuf_page_pool_create - dmabuf_page_pool_destroy - dmabuf_page_pool_free - dmaengine_unmap_put - dmam_alloc_attrs - dmam_free_coherent - dmam_pool_create - do_SAK - do_exit - do_trace_rcu_torture_read - do_wait_intr - do_wait_intr_irq - down - down_interruptible - down_read - down_read_killable - down_read_trylock - down_timeout - down_trylock - down_write - downgrade_write - dput - drain_workqueue - driver_attach - driver_create_file - driver_find_device - driver_register - driver_remove_file - driver_unregister - drm_add_edid_modes - drm_add_modes_noedid - drm_atomic_add_affected_connectors - drm_atomic_add_affected_planes - drm_atomic_commit - drm_atomic_get_connector_state - drm_atomic_get_crtc_state - drm_atomic_get_new_connector_for_encoder - drm_atomic_get_plane_state - drm_atomic_get_private_obj_state - drm_atomic_helper_bridge_destroy_state - drm_atomic_helper_bridge_duplicate_state - drm_atomic_helper_bridge_reset - drm_atomic_helper_check - drm_atomic_helper_check_modeset - drm_atomic_helper_check_plane_state - drm_atomic_helper_check_planes - drm_atomic_helper_cleanup_planes - drm_atomic_helper_commit - drm_atomic_helper_commit_cleanup_done - drm_atomic_helper_commit_duplicated_state - drm_atomic_helper_commit_hw_done - drm_atomic_helper_commit_modeset_disables - drm_atomic_helper_commit_modeset_enables - drm_atomic_helper_commit_planes - drm_atomic_helper_commit_tail - drm_atomic_helper_connector_destroy_state - drm_atomic_helper_connector_duplicate_state - drm_atomic_helper_connector_reset - drm_atomic_helper_crtc_destroy_state - drm_atomic_helper_crtc_duplicate_state - drm_atomic_helper_crtc_reset - drm_atomic_helper_damage_merged - drm_atomic_helper_dirtyfb - drm_atomic_helper_disable_plane - drm_atomic_helper_disable_planes_on_crtc - drm_atomic_helper_duplicate_state - drm_atomic_helper_fake_vblank - drm_atomic_helper_page_flip - drm_atomic_helper_plane_destroy_state - drm_atomic_helper_plane_duplicate_state - drm_atomic_helper_plane_reset - drm_atomic_helper_prepare_planes - drm_atomic_helper_set_config - drm_atomic_helper_setup_commit - drm_atomic_helper_shutdown - drm_atomic_helper_swap_state - drm_atomic_helper_update_legacy_modeset_state - drm_atomic_helper_update_plane - drm_atomic_helper_wait_for_dependencies - drm_atomic_helper_wait_for_fences - drm_atomic_helper_wait_for_flip_done - drm_atomic_helper_wait_for_vblanks - drm_atomic_normalize_zpos - drm_atomic_private_obj_fini - drm_atomic_private_obj_init - drm_atomic_set_crtc_for_connector - drm_atomic_set_crtc_for_plane - drm_atomic_set_fb_for_plane - drm_atomic_set_fence_for_plane - drm_atomic_set_mode_for_crtc - drm_atomic_state_alloc - drm_atomic_state_clear - drm_atomic_state_default_clear - drm_atomic_state_default_release - drm_atomic_state_init - drm_bridge_add - drm_bridge_attach - drm_bridge_chain_disable - drm_bridge_chain_enable - drm_bridge_chain_mode_set - drm_bridge_chain_post_disable - drm_bridge_chain_pre_enable - drm_bridge_hpd_notify - drm_bridge_remove - drm_client_init - drm_client_modeset_commit_locked - drm_client_register - drm_compat_ioctl - drm_connector_attach_dp_subconnector_property - drm_connector_attach_edid_property - drm_connector_attach_encoder - drm_connector_cleanup - drm_connector_has_possible_encoder - drm_connector_init - drm_connector_init_with_ddc - drm_connector_list_iter_begin - drm_connector_list_iter_end - drm_connector_list_iter_next - drm_connector_register - drm_connector_set_tile_property - drm_connector_unregister - drm_connector_update_edid_property - drm_crtc_arm_vblank_event - drm_crtc_cleanup - drm_crtc_enable_color_mgmt - drm_crtc_from_index - drm_crtc_handle_vblank - drm_crtc_helper_set_config - drm_crtc_helper_set_mode - drm_crtc_init - drm_crtc_init_with_planes - drm_crtc_send_vblank_event - drm_crtc_set_max_vblank_count - drm_crtc_vblank_count - drm_crtc_vblank_count_and_time - drm_crtc_vblank_get - drm_crtc_vblank_helper_get_vblank_timestamp - drm_crtc_vblank_off - drm_crtc_vblank_on - drm_crtc_vblank_put - drm_crtc_vblank_reset - drm_crtc_wait_one_vblank - drm_cvt_mode - drm_debugfs_create_files - drm_detect_hdmi_monitor - drm_detect_monitor_audio - drm_dev_alloc - drm_dev_dbg - drm_dev_enter - drm_dev_exit - drm_dev_get - drm_dev_printk - drm_dev_put - drm_dev_register - drm_dev_set_unique - drm_dev_unplug - drm_dev_unregister - drm_display_mode_to_videomode - drm_do_get_edid - drm_dp_atomic_find_vcpi_slots - drm_dp_atomic_release_vcpi_slots - drm_dp_aux_init - drm_dp_aux_register - drm_dp_aux_unregister - drm_dp_bw_code_to_link_rate - drm_dp_calc_pbn_mode - drm_dp_channel_eq_ok - drm_dp_check_act_status - drm_dp_clock_recovery_ok - drm_dp_dpcd_read - drm_dp_dpcd_read_link_status - drm_dp_dpcd_write - drm_dp_find_vcpi_slots - drm_dp_get_adjust_request_pre_emphasis - drm_dp_get_adjust_request_voltage - drm_dp_get_edid_quirks - drm_dp_link_rate_to_bw_code - drm_dp_link_train_channel_eq_delay - drm_dp_link_train_clock_recovery_delay - drm_dp_mst_allocate_vcpi - drm_dp_mst_deallocate_vcpi - drm_dp_mst_detect_port - drm_dp_mst_get_edid - drm_dp_mst_get_port_malloc - drm_dp_mst_hpd_irq - drm_dp_mst_put_port_malloc - drm_dp_mst_reset_vcpi_slots - drm_dp_mst_topology_mgr_destroy - drm_dp_mst_topology_mgr_init - drm_dp_mst_topology_mgr_set_mst - drm_dp_send_power_updown_phy - drm_dp_set_subconnector_property - drm_dp_update_payload_part1 - drm_dp_update_payload_part2 - drm_edid_block_valid - drm_edid_duplicate - drm_edid_get_monitor_name - drm_edid_header_is_valid - drm_edid_is_valid - drm_edid_to_sad - drm_edid_to_speaker_allocation - drm_encoder_cleanup - drm_encoder_init - drm_event_cancel_free - drm_event_reserve_init - drm_event_reserve_init_locked - drm_fb_cma_get_gem_obj - drm_flip_work_cleanup - drm_flip_work_commit - drm_flip_work_init - drm_flip_work_queue - drm_format_info - drm_framebuffer_cleanup - drm_framebuffer_init - drm_framebuffer_lookup - drm_framebuffer_remove - drm_framebuffer_unregister_private - drm_gem_cma_dumb_create_internal - drm_gem_cma_free_object - drm_gem_cma_mmap - drm_gem_cma_prime_get_sg_table - drm_gem_cma_prime_import_sg_table - drm_gem_cma_prime_mmap - drm_gem_cma_prime_vmap - drm_gem_cma_prime_vunmap - drm_gem_cma_vm_ops - drm_gem_create_mmap_offset - drm_gem_dmabuf_mmap - drm_gem_dmabuf_release - drm_gem_dmabuf_vmap - drm_gem_dmabuf_vunmap - drm_gem_fb_create - drm_gem_fb_create_handle - drm_gem_fb_destroy - drm_gem_fb_get_obj - drm_gem_fb_prepare_fb - drm_gem_free_mmap_offset - drm_gem_get_pages - drm_gem_handle_create - drm_gem_lock_reservations - drm_gem_map_attach - drm_gem_map_detach - drm_gem_map_dma_buf - drm_gem_mmap - drm_gem_mmap_obj - drm_gem_object_free - drm_gem_object_init - drm_gem_object_lookup - drm_gem_object_put_locked - drm_gem_object_release - drm_gem_prime_export - drm_gem_prime_fd_to_handle - drm_gem_prime_handle_to_fd - drm_gem_prime_import - drm_gem_prime_import_dev - drm_gem_prime_mmap - drm_gem_private_object_init - drm_gem_put_pages - drm_gem_shmem_create - drm_gem_shmem_free_object - drm_gem_shmem_get_sg_table - drm_gem_shmem_mmap - drm_gem_shmem_pin - drm_gem_shmem_print_info - drm_gem_shmem_unpin - drm_gem_shmem_vmap - drm_gem_shmem_vunmap - drm_gem_unlock_reservations - drm_gem_unmap_dma_buf - drm_gem_vm_close - drm_gem_vm_open - drm_get_connector_status_name - drm_get_edid - drm_get_format_info - drm_get_format_name - drm_handle_vblank - drm_hdmi_avi_infoframe_from_display_mode - drm_helper_connector_dpms - drm_helper_disable_unused_functions - drm_helper_force_disable_all - drm_helper_hpd_irq_event - drm_helper_mode_fill_fb_struct - drm_helper_probe_single_connector_modes - drm_helper_resume_force_mode - drm_ioctl - drm_irq_install - drm_irq_uninstall - drm_is_current_master - drm_kms_helper_hotplug_event - drm_kms_helper_is_poll_worker - drm_kms_helper_poll_disable - drm_kms_helper_poll_enable - drm_kms_helper_poll_fini - drm_kms_helper_poll_init - drm_match_cea_mode - drm_mm_init - drm_mm_insert_node_in_range - drm_mm_print - drm_mm_remove_node - drm_mm_takedown - drm_mode_config_cleanup - drm_mode_config_helper_resume - drm_mode_config_helper_suspend - drm_mode_config_reset - drm_mode_convert_to_umode - drm_mode_convert_umode - drm_mode_copy - drm_mode_create - drm_mode_create_dp_colorspace_property - drm_mode_create_scaling_mode_property - drm_mode_create_tile_group - drm_mode_crtc_set_gamma_size - drm_mode_debug_printmodeline - drm_mode_destroy - drm_mode_duplicate - drm_mode_equal - drm_mode_equal_no_clocks - drm_mode_get_tile_group - drm_mode_is_420_only - drm_mode_match - drm_mode_object_find - drm_mode_object_get - drm_mode_object_put - drm_mode_probed_add - drm_mode_set_crtcinfo - drm_mode_set_name - drm_mode_sort - drm_mode_vrefresh - drm_modeset_acquire_fini - drm_modeset_acquire_init - drm_modeset_backoff - drm_modeset_drop_locks - drm_modeset_lock - drm_modeset_lock_all - drm_modeset_lock_all_ctx - drm_modeset_lock_init - drm_modeset_unlock - drm_modeset_unlock_all - drm_need_swiotlb - drm_object_attach_property - drm_object_property_set_value - drm_of_component_match_add - drm_of_find_possible_crtcs - drm_open - drm_panel_add - drm_panel_disable - drm_panel_enable - drm_panel_get_modes - drm_panel_init - drm_panel_prepare - drm_panel_remove - drm_panel_unprepare - drm_plane_cleanup - drm_plane_create_alpha_property - drm_plane_create_blend_mode_property - drm_plane_create_rotation_property - drm_plane_create_zpos_property - drm_plane_enable_fb_damage_clips - drm_poll - drm_prime_gem_destroy - drm_prime_pages_to_sg - drm_prime_sg_to_page_addr_arrays - drm_printf - drm_property_blob_get - drm_property_blob_put - drm_property_create - drm_property_create_bitmask - drm_property_create_blob - drm_property_create_bool - drm_property_create_enum - drm_property_create_range - drm_property_create_signed_range - drm_property_lookup_blob - drm_property_replace_blob - drm_puts - drm_read - drm_rect_calc_hscale - drm_rect_calc_vscale - drm_rect_clip_scaled - drm_rect_intersect - drm_release - drm_rotation_simplify - drm_send_event - drm_send_event_locked - drm_set_preferred_mode - drm_simple_encoder_init - drm_state_dump - drm_syncobj_add_point - drm_syncobj_create - drm_syncobj_find - drm_syncobj_find_fence - drm_syncobj_free - drm_syncobj_get_fd - drm_syncobj_get_handle - drm_syncobj_replace_fence - drm_sysfs_hotplug_event - drm_universal_plane_init - drm_vblank_init - drm_vma_node_allow - drm_vma_node_is_allowed - drm_vma_node_revoke - drm_wait_one_vblank - drm_writeback_connector_init - drm_writeback_queue_job - drm_writeback_signal_completion - drmm_kmalloc - drmm_mode_config_init - dst_release - dump_align - dump_backtrace - dump_emit - dump_stack - dup_iter - dw_handle_msi_irq - dw_pcie_host_init - dw_pcie_msi_init - dw_pcie_own_conf_map_bus - dw_pcie_read - dw_pcie_setup_rc - dw_pcie_write - dwc3_send_gadget_ep_cmd - dwc3_stop_active_transfer - edac_device_add_device - edac_device_alloc_ctl_info - edac_device_alloc_index - edac_device_del_device - edac_device_free_ctl_info - edac_device_handle_ce_count - edac_device_handle_ue_count - efi - efi_tpm_final_log_size - elevator_alloc - elv_bio_merge_ok - elv_rb_add - elv_rb_del - elv_rb_find - elv_rb_former_request - elv_rb_latter_request - elv_register - elv_rqhash_add - elv_rqhash_del - elv_unregister - emergency_restart - enable_irq - enable_percpu_irq - eth_commit_mac_addr_change - eth_mac_addr - eth_platform_get_mac_address - eth_prepare_mac_addr_change - eth_type_trans - eth_validate_addr - ether_setup - ethtool_op_get_link - ethtool_op_get_ts_info - ethtool_virtdev_set_link_ksettings - event_triggers_call - eventfd_ctx_fdget - eventfd_ctx_fileget - eventfd_ctx_put - eventfd_ctx_remove_wait_queue - eventfd_signal - extcon_find_edev_by_node - extcon_get_edev_by_phandle - extcon_get_edev_name - extcon_get_extcon_dev - extcon_get_property - extcon_get_state - extcon_register_notifier - extcon_set_property - extcon_set_property_capability - extcon_set_state_sync - extcon_unregister_notifier - fasync_helper - fd_install - fget - file_path - file_ra_state_init - filp_close - filp_open_block - find_get_pid - find_last_bit - find_next_bit - find_next_zero_bit - find_snd_usb_substream - find_task_by_vpid - find_vma - find_vpid - finish_wait - firmware_request_nowarn - fixed_phy_register - fixed_phy_unregister - fixed_size_llseek - flow_keys_basic_dissector - flush_dcache_page - flush_delayed_work - flush_signals - flush_work - flush_workqueue - fput - frame_vector_create - frame_vector_destroy - frame_vector_to_pages - free_buffer_head - free_io_pgtable_ops - free_irq - free_netdev - free_pages - free_pages_exact - free_percpu - free_percpu_irq - freezing_slow_path - freq_qos_add_request - freq_qos_remove_request - freq_qos_update_request - freq_scale - fs_bio_set - fsync_bdev - ftrace_dump - full_name_hash - fwnode_find_reference - fwnode_get_name - fwnode_get_named_child_node - fwnode_get_next_child_node - fwnode_gpiod_get_index - fwnode_handle_get - fwnode_handle_put - fwnode_property_present - fwnode_property_read_string - fwnode_property_read_u32_array - fwnode_usb_role_switch_get - gcd - gen_pool_add_owner - gen_pool_alloc_algo_owner - gen_pool_avail - gen_pool_best_fit - gen_pool_create - gen_pool_destroy - gen_pool_dma_alloc_align - gen_pool_dma_zalloc_align - gen_pool_first_fit_align - gen_pool_first_fit_order_align - gen_pool_free_owner - gen_pool_has_addr - gen_pool_set_algo - gen_pool_size - gen_pool_virt_to_phys - generic_delete_inode - generic_device_group - generic_file_llseek - generic_file_read_iter - generic_handle_irq - generic_iommu_put_resv_regions - generic_mii_ioctl - generic_perform_write - generic_write_checks - genl_notify - genl_register_family - genl_unregister_family - genlmsg_put - genphy_read_status - genphy_resume - genphy_soft_reset - genphy_suspend - get_cpu_device - get_cpu_idle_time - get_cpu_idle_time_us - get_cpu_iowait_time_us - get_device - get_device_system_crosststamp - get_governor_parent_kobj - get_next_ino - get_option - get_options - get_pid_task - get_random_bytes - get_random_bytes_arch - get_random_u32 - get_random_u64 - get_sg_io_hdr - get_state_synchronize_rcu - get_task_exe_file - get_task_mm - get_task_pid - get_thermal_instance - get_tree_single - get_unmapped_area - get_unused_fd_flags - get_user_pages - get_user_pages_fast - get_user_pages_remote - get_vaddr_frames - get_zeroed_page - getboottime64 - gfp_zone - gic_nonsecure_priorities - glob_match - gnss_allocate_device - gnss_deregister_device - gnss_insert_raw - gnss_put_device - gnss_register_device - gov_attr_set_get - gov_attr_set_init - gov_attr_set_put - governor_sysfs_ops - gpio_free - gpio_free_array - gpio_request - gpio_request_one - gpio_to_desc - gpiochip_add_data_with_key - gpiochip_add_pin_range - gpiochip_find - gpiochip_generic_config - gpiochip_generic_free - gpiochip_generic_request - gpiochip_get_data - gpiochip_irqchip_add_key - gpiochip_line_is_valid - gpiochip_lock_as_irq - gpiochip_populate_parent_fwspec_fourcell - gpiochip_remove - gpiochip_set_nested_irqchip - gpiochip_unlock_as_irq - gpiod_cansleep - gpiod_count - gpiod_direction_input - gpiod_direction_output - gpiod_direction_output_raw - gpiod_get_optional - gpiod_get_raw_value - gpiod_get_raw_value_cansleep - gpiod_get_value - gpiod_get_value_cansleep - gpiod_set_consumer_name - gpiod_set_debounce - gpiod_set_raw_value - gpiod_set_raw_value_cansleep - gpiod_set_value - gpiod_set_value_cansleep - gpiod_to_chip - gpiod_to_irq - gro_cells_destroy - gro_cells_init - gro_cells_receive - gs_alloc_req - gs_free_req - gserial_alloc_line - gserial_connect - gserial_disconnect - gserial_free_line - gserial_resume - gserial_suspend - guid_gen - handle_bad_irq - handle_edge_irq - handle_fasteoi_ack_irq - handle_fasteoi_irq - handle_level_irq - handle_nested_irq - handle_simple_irq - handle_sysrq - hash_digest_size - hashlen_string - have_governor_per_policy - hci_alloc_dev - hci_free_dev - hci_recv_frame - hci_register_dev - hci_unregister_dev - hdmi_audio_infoframe_init - hdmi_audio_infoframe_pack - hdmi_avi_infoframe_init - hdmi_avi_infoframe_pack - hdmi_infoframe_pack - hex2bin - hex_dump_to_buffer - hex_to_bin - hid_hw_close - hid_hw_open - hid_hw_start - hid_hw_stop - hid_open_report - hid_report_raw_event - hid_unregister_driver - hmm_range_fault - hrtimer_active - hrtimer_cancel - hrtimer_forward - hrtimer_init - hrtimer_init_sleeper - hrtimer_sleeper_start_expires - hrtimer_start_range_ns - hrtimer_try_to_cancel - hvc_alloc - hvc_instantiate - hvc_kick - hvc_poll - hvc_remove - hwrng_register - hwrng_unregister - hwspin_lock_free - hwspin_lock_request_specific - hypervisor_kobj - i2c_adapter_type - i2c_add_adapter - i2c_add_numbered_adapter - i2c_bit_add_bus - i2c_bit_add_numbered_bus - i2c_bus_type - i2c_client_type - i2c_del_adapter - i2c_del_driver - i2c_for_each_dev - i2c_generic_scl_recovery - i2c_get_adapter - i2c_get_device_id - i2c_get_dma_safe_msg_buf - i2c_match_id - i2c_new_ancillary_device - i2c_new_client_device - i2c_new_dummy_device - i2c_new_scanned_device - i2c_parse_fw_timings - i2c_put_adapter - i2c_put_dma_safe_msg_buf - i2c_recover_bus - i2c_register_driver - i2c_smbus_read_byte - i2c_smbus_read_byte_data - i2c_smbus_read_i2c_block_data - i2c_smbus_read_word_data - i2c_smbus_write_byte - i2c_smbus_write_byte_data - i2c_smbus_write_i2c_block_data - i2c_smbus_write_word_data - i2c_smbus_xfer - i2c_transfer - i2c_transfer_buffer_flags - i2c_unregister_device - i2c_verify_adapter - i2c_verify_client - icc_disable - icc_enable - icc_get - icc_link_create - icc_node_add - icc_node_create - icc_node_del - icc_node_destroy - icc_nodes_remove - icc_provider_add - icc_provider_del - icc_put - icc_set_bw - icc_set_tag - icc_std_aggregate - icc_sync_state - ida_alloc_range - ida_destroy - ida_free - idr_alloc - idr_alloc_cyclic - idr_alloc_u32 - idr_destroy - idr_find - idr_for_each - idr_get_next - idr_preload - idr_remove - idr_replace - ieee802154_alloc_hw - ieee802154_free_hw - ieee802154_register_hw - ieee802154_rx_irqsafe - ieee802154_unregister_hw - ieee802154_wake_queue - ieee802154_xmit_complete - iio_buffer_init - iio_buffer_put - iio_channel_get - iio_channel_get_all - iio_channel_release - iio_device_alloc - iio_device_attach_buffer - iio_device_free - iio_device_unregister - iio_push_to_buffers - iio_read_channel_processed - iio_read_channel_raw - import_iovec - in4_pton - in6_dev_finish_destroy - in6_pton - in_aton - in_egroup_p - inc_zone_page_state - inet_proto_csum_replace4 - init_dummy_netdev - init_iova_domain - init_net - init_on_free - init_pid_ns - init_pseudo - init_srcu_struct - init_task - init_timer_key - init_uts_ns - init_wait_entry - input_alloc_absinfo - input_allocate_device - input_close_device - input_event - input_ff_create - input_ff_create_memless - input_ff_destroy - input_free_device - input_mt_assign_slots - input_mt_destroy_slots - input_mt_drop_unused - input_mt_init_slots - input_mt_report_finger_count - input_mt_report_pointer_emulation - input_mt_report_slot_state - input_mt_sync_frame - input_open_device - input_register_device - input_register_handle - input_register_handler - input_set_abs_params - input_set_capability - input_set_timestamp - input_unregister_device - input_unregister_handle - input_unregister_handler - int_pow - int_sqrt - interval_tree_insert - interval_tree_iter_first - interval_tree_iter_next - interval_tree_remove - invalidate_bdev - invalidate_mapping_pages - io_schedule_timeout - iomem_resource - iommu_alloc_resv_region - iommu_attach_device - iommu_attach_group - iommu_aux_attach_device - iommu_aux_detach_device - iommu_aux_get_pasid - iommu_detach_device - iommu_detach_group - iommu_dev_enable_feature - iommu_dev_feature_enabled - iommu_device_register - iommu_device_sysfs_add - iommu_device_sysfs_remove - iommu_device_unlink - iommu_device_unregister - iommu_dma_enable_best_fit_algo - iommu_dma_get_resv_regions - iommu_dma_reserve_iova - iommu_domain_alloc - iommu_domain_free - iommu_domain_get_attr - iommu_domain_set_attr - iommu_fwspec_add_ids - iommu_fwspec_free - iommu_get_dma_cookie - iommu_get_domain_for_dev - iommu_get_msi_cookie - iommu_group_alloc - iommu_group_for_each_dev - iommu_group_get - iommu_group_get_iommudata - iommu_group_put - iommu_group_ref_get - iommu_group_set_iommudata - iommu_group_set_name - iommu_iova_to_phys - iommu_map - iommu_map_sg - iommu_present - iommu_put_dma_cookie - iommu_register_device_fault_handler - iommu_report_device_fault - iommu_set_fault_handler - iommu_unmap - iommu_unregister_device_fault_handler - iounmap - iov_iter_bvec - iov_iter_kvec - ip_compute_csum - ip_send_check - ipi_desc_get - iput - ipv6_ext_hdr - ipv6_find_hdr - ipv6_skip_exthdr - irq_chip_ack_parent - irq_chip_disable_parent - irq_chip_enable_parent - irq_chip_eoi_parent - irq_chip_get_parent_state - irq_chip_mask_parent - irq_chip_retrigger_hierarchy - irq_chip_set_affinity_parent - irq_chip_set_parent_state - irq_chip_set_type_parent - irq_chip_set_vcpu_affinity_parent - irq_chip_set_wake_parent - irq_chip_unmask_parent - irq_create_fwspec_mapping - irq_create_mapping_affinity - irq_create_of_mapping - irq_dispose_mapping - irq_domain_add_simple - irq_domain_alloc_irqs_parent - irq_domain_create_hierarchy - irq_domain_free_irqs_common - irq_domain_free_irqs_parent - irq_domain_get_irq_data - irq_domain_remove - irq_domain_set_hwirq_and_chip - irq_domain_set_info - irq_domain_simple_ops - irq_domain_update_bus_token - irq_domain_xlate_onecell - irq_domain_xlate_onetwocell - irq_domain_xlate_twocell - irq_find_mapping - irq_find_matching_fwspec - irq_get_irq_data - irq_get_irqchip_state - irq_modify_status - irq_of_parse_and_map - irq_set_affinity_hint - irq_set_affinity_notifier - irq_set_chained_handler_and_data - irq_set_chip - irq_set_chip_and_handler_name - irq_set_chip_data - irq_set_handler_data - irq_set_irq_type - irq_set_irq_wake - irq_set_irqchip_state - irq_set_parent - irq_to_desc - irq_work_queue - irq_work_queue_on - irq_work_sync - is_dma_buf_file - is_vmalloc_addr - iwe_stream_add_event - iwe_stream_add_point - iwe_stream_add_value - jiffies - jiffies64_to_msecs - jiffies_64_to_clock_t - jiffies_to_msecs - jiffies_to_usecs - kasan_flag_enabled - kasprintf - kern_mount - kern_path - kern_unmount - kernel_bind - kernel_connect - kernel_cpustat - kernel_getsockname - kernel_kobj - kernel_power_off - kernel_recvmsg - kernel_restart - kernel_sendmsg - kernel_sigaction - kernfs_find_and_get_ns - kernfs_notify - kernfs_path_from_node - kernfs_put - kfree - kfree_const - kfree_sensitive - kfree_skb - kick_all_cpus_sync - kill_anon_super - kill_fasync - kill_litter_super - kimage_vaddr - kimage_voffset - kiocb_set_cancel_fn - kmalloc_caches - kmalloc_order - kmalloc_order_trace - kmem_cache_alloc - kmem_cache_alloc_trace - kmem_cache_create - kmem_cache_create_usercopy - kmem_cache_destroy - kmem_cache_free - kmemdup - kmemdup_nul - kmsg_dump_get_line - kmsg_dump_rewind - kobj_sysfs_ops - kobject_add - kobject_create_and_add - kobject_del - kobject_get - kobject_init - kobject_init_and_add - kobject_put - kobject_set_name - kobject_uevent - kobject_uevent_env - krealloc - kset_create_and_add - kset_unregister - ksize - ksoftirqd - kstat - kstat_irqs_cpu - kstat_irqs_usr - kstrdup - kstrdup_const - kstrdup_quotable_cmdline - kstrndup - kstrtobool - kstrtobool_from_user - kstrtoint - kstrtoint_from_user - kstrtol_from_user - kstrtoll - kstrtos16 - kstrtos8 - kstrtos8_from_user - kstrtou16 - kstrtou16_from_user - kstrtou8 - kstrtou8_from_user - kstrtouint - kstrtouint_from_user - kstrtoul_from_user - kstrtoull - kstrtoull_from_user - ksys_sync_helper - kthread_bind - kthread_bind_mask - kthread_blkcg - kthread_cancel_delayed_work_sync - kthread_cancel_work_sync - kthread_create_on_node - kthread_create_worker - kthread_delayed_work_timer_fn - kthread_destroy_worker - kthread_flush_work - kthread_flush_worker - kthread_mod_delayed_work - kthread_park - kthread_parkme - kthread_queue_delayed_work - kthread_queue_work - kthread_should_park - kthread_should_stop - kthread_stop - kthread_unpark - kthread_unuse_mm - kthread_use_mm - kthread_worker_fn - ktime_add_safe - ktime_get - ktime_get_coarse_with_offset - ktime_get_mono_fast_ns - ktime_get_raw - ktime_get_raw_ts64 - ktime_get_real_seconds - ktime_get_real_ts64 - ktime_get_seconds - ktime_get_ts64 - ktime_get_with_offset - kvasprintf - kvfree - kvfree_call_rcu - kvmalloc_node - led_classdev_flash_register_ext - led_classdev_flash_unregister - led_classdev_register_ext - led_classdev_unregister - led_trigger_event - led_trigger_register_simple - led_trigger_unregister_simple - list_sort - llist_add_batch - llist_reverse_order - lock_sock_nested - log_abnormal_wakeup_reason - log_buf_addr_get - log_buf_len_get - log_threaded_irq_wakeup_reason - loops_per_jiffy - lzo1x_1_compress - lzo1x_decompress_safe - lzorle1x_1_compress - mac_pton - match_string - mbox_chan_received_data - mbox_chan_txdone - mbox_client_txdone - mbox_controller_register - mbox_controller_unregister - mbox_free_channel - mbox_request_channel - mbox_send_message - mdiobus_alloc_size - mdiobus_free - mdiobus_read - mdiobus_unregister - mdiobus_write - media_device_cleanup - media_device_init - media_device_unregister - media_entity_pads_init - memblock_end_of_DRAM - memblock_free - memchr - memchr_inv - memcmp - memcpy - memdup_user - memdup_user_nul - memmove - memory_block_size_bytes - memory_read_from_buffer - memparse - mempool_alloc - mempool_alloc_slab - mempool_create - mempool_create_node - mempool_destroy - mempool_exit - mempool_free - mempool_free_slab - mempool_init - mempool_kfree - mempool_kmalloc - memremap - memset - memset64 - memstart_addr - memunmap - mfd_add_devices - mfd_remove_devices - migrate_swap - mii_check_media - mii_ethtool_get_link_ksettings - mii_ethtool_gset - mii_ethtool_set_link_ksettings - mii_link_ok - mii_nway_restart - mipi_dsi_attach - mipi_dsi_compression_mode - mipi_dsi_create_packet - mipi_dsi_dcs_read - mipi_dsi_dcs_set_column_address - mipi_dsi_dcs_set_display_brightness - mipi_dsi_dcs_set_page_address - mipi_dsi_dcs_set_tear_off - mipi_dsi_dcs_write_buffer - mipi_dsi_detach - mipi_dsi_device_register_full - mipi_dsi_device_unregister - mipi_dsi_driver_register_full - mipi_dsi_driver_unregister - mipi_dsi_host_register - mipi_dsi_host_unregister - mipi_dsi_packet_format_is_long - mipi_dsi_picture_parameter_set - misc_deregister - misc_register - mktime64 - mm_trace_rss_stat - mmc_add_host - mmc_alloc_host - mmc_app_cmd - mmc_calc_max_discard - mmc_can_erase - mmc_can_gpio_cd - mmc_can_secure_erase_trim - mmc_can_trim - mmc_cmdq_disable - mmc_cmdq_enable - mmc_cqe_post_req - mmc_cqe_recovery - mmc_cqe_request_done - mmc_cqe_start_req - mmc_detect_card_removed - mmc_detect_change - mmc_erase - mmc_erase_group_aligned - mmc_flush_cache - mmc_free_host - mmc_get_card - mmc_get_ext_csd - mmc_gpio_get_cd - mmc_gpio_get_ro - mmc_gpiod_request_cd - mmc_gpiod_request_cd_irq - mmc_gpiod_request_ro - mmc_hw_reset - mmc_of_parse - mmc_of_parse_voltage - mmc_put_card - mmc_register_driver - mmc_regulator_get_supply - mmc_regulator_set_ocr - mmc_regulator_set_vqmmc - mmc_release_host - mmc_remove_host - mmc_request_done - mmc_retune_pause - mmc_retune_release - mmc_retune_unpause - mmc_run_bkops - mmc_sanitize - mmc_send_status - mmc_send_tuning - mmc_set_data_timeout - mmc_start_request - mmc_switch - mmc_unregister_driver - mmc_wait_for_cmd - mmc_wait_for_req - mmput - mmu_interval_notifier_insert - mmu_interval_notifier_remove - mmu_interval_read_begin - mmu_notifier_synchronize - mod_delayed_work_on - mod_node_page_state - mod_timer - module_layout - module_put - msleep - msleep_interruptible - mutex_is_locked - mutex_lock - mutex_lock_interruptible - mutex_trylock - mutex_trylock_recursive - mutex_unlock - name_to_dev_t - names_cachep - napi_complete_done - napi_consume_skb - napi_disable - napi_gro_flush - napi_gro_receive - napi_schedule_prep - net_namespace_list - net_ratelimit - netdev_change_features - netdev_err - netdev_increment_features - netdev_info - netdev_lower_state_changed - netdev_master_upper_dev_link - netdev_notify_peers - netdev_pick_tx - netdev_rx_handler_register - netdev_rx_handler_unregister - netdev_state_change - netdev_update_features - netdev_upper_dev_link - netdev_upper_dev_unlink - netdev_warn - netif_carrier_off - netif_carrier_on - netif_device_attach - netif_device_detach - netif_napi_add - netif_receive_skb - netif_receive_skb_list - netif_rx - netif_rx_ni - netif_schedule_queue - netif_set_real_num_rx_queues - netif_set_real_num_tx_queues - netif_stacked_transfer_operstate - netif_tx_stop_all_queues - netif_tx_wake_queue - netlink_ack - netlink_broadcast - netlink_capable - netlink_has_listeners - netlink_kernel_release - netlink_register_notifier - netlink_unicast - netlink_unregister_notifier - new_inode - nf_conntrack_destroy - nla_append - nla_find - nla_memcpy - nla_put - nla_put_64bit - nla_put_nohdr - nla_reserve - nla_reserve_64bit - nla_strlcpy - no_llseek - no_seek_end_llseek - nonseekable_open - noop_llseek - nr_cpu_ids - nr_ipi_get - nr_irqs - ns_capable - ns_to_timespec64 - nsec_to_clock_t - nsecs_to_jiffies - nvdimm_bus_register - nvdimm_bus_unregister - nvdimm_pmem_region_create - nvmem_cell_get - nvmem_cell_put - nvmem_cell_read - nvmem_cell_read_u32 - nvmem_cell_write - nvmem_device_put - nvmem_device_read - nvmem_device_write - of_address_to_resource - of_alias_get_highest_id - of_alias_get_id - of_clk_add_hw_provider - of_clk_add_provider - of_clk_del_provider - of_clk_get - of_clk_get_by_name - of_clk_get_from_provider - of_clk_get_parent_count - of_clk_get_parent_name - of_clk_hw_onecell_get - of_clk_hw_simple_get - of_clk_set_defaults - of_clk_src_onecell_get - of_clk_src_simple_get - of_count_phandle_with_args - of_cpu_node_to_id - of_cpufreq_cooling_register - of_css - of_devfreq_cooling_register - of_devfreq_cooling_register_power - of_device_get_match_data - of_device_is_available - of_device_is_compatible - of_device_modalias - of_device_request_module - of_device_uevent_modalias - of_dma_configure_id - of_dma_controller_free - of_dma_controller_register - of_dma_is_coherent - of_drm_find_bridge - of_drm_find_panel - of_find_all_nodes - of_find_compatible_node - of_find_device_by_node - of_find_i2c_adapter_by_node - of_find_i2c_device_by_node - of_find_matching_node_and_match - of_find_mipi_dsi_host_by_node - of_find_node_by_name - of_find_node_by_phandle - of_find_node_by_type - of_find_node_opts_by_path - of_find_node_with_property - of_find_property - of_fwnode_ops - of_genpd_add_provider_onecell - of_genpd_add_provider_simple - of_genpd_del_provider - of_get_address - of_get_child_by_name - of_get_compatible_child - of_get_cpu_node - of_get_dma_window - of_get_named_gpio_flags - of_get_next_available_child - of_get_next_child - of_get_next_parent - of_get_parent - of_get_property - of_get_regulator_init_data - of_graph_get_endpoint_by_regs - of_graph_get_next_endpoint - of_graph_get_port_parent - of_graph_get_remote_endpoint - of_graph_get_remote_node - of_graph_get_remote_port - of_graph_get_remote_port_parent - of_graph_is_present - of_graph_parse_endpoint - of_hwspin_lock_get_id - of_i2c_get_board_info - of_icc_get - of_icc_xlate_onecell - of_iomap - of_irq_find_parent - of_irq_get - of_irq_get_byname - of_irq_parse_one - of_machine_is_compatible - of_match_device - of_match_node - of_modalias_node - of_n_addr_cells - of_n_size_cells - of_node_name_eq - of_nvmem_device_get - of_parse_phandle - of_parse_phandle_with_args - of_parse_phandle_with_fixed_args - of_phandle_iterator_init - of_phandle_iterator_next - of_phy_simple_xlate - of_platform_depopulate - of_platform_device_create - of_platform_device_destroy - of_platform_populate - of_prop_next_string - of_prop_next_u32 - of_property_count_elems_of_size - of_property_match_string - of_property_read_string - of_property_read_string_helper - of_property_read_u32_index - of_property_read_u64 - of_property_read_u64_index - of_property_read_variable_u16_array - of_property_read_variable_u32_array - of_property_read_variable_u64_array - of_property_read_variable_u8_array - of_pwm_xlate_with_flags - of_reserved_mem_device_init_by_idx - of_reserved_mem_device_release - of_reserved_mem_lookup - of_reset_control_array_get - of_root - of_thermal_get_ntrips - of_thermal_get_trip_points - of_thermal_is_trip_valid - of_translate_address - of_usb_get_phy_mode - of_usb_host_tpl_support - on_each_cpu - oops_in_progress - orderly_poweroff - overflowuid - page_endio - page_mapping - page_reporting_register - page_reporting_unregister - panic - panic_notifier_list - panic_timeout - param_array_ops - param_get_int - param_get_string - param_get_uint - param_get_ullong - param_ops_bint - param_ops_bool - param_ops_byte - param_ops_charp - param_ops_hexint - param_ops_int - param_ops_long - param_ops_short - param_ops_string - param_ops_uint - param_ops_ullong - param_ops_ulong - param_ops_ushort - param_set_bool - param_set_copystring - param_set_int - param_set_uint - part_end_io_acct - part_start_io_acct - passthru_features_check - path_put - pause_cpus - pci_alloc_irq_vectors_affinity - pci_assign_resource - pci_assign_unassigned_bus_resources - pci_bus_resource_n - pci_bus_type - pci_clear_master - pci_d3cold_disable - pci_dev_present - pci_dev_put - pci_device_group - pci_device_is_present - pci_disable_device - pci_disable_msi - pci_enable_atomic_ops_to_root - pci_enable_device - pci_enable_device_mem - pci_enable_msi - pci_enable_wake - pci_find_bus - pci_find_capability - pci_find_ext_capability - pci_find_next_capability - pci_free_irq - pci_free_irq_vectors - pci_generic_config_read - pci_generic_config_write - pci_get_device - pci_get_domain_bus_and_slot - pci_get_slot - pci_host_probe - pci_intx - pci_iomap - pci_iomap_range - pci_ioremap_bar - pci_irq_get_affinity - pci_irq_vector - pci_load_and_free_saved_state - pci_load_saved_state - pci_map_rom - pci_match_id - pci_msi_create_irq_domain - pci_msi_mask_irq - pci_msi_unmask_irq - pci_msix_vec_count - pci_read_config_byte - pci_read_config_dword - pci_read_config_word - pci_release_region - pci_release_regions - pci_release_resource - pci_release_selected_regions - pci_request_irq - pci_request_region - pci_request_regions - pci_request_selected_regions - pci_rescan_bus - pci_resize_resource - pci_restore_msi_state - pci_restore_state - pci_save_state - pci_select_bars - pci_set_master - pci_set_mwi - pci_set_power_state - pci_store_saved_state - pci_unmap_rom - pci_unregister_driver - pci_wake_from_d3 - pci_walk_bus - pci_write_config_byte - pci_write_config_dword - pci_write_config_word - pcibios_resource_to_bus - pcie_aspm_enabled - pcie_bandwidth_available - pcie_capability_read_word - pcie_capability_write_word - pcie_get_mps - pcie_get_speed_cap - pcim_enable_device - per_cpu_ptr_to_phys - percpu_down_write - percpu_ref_exit - percpu_ref_init - percpu_ref_is_zero - percpu_ref_kill_and_confirm - percpu_ref_switch_to_atomic_sync - percpu_ref_switch_to_percpu - percpu_up_write - perf_aux_output_begin - perf_aux_output_end - perf_aux_output_flag - perf_event_addr_filters_sync - perf_event_create_kernel_counter - perf_event_disable - perf_event_enable - perf_event_pause - perf_event_read_local - perf_event_read_value - perf_event_release_kernel - perf_event_update_userpage - perf_get_aux - perf_pmu_migrate_context - perf_pmu_register - perf_pmu_unregister - perf_trace_buf_alloc - perf_trace_run_bpf_submit - pfn_valid - phy_attached_info - phy_calibrate - phy_configure - phy_connect - phy_connect_direct - phy_disconnect - phy_do_ioctl_running - phy_drivers_register - phy_drivers_unregister - phy_ethtool_get_link_ksettings - phy_ethtool_nway_reset - phy_ethtool_set_link_ksettings - phy_ethtool_set_wol - phy_exit - phy_find_first - phy_get_pause - phy_init - phy_init_hw - phy_mii_ioctl - phy_pm_runtime_get_sync - phy_pm_runtime_put_sync - phy_power_off - phy_power_on - phy_print_status - phy_register_fixup_for_uid - phy_save_page - phy_set_mode_ext - phy_start - phy_stop - phy_unregister_fixup_for_uid - pick_highest_pushable_task - pid_nr_ns - pid_task - pin_get_name - pin_user_pages - pin_user_pages_fast - pin_user_pages_remote - pinconf_generic_dt_free_map - pinconf_generic_dt_node_to_map - pinctrl_add_gpio_range - pinctrl_dev_get_drvdata - pinctrl_enable - pinctrl_force_default - pinctrl_force_sleep - pinctrl_get - pinctrl_lookup_state - pinctrl_pm_select_default_state - pinctrl_pm_select_idle_state - pinctrl_pm_select_sleep_state - pinctrl_put - pinctrl_remove_gpio_range - pinctrl_select_default_state - pinctrl_select_state - pinctrl_utils_free_map - pipe_lock - pipe_unlock - pktgen_xfrm_outer_mode_output - platform_add_devices - platform_bus_type - platform_device_add - platform_device_add_data - platform_device_add_properties - platform_device_add_resources - platform_device_alloc - platform_device_del - platform_device_put - platform_device_register - platform_device_register_full - platform_device_unregister - platform_driver_unregister - platform_find_device_by_driver - platform_get_irq - platform_get_irq_byname - platform_get_irq_byname_optional - platform_get_irq_optional - platform_get_resource - platform_get_resource_byname - platform_irq_count - pm_clk_add - pm_clk_create - pm_clk_destroy - pm_clk_resume - pm_clk_suspend - pm_generic_resume - pm_generic_runtime_resume - pm_generic_runtime_suspend - pm_generic_suspend - pm_genpd_add_subdomain - pm_genpd_init - pm_genpd_remove - pm_genpd_remove_subdomain - pm_power_off - pm_relax - pm_runtime_allow - pm_runtime_autosuspend_expiration - pm_runtime_barrier - pm_runtime_enable - pm_runtime_forbid - pm_runtime_force_resume - pm_runtime_force_suspend - pm_runtime_get_if_active - pm_runtime_irq_safe - pm_runtime_no_callbacks - pm_runtime_set_autosuspend_delay - pm_stay_awake - pm_suspend_global_flags - pm_system_wakeup - pm_wakeup_dev_event - pm_wakeup_ws_event - policy_has_boost_freq - power_supply_changed - power_supply_get_by_name - power_supply_get_by_phandle_array - power_supply_get_drvdata - power_supply_get_property - power_supply_is_system_supplied - power_supply_put - power_supply_reg_notifier - power_supply_register - power_supply_set_property - power_supply_unreg_notifier - power_supply_unregister - prandom_bytes - prandom_u32 - preempt_schedule - preempt_schedule_notrace - prepare_to_wait - prepare_to_wait_event - print_hex_dump - printk - printk_deferred - printk_timed_ratelimit - proc_create - proc_create_data - proc_create_single_data - proc_dointvec - proc_dointvec_minmax - proc_dostring - proc_douintvec_minmax - proc_mkdir - proc_mkdir_data - proc_remove - proc_set_size - proc_set_user - proc_symlink - proto_register - proto_unregister - ps2_begin_command - ps2_cmd_aborted - ps2_command - ps2_drain - ps2_end_command - ps2_handle_ack - ps2_handle_response - ps2_init - ps2_sendbyte - ps2_sliced_command - pskb_expand_head - pstore_register - pstore_unregister - public_key_verify_signature - put_device - put_disk - put_iova_domain - put_pid - put_sg_io_hdr - put_tty_driver - put_unused_fd - put_vaddr_frames - pwm_apply_state - pwm_get_chip_data - pwm_set_chip_data - pwmchip_add - pwmchip_remove - qcom_smem_state_get - qcom_smem_state_register - qcom_smem_state_unregister - qcom_smem_state_update_bits - qdisc_reset - queue_delayed_work_on - queue_work_on - radix_tree_delete - radix_tree_insert - radix_tree_iter_delete - radix_tree_iter_resume - radix_tree_lookup - radix_tree_maybe_preload - radix_tree_next_chunk - radix_tree_tagged - rational_best_approximation - raw_notifier_call_chain - raw_notifier_chain_register - raw_notifier_chain_unregister - rb_erase - rb_first - rb_first_postorder - rb_insert_color - rb_last - rb_next - rb_next_postorder - rb_prev - rb_replace_node - rcu_barrier - rcu_barrier_tasks - rcu_barrier_tasks_trace - rcu_bind_current_to_nocb - rcu_cpu_stall_suppress - rcu_cpu_stall_suppress_at_boot - rcu_expedite_gp - rcu_force_quiescent_state - rcu_fwd_progress_check - rcu_get_gp_kthreads_prio - rcu_get_gp_seq - rcu_gp_is_expedited - rcu_gp_is_normal - rcu_gp_set_torture_wait - rcu_inkernel_boot_has_ended - rcu_is_watching - rcu_jiffies_till_stall_check - rcu_read_unlock_trace_special - rcu_unexpedite_gp - rcutorture_get_gp_data - rcuwait_wake_up - rdev_get_drvdata - rdev_get_id - reboot_mode - reciprocal_value - refcount_dec_and_lock - refcount_dec_and_mutex_lock - refcount_dec_not_one - refcount_warn_saturate - refresh_frequency_limits - regcache_cache_bypass - regcache_cache_only - regcache_drop_region - regcache_mark_dirty - regcache_sync - regcache_sync_region - register_blkdev - register_chrdev_region - register_console - register_die_notifier - register_filesystem - register_ftrace_export - register_inet6addr_notifier - register_inetaddr_notifier - register_kernel_break_hook - register_kprobe - register_kretprobe - register_memory_notifier - register_module_notifier - register_net_sysctl - register_netdev - register_netdevice - register_netdevice_notifier - register_netevent_notifier - register_oom_notifier - register_pernet_device - register_pernet_subsys - register_pm_notifier - register_reboot_notifier - register_restart_handler - register_shrinker - register_syscore_ops - register_sysctl - register_sysctl_table - register_virtio_device - register_virtio_driver - register_vmap_purge_notifier - regmap_add_irq_chip - regmap_async_complete - regmap_bulk_read - regmap_bulk_write - regmap_check_range_table - regmap_del_irq_chip - regmap_exit - regmap_field_read - regmap_field_update_bits_base - regmap_get_device - regmap_irq_get_domain - regmap_irq_get_virq - regmap_mmio_detach_clk - regmap_multi_reg_write - regmap_multi_reg_write_bypassed - regmap_raw_read - regmap_raw_write - regmap_raw_write_async - regmap_read - regmap_register_patch - regmap_update_bits_base - regmap_write - regulator_allow_bypass - regulator_bulk_disable - regulator_bulk_enable - regulator_bulk_get - regulator_count_voltages - regulator_disable - regulator_disable_deferred - regulator_disable_regmap - regulator_enable - regulator_enable_regmap - regulator_force_disable - regulator_get - regulator_get_current_limit - regulator_get_drvdata - regulator_get_mode - regulator_get_optional - regulator_get_voltage - regulator_get_voltage_rdev - regulator_get_voltage_sel_regmap - regulator_is_enabled - regulator_is_enabled_regmap - regulator_is_supported_voltage - regulator_list_voltage_linear - regulator_list_voltage_linear_range - regulator_list_voltage_table - regulator_map_voltage_ascend - regulator_map_voltage_linear - regulator_notifier_call_chain - regulator_put - regulator_register - regulator_register_notifier - regulator_set_current_limit - regulator_set_load - regulator_set_mode - regulator_set_voltage - regulator_set_voltage_sel_regmap - regulator_unregister - regulator_unregister_notifier - release_firmware - release_pages - release_sock - remap_pfn_range - remap_vmalloc_range - remove_cpu - remove_memory_subsection - remove_proc_entry - remove_wait_queue - report_iommu_fault - request_any_context_irq - request_firmware - request_firmware_direct - request_firmware_into_buf - request_firmware_nowait - request_threaded_irq - resched_curr - reservation_ww_class - reset_control_assert - reset_control_deassert - reset_control_put - reset_control_reset - resume_cpus - return_address - revalidate_disk_size - rfkill_alloc - rfkill_destroy - rfkill_find_type - rfkill_init_sw_state - rfkill_register - rfkill_set_sw_state - rfkill_unregister - rhashtable_destroy - rhashtable_init - rhashtable_insert_slow - rht_bucket_nested - rht_bucket_nested_insert - rndis_deregister - rndis_free_response - rndis_get_next_response - rndis_msg_parser - rndis_register - rndis_set_host_mac - rndis_set_param_dev - rndis_set_param_medium - rndis_set_param_vendor - rndis_signal_connect - rndis_uninit - root_task_group - round_jiffies_relative - round_jiffies_up - rpmsg_get_signals - rpmsg_poll - rpmsg_register_device - rpmsg_send - rpmsg_set_signals - rpmsg_trysend - rpmsg_unregister_device - rproc_add - rproc_add_subdev - rproc_alloc - rproc_boot - rproc_coredump_add_custom_segment - rproc_coredump_add_segment - rproc_coredump_set_elf_info - rproc_coredump_using_sections - rproc_del - rproc_elf_get_boot_addr - rproc_free - rproc_get_by_child - rproc_get_by_phandle - rproc_put - rproc_remove_subdev - rproc_report_crash - rproc_shutdown - rps_needed - rt_mutex_lock - rt_mutex_trylock - rt_mutex_unlock - rtc_class_close - rtc_class_open - rtc_read_time - rtc_set_time - rtc_time64_to_tm - rtc_tm_to_time64 - rtc_update_irq - rtc_valid_tm - rtc_year_days - rtnl_is_locked - rtnl_link_register - rtnl_link_unregister - rtnl_lock - rtnl_register_module - rtnl_trylock - rtnl_unicast - rtnl_unlock - rtnl_unregister - runqueues - sb800_prefetch - sbitmap_queue_min_shallow_depth - sched_clock - sched_feat_keys - sched_feat_names - sched_set_fifo - sched_set_fifo_low - sched_set_normal - sched_setattr - sched_setattr_nocheck - sched_setscheduler - sched_setscheduler_nocheck - sched_show_task - sched_trace_cfs_rq_avg - sched_trace_cfs_rq_cpu - sched_trace_cfs_rq_path - sched_trace_rd_span - sched_trace_rq_avg_dl - sched_trace_rq_avg_irq - sched_trace_rq_avg_rt - sched_trace_rq_cpu - sched_uclamp_used - schedule - schedule_hrtimeout - schedule_timeout - schedule_timeout_interruptible - schedule_timeout_uninterruptible - scnprintf - scsi_autopm_get_device - scsi_autopm_put_device - scsi_block_requests - scsi_block_when_processing_errors - scsi_command_size_tbl - scsi_compat_ioctl - scsi_device_get - scsi_device_put - scsi_device_quiesce - scsi_dma_unmap - scsi_eh_ready_devs - scsi_ioctl - scsi_ioctl_block_when_processing_errors - scsi_normalize_sense - scsi_print_sense_hdr - scsi_register_interface - scsi_remove_device - scsi_unblock_requests - sdev_prefix_printk - sdhci_add_host - sdhci_cleanup_host - sdhci_cqe_disable - sdhci_cqe_enable - sdhci_cqe_irq - sdhci_enable_clk - sdhci_get_property - sdhci_pltfm_free - sdhci_pltfm_init - sdhci_remove_host - sdhci_reset - sdhci_set_bus_width - sdhci_set_power_noreg - sdhci_setup_host - sdio_claim_host - sdio_disable_func - sdio_enable_func - sdio_f0_readb - sdio_f0_writeb - sdio_get_host_pm_caps - sdio_memcpy_fromio - sdio_memcpy_toio - sdio_readsb - sdio_register_driver - sdio_release_host - sdio_set_block_size - sdio_set_host_pm_flags - sdio_signal_irq - sdio_unregister_driver - sdio_writesb - securityfs_create_dir - securityfs_create_file - securityfs_remove - send_sig_info - seq_buf_printf - seq_file_path - seq_hex_dump - seq_list_next - seq_list_start - seq_lseek - seq_open - seq_printf - seq_putc - seq_puts - seq_read - seq_release - seq_release_private - seq_vprintf - seq_write - serdev_device_close - serdev_device_open - serdev_device_set_baudrate - serdev_device_set_flow_control - serdev_device_wait_until_sent - serdev_device_write - serdev_device_write_wakeup - serio_close - serio_interrupt - serio_open - serio_reconnect - serio_rescan - serio_unregister_child_port - serio_unregister_driver - serio_unregister_port - set_blocksize - set_capacity_revalidate_and_notify - set_cpus_allowed_ptr - set_disk_ro - set_freezable - set_normalized_timespec64 - set_page_dirty - set_page_dirty_lock - set_task_cpu - set_user_nice - sg_alloc_table - sg_alloc_table_from_pages - sg_free_table - sg_init_one - sg_init_table - sg_miter_next - sg_miter_start - sg_miter_stop - sg_nents_for_len - sg_next - sg_pcopy_from_buffer - sg_pcopy_to_buffer - sg_scsi_ioctl - sg_zero_buffer - sgl_alloc - sgl_free - shmem_truncate_range - show_rcu_gp_kthreads - show_regs - si_mem_available - si_meminfo - si_swapinfo - sigprocmask - simple_attr_open - simple_attr_read - simple_attr_release - simple_attr_write - simple_dir_inode_operations - simple_dir_operations - simple_open - simple_read_from_buffer - simple_statfs - simple_strtol - simple_strtoll - simple_strtoul - simple_strtoull - simple_write_to_buffer - single_open - single_open_size - single_release - sk_alloc - sk_free - skb_add_rx_frag - skb_append_pagefrags - skb_checksum - skb_clone - skb_coalesce_rx_frag - skb_copy - skb_copy_bits - skb_copy_datagram_iter - skb_copy_expand - skb_copy_ubufs - skb_dequeue - skb_dequeue_tail - skb_ensure_writable - skb_free_datagram - skb_page_frag_refill - skb_partial_csum_set - skb_pull - skb_push - skb_put - skb_queue_head - skb_queue_purge - skb_queue_tail - skb_realloc_headroom - skb_recv_datagram - skb_set_owner_w - skb_store_bits - skb_to_sgvec - skb_trim - skb_tstamp_tx - skb_unlink - skip_spaces - smp_call_function - smp_call_function_any - smp_call_function_many - smp_call_function_single - smp_call_function_single_async - smp_call_on_cpu - smpboot_register_percpu_thread - smpboot_unregister_percpu_thread - snd_card_disconnect - snd_card_free - snd_card_new - snd_card_register - snd_card_rw_proc_new - snd_component_add - snd_compr_stop_error - snd_ctl_add - snd_ctl_add_vmaster_hook - snd_ctl_apply_vmaster_followers - snd_ctl_boolean_mono_info - snd_ctl_boolean_stereo_info - snd_ctl_enum_info - snd_ctl_find_id - snd_ctl_make_virtual_master - snd_ctl_new1 - snd_ctl_notify - snd_ctl_remove - snd_ctl_remove_id - snd_ctl_sync_vmaster - snd_device_disconnect - snd_device_free - snd_device_new - snd_dma_alloc_pages - snd_dma_free_pages - snd_dmaengine_pcm_prepare_slave_config - snd_hwdep_new - snd_info_create_card_entry - snd_info_create_module_entry - snd_info_free_entry - snd_info_register - snd_interval_refine - snd_jack_new - snd_jack_report - snd_jack_set_key - snd_pci_quirk_lookup - snd_pcm_add_chmap_ctls - snd_pcm_alt_chmaps - snd_pcm_create_iec958_consumer_hw_params - snd_pcm_format_physical_width - snd_pcm_format_width - snd_pcm_hw_constraint_eld - snd_pcm_hw_constraint_integer - snd_pcm_hw_constraint_list - snd_pcm_hw_constraint_minmax - snd_pcm_hw_constraint_msbits - snd_pcm_hw_constraint_step - snd_pcm_hw_limit_rates - snd_pcm_hw_rule_add - snd_pcm_lib_default_mmap - snd_pcm_lib_free_pages - snd_pcm_lib_ioctl - snd_pcm_lib_malloc_pages - snd_pcm_lib_preallocate_free_for_all - snd_pcm_lib_preallocate_pages - snd_pcm_new - snd_pcm_period_elapsed - snd_pcm_rate_range_to_bits - snd_pcm_set_managed_buffer_all - snd_pcm_set_ops - snd_pcm_set_sync - snd_pcm_std_chmaps - snd_pcm_stream_lock - snd_pcm_stream_unlock - snd_pcm_stream_unlock_irqrestore - snd_soc_add_card_controls - snd_soc_add_component_controls - snd_soc_add_dai_controls - snd_soc_bytes_info_ext - snd_soc_bytes_tlv_callback - snd_soc_card_get_kcontrol - snd_soc_card_jack_new - snd_soc_component_async_complete - snd_soc_component_disable_pin - snd_soc_component_exit_regmap - snd_soc_component_force_enable_pin - snd_soc_component_init_regmap - snd_soc_component_read - snd_soc_component_set_jack - snd_soc_component_set_pll - snd_soc_component_set_sysclk - snd_soc_component_update_bits - snd_soc_component_update_bits_async - snd_soc_component_write - snd_soc_dai_get_channel_map - snd_soc_dai_link_set_capabilities - snd_soc_dai_set_bclk_ratio - snd_soc_dai_set_channel_map - snd_soc_dai_set_fmt - snd_soc_dai_set_pll - snd_soc_dai_set_sysclk - snd_soc_dai_set_tdm_slot - snd_soc_dapm_add_routes - snd_soc_dapm_disable_pin - snd_soc_dapm_disable_pin_unlocked - snd_soc_dapm_enable_pin - snd_soc_dapm_force_enable_pin - snd_soc_dapm_force_enable_pin_unlocked - snd_soc_dapm_get_enum_double - snd_soc_dapm_get_pin_status - snd_soc_dapm_get_pin_switch - snd_soc_dapm_get_volsw - snd_soc_dapm_ignore_suspend - snd_soc_dapm_info_pin_switch - snd_soc_dapm_kcontrol_dapm - snd_soc_dapm_kcontrol_widget - snd_soc_dapm_mixer_update_power - snd_soc_dapm_mux_update_power - snd_soc_dapm_new_control - snd_soc_dapm_new_controls - snd_soc_dapm_new_widgets - snd_soc_dapm_put_enum_double - snd_soc_dapm_put_pin_switch - snd_soc_dapm_put_volsw - snd_soc_dapm_sync - snd_soc_dapm_sync_unlocked - snd_soc_dapm_weak_routes - snd_soc_find_dai - snd_soc_get_enum_double - snd_soc_get_pcm_runtime - snd_soc_get_volsw - snd_soc_get_volsw_range - snd_soc_get_volsw_sx - snd_soc_get_xr_sx - snd_soc_info_enum_double - snd_soc_info_multi_ext - snd_soc_info_volsw - snd_soc_info_volsw_range - snd_soc_info_volsw_sx - snd_soc_info_xr_sx - snd_soc_jack_add_gpios - snd_soc_jack_report - snd_soc_lookup_component - snd_soc_new_compress - snd_soc_of_get_dai_link_codecs - snd_soc_of_get_dai_name - snd_soc_of_parse_audio_routing - snd_soc_of_parse_audio_simple_widgets - snd_soc_of_parse_aux_devs - snd_soc_of_parse_card_name - snd_soc_of_parse_daifmt - snd_soc_of_parse_node_prefix - snd_soc_of_parse_tdm_slot - snd_soc_of_put_dai_link_codecs - snd_soc_params_to_bclk - snd_soc_params_to_frame_size - snd_soc_pm_ops - snd_soc_put_enum_double - snd_soc_put_volsw - snd_soc_put_volsw_range - snd_soc_put_volsw_sx - snd_soc_put_xr_sx - snd_soc_register_card - snd_soc_register_component - snd_soc_rtdcom_lookup - snd_soc_runtime_calc_hw - snd_soc_runtime_set_dai_fmt - snd_soc_set_runtime_hwparams - snd_soc_tplg_component_load - snd_soc_tplg_component_remove - snd_soc_tplg_widget_bind_event - snd_soc_unregister_card - snd_soc_unregister_component - snd_usb_enable_audio_stream - snd_vendor_set_ops - snprintf - soc_device_register - soc_device_unregister - sock_alloc_send_skb - sock_create_kern - sock_gettstamp - sock_i_uid - sock_init_data - sock_no_accept - sock_no_listen - sock_no_mmap - sock_no_sendpage - sock_no_shutdown - sock_no_socketpair - sock_queue_rcv_skb - sock_register - sock_release - sock_setsockopt - sock_unregister - sock_wfree - softnet_data - sort - spi_bus_lock - spi_bus_type - spi_bus_unlock - spi_controller_resume - spi_controller_suspend - spi_delay_exec - spi_finalize_current_message - spi_finalize_current_transfer - spi_get_next_queued_message - spi_register_controller - spi_setup - spi_sync - spi_sync_locked - spi_unregister_controller - split_page - spmi_controller_add - spmi_controller_alloc - spmi_controller_remove - spmi_ext_register_read - spmi_ext_register_readl - spmi_ext_register_write - spmi_ext_register_writel - spmi_register_read - spmi_register_write - spmi_register_zero_write - sprint_symbol - sprint_symbol_no_offset - sprintf - srcu_barrier - srcu_batches_completed - srcu_init_notifier_head - srcu_notifier_call_chain - srcu_notifier_chain_register - srcu_notifier_chain_unregister - srcu_torture_stats_print - srcutorture_get_gp_data - sscanf - stack_trace_print - stack_trace_save - stack_trace_save_regs - stack_trace_save_tsk - static_key_disable - static_key_disable_cpuslocked - static_key_slow_dec - static_key_slow_inc - stop_machine - stop_one_cpu_nowait - stpcpy - strcasecmp - strcat - strchr - strchrnul - strcmp - strcpy - strcspn - stream_open - strim - string_get_size - strlcat - strlcpy - strlen - strncasecmp - strncat - strnchr - strncmp - strncpy - strncpy_from_user - strndup_user - strnlen - strnstr - strpbrk - strrchr - strreplace - strscpy - strsep - strspn - strstr - submit_bh - submit_bio - submit_bio_wait - subsys_system_register - swiotlb_nr_tbl - sync_blockdev - sync_file_create - sync_file_get_fence - synchronize_irq - synchronize_net - synchronize_rcu - synchronize_rcu_expedited - synchronize_rcu_tasks - synchronize_rcu_tasks_trace - synchronize_srcu - synchronize_srcu_expedited - sys_tz - syscon_node_to_regmap - syscon_regmap_lookup_by_phandle - sysctl_sched_features - sysctl_sched_latency - sysctl_vals - sysfs_add_file_to_group - sysfs_add_link_to_group - sysfs_create_bin_file - sysfs_create_file_ns - sysfs_create_files - sysfs_create_group - sysfs_create_groups - sysfs_create_link - sysfs_emit - sysfs_emit_at - sysfs_notify - sysfs_remove_bin_file - sysfs_remove_file_from_group - sysfs_remove_file_ns - sysfs_remove_files - sysfs_remove_group - sysfs_remove_groups - sysfs_remove_link - sysfs_remove_link_from_group - sysfs_streq - sysfs_update_group - sysrq_mask - system_freezable_wq - system_freezing_cnt - system_highpri_wq - system_long_wq - system_power_efficient_wq - system_state - system_unbound_wq - system_wq - task_active_pid_ns - task_groups - task_may_not_preempt - task_rq_lock - tasklet_init - tasklet_kill - tasklet_setup - tasklist_lock - tcp_register_congestion_control - tcp_reno_cong_avoid - tcp_reno_ssthresh - tcp_reno_undo_cwnd - tcp_slow_start - tcp_unregister_congestion_control - tcpci_get_tcpm_port - tcpci_irq - tcpci_register_port - tcpci_unregister_port - tcpm_cc_change - tcpm_is_toggling - tcpm_pd_hard_reset - tcpm_pd_receive - tcpm_pd_transmit_complete - tcpm_sink_frs - tcpm_sourcing_vbus - tcpm_update_sink_capabilities - tcpm_vbus_change - thermal_cdev_update - thermal_cooling_device_register - thermal_cooling_device_unregister - thermal_of_cooling_device_register - thermal_pressure - thermal_zone_device_disable - thermal_zone_device_enable - thermal_zone_device_is_enabled - thermal_zone_device_register - thermal_zone_device_unregister - thermal_zone_device_update - thermal_zone_get_slope - thermal_zone_get_temp - thermal_zone_get_zone_by_name - thermal_zone_of_sensor_register - thermal_zone_of_sensor_unregister - thread_group_cputime_adjusted - tick_nohz_get_idle_calls_cpu - tick_nohz_get_sleep_length - time64_to_tm - timecounter_init - timecounter_read - timer_unstable_counter_workaround - topology_set_thermal_pressure - total_swapcache_pages - trace_clock_local - trace_event_buffer_commit - trace_event_buffer_reserve - trace_event_ignore_this_pid - trace_event_raw_init - trace_event_reg - trace_handle_return - trace_output_call trace_print_array_seq trace_print_flags_seq trace_print_hex_seq + __trace_printk trace_print_symbols_seq trace_raw_output_prep trace_seq_printf trace_seq_putc - tracepoint_probe_register - tracepoint_probe_register_prio - tracepoint_probe_unregister tracing_off try_module_get try_to_del_timer_sync @@ -4038,8 +4018,8 @@ ttm_bo_device_init ttm_bo_device_release ttm_bo_dma_acc_size - ttm_bo_evict_mm ttm_bo_eviction_valuable + ttm_bo_evict_mm ttm_bo_glob ttm_bo_init_reserved ttm_bo_kmap @@ -4074,8 +4054,10 @@ ttm_tt_populate ttm_tt_set_placement_caching ttm_unmap_and_unpopulate_pages + __tty_alloc_driver tty_encode_baud_rate tty_flip_buffer_push + __tty_insert_flip_char tty_insert_flip_string_fixed_flag tty_kref_put tty_ldisc_deref @@ -4137,6 +4119,7 @@ ucsi_register ucsi_set_drvdata ucsi_unregister + __udelay udp4_hwcsum ufshcd_auto_hibern8_update ufshcd_bkops_ctrl @@ -4168,11 +4151,13 @@ ufshcd_system_suspend ufshcd_uic_hibern8_enter ufshcd_uic_hibern8_exit + __uio_register_device uio_unregister_device unlock_page unmap_mapping_range unpin_user_page unregister_blkdev + __unregister_chrdev unregister_chrdev_region unregister_console unregister_die_notifier @@ -4202,10 +4187,11 @@ unregister_virtio_driver unregister_vmap_purge_notifier up + update_devfreq + __update_load_avg_blocked_se + update_rq_clock up_read up_write - update_devfreq - update_rq_clock usb_add_function usb_add_gadget usb_add_gadget_udc @@ -4233,14 +4219,15 @@ usb_composite_setup_continue usb_control_msg usb_copy_descriptors + __usb_create_hcd usb_create_hcd usb_debug_root usb_decode_ctrl usb_del_gadget_udc usb_deregister usb_deregister_dev - usb_disable_xhci_ports usb_disabled + usb_disable_xhci_ports usb_enable_autosuspend usb_enable_intel_xhci_ports usb_ep_alloc_request @@ -4275,15 +4262,16 @@ usb_gadget_wakeup usb_get_dev usb_get_dr_mode + __usb_get_extra_descriptor usb_get_gadget_udc_name usb_get_intf usb_get_maximum_speed usb_get_urb usb_gstrings_attach - usb_hc_died usb_hcd_check_unlink_urb usb_hcd_end_port_resume usb_hcd_giveback_urb + usb_hc_died usb_hcd_irq usb_hcd_is_primary_hcd usb_hcd_link_urb_to_ep @@ -4295,9 +4283,9 @@ usb_hcd_platform_shutdown usb_hcd_poll_rh_status usb_hcd_resume_root_hub + usb_hcds_loaded usb_hcd_start_port_resume usb_hcd_unlink_urb_from_ep - usb_hcds_loaded usb_hid_driver usb_hub_clear_tt_buffer usb_hub_find_child @@ -4308,6 +4296,36 @@ usb_kill_urb usb_match_id usb_match_one_id + usbnet_cdc_unbind + usbnet_change_mtu + usbnet_defer_kevent + usbnet_disconnect + usbnet_generic_cdc_bind + usbnet_get_drvinfo + usbnet_get_endpoints + usbnet_get_link + usbnet_get_link_ksettings + usbnet_get_msglevel + usbnet_get_stats64 + usbnet_link_change + usbnet_nway_reset + usbnet_open + usbnet_probe + usbnet_read_cmd + usbnet_read_cmd_nopm + usbnet_resume + usbnet_set_link_ksettings + usbnet_set_msglevel + usbnet_skb_return + usbnet_start_xmit + usbnet_stop + usbnet_suspend + usbnet_tx_timeout + usbnet_unlink_rx_urbs + usbnet_update_max_qlen + usbnet_write_cmd + usbnet_write_cmd_async + usbnet_write_cmd_nopm usb_otg_state_string usb_phy_set_charger_current usb_poison_anchored_urbs @@ -4339,36 +4357,7 @@ usb_unpoison_urb usb_unregister_notify usb_wakeup_notification - usbnet_cdc_unbind - usbnet_change_mtu - usbnet_defer_kevent - usbnet_disconnect - usbnet_generic_cdc_bind - usbnet_get_drvinfo - usbnet_get_endpoints - usbnet_get_link - usbnet_get_link_ksettings - usbnet_get_msglevel - usbnet_get_stats64 - usbnet_link_change - usbnet_nway_reset - usbnet_open - usbnet_probe - usbnet_read_cmd - usbnet_read_cmd_nopm - usbnet_resume - usbnet_set_link_ksettings - usbnet_set_msglevel - usbnet_skb_return - usbnet_start_xmit - usbnet_stop - usbnet_suspend - usbnet_tx_timeout - usbnet_unlink_rx_urbs - usbnet_update_max_qlen - usbnet_write_cmd - usbnet_write_cmd_async - usbnet_write_cmd_nopm + __usecs_to_jiffies usleep_range uuid_gen uuid_null @@ -4384,6 +4373,7 @@ v4l2_ctrl_new_std_menu v4l2_device_register v4l2_device_register_subdev + __v4l2_device_register_subdev_nodes v4l2_device_set_name v4l2_device_unregister v4l2_device_unregister_subdev @@ -4476,6 +4466,7 @@ video_device_release video_device_release_empty video_ioctl2 + __video_register_device video_unregister_device virtio_check_driver_offered_feature virtio_config_changed @@ -4532,7 +4523,17 @@ virtqueue_kick_prepare virtqueue_notify virtqueue_poll + vmalloc + vmalloc_nr_pages + vmalloc_to_page + vmalloc_to_pfn + vmalloc_user + vmap + vmemdup_user vm_event_states + vmf_insert_mixed + vmf_insert_pfn + vmf_insert_pfn_prot vm_get_page_prot vm_insert_page vm_iomap_memory @@ -4543,16 +4544,6 @@ vm_node_stat vm_unmap_ram vm_zone_stat - vmalloc - vmalloc_nr_pages - vmalloc_to_page - vmalloc_to_pfn - vmalloc_user - vmap - vmemdup_user - vmf_insert_mixed - vmf_insert_pfn - vmf_insert_pfn_prot vprintk vring_create_virtqueue vring_del_virtqueue @@ -4575,8 +4566,12 @@ wait_for_completion_killable wait_for_completion_killable_timeout wait_for_completion_timeout + __wait_rcu_gp wait_woken + __wake_up wake_up_if_idle + __wake_up_locked + __wake_up_locked_key wake_up_process wakeup_source_add wakeup_source_create @@ -4584,6 +4579,8 @@ wakeup_source_register wakeup_source_remove wakeup_source_unregister + __wake_up_sync + __warn_printk watchdog_init_timeout watchdog_register_device watchdog_set_restart_priority @@ -4594,10 +4591,12 @@ ww_mutex_lock ww_mutex_lock_interruptible ww_mutex_unlock + __xa_alloc xa_destroy xa_erase xa_find xa_find_after + __xa_insert xa_load xa_store xdp_convert_zc_to_xdp_frame @@ -4609,6 +4608,7 @@ xdp_rxq_info_reg_mem_model xdp_rxq_info_unreg xdp_warn + __xfrm_state_destroy xfrm_state_lookup_byspi xfrm_stateonly_find xhci_add_endpoint diff --git a/android/abi_gki_aarch64_generic b/android/abi_gki_aarch64_generic index cd7ca5f41b8b..f0808ba8372e 100644 --- a/android/abi_gki_aarch64_generic +++ b/android/abi_gki_aarch64_generic @@ -87,10 +87,10 @@ blocking_notifier_call_chain blocking_notifier_chain_register blocking_notifier_chain_unregister - bpf_trace_run1 bpf_trace_run10 bpf_trace_run11 bpf_trace_run12 + bpf_trace_run1 bpf_trace_run2 bpf_trace_run3 bpf_trace_run4 @@ -993,8 +993,8 @@ irq_work_queue irq_work_sync is_vmalloc_addr - jiffies jiffies64_to_msecs + jiffies jiffies_to_msecs jiffies_to_usecs kasan_flag_enabled @@ -1123,8 +1123,8 @@ memmove memparse memremap - memset memset64 + memset memstart_addr memunmap mfd_add_devices @@ -1198,8 +1198,8 @@ nla_find nla_memcpy __nla_parse - nla_put nla_put_64bit + nla_put nla_put_nohdr nla_reserve nla_strlcpy diff --git a/android/abi_gki_aarch64_lenovo b/android/abi_gki_aarch64_lenovo index 0049535a4a1f..6815423a1c7c 100644 --- a/android/abi_gki_aarch64_lenovo +++ b/android/abi_gki_aarch64_lenovo @@ -1,10 +1,10 @@ [abi_symbol_list] # required by raid0.ko - __tracepoint_block_bio_remap - disk_stack_limits - blk_queue_max_write_same_sectors - __traceiter_block_bio_remap - submit_bio_noacct bio_split + blk_queue_max_write_same_sectors + disk_stack_limits + submit_bio_noacct + __traceiter_block_bio_remap + __tracepoint_block_bio_remap # required by lenovo-fan.ko clk_set_duty_cycle diff --git a/android/abi_gki_aarch64_mtk b/android/abi_gki_aarch64_mtk index 630e18957ea8..5473f314864b 100644 --- a/android/abi_gki_aarch64_mtk +++ b/android/abi_gki_aarch64_mtk @@ -199,8 +199,8 @@ cpufreq_disable_fast_switch cpufreq_driver_fast_switch cpufreq_driver_resolve_freq - cpufreq_driver_target __cpufreq_driver_target + cpufreq_driver_target cpufreq_enable_fast_switch cpufreq_frequency_table_get_index cpufreq_generic_attr @@ -374,8 +374,8 @@ __dev_kfree_skb_any __dev_kfree_skb_irq devm_add_action - __devm_alloc_percpu devm_alloc_etherdev_mqs + __devm_alloc_percpu devm_blk_ksm_init devm_clk_bulk_get devm_clk_bulk_get_optional @@ -3159,10 +3159,10 @@ __tracepoint_android_rvh_select_task_rq_rt __tracepoint_android_rvh_setscheduler __tracepoint_android_rvh_set_user_nice + __tracepoint_android_rvh_uclamp_eff_get __tracepoint_android_rvh_v4l2subdev_set_fmt __tracepoint_android_rvh_v4l2subdev_set_frame_interval __tracepoint_android_rvh_v4l2subdev_set_selection - __tracepoint_android_rvh_uclamp_eff_get __tracepoint_android_vh_alter_futex_plist_add __tracepoint_android_vh_alter_rwsem_list_add __tracepoint_android_vh_arch_set_freq_scale diff --git a/android/abi_gki_aarch64_oplus b/android/abi_gki_aarch64_oplus index 5693bb828b42..b1b464d893fe 100644 --- a/android/abi_gki_aarch64_oplus +++ b/android/abi_gki_aarch64_oplus @@ -115,9 +115,9 @@ blocking_notifier_call_chain blocking_notifier_chain_register blocking_notifier_chain_unregister - bpf_trace_run1 bpf_trace_run10 bpf_trace_run12 + bpf_trace_run1 bpf_trace_run2 bpf_trace_run3 bpf_trace_run4 @@ -685,8 +685,8 @@ dma_unmap_resource dma_unmap_sg_attrs do_exit - do_wait_intr_irq do_traversal_all_lruvec + do_wait_intr_irq down down_interruptible down_read @@ -1568,8 +1568,8 @@ mempool_free mempool_free_slab memremap - memset memset64 + memset __memset_io memstart_addr memunmap @@ -1670,10 +1670,10 @@ nla_find nla_memcpy __nla_parse - nla_put nla_put_64bit - nla_reserve + nla_put nla_reserve_64bit + nla_reserve __nla_validate __nlmsg_put no_llseek @@ -1810,8 +1810,8 @@ page_endio __page_file_index __page_file_mapping - __page_mapcount page_get_link + __page_mapcount page_mapping __page_pinner_migration_failed page_symlink @@ -2059,8 +2059,8 @@ radix_tree_lookup radix_tree_lookup_slot radix_tree_next_chunk - radix_tree_replace_slot radix_tree_preload + radix_tree_replace_slot ___ratelimit rational_best_approximation raw_notifier_call_chain @@ -2696,8 +2696,8 @@ __traceiter_android_rvh_after_enqueue_task __traceiter_android_rvh_build_perf_domains __traceiter_android_rvh_can_migrate_task - __traceiter_android_rvh_check_preempt_wakeup __traceiter_android_rvh_check_preempt_tick + __traceiter_android_rvh_check_preempt_wakeup __traceiter_android_rvh_cpu_cgroup_attach __traceiter_android_rvh_cpu_cgroup_online __traceiter_android_rvh_cpu_overutilized @@ -2754,6 +2754,9 @@ __traceiter_android_rvh_v4l2subdev_set_selection __traceiter_android_rvh_wake_up_new_task __traceiter_android_vh_account_task_time + __traceiter_android_vh_add_page_to_lrulist + __traceiter_android_vh_alloc_pages_slowpath_begin + __traceiter_android_vh_alloc_pages_slowpath_end __traceiter_android_vh_allow_domain_state __traceiter_android_vh_alter_futex_plist_add __traceiter_android_vh_alter_mutex_list_add @@ -2784,6 +2787,7 @@ __traceiter_android_vh_check_bpf_syscall __traceiter_android_vh_check_file_open __traceiter_android_vh_check_mmap_file + __traceiter_android_vh_check_page_look_around_ref __traceiter_android_vh_check_uninterruptible_tasks __traceiter_android_vh_check_uninterruptible_tasks_dn __traceiter_android_vh_clear_mask_adjust @@ -2797,9 +2801,11 @@ __traceiter_android_vh_cpu_idle_enter __traceiter_android_vh_cpu_idle_exit __traceiter_android_vh_cpu_up - __traceiter_android_vh_check_page_look_around_ref + __traceiter_android_vh_del_page_from_lrulist __traceiter_android_vh_do_futex + __traceiter_android_vh_do_page_trylock __traceiter_android_vh_do_send_sig_info + __traceiter_android_vh_do_traversal_lruvec __traceiter_android_vh_drain_all_pages_bypass __traceiter_android_vh_em_cpu_energy __traceiter_android_vh_exclude_reserved_zone @@ -2833,14 +2839,13 @@ __traceiter_android_vh_logbuf __traceiter_android_vh_look_around __traceiter_android_vh_look_around_migrate_page + __traceiter_android_vh_mark_page_accessed __traceiter_android_vh_mem_cgroup_alloc __traceiter_android_vh_mem_cgroup_css_offline __traceiter_android_vh_mem_cgroup_css_online __traceiter_android_vh_mem_cgroup_free __traceiter_android_vh_mem_cgroup_id_remove __traceiter_android_vh_meminfo_proc_show - __traceiter_android_vh_alloc_pages_slowpath_begin - __traceiter_android_vh_alloc_pages_slowpath_end __traceiter_android_vh_mutex_can_spin_on_owner __traceiter_android_vh_mutex_opt_spin_finish __traceiter_android_vh_mutex_opt_spin_start @@ -2851,25 +2856,19 @@ __traceiter_android_vh_override_creds __traceiter_android_vh_page_referenced_check_bypass __traceiter_android_vh_page_should_be_protected - __traceiter_android_vh_page_trylock_set __traceiter_android_vh_page_trylock_clear __traceiter_android_vh_page_trylock_get_result - __traceiter_android_vh_mark_page_accessed - __traceiter_android_vh_show_mapcount_pages - __traceiter_android_vh_do_traversal_lruvec - __traceiter_android_vh_do_page_trylock - __traceiter_android_vh_update_page_mapcount - __traceiter_android_vh_add_page_to_lrulist - __traceiter_android_vh_del_page_from_lrulist + __traceiter_android_vh_page_trylock_set __traceiter_android_vh_pcplist_add_cma_pages_bypass __traceiter_android_vh_prepare_update_load_avg_se __traceiter_android_vh_printk_hotplug __traceiter_android_vh_process_killed - __traceiter_android_vh_revert_creds __traceiter_android_vh_record_mutex_lock_starttime + __traceiter_android_vh_record_pcpu_rwsem_starttime __traceiter_android_vh_record_rtmutex_lock_starttime __traceiter_android_vh_record_rwsem_lock_starttime - __traceiter_android_vh_record_pcpu_rwsem_starttime + __traceiter_android_vh_remove_vmalloc_stack + __traceiter_android_vh_revert_creds __traceiter_android_vh_rmqueue __traceiter_android_vh_rwsem_can_spin_on_owner __traceiter_android_vh_rwsem_init @@ -2885,7 +2884,6 @@ __traceiter_android_vh_rwsem_write_finished __traceiter_android_vh_save_track_hash __traceiter_android_vh_save_vmalloc_stack - __traceiter_android_vh_remove_vmalloc_stack __traceiter_android_vh_sched_stat_runtime_rt __traceiter_android_vh_scheduler_tick __traceiter_android_vh_selinux_avc_insert @@ -2901,6 +2899,7 @@ __traceiter_android_vh_set_module_permit_before_init __traceiter_android_vh_setscheduler_uclamp __traceiter_android_vh_set_wake_flags + __traceiter_android_vh_show_mapcount_pages __traceiter_android_vh_show_max_freq __traceiter_android_vh_show_resume_epoch_val __traceiter_android_vh_show_stack_hash @@ -2908,6 +2907,7 @@ __traceiter_android_vh_shrink_node_memcgs __traceiter_android_vh_sync_txn_recvd __traceiter_android_vh_syscall_prctl_finished + __traceiter_android_vh_test_clear_look_around_ref __traceiter_android_vh_timer_calc_index __traceiter_android_vh_tune_inactive_ratio __traceiter_android_vh_tune_scan_type @@ -2915,6 +2915,7 @@ __traceiter_android_vh_ufs_compl_command __traceiter_android_vh_ufs_send_command __traceiter_android_vh_ufs_send_tm_command + __traceiter_android_vh_update_page_mapcount __traceiter_android_vh_update_topology_flags_workfn __traceiter_binder_transaction_received __traceiter_cpu_frequency @@ -2940,14 +2941,13 @@ __traceiter_suspend_resume __traceiter_task_newtask __traceiter_task_rename - __traceiter_android_vh_test_clear_look_around_ref __traceiter_xhci_urb_giveback __tracepoint_android_rvh_account_irq __tracepoint_android_rvh_after_enqueue_task __tracepoint_android_rvh_build_perf_domains __tracepoint_android_rvh_can_migrate_task - __tracepoint_android_rvh_check_preempt_wakeup __tracepoint_android_rvh_check_preempt_tick + __tracepoint_android_rvh_check_preempt_wakeup __tracepoint_android_rvh_cpu_cgroup_attach __tracepoint_android_rvh_cpu_cgroup_online __tracepoint_android_rvh_cpu_overutilized @@ -3004,6 +3004,9 @@ __tracepoint_android_rvh_v4l2subdev_set_selection __tracepoint_android_rvh_wake_up_new_task __tracepoint_android_vh_account_task_time + __tracepoint_android_vh_add_page_to_lrulist + __tracepoint_android_vh_alloc_pages_slowpath_begin + __tracepoint_android_vh_alloc_pages_slowpath_end __tracepoint_android_vh_allow_domain_state __tracepoint_android_vh_alter_futex_plist_add __tracepoint_android_vh_alter_mutex_list_add @@ -3034,6 +3037,7 @@ __tracepoint_android_vh_check_bpf_syscall __tracepoint_android_vh_check_file_open __tracepoint_android_vh_check_mmap_file + __tracepoint_android_vh_check_page_look_around_ref __tracepoint_android_vh_check_uninterruptible_tasks __tracepoint_android_vh_check_uninterruptible_tasks_dn __tracepoint_android_vh_clear_mask_adjust @@ -3047,9 +3051,11 @@ __tracepoint_android_vh_cpu_idle_enter __tracepoint_android_vh_cpu_idle_exit __tracepoint_android_vh_cpu_up - __tracepoint_android_vh_check_page_look_around_ref + __tracepoint_android_vh_del_page_from_lrulist __tracepoint_android_vh_do_futex + __tracepoint_android_vh_do_page_trylock __tracepoint_android_vh_do_send_sig_info + __tracepoint_android_vh_do_traversal_lruvec __tracepoint_android_vh_drain_all_pages_bypass __tracepoint_android_vh_em_cpu_energy __tracepoint_android_vh_exclude_reserved_zone @@ -3083,14 +3089,13 @@ __tracepoint_android_vh_logbuf __tracepoint_android_vh_look_around __tracepoint_android_vh_look_around_migrate_page + __tracepoint_android_vh_mark_page_accessed __tracepoint_android_vh_mem_cgroup_alloc __tracepoint_android_vh_mem_cgroup_css_offline __tracepoint_android_vh_mem_cgroup_css_online __tracepoint_android_vh_mem_cgroup_free __tracepoint_android_vh_mem_cgroup_id_remove __tracepoint_android_vh_meminfo_proc_show - __tracepoint_android_vh_alloc_pages_slowpath_begin - __tracepoint_android_vh_alloc_pages_slowpath_end __tracepoint_android_vh_mutex_can_spin_on_owner __tracepoint_android_vh_mutex_opt_spin_finish __tracepoint_android_vh_mutex_opt_spin_start @@ -3101,25 +3106,19 @@ __tracepoint_android_vh_override_creds __tracepoint_android_vh_page_referenced_check_bypass __tracepoint_android_vh_page_should_be_protected - __tracepoint_android_vh_page_trylock_set __tracepoint_android_vh_page_trylock_clear __tracepoint_android_vh_page_trylock_get_result - __tracepoint_android_vh_mark_page_accessed - __tracepoint_android_vh_show_mapcount_pages - __tracepoint_android_vh_do_traversal_lruvec - __tracepoint_android_vh_do_page_trylock - __tracepoint_android_vh_update_page_mapcount - __tracepoint_android_vh_add_page_to_lrulist - __tracepoint_android_vh_del_page_from_lrulist + __tracepoint_android_vh_page_trylock_set __tracepoint_android_vh_pcplist_add_cma_pages_bypass __tracepoint_android_vh_prepare_update_load_avg_se __tracepoint_android_vh_printk_hotplug __tracepoint_android_vh_process_killed - __tracepoint_android_vh_revert_creds __tracepoint_android_vh_record_mutex_lock_starttime + __tracepoint_android_vh_record_pcpu_rwsem_starttime __tracepoint_android_vh_record_rtmutex_lock_starttime __tracepoint_android_vh_record_rwsem_lock_starttime - __tracepoint_android_vh_record_pcpu_rwsem_starttime + __tracepoint_android_vh_remove_vmalloc_stack + __tracepoint_android_vh_revert_creds __tracepoint_android_vh_rmqueue __tracepoint_android_vh_rwsem_can_spin_on_owner __tracepoint_android_vh_rwsem_init @@ -3135,7 +3134,6 @@ __tracepoint_android_vh_rwsem_write_finished __tracepoint_android_vh_save_track_hash __tracepoint_android_vh_save_vmalloc_stack - __tracepoint_android_vh_remove_vmalloc_stack __tracepoint_android_vh_sched_stat_runtime_rt __tracepoint_android_vh_scheduler_tick __tracepoint_android_vh_selinux_avc_insert @@ -3151,6 +3149,7 @@ __tracepoint_android_vh_set_module_permit_before_init __tracepoint_android_vh_setscheduler_uclamp __tracepoint_android_vh_set_wake_flags + __tracepoint_android_vh_show_mapcount_pages __tracepoint_android_vh_show_max_freq __tracepoint_android_vh_show_resume_epoch_val __tracepoint_android_vh_show_stack_hash @@ -3158,14 +3157,15 @@ __tracepoint_android_vh_shrink_node_memcgs __tracepoint_android_vh_sync_txn_recvd __tracepoint_android_vh_syscall_prctl_finished + __tracepoint_android_vh_test_clear_look_around_ref __tracepoint_android_vh_timer_calc_index __tracepoint_android_vh_tune_inactive_ratio __tracepoint_android_vh_tune_scan_type __tracepoint_android_vh_tune_swappiness - __tracepoint_android_vh_test_clear_look_around_ref __tracepoint_android_vh_ufs_compl_command __tracepoint_android_vh_ufs_send_command __tracepoint_android_vh_ufs_send_tm_command + __tracepoint_android_vh_update_page_mapcount __tracepoint_android_vh_update_topology_flags_workfn __tracepoint_binder_transaction_received __tracepoint_cpu_frequency diff --git a/android/abi_gki_aarch64_qcom b/android/abi_gki_aarch64_qcom index 0004b141d673..bc5d94e3630a 100644 --- a/android/abi_gki_aarch64_qcom +++ b/android/abi_gki_aarch64_qcom @@ -93,10 +93,10 @@ blocking_notifier_call_chain blocking_notifier_chain_register blocking_notifier_chain_unregister - bpf_trace_run1 bpf_trace_run10 bpf_trace_run11 bpf_trace_run12 + bpf_trace_run1 bpf_trace_run2 bpf_trace_run3 bpf_trace_run4 @@ -1431,8 +1431,8 @@ mempool_free mempool_free_slab memremap - memset memset64 + memset __memset_io memstart_addr memunmap @@ -1453,8 +1453,8 @@ mmc_regulator_set_ocr mmc_regulator_set_vqmmc mmc_select_bus_width - mmc_select_hs mmc_select_hs400 + mmc_select_hs mmc_select_hs_ddr mmc_select_timing mmc_send_tuning @@ -1524,10 +1524,10 @@ nla_find nla_memcpy __nla_parse - nla_put nla_put_64bit - nla_reserve + nla_put nla_reserve_64bit + nla_reserve __nla_validate __nlmsg_put no_llseek diff --git a/android/abi_gki_aarch64_transsion b/android/abi_gki_aarch64_transsion index 83e28c1e1746..26f1a25320be 100644 --- a/android/abi_gki_aarch64_transsion +++ b/android/abi_gki_aarch64_transsion @@ -1,74 +1,74 @@ [abi_symbol_list] + check_cache_active get_mem_cgroup_from_mm is_swap_slot_cache_enabled - swapcache_free_entries - swap_type_to_swap_info + nr_swap_pages + plist_del + plist_requeue scan_swap_map_slots swap_alloc_cluster - check_cache_active - zero_pfn - nr_swap_pages - plist_requeue - plist_del + swapcache_free_entries + swap_type_to_swap_info + __traceiter_android_rvh_alloc_si + __traceiter_android_rvh_alloc_swap_slot_cache + __traceiter_android_rvh_drain_slots_cache_cpu + __traceiter_android_rvh_free_swap_slot + __traceiter_android_rvh_get_swap_page __traceiter_android_rvh_handle_pte_fault_end - __traceiter_android_vh_handle_pte_fault_end - __traceiter_android_vh_cow_user_page - __traceiter_android_vh_swapin_add_anon_rmap - __traceiter_android_vh_waiting_for_page_migration - __traceiter_android_vh_migrate_page_states - __traceiter_android_vh_page_referenced_one_end + __traceiter_android_vh_account_swap_pages + __traceiter_android_vh_alloc_si + __traceiter_android_vh_alloc_swap_slot_cache __traceiter_android_vh_count_pswpin __traceiter_android_vh_count_pswpout __traceiter_android_vh_count_swpout_vm_event - __traceiter_android_vh_swap_slot_cache_active - __traceiter_android_rvh_drain_slots_cache_cpu + __traceiter_android_vh_cow_user_page __traceiter_android_vh_drain_slots_cache_cpu - __traceiter_android_rvh_alloc_swap_slot_cache - __traceiter_android_vh_alloc_swap_slot_cache - __traceiter_android_rvh_free_swap_slot - __traceiter_android_vh_free_swap_slot - __traceiter_android_rvh_get_swap_page - __traceiter_android_vh_get_swap_page - __traceiter_android_vh_page_isolated_for_reclaim - __traceiter_android_vh_inactive_is_low - __traceiter_android_vh_snapshot_refaults - __traceiter_android_vh_account_swap_pages - __traceiter_android_vh_unuse_swap_page - __traceiter_android_vh_init_swap_info_struct - __traceiter_android_vh_si_swapinfo - __traceiter_android_rvh_alloc_si - __traceiter_android_vh_alloc_si __traceiter_android_vh_free_pages - __traceiter_android_vh_set_shmem_page_flag + __traceiter_android_vh_free_swap_slot + __traceiter_android_vh_get_swap_page + __traceiter_android_vh_handle_pte_fault_end + __traceiter_android_vh_inactive_is_low + __traceiter_android_vh_init_swap_info_struct + __traceiter_android_vh_migrate_page_states + __traceiter_android_vh_page_isolated_for_reclaim + __traceiter_android_vh_page_referenced_one_end __traceiter_android_vh_ra_tuning_max_page + __traceiter_android_vh_set_shmem_page_flag + __traceiter_android_vh_si_swapinfo + __traceiter_android_vh_snapshot_refaults + __traceiter_android_vh_swapin_add_anon_rmap + __traceiter_android_vh_swap_slot_cache_active + __traceiter_android_vh_unuse_swap_page + __traceiter_android_vh_waiting_for_page_migration + __tracepoint_android_rvh_alloc_si + __tracepoint_android_rvh_alloc_swap_slot_cache + __tracepoint_android_rvh_drain_slots_cache_cpu + __tracepoint_android_rvh_free_swap_slot + __tracepoint_android_rvh_get_swap_page __tracepoint_android_rvh_handle_pte_fault_end - __tracepoint_android_vh_handle_pte_fault_end - __tracepoint_android_vh_cow_user_page - __tracepoint_android_vh_swapin_add_anon_rmap - __tracepoint_android_vh_waiting_for_page_migration - __tracepoint_android_vh_migrate_page_states - __tracepoint_android_vh_page_referenced_one_end + __tracepoint_android_vh_account_swap_pages + __tracepoint_android_vh_alloc_si + __tracepoint_android_vh_alloc_swap_slot_cache __tracepoint_android_vh_count_pswpin __tracepoint_android_vh_count_pswpout __tracepoint_android_vh_count_swpout_vm_event - __tracepoint_android_vh_swap_slot_cache_active - __tracepoint_android_rvh_drain_slots_cache_cpu + __tracepoint_android_vh_cow_user_page __tracepoint_android_vh_drain_slots_cache_cpu - __tracepoint_android_rvh_alloc_swap_slot_cache - __tracepoint_android_vh_alloc_swap_slot_cache - __tracepoint_android_rvh_free_swap_slot - __tracepoint_android_vh_free_swap_slot - __tracepoint_android_rvh_get_swap_page - __tracepoint_android_vh_get_swap_page - __tracepoint_android_vh_page_isolated_for_reclaim - __tracepoint_android_vh_inactive_is_low - __tracepoint_android_vh_snapshot_refaults - __tracepoint_android_vh_account_swap_pages - __tracepoint_android_vh_unuse_swap_page - __tracepoint_android_vh_init_swap_info_struct - __tracepoint_android_vh_si_swapinfo - __tracepoint_android_rvh_alloc_si - __tracepoint_android_vh_alloc_si __tracepoint_android_vh_free_pages - __tracepoint_android_vh_set_shmem_page_flag + __tracepoint_android_vh_free_swap_slot + __tracepoint_android_vh_get_swap_page + __tracepoint_android_vh_handle_pte_fault_end + __tracepoint_android_vh_inactive_is_low + __tracepoint_android_vh_init_swap_info_struct + __tracepoint_android_vh_migrate_page_states + __tracepoint_android_vh_page_isolated_for_reclaim + __tracepoint_android_vh_page_referenced_one_end __tracepoint_android_vh_ra_tuning_max_page + __tracepoint_android_vh_set_shmem_page_flag + __tracepoint_android_vh_si_swapinfo + __tracepoint_android_vh_snapshot_refaults + __tracepoint_android_vh_swapin_add_anon_rmap + __tracepoint_android_vh_swap_slot_cache_active + __tracepoint_android_vh_unuse_swap_page + __tracepoint_android_vh_waiting_for_page_migration + zero_pfn diff --git a/android/abi_gki_aarch64_type_visibility b/android/abi_gki_aarch64_type_visibility index 705bf5574222..97a077fdf46e 100644 --- a/android/abi_gki_aarch64_type_visibility +++ b/android/abi_gki_aarch64_type_visibility @@ -1,6 +1,6 @@ [abi_symbol_list] # for type visibility - GKI_struct_selinux_state GKI_struct_gic_chip_data + GKI_struct_selinux_state GKI_struct_swap_slots_cache diff --git a/android/abi_gki_aarch64_vivo b/android/abi_gki_aarch64_vivo index 28c4b05aa43f..9b890ada7ad6 100644 --- a/android/abi_gki_aarch64_vivo +++ b/android/abi_gki_aarch64_vivo @@ -84,9 +84,9 @@ blocking_notifier_call_chain blocking_notifier_chain_register blocking_notifier_chain_unregister - bpf_trace_run1 bpf_trace_run10 bpf_trace_run12 + bpf_trace_run1 bpf_trace_run2 bpf_trace_run3 bpf_trace_run4 @@ -938,8 +938,8 @@ mempool_free mempool_free_slab memremap - memset memset64 + memset __memset_io memstart_addr memunmap @@ -975,8 +975,8 @@ __next_zones_zonelist nla_find nla_put - nla_reserve nla_reserve_64bit + nla_reserve __nla_validate __nlmsg_put no_llseek diff --git a/android/abi_gki_aarch64_xiaomi b/android/abi_gki_aarch64_xiaomi index ded2c5464994..67c83533d643 100644 --- a/android/abi_gki_aarch64_xiaomi +++ b/android/abi_gki_aarch64_xiaomi @@ -2,8 +2,8 @@ # commonly used symbols # required by touch module - proc_mkdir_data proc_create_seq_private + proc_mkdir_data # required by aw8697-haptic.ko devm_gpio_free @@ -11,36 +11,43 @@ i2c_smbus_write_byte_data #required by memory module - blk_execute_rq - blk_rq_map_kern - scsi_device_lookup - scsi_host_lookup - scsi_host_put - ufshcd_read_desc_param - utf16s_to_utf8s async_schedule_node + blk_execute_rq + blk_ksm_get_slot_idx blk_ksm_register blk_ksm_reprogram_all_keys blk_mq_alloc_tag_set + blk_mq_free_tag_set blk_mq_init_queue blk_mq_tagset_busy_iter + blk_queue_update_dma_alignment + blk_queue_update_dma_pad + blk_rq_map_kern bsg_job_done bsg_remove_queue bsg_setup_queue dev_pm_opp_remove + mempool_alloc_pages + mempool_free_pages + mempool_resize + __scsi_add_device scsi_add_host_with_dma scsi_block_requests + scsi_change_queue_depth + scsi_device_lookup + scsi_dma_map scsi_dma_unmap + __scsi_execute + scsi_host_alloc + scsi_host_lookup + scsi_host_put scsi_is_host_device + scsi_normalize_sense + scsi_print_command scsi_remove_host scsi_report_bus_reset scsi_scan_host scsi_unblock_requests - scsi_change_queue_depth - scsi_print_command - scsi_dma_map - scsi_host_alloc - scsi_normalize_sense sg_copy_from_buffer sg_copy_to_buffer ufshcd_alloc_host @@ -51,44 +58,40 @@ ufshcd_map_desc_id_to_length ufshcd_query_attr_retry ufshcd_query_flag_retry + ufshcd_read_desc_param ufshcd_update_evt_hist + utf16s_to_utf8s wait_for_completion_io_timeout - __scsi_add_device - __scsi_execute - blk_mq_free_tag_set - blk_queue_update_dma_alignment - blk_queue_update_dma_pad - blk_ksm_get_slot_idx - mempool_resize - mempool_alloc_pages - mempool_free_pages #required by cs35l41 module - regmap_raw_write_async - snd_soc_bytes_tlv_callback + regcache_drop_region regmap_async_complete + regmap_multi_reg_write + regmap_multi_reg_write_bypassed + regmap_raw_read + regmap_raw_write + regmap_raw_write_async + regulator_bulk_enable snd_compr_stop_error - snd_soc_component_disable_pin - snd_soc_component_force_enable_pin + snd_ctl_boolean_mono_info snd_pcm_format_physical_width snd_pcm_hw_constraint_list - regmap_multi_reg_write_bypassed - snd_ctl_boolean_mono_info - snd_soc_put_volsw_range + snd_soc_bytes_tlv_callback + snd_soc_component_disable_pin + snd_soc_component_force_enable_pin snd_soc_get_volsw_range snd_soc_info_volsw_range - regmap_raw_write - regcache_drop_region - regmap_raw_read - regmap_multi_reg_write - regulator_bulk_enable + snd_soc_put_volsw_range #required by mtd module - __blk_mq_end_request balance_dirty_pages_ratelimited bdi_alloc bdi_put bdi_register + blkdev_get_by_dev + blkdev_get_by_path + blkdev_put + __blk_mq_end_request blk_mq_freeze_queue blk_mq_init_sq_queue blk_mq_quiesce_queue @@ -97,9 +100,6 @@ blk_mq_unquiesce_queue blk_queue_write_cache blk_update_request - blkdev_get_by_dev - blkdev_get_by_path - blkdev_put deactivate_locked_super fixed_size_llseek generic_shutdown_super @@ -126,42 +126,42 @@ #required by millet.ko freezer_cgrp_subsys - __traceiter_android_vh_do_send_sig_info - __traceiter_android_vh_binder_preset - __traceiter_android_vh_binder_wait_for_work - __traceiter_android_vh_binder_trans - __traceiter_android_vh_binder_reply __traceiter_android_vh_binder_alloc_new_buf_locked - __tracepoint_android_vh_do_send_sig_info - __tracepoint_android_vh_binder_preset - __tracepoint_android_vh_binder_wait_for_work - __tracepoint_android_vh_binder_trans - __tracepoint_android_vh_binder_reply + __traceiter_android_vh_binder_preset + __traceiter_android_vh_binder_reply + __traceiter_android_vh_binder_trans + __traceiter_android_vh_binder_wait_for_work + __traceiter_android_vh_do_send_sig_info __tracepoint_android_vh_binder_alloc_new_buf_locked + __tracepoint_android_vh_binder_preset + __tracepoint_android_vh_binder_reply + __tracepoint_android_vh_binder_trans + __tracepoint_android_vh_binder_wait_for_work + __tracepoint_android_vh_do_send_sig_info #required by mi_sched.ko + find_user + free_uid + jiffies_64 __traceiter_android_vh_free_task __tracepoint_android_vh_free_task - jiffies_64 - free_uid - find_user #required by migt.ko - __traceiter_android_rvh_after_enqueue_task __traceiter_android_rvh_after_dequeue_task + __traceiter_android_rvh_after_enqueue_task __traceiter_android_vh_map_util_freq - __tracepoint_android_rvh_after_enqueue_task __tracepoint_android_rvh_after_dequeue_task + __tracepoint_android_rvh_after_enqueue_task __tracepoint_android_vh_map_util_freq #required by turbo.ko + cpuset_cpus_allowed + __traceiter_android_rvh_cpuset_fork __traceiter_android_rvh_set_cpus_allowed_comm __traceiter_android_vh_sched_setaffinity_early - __traceiter_android_rvh_cpuset_fork + __tracepoint_android_rvh_cpuset_fork __tracepoint_android_rvh_set_cpus_allowed_comm __tracepoint_android_vh_sched_setaffinity_early - __tracepoint_android_rvh_cpuset_fork - cpuset_cpus_allowed #required by fas.ko __traceiter_android_rvh_check_preempt_tick @@ -175,15 +175,15 @@ console_printk #required by binderinfo.ko module - __traceiter_android_vh_binder_transaction_init __traceiter_android_vh_binder_print_transaction_info - __tracepoint_android_vh_binder_transaction_init + __traceiter_android_vh_binder_transaction_init __tracepoint_android_vh_binder_print_transaction_info + __tracepoint_android_vh_binder_transaction_init #required by reclaim module __traceiter_android_vh_tune_scan_type - __tracepoint_android_vh_tune_scan_type __traceiter_android_vh_tune_swappiness + __tracepoint_android_vh_tune_scan_type __tracepoint_android_vh_tune_swappiness #required by msm_drm.ko module @@ -198,19 +198,19 @@ ##required by xm_power_debug.ko module wakeup_sources_read_lock wakeup_sources_read_unlock - wakeup_sources_walk_start wakeup_sources_walk_next + wakeup_sources_walk_start #required by mi_mempool.ko module - __traceiter_android_vh_mmput - __tracepoint_android_vh_mmput - __traceiter_android_vh_alloc_pages_reclaim_bypass - __tracepoint_android_vh_alloc_pages_reclaim_bypass __traceiter_android_vh_alloc_pages_failure_bypass + __traceiter_android_vh_alloc_pages_reclaim_bypass + __traceiter_android_vh_mmput __tracepoint_android_vh_alloc_pages_failure_bypass + __tracepoint_android_vh_alloc_pages_reclaim_bypass + __tracepoint_android_vh_mmput #required by us_prox.ko module iio_trigger_alloc - __iio_trigger_register iio_trigger_free + __iio_trigger_register iio_trigger_unregister From 4d70900718765404719e83be71e98ddbe655e1b6 Mon Sep 17 00:00:00 2001 From: Giuliano Procida Date: Wed, 3 May 2023 09:23:36 +0100 Subject: [PATCH 49/68] ANDROID: GKI: add missing vendor hook and other ktrace symbols For each traceiter or tracepoint symbol in a section of a symbol list, this change ensures its partner is also present in the same section. 38 function symbol(s) added 'int __traceiter_android_rvh_arm64_serror_panic(void*, struct pt_regs*, unsigned int)' 'int __traceiter_android_rvh_bad_mode(void*, struct pt_regs*, unsigned int, int)' 'int __traceiter_android_rvh_dequeue_task_idle(void*, struct task_struct*)' 'int __traceiter_android_rvh_do_ptrauth_fault(void*, struct pt_regs*, unsigned int, bool)' 'int __traceiter_android_rvh_do_sea(void*, struct pt_regs*, unsigned int, unsigned long int, const char*)' 'int __traceiter_android_rvh_do_undefinstr(void*, struct pt_regs*, bool)' 'int __traceiter_android_rvh_refrigerator(void*, bool)' 'int __traceiter_android_rvh_tcp_recvmsg(void*, struct sock*)' 'int __traceiter_android_rvh_tcp_recvmsg_stat(void*, struct sock*, int)' 'int __traceiter_android_rvh_tcp_sendmsg_locked(void*, struct sock*, int)' 'int __traceiter_android_rvh_udp_recvmsg(void*, struct sock*)' 'int __traceiter_android_rvh_udp_sendmsg(void*, struct sock*)' 'int __traceiter_android_vh_disable_thermal_cooling_stats(void*, struct thermal_cooling_device*, bool*)' 'int __traceiter_android_vh_dup_task_struct(void*, struct task_struct*, struct task_struct*)' 'int __traceiter_android_vh_handle_tlb_conf(void*, unsigned long int, unsigned int, int*)' 'int __traceiter_android_vh_irqtime_account_process_tick(void*, struct task_struct*, struct rq*, int, int)' 'int __traceiter_android_vh_madvise_cold_or_pageout(void*, struct vm_area_struct*, bool*)' 'int __traceiter_android_vh_oom_check_panic(void*, struct oom_control*, int*)' 'int __traceiter_android_vh_psi_event(void*, struct psi_trigger*)' 'int __traceiter_android_vh_psi_group(void*, struct psi_group*)' 'int __traceiter_android_vh_rtmutex_wait_finish(void*, struct rt_mutex*)' 'int __traceiter_android_vh_rtmutex_wait_start(void*, struct rt_mutex*)' 'int __traceiter_android_vh_rwsem_read_wait_finish(void*, struct rw_semaphore*)' 'int __traceiter_android_vh_rwsem_read_wait_start(void*, struct rw_semaphore*)' 'int __traceiter_android_vh_rwsem_write_wait_finish(void*, struct rw_semaphore*)' 'int __traceiter_android_vh_rwsem_write_wait_start(void*, struct rw_semaphore*)' 'int __traceiter_android_vh_sched_show_task(void*, struct task_struct*)' 'int __traceiter_android_vh_shmem_alloc_page(void*, struct page**)' 'int __traceiter_android_vh_subpage_dma_contig_alloc(void*, bool*, struct device*, size_t*)' 'int __traceiter_android_vh_try_to_freeze_todo(void*, unsigned int, unsigned int, bool)' 'int __traceiter_android_vh_try_to_freeze_todo_unfrozen(void*, struct task_struct*)' 'int __traceiter_android_vh_vmpressure(void*, struct mem_cgroup*, bool*)' 'int __traceiter_android_vh_watchdog_timer_softlockup(void*, int, struct pt_regs*, bool)' 'int __traceiter_android_vh_wq_lockup_pool(void*, int, unsigned long int)' 'int __traceiter_net_dev_queue(void*, struct sk_buff*)' 'int __traceiter_net_dev_xmit(void*, struct sk_buff*, int, struct net_device*, unsigned int)' 'int __traceiter_netif_receive_skb(void*, struct sk_buff*)' 'int __traceiter_netif_rx(void*, struct sk_buff*)' Bug: 280431338 Change-Id: Id46fa6a5f9d7923897e29a46d39d9d17c6d2fa9a Signed-off-by: Giuliano Procida --- android/abi_gki_aarch64.xml | 522 ++++++++++++++++++++++++++------- android/abi_gki_aarch64_galaxy | 47 +++ android/abi_gki_aarch64_mtk | 1 + android/abi_gki_aarch64_oplus | 4 + android/abi_gki_aarch64_qcom | 13 + android/abi_gki_aarch64_unisoc | 3 + android/abi_gki_aarch64_vivo | 13 + 7 files changed, 500 insertions(+), 103 deletions(-) diff --git a/android/abi_gki_aarch64.xml b/android/abi_gki_aarch64.xml index f67fa1192d73..6a06ed9aaa13 100644 --- a/android/abi_gki_aarch64.xml +++ b/android/abi_gki_aarch64.xml @@ -307,6 +307,8 @@ + + @@ -322,11 +324,15 @@ + + + + @@ -357,6 +363,7 @@ + @@ -386,6 +393,9 @@ + + + @@ -393,6 +403,8 @@ + + @@ -472,6 +484,7 @@ + @@ -480,6 +493,7 @@ + @@ -514,6 +528,7 @@ + @@ -524,6 +539,7 @@ + @@ -533,6 +549,7 @@ + @@ -558,6 +575,7 @@ + @@ -571,6 +589,8 @@ + + @@ -582,11 +602,15 @@ + + + + @@ -594,10 +618,13 @@ + + + @@ -618,6 +645,7 @@ + @@ -631,6 +659,7 @@ + @@ -639,6 +668,8 @@ + + @@ -666,7 +697,10 @@ + + + @@ -703,6 +737,10 @@ + + + + @@ -9739,6 +9777,41 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -10645,7 +10718,7 @@ - + @@ -13946,7 +14019,7 @@ - + @@ -18720,42 +18793,42 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + @@ -25950,6 +26023,7 @@ + @@ -27308,7 +27382,7 @@ - + @@ -29387,18 +29461,18 @@ - + - + - + - + - + @@ -33250,7 +33324,7 @@ - + @@ -40888,18 +40962,18 @@ - + - + - + - + - + @@ -42924,6 +42998,13 @@ + + + + + + + @@ -44532,23 +44613,7 @@ - - - - - - - - - - - - - - - - - + @@ -47445,7 +47510,7 @@ - + @@ -48241,6 +48306,16 @@ + + + + + + + + + + @@ -48878,7 +48953,6 @@ - @@ -52438,6 +52512,20 @@ + + + + + + + + + + + + + + @@ -53822,13 +53910,6 @@ - - - - - - - @@ -62584,7 +62665,7 @@ - + @@ -64249,6 +64330,7 @@ + @@ -66488,13 +66570,6 @@ - - - - - - - @@ -68164,18 +68239,18 @@ - + - + - + - + - + @@ -78094,7 +78169,7 @@ - + @@ -84503,6 +84578,32 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -91260,7 +91361,6 @@ - @@ -95433,6 +95533,7 @@ + @@ -96091,24 +96192,24 @@ - + - + - + - + - + - + - + @@ -103027,12 +103128,6 @@ - - - - - - @@ -104649,7 +104744,7 @@ - + @@ -111181,6 +111276,7 @@ + @@ -111278,7 +111374,6 @@ - @@ -118124,6 +118219,19 @@ + + + + + + + + + + + + + @@ -118228,6 +118336,11 @@ + + + + + @@ -118250,11 +118363,26 @@ + + + + + + + + + + + + + + + @@ -118263,6 +118391,12 @@ + + + + + + @@ -118463,6 +118597,11 @@ + + + + + @@ -118645,6 +118784,23 @@ + + + + + + + + + + + + + + + + + @@ -118689,6 +118845,16 @@ + + + + + + + + + + @@ -119223,6 +119389,12 @@ + + + + + + @@ -119283,6 +119455,12 @@ + + + + + + @@ -119494,6 +119672,13 @@ + + + + + + + @@ -119561,6 +119746,14 @@ + + + + + + + + @@ -119617,6 +119810,12 @@ + + + + + + @@ -119769,6 +119968,12 @@ + + + + + + @@ -119850,6 +120055,16 @@ + + + + + + + + + + @@ -119917,6 +120132,16 @@ + + + + + + + + + + @@ -119950,6 +120175,16 @@ + + + + + + + + + + @@ -119985,6 +120220,16 @@ + + + + + + + + + + @@ -120011,6 +120256,11 @@ + + + + + @@ -120127,6 +120377,11 @@ + + + + + @@ -120205,6 +120460,13 @@ + + + + + + + @@ -120251,6 +120513,18 @@ + + + + + + + + + + + + @@ -120435,11 +120709,30 @@ + + + + + + + + + + + + + + + + + + + @@ -120659,6 +120952,29 @@ + + + + + + + + + + + + + + + + + + + + + + + @@ -123575,8 +123891,8 @@ - - + + @@ -130526,10 +130842,10 @@ - - - - + + + + @@ -140701,8 +141017,8 @@ - - + + @@ -145795,8 +146111,8 @@ - - + + @@ -146172,11 +146488,11 @@ - - - - - + + + + + @@ -146658,9 +146974,9 @@ - - - + + + @@ -146709,8 +147025,8 @@ - - + + diff --git a/android/abi_gki_aarch64_galaxy b/android/abi_gki_aarch64_galaxy index 6b921ab3a901..db5abff44b22 100644 --- a/android/abi_gki_aarch64_galaxy +++ b/android/abi_gki_aarch64_galaxy @@ -3712,6 +3712,8 @@ trace_event_reg trace_handle_return __traceiter_android_rvh_account_irq + __traceiter_android_rvh_arm64_serror_panic + __traceiter_android_rvh_bad_mode __traceiter_android_rvh_build_perf_domains __traceiter_android_rvh_can_migrate_task __traceiter_android_rvh_check_preempt_wakeup @@ -3721,9 +3723,12 @@ __traceiter_android_rvh_cpufreq_transition __traceiter_android_rvh_cpu_overutilized __traceiter_android_rvh_dequeue_task + __traceiter_android_rvh_dequeue_task_idle __traceiter_android_rvh_die_kernel_fault __traceiter_android_rvh_do_mem_abort + __traceiter_android_rvh_do_sea __traceiter_android_rvh_do_sp_pc_abort + __traceiter_android_rvh_do_undefinstr __traceiter_android_rvh_enqueue_task __traceiter_android_rvh_find_busiest_queue __traceiter_android_rvh_find_energy_efficient_cpu @@ -3777,6 +3782,7 @@ __traceiter_android_vh_binder_set_priority __traceiter_android_vh_binder_transaction_init __traceiter_android_vh_binder_wakeup_ilocked + __traceiter_android_vh_cgroup_attach __traceiter_android_vh_cma_alloc_finish __traceiter_android_vh_cma_alloc_start __traceiter_android_vh_cpu_idle_enter @@ -3798,10 +3804,19 @@ __traceiter_android_vh_logbuf __traceiter_android_vh_logbuf_pr_cont __traceiter_android_vh_meminfo_proc_show + __traceiter_android_vh_mutex_wait_finish + __traceiter_android_vh_mutex_wait_start __traceiter_android_vh_pagecache_get_page __traceiter_android_vh_printk_hotplug __traceiter_android_vh_ptype_head __traceiter_android_vh_rmqueue + __traceiter_android_vh_rtmutex_wait_finish + __traceiter_android_vh_rtmutex_wait_start + __traceiter_android_vh_rwsem_read_wait_finish + __traceiter_android_vh_rwsem_read_wait_start + __traceiter_android_vh_rwsem_write_wait_finish + __traceiter_android_vh_rwsem_write_wait_start + __traceiter_android_vh_sched_show_task __traceiter_android_vh_scheduler_tick __traceiter_android_vh_show_max_freq __traceiter_android_vh_show_mem @@ -3809,6 +3824,8 @@ __traceiter_android_vh_show_suspend_epoch_val __traceiter_android_vh_timer_calc_index __traceiter_android_vh_timerfd_create + __traceiter_android_vh_try_to_freeze_todo + __traceiter_android_vh_try_to_freeze_todo_unfrozen __traceiter_android_vh_typec_store_partner_src_caps __traceiter_android_vh_typec_tcpci_override_toggling __traceiter_android_vh_typec_tcpm_adj_current_limit @@ -3822,14 +3839,44 @@ __traceiter_android_vh_ufs_send_uic_command __traceiter_android_vh_ufs_update_sdev __traceiter_android_vh_ufs_update_sysfs + __traceiter_android_vh_watchdog_timer_softlockup + __traceiter_android_vh_wq_lockup_pool + __traceiter_binder_transaction_received __traceiter_clock_set_rate __traceiter_cpu_frequency + __traceiter_cpu_frequency_limits + __traceiter_cpu_idle + __traceiter_device_pm_callback_end + __traceiter_device_pm_callback_start __traceiter_dma_fence_emit + __traceiter_dwc3_ep_queue __traceiter_dwc3_readl __traceiter_dwc3_writel __traceiter_gpu_mem_total + __traceiter_hrtimer_expire_entry + __traceiter_hrtimer_expire_exit + __traceiter_ipi_entry + __traceiter_ipi_exit + __traceiter_ipi_raise + __traceiter_irq_handler_entry + __traceiter_irq_handler_exit __traceiter_kfree_skb + __traceiter_pelt_cfs_tp + __traceiter_pelt_dl_tp + __traceiter_pelt_irq_tp + __traceiter_pelt_rt_tp + __traceiter_pelt_se_tp + __traceiter_rwmmio_post_read + __traceiter_rwmmio_read + __traceiter_rwmmio_write + __traceiter_sched_cpu_capacity_tp + __traceiter_sched_overutilized_tp + __traceiter_sched_switch + __traceiter_sched_util_est_cfs_tp __traceiter_sched_util_est_se_tp + __traceiter_suspend_resume + __traceiter_workqueue_execute_end + __traceiter_workqueue_execute_start __traceiter_xdp_exception trace_output_call __tracepoint_android_rvh_account_irq diff --git a/android/abi_gki_aarch64_mtk b/android/abi_gki_aarch64_mtk index 5473f314864b..2ac7b11faf77 100644 --- a/android/abi_gki_aarch64_mtk +++ b/android/abi_gki_aarch64_mtk @@ -3142,6 +3142,7 @@ __traceiter_android_vh_snd_soc_card_get_comp_chain __traceiter_android_vh_sound_usb_support_cpu_suspend __traceiter_android_vh_syscall_prctl_finished + __traceiter_android_vh_ufs_update_sdev __traceiter_android_vh_v4l2subdev_set_fmt __traceiter_android_vh_v4l2subdev_set_frame_interval __traceiter_android_vh_v4l2subdev_set_selection diff --git a/android/abi_gki_aarch64_oplus b/android/abi_gki_aarch64_oplus index b1b464d893fe..9544ea84c8f1 100644 --- a/android/abi_gki_aarch64_oplus +++ b/android/abi_gki_aarch64_oplus @@ -2925,6 +2925,10 @@ __traceiter_ipi_entry __traceiter_ipi_raise __traceiter_irq_handler_entry + __traceiter_net_dev_queue + __traceiter_net_dev_xmit + __traceiter_netif_receive_skb + __traceiter_netif_rx __traceiter_pelt_se_tp __traceiter_rwmmio_post_read __traceiter_rwmmio_read diff --git a/android/abi_gki_aarch64_qcom b/android/abi_gki_aarch64_qcom index bc5d94e3630a..b269c937101c 100644 --- a/android/abi_gki_aarch64_qcom +++ b/android/abi_gki_aarch64_qcom @@ -2514,6 +2514,7 @@ __traceiter_android_rvh_cpu_cgroup_online __traceiter_android_rvh_cpufreq_transition __traceiter_android_rvh_dequeue_task + __traceiter_android_rvh_do_ptrauth_fault __traceiter_android_rvh_do_sched_yield __traceiter_android_rvh_enqueue_task __traceiter_android_rvh_find_busiest_queue @@ -2561,14 +2562,18 @@ __traceiter_android_rvh_update_misfit_status __traceiter_android_rvh_wake_up_new_task __traceiter_android_vh_allow_domain_state + __traceiter_android_vh_alter_rwsem_list_add __traceiter_android_vh_binder_restore_priority __traceiter_android_vh_binder_set_priority __traceiter_android_vh_binder_transaction_init __traceiter_android_vh_binder_wakeup_ilocked + __traceiter_android_vh_check_uninterruptible_tasks + __traceiter_android_vh_check_uninterruptible_tasks_dn __traceiter_android_vh_cpu_idle_enter __traceiter_android_vh_cpu_idle_exit __traceiter_android_vh_cpuidle_psci_enter __traceiter_android_vh_cpuidle_psci_exit + __traceiter_android_vh_disable_thermal_cooling_stats __traceiter_android_vh_dump_throttled_rt_tasks __traceiter_android_vh_freq_table_limits __traceiter_android_vh_ftrace_dump_buffer @@ -2578,18 +2583,26 @@ __traceiter_android_vh_ftrace_size_check __traceiter_android_vh_gic_resume __traceiter_android_vh_gpio_block_read + __traceiter_android_vh_handle_tlb_conf __traceiter_android_vh_iommu_setup_dma_ops __traceiter_android_vh_ipi_stop __traceiter_android_vh_jiffies_update __traceiter_android_vh_logbuf __traceiter_android_vh_logbuf_pr_cont + __traceiter_android_vh_madvise_cold_or_pageout + __traceiter_android_vh_oom_check_panic __traceiter_android_vh_printk_hotplug + __traceiter_android_vh_process_killed + __traceiter_android_vh_psi_event + __traceiter_android_vh_psi_group __traceiter_android_vh_rproc_recovery __traceiter_android_vh_rproc_recovery_set __traceiter_android_vh_scheduler_tick + __traceiter_android_vh_shmem_alloc_page __traceiter_android_vh_show_max_freq __traceiter_android_vh_show_resume_epoch_val __traceiter_android_vh_show_suspend_epoch_val + __traceiter_android_vh_subpage_dma_contig_alloc __traceiter_android_vh_timer_calc_index __traceiter_android_vh_ufs_check_int_errors __traceiter_android_vh_ufs_clock_scaling diff --git a/android/abi_gki_aarch64_unisoc b/android/abi_gki_aarch64_unisoc index d065398a5fd0..ec061835a335 100644 --- a/android/abi_gki_aarch64_unisoc +++ b/android/abi_gki_aarch64_unisoc @@ -254,6 +254,9 @@ __tasklet_schedule thermal_zone_device_disable thermal_zone_device_enable + __traceiter_rwmmio_post_read + __traceiter_rwmmio_read + __traceiter_rwmmio_write __tracepoint_rwmmio_post_read __tracepoint_rwmmio_read __tracepoint_rwmmio_write diff --git a/android/abi_gki_aarch64_vivo b/android/abi_gki_aarch64_vivo index 9b890ada7ad6..9143afa6c2dc 100644 --- a/android/abi_gki_aarch64_vivo +++ b/android/abi_gki_aarch64_vivo @@ -1687,6 +1687,7 @@ __traceiter_android_rvh_flush_task __traceiter_android_rvh_migrate_queued_task __traceiter_android_rvh_new_task_stats + __traceiter_android_rvh_refrigerator __traceiter_android_rvh_replace_next_task_fair __traceiter_android_rvh_resume_cpus __traceiter_android_rvh_sched_cpu_dying @@ -1704,22 +1705,30 @@ __traceiter_android_rvh_set_readahead_gfp_mask __traceiter_android_rvh_set_skip_swapcache_flags __traceiter_android_rvh_set_task_cpu + __traceiter_android_rvh_tcp_recvmsg + __traceiter_android_rvh_tcp_recvmsg_stat + __traceiter_android_rvh_tcp_sendmsg_locked __traceiter_android_rvh_tick_entry __traceiter_android_rvh_try_to_wake_up __traceiter_android_rvh_try_to_wake_up_success __traceiter_android_rvh_ttwu_cond + __traceiter_android_rvh_udp_recvmsg + __traceiter_android_rvh_udp_sendmsg __traceiter_android_rvh_update_cpu_capacity __traceiter_android_rvh_update_cpus_allowed __traceiter_android_rvh_update_misfit_status __traceiter_android_rvh_wake_up_new_task + __traceiter_android_vh_account_task_time __traceiter_android_vh_allow_domain_state __traceiter_android_vh_binder_restore_priority __traceiter_android_vh_binder_set_priority + __traceiter_android_vh_binder_trans __traceiter_android_vh_binder_wakeup_ilocked __traceiter_android_vh_blk_alloc_rqs __traceiter_android_vh_blk_rq_ctx_init __traceiter_android_vh_cpu_idle_enter __traceiter_android_vh_cpu_idle_exit + __traceiter_android_vh_dup_task_struct __traceiter_android_vh_filemap_fault_cache_page __traceiter_android_vh_filemap_fault_get_page __traceiter_android_vh_ftrace_dump_buffer @@ -1729,6 +1738,7 @@ __traceiter_android_vh_ftrace_size_check __traceiter_android_vh_iommu_setup_dma_ops __traceiter_android_vh_ipi_stop + __traceiter_android_vh_irqtime_account_process_tick __traceiter_android_vh_jiffies_update __traceiter_android_vh_mmap_region __traceiter_android_vh_mmc_attach_sd @@ -1746,10 +1756,13 @@ __traceiter_android_vh_shrink_slab_bypass __traceiter_android_vh_timer_calc_index __traceiter_android_vh_try_to_unmap_one + __traceiter_android_vh_tune_scan_type + __traceiter_android_vh_tune_swappiness __traceiter_android_vh_ufs_check_int_errors __traceiter_android_vh_ufs_compl_command __traceiter_android_vh_ufs_send_command __traceiter_android_vh_ufs_update_sdev + __traceiter_android_vh_vmpressure __traceiter_binder_transaction_received __traceiter_block_bio_complete __traceiter_block_bio_queue From ce88d51c722f26f604abdaa4b105d37172ee51ae Mon Sep 17 00:00:00 2001 From: Alistair Delva Date: Fri, 28 Apr 2023 09:52:58 -0700 Subject: [PATCH 50/68] ANDROID: GKI: Increase max 8250 uarts Some boards need more than the default maximum of 4 uarts. This has no impact unless 8250.nr_uarts is specified on the cmdline to increase the number of runtime uarts from the GKI default of 0. Bug: 280015873 Signed-off-by: Alistair Delva Change-Id: I5ba4e1dcce4f4e01b7d306fa3ab05319768eef00 --- arch/arm64/configs/gki_defconfig | 1 + arch/x86/configs/gki_defconfig | 1 + 2 files changed, 2 insertions(+) diff --git a/arch/arm64/configs/gki_defconfig b/arch/arm64/configs/gki_defconfig index d82e363ddff8..8fa037f86347 100644 --- a/arch/arm64/configs/gki_defconfig +++ b/arch/arm64/configs/gki_defconfig @@ -373,6 +373,7 @@ CONFIG_SERIAL_8250=y # CONFIG_SERIAL_8250_DEPRECATED_OPTIONS is not set CONFIG_SERIAL_8250_CONSOLE=y # CONFIG_SERIAL_8250_EXAR is not set +CONFIG_SERIAL_8250_NR_UARTS=32 CONFIG_SERIAL_8250_RUNTIME_UARTS=0 CONFIG_SERIAL_OF_PLATFORM=y CONFIG_SERIAL_AMBA_PL011=y diff --git a/arch/x86/configs/gki_defconfig b/arch/x86/configs/gki_defconfig index 63419263e5ac..9507ff815d82 100644 --- a/arch/x86/configs/gki_defconfig +++ b/arch/x86/configs/gki_defconfig @@ -343,6 +343,7 @@ CONFIG_INPUT_UINPUT=y CONFIG_SERIAL_8250=y # CONFIG_SERIAL_8250_DEPRECATED_OPTIONS is not set CONFIG_SERIAL_8250_CONSOLE=y +CONFIG_SERIAL_8250_NR_UARTS=32 CONFIG_SERIAL_8250_RUNTIME_UARTS=0 CONFIG_SERIAL_OF_PLATFORM=y CONFIG_SERIAL_SAMSUNG=y From 66cba6260a95c3bfa1f8db0e77b10c0bacfab4b6 Mon Sep 17 00:00:00 2001 From: Carlos Llamas Date: Fri, 5 May 2023 06:48:10 +0000 Subject: [PATCH 51/68] FROMLIST: binder: fix UAF caused by faulty buffer cleanup In binder_transaction_buffer_release() the 'failed_at' offset indicates the number of objects to clean up. However, this function was changed by commit 44d8047f1d87 ("binder: use standard functions to allocate fds"), to release all the objects in the buffer when 'failed_at' is zero. This introduced an issue when a transaction buffer is released without any objects having been processed so far. In this case, 'failed_at' is indeed zero yet it is misinterpreted as releasing the entire buffer. This leads to use-after-free errors where nodes are incorrectly freed and subsequently accessed. Such is the case in the following KASAN report: ================================================================== BUG: KASAN: slab-use-after-free in binder_thread_read+0xc40/0x1f30 Read of size 8 at addr ffff4faf037cfc58 by task poc/474 CPU: 6 PID: 474 Comm: poc Not tainted 6.3.0-12570-g7df047b3f0aa #5 Hardware name: linux,dummy-virt (DT) Call trace: dump_backtrace+0x94/0xec show_stack+0x18/0x24 dump_stack_lvl+0x48/0x60 print_report+0xf8/0x5b8 kasan_report+0xb8/0xfc __asan_load8+0x9c/0xb8 binder_thread_read+0xc40/0x1f30 binder_ioctl+0xd9c/0x1768 __arm64_sys_ioctl+0xd4/0x118 invoke_syscall+0x60/0x188 [...] Allocated by task 474: kasan_save_stack+0x3c/0x64 kasan_set_track+0x2c/0x40 kasan_save_alloc_info+0x24/0x34 __kasan_kmalloc+0xb8/0xbc kmalloc_trace+0x48/0x5c binder_new_node+0x3c/0x3a4 binder_transaction+0x2b58/0x36f0 binder_thread_write+0x8e0/0x1b78 binder_ioctl+0x14a0/0x1768 __arm64_sys_ioctl+0xd4/0x118 invoke_syscall+0x60/0x188 [...] Freed by task 475: kasan_save_stack+0x3c/0x64 kasan_set_track+0x2c/0x40 kasan_save_free_info+0x38/0x5c __kasan_slab_free+0xe8/0x154 __kmem_cache_free+0x128/0x2bc kfree+0x58/0x70 binder_dec_node_tmpref+0x178/0x1fc binder_transaction_buffer_release+0x430/0x628 binder_transaction+0x1954/0x36f0 binder_thread_write+0x8e0/0x1b78 binder_ioctl+0x14a0/0x1768 __arm64_sys_ioctl+0xd4/0x118 invoke_syscall+0x60/0x188 [...] ================================================================== In order to avoid these issues, let's always calculate the intended 'failed_at' offset beforehand. This is renamed and wrapped in a helper function to make it clear and convenient. Fixes: 32e9f56a96d8 ("binder: don't detect sender/target during buffer cleanup") Reported-by: Zi Fan Tan Link: https://b.corp.google.com/issues/275041864 Cc: stable@vger.kernel.org Signed-off-by: Carlos Llamas Bug: 275041864 Link: https://lore.kernel.org/all/20230505203020.4101154-1-cmllamas@google.com Change-Id: I4bcc8bde77a8118872237d100cccb5caf95d99a1 Signed-off-by: Carlos Llamas --- drivers/android/binder.c | 28 +++++++++++++++++++++------- 1 file changed, 21 insertions(+), 7 deletions(-) diff --git a/drivers/android/binder.c b/drivers/android/binder.c index 66152cc321a9..75072d3bc98c 100644 --- a/drivers/android/binder.c +++ b/drivers/android/binder.c @@ -2034,24 +2034,23 @@ static void binder_deferred_fd_close(int fd) static void binder_transaction_buffer_release(struct binder_proc *proc, struct binder_thread *thread, struct binder_buffer *buffer, - binder_size_t failed_at, + binder_size_t off_end_offset, bool is_failure) { int debug_id = buffer->debug_id; - binder_size_t off_start_offset, buffer_offset, off_end_offset; + binder_size_t off_start_offset, buffer_offset; binder_debug(BINDER_DEBUG_TRANSACTION, "%d buffer release %d, size %zd-%zd, failed at %llx\n", proc->pid, buffer->debug_id, buffer->data_size, buffer->offsets_size, - (unsigned long long)failed_at); + (unsigned long long)off_end_offset); if (buffer->target_node) binder_dec_node(buffer->target_node, 1, 0); off_start_offset = ALIGN(buffer->data_size, sizeof(void *)); - off_end_offset = is_failure && failed_at ? failed_at : - off_start_offset + buffer->offsets_size; + for (buffer_offset = off_start_offset; buffer_offset < off_end_offset; buffer_offset += sizeof(binder_size_t)) { struct binder_object_header *hdr; @@ -2211,6 +2210,21 @@ static void binder_transaction_buffer_release(struct binder_proc *proc, } } +/* Clean up all the objects in the buffer */ +static inline void binder_release_entire_buffer(struct binder_proc *proc, + struct binder_thread *thread, + struct binder_buffer *buffer, + bool is_failure) +{ + binder_size_t off_end_offset; + + off_end_offset = ALIGN(buffer->data_size, sizeof(void *)); + off_end_offset += buffer->offsets_size; + + binder_transaction_buffer_release(proc, thread, buffer, + off_end_offset, is_failure); +} + static int binder_translate_binder(struct flat_binder_object *fp, struct binder_transaction *t, struct binder_thread *thread) @@ -2916,7 +2930,7 @@ static int binder_proc_transaction(struct binder_transaction *t, t_outdated->buffer = NULL; buffer->transaction = NULL; trace_binder_transaction_update_buffer_release(buffer); - binder_transaction_buffer_release(proc, NULL, buffer, 0, 0); + binder_release_entire_buffer(proc, NULL, buffer, false); binder_alloc_free_buf(&proc->alloc, buffer); kfree(t_outdated); binder_stats_deleted(BINDER_STAT_TRANSACTION); @@ -3830,7 +3844,7 @@ binder_free_buf(struct binder_proc *proc, binder_node_inner_unlock(buf_node); } trace_binder_transaction_buffer_release(buffer); - binder_transaction_buffer_release(proc, thread, buffer, 0, is_failure); + binder_release_entire_buffer(proc, thread, buffer, is_failure); binder_alloc_free_buf(&proc->alloc, buffer); } From 57f609a261a333f605bd1b07e139c25df3d80c5f Mon Sep 17 00:00:00 2001 From: Wesley Cheng Date: Mon, 19 Sep 2022 16:12:13 -0700 Subject: [PATCH 52/68] BACKPORT: usb: dwc3: gadget: Do not clear ep delayed stop flag during ep disable DWC3_EP_DELAYED_STOP is utilized to defer issuing the end transfer command until the subsequent SETUP stage, in order to avoid end transfer timeouts. During cable disconnect scenarios, __dwc3_gadget_ep_disable() is responsible for ensuring endpoints have no active transfers pending. Since dwc3_remove_request() can now exit early if the EP delayed stop is set, avoid clearing all DEP flags, otherwise the transition back into the SETUP stage won't issue an endxfer command. Bug: 280698396 Bug: 276227797 Fixes: 2b2da6574e77 ("usb: dwc3: Avoid unmapping USB requests if endxfer is not complete") Reviewed-by: Thinh Nguyen Change-Id: I4453c4ddfe7ad15e9c5b1ba2be09d20cac72b0bf Signed-off-by: Wesley Cheng Link: https://lore.kernel.org/r/20220919231213.21364-1-quic_wcheng@quicinc.com Signed-off-by: Greg Kroah-Hartman (cherry picked from commit 76bff31c7fba) (cherry picked from commit c0b28ac8b3976be4277de828aefc914ce2741f95) --- drivers/usb/dwc3/gadget.c | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/drivers/usb/dwc3/gadget.c b/drivers/usb/dwc3/gadget.c index 7224cb6e6b78..3c471b1d03a4 100644 --- a/drivers/usb/dwc3/gadget.c +++ b/drivers/usb/dwc3/gadget.c @@ -1013,6 +1013,7 @@ static int __dwc3_gadget_ep_disable(struct dwc3_ep *dep) { struct dwc3 *dwc = dep->dwc; u32 reg; + u32 mask; trace_dwc3_gadget_ep_disable(dep); @@ -1028,7 +1029,15 @@ static int __dwc3_gadget_ep_disable(struct dwc3_ep *dep) dep->stream_capable = false; dep->type = 0; - dep->flags &= DWC3_EP_TXFIFO_RESIZED; + mask = DWC3_EP_TXFIFO_RESIZED; + /* + * dwc3_remove_requests() can exit early if DWC3 EP delayed stop is + * set. Do not clear DEP flags, so that the end transfer command will + * be reattempted during the next SETUP stage. + */ + if (dep->flags & DWC3_EP_DELAY_STOP) + mask |= (DWC3_EP_DELAY_STOP | DWC3_EP_TRANSFER_STARTED); + dep->flags &= mask; /* Clear out the ep descriptors for non-ep0 */ if (dep->number > 1) { From a42b1b61190b3d12b23c1ba568e8b98d0cb70876 Mon Sep 17 00:00:00 2001 From: Thinh Nguyen Date: Thu, 8 Dec 2022 16:50:35 -0800 Subject: [PATCH 53/68] BACKPORT: usb: dwc3: gadget: Ignore End Transfer delay on teardown If we delay sending End Transfer for Setup TRB to be prepared, we need to check if the End Transfer was in preparation for a driver teardown/soft-disconnect. In those cases, just send the End Transfer command without delay. In the case of soft-disconnect, there's a very small chance the command may not go through immediately. But should it happen, the Setup TRB will be prepared during the polling of the controller halted state, allowing the command to go through then. In the case of disabling endpoint due to reconfiguration (e.g. set_interface(alt-setting) or usb reset), then it's driven by the host. Typically the host wouldn't immediately cancel the control request and send another control transfer to trigger the End Transfer command timeout. Bug: 280698394 Bug: 276227797 Fixes: 4db0fbb60136 ("usb: dwc3: gadget: Don't delay End Transfer on delayed_status") Cc: stable@vger.kernel.org Signed-off-by: Thinh Nguyen Link: https://lore.kernel.org/r/f1617a323e190b9cc408fb8b65456e32b5814113.1670546756.git.Thinh.Nguyen@synopsys.com Signed-off-by: Greg Kroah-Hartman (cherry picked from commit c4e3ef568539) Change-Id: If49c07d3822e8d637f7dca337c895b0fd1a156f2 (cherry picked from commit 2f2c6f2cf0602ca2b82c70c49aa4e3dab0ab8e11) --- drivers/usb/dwc3/gadget.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/drivers/usb/dwc3/gadget.c b/drivers/usb/dwc3/gadget.c index 3c471b1d03a4..fbceba256317 100644 --- a/drivers/usb/dwc3/gadget.c +++ b/drivers/usb/dwc3/gadget.c @@ -1714,6 +1714,7 @@ static int __dwc3_stop_active_transfer(struct dwc3_ep *dep, bool force, bool int dep->flags |= DWC3_EP_END_TRANSFER_PENDING; } + dep->flags &= ~DWC3_EP_DELAY_STOP; return ret; } @@ -3721,8 +3722,10 @@ void dwc3_stop_active_transfer(struct dwc3_ep *dep, bool force, if (dep->number <= 1 && dwc->ep0state != EP0_DATA_PHASE) return; + if (interrupt && (dep->flags & DWC3_EP_DELAY_STOP)) + return; + if (!(dep->flags & DWC3_EP_TRANSFER_STARTED) || - (dep->flags & DWC3_EP_DELAY_STOP) || (dep->flags & DWC3_EP_END_TRANSFER_PENDING)) return; From e36eef3783edf177800df2102e6aec784ef4b27f Mon Sep 17 00:00:00 2001 From: Lee Jones Date: Tue, 18 Apr 2023 10:35:38 +0100 Subject: [PATCH 54/68] Revert "Revert "mm/rmap: Fix anon_vma->degree ambiguity leading to double-reuse"" This reverts commit 4f35cec76058557d9eaec0d501d03c7657eb56b4 and does so in an abi-safe way. This is done by adding the new fields only to the end of the structure and this structure is only passed around to other functions as a pointer, the internal structure layout is only touched by the core kernel, so adding it to the end is safe. Update ABI using The Button: Leaf changes summary: 1 artifact changed Changed leaf types summary: 1 leaf type changed Removed/Changed/Added functions summary: 0 Removed, 0 Changed, 0 Added function Removed/Changed/Added variables summary: 0 Removed, 0 Changed, 0 Added variable 'struct anon_vma at rmap.h:33:1' changed: type size changed from 832 to 960 (in bits) 2 data member insertions: 'unsigned long int num_children', at offset 832 (in bits) at rmap.h:74:1 'unsigned long int num_active_vmas', at offset 896 (in bits) at rmap.h:76:1 5406 impacted interfaces Bug: 260678056 Bug: 253167854 Change-Id: Ib1d45625cbc2e0b21330ca3dc2aa7aff34666d31 Signed-off-by: Lee Jones Signed-off-by: Greg Kroah-Hartman --- android/abi_gki_aarch64.xml | 34 ++++++++++++++++++++-------------- include/linux/rmap.h | 27 ++++++++++++++++++++------- mm/rmap.c | 30 +++++++++++++++++------------- 3 files changed, 57 insertions(+), 34 deletions(-) diff --git a/android/abi_gki_aarch64.xml b/android/abi_gki_aarch64.xml index 6a06ed9aaa13..94f6ea7547dc 100644 --- a/android/abi_gki_aarch64.xml +++ b/android/abi_gki_aarch64.xml @@ -14860,7 +14860,7 @@ - + @@ -14871,13 +14871,19 @@ - + - + - + + + + + + + @@ -99212,27 +99218,27 @@ - + - + - + - + - + - + - + - + @@ -138389,8 +138395,8 @@ - - + + diff --git a/include/linux/rmap.h b/include/linux/rmap.h index 0a4d49ca8ccf..5a64e48ef207 100644 --- a/include/linux/rmap.h +++ b/include/linux/rmap.h @@ -42,13 +42,7 @@ struct anon_vma { */ atomic_t refcount; - /* - * Count of child anon_vmas and VMAs which points to this anon_vma. - * - * This counter is used for making decision about reusing anon_vma - * instead of forking new one. See comments in function anon_vma_clone. - */ - unsigned degree; + unsigned degree; /* ANDROID: KABI preservation, DO NOT USE! */ struct anon_vma *parent; /* Parent of this anon_vma */ @@ -63,6 +57,25 @@ struct anon_vma { /* Interval tree of private "related" vmas */ struct rb_root_cached rb_root; + + /* + * ANDROID: KABI preservation, it's safe to put these at the end of this structure as it's + * only passed by a pointer everywhere, the size and internal structures are local to the + * core kernel. + */ +#ifndef __GENKSYMS__ + /* + * Count of child anon_vmas. Equals to the count of all anon_vmas that + * have ->parent pointing to this one, including itself. + * + * This counter is used for making decision about reusing anon_vma + * instead of forking new one. See comments in function anon_vma_clone. + */ + unsigned long num_children; + /* Count of VMAs whose ->anon_vma pointer points to this object. */ + unsigned long num_active_vmas; +#endif + }; /* diff --git a/mm/rmap.c b/mm/rmap.c index 033b04704b59..422b3d0deb8f 100644 --- a/mm/rmap.c +++ b/mm/rmap.c @@ -91,7 +91,8 @@ static inline struct anon_vma *anon_vma_alloc(void) anon_vma = kmem_cache_alloc(anon_vma_cachep, GFP_KERNEL); if (anon_vma) { atomic_set(&anon_vma->refcount, 1); - anon_vma->degree = 1; /* Reference for first vma */ + anon_vma->num_children = 0; + anon_vma->num_active_vmas = 0; anon_vma->parent = anon_vma; /* * Initialise the anon_vma root to point to itself. If called @@ -199,6 +200,7 @@ int __anon_vma_prepare(struct vm_area_struct *vma) anon_vma = anon_vma_alloc(); if (unlikely(!anon_vma)) goto out_enomem_free_avc; + anon_vma->num_children++; /* self-parent link for new root */ allocated = anon_vma; } @@ -208,8 +210,7 @@ int __anon_vma_prepare(struct vm_area_struct *vma) if (likely(!vma->anon_vma)) { vma->anon_vma = anon_vma; anon_vma_chain_link(vma, avc, anon_vma); - /* vma reference or self-parent link for new root */ - anon_vma->degree++; + anon_vma->num_active_vmas++; allocated = NULL; avc = NULL; } @@ -294,19 +295,19 @@ int anon_vma_clone(struct vm_area_struct *dst, struct vm_area_struct *src) anon_vma_chain_link(dst, avc, anon_vma); /* - * Reuse existing anon_vma if its degree lower than two, - * that means it has no vma and only one anon_vma child. + * Reuse existing anon_vma if it has no vma and only one + * anon_vma child. * - * Do not chose parent anon_vma, otherwise first child - * will always reuse it. Root anon_vma is never reused: + * Root anon_vma is never reused: * it has self-parent reference and at least one child. */ if (!dst->anon_vma && src->anon_vma && - anon_vma != src->anon_vma && anon_vma->degree < 2) + anon_vma->num_children < 2 && + anon_vma->num_active_vmas == 0) dst->anon_vma = anon_vma; } if (dst->anon_vma) - dst->anon_vma->degree++; + dst->anon_vma->num_active_vmas++; unlock_anon_vma_root(root); return 0; @@ -356,6 +357,7 @@ int anon_vma_fork(struct vm_area_struct *vma, struct vm_area_struct *pvma) anon_vma = anon_vma_alloc(); if (!anon_vma) goto out_error; + anon_vma->num_active_vmas++; avc = anon_vma_chain_alloc(GFP_KERNEL); if (!avc) goto out_error_free_anon_vma; @@ -376,7 +378,7 @@ int anon_vma_fork(struct vm_area_struct *vma, struct vm_area_struct *pvma) vma->anon_vma = anon_vma; anon_vma_lock_write(anon_vma); anon_vma_chain_link(vma, avc, anon_vma); - anon_vma->parent->degree++; + anon_vma->parent->num_children++; anon_vma_unlock_write(anon_vma); return 0; @@ -408,7 +410,7 @@ void unlink_anon_vmas(struct vm_area_struct *vma) * to free them outside the lock. */ if (RB_EMPTY_ROOT(&anon_vma->rb_root.rb_root)) { - anon_vma->parent->degree--; + anon_vma->parent->num_children--; continue; } @@ -416,7 +418,8 @@ void unlink_anon_vmas(struct vm_area_struct *vma) anon_vma_chain_free(avc); } if (vma->anon_vma) - vma->anon_vma->degree--; + vma->anon_vma->num_active_vmas--; + unlock_anon_vma_root(root); /* @@ -427,7 +430,8 @@ void unlink_anon_vmas(struct vm_area_struct *vma) list_for_each_entry_safe(avc, next, &vma->anon_vma_chain, same_vma) { struct anon_vma *anon_vma = avc->anon_vma; - VM_WARN_ON(anon_vma->degree); + VM_WARN_ON(anon_vma->num_children); + VM_WARN_ON(anon_vma->num_active_vmas); put_anon_vma(anon_vma); list_del(&avc->same_vma); From 368fb8a50c9a26a5632f502310066bb74daa0005 Mon Sep 17 00:00:00 2001 From: "tanghuan@vivo.com" Date: Tue, 9 May 2023 20:55:30 +0800 Subject: [PATCH 55/68] BACKPORT: scsi: ufs: fix a race condition related to device management If a device management command completion happens after wait_for_completion_timeout() times out and before ufshcd_clear_cmds() is called, then the completion code may crash on the complete() call in __ufshcd_transfer_req_compl(). Fix the following crash: Unable to handle kernel NULL pointer dereference at virtual address 0000000000000008 Call trace: complete+0x64/0x178 __ufshcd_transfer_req_compl+0x30c/0x9c0 ufshcd_poll+0xf0/0x208 ufshcd_sl_intr+0xb8/0xf0 ufshcd_intr+0x168/0x2f4 __handle_irq_event_percpu+0xa0/0x30c handle_irq_event+0x84/0x178 handle_fasteoi_irq+0x150/0x2e8 __handle_domain_irq+0x114/0x1e4 gic_handle_irq.31846+0x58/0x300 el1_irq+0xe4/0x1c0 efi_header_end+0x110/0x680 __irq_exit_rcu+0x108/0x124 __handle_domain_irq+0x118/0x1e4 gic_handle_irq.31846+0x58/0x300 el1_irq+0xe4/0x1c0 cpuidle_enter_state+0x3ac/0x8c4 do_idle+0x2fc/0x55c cpu_startup_entry+0x84/0x90 kernel_init+0x0/0x310 start_kernel+0x0/0x608 start_kernel+0x4ec/0x608 Bug:280957963 Change-Id: I317f9a92ddbd38a952328ce132a60228f41651be (cherry picked from commit f5c2976e0cb0f6236013bfb479868531b04f61d4) Link: https://lore.kernel.org/r/20220720170228.1598842-1-bvanassche@acm.org Fixes: 5a0b0cb9bee7 ("[SCSI] ufs: Add support for sending NOP OUT UPIU") Cc: Adrian Hunter Cc: Avri Altman Cc: Bean Huo Cc: Stanley Chu Signed-off-by: Bart Van Assche Signed-off-by: Martin K. Petersen Signed-off-by: tanghuan@vivo.com --- drivers/scsi/ufs/ufshcd.c | 66 ++++++++++++++++++++++++--------------- 1 file changed, 40 insertions(+), 26 deletions(-) diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c index 1812edbb7d72..625ea25580da 100644 --- a/drivers/scsi/ufs/ufshcd.c +++ b/drivers/scsi/ufs/ufshcd.c @@ -730,16 +730,6 @@ static inline void ufshcd_utmrl_clear(struct ufs_hba *hba, u32 pos) ufshcd_writel(hba, ~(1 << pos), REG_UTP_TASK_REQ_LIST_CLEAR); } -/** - * ufshcd_outstanding_req_clear - Clear a bit in outstanding request field - * @hba: per adapter instance - * @tag: position of the bit to be cleared - */ -static inline void ufshcd_outstanding_req_clear(struct ufs_hba *hba, int tag) -{ - clear_bit(tag, &hba->outstanding_reqs); -} - /** * ufshcd_get_lists_status - Check UCRDY, UTRLRDY and UTMRLRDY * @reg: Register value of host controller status @@ -2882,37 +2872,61 @@ ufshcd_dev_cmd_completion(struct ufs_hba *hba, struct ufshcd_lrb *lrbp) static int ufshcd_wait_for_dev_cmd(struct ufs_hba *hba, struct ufshcd_lrb *lrbp, int max_timeout) { - int err = 0; - unsigned long time_left; + unsigned long time_left = msecs_to_jiffies(max_timeout); unsigned long flags; + bool pending; + int err; +retry: time_left = wait_for_completion_timeout(hba->dev_cmd.complete, - msecs_to_jiffies(max_timeout)); + time_left); /* Make sure descriptors are ready before ringing the doorbell */ wmb(); - spin_lock_irqsave(hba->host->host_lock, flags); - hba->dev_cmd.complete = NULL; if (likely(time_left)) { + /* + * The completion handler called complete() and the caller of + * this function still owns the @lrbp tag so the code below does + * not trigger any race conditions. + */ + hba->dev_cmd.complete = NULL; err = ufshcd_get_tr_ocs(lrbp); if (!err) err = ufshcd_dev_cmd_completion(hba, lrbp); - } - spin_unlock_irqrestore(hba->host->host_lock, flags); - - if (!time_left) { + } else { err = -ETIMEDOUT; dev_dbg(hba->dev, "%s: dev_cmd request timedout, tag %d\n", __func__, lrbp->task_tag); - if (!ufshcd_clear_cmd(hba, lrbp->task_tag)) + if (ufshcd_clear_cmd(hba, lrbp->task_tag) == 0) { /* successfully cleared the command, retry if needed */ err = -EAGAIN; - /* - * in case of an error, after clearing the doorbell, - * we also need to clear the outstanding_request - * field in hba - */ - ufshcd_outstanding_req_clear(hba, lrbp->task_tag); + /* + * Since clearing the command succeeded we also need to + * clear the task tag bit from the outstanding_reqs + * variable. + */ + spin_lock_irqsave(hba->host->host_lock, flags); + pending = test_bit(lrbp->task_tag, + &hba->outstanding_reqs); + if (pending) { + hba->dev_cmd.complete = NULL; + __clear_bit(lrbp->task_tag, + &hba->outstanding_reqs); + } + spin_unlock_irqrestore(hba->host->host_lock, flags); + + if (!pending) { + /* + * The completion handler ran while we tried to + * clear the command. + */ + time_left = 1; + goto retry; + } + } else { + dev_err(hba->dev, "%s: failed to clear tag %d\n", + __func__, lrbp->task_tag); + } } return err; From 694b75e0ce805e65566636aadc093478e6c20c62 Mon Sep 17 00:00:00 2001 From: Greg Kroah-Hartman Date: Tue, 14 Feb 2023 11:33:04 +0100 Subject: [PATCH 56/68] UPSTREAM: kvm: initialize all of the kvm_debugregs structure before sending it to userspace commit 2c10b61421a28e95a46ab489fd56c0f442ff6952 upstream. When calling the KVM_GET_DEBUGREGS ioctl, on some configurations, there might be some unitialized portions of the kvm_debugregs structure that could be copied to userspace. Prevent this as is done in the other kvm ioctls, by setting the whole structure to 0 before copying anything into it. Bonus is that this reduces the lines of code as the explicit flag setting and reserved space zeroing out can be removed. Bug: 276839298 Cc: Sean Christopherson Cc: Paolo Bonzini Cc: Thomas Gleixner Cc: Ingo Molnar Cc: Borislav Petkov Cc: Dave Hansen Cc: Cc: "H. Peter Anvin" Cc: stable Reported-by: Xingyuan Mo Signed-off-by: Greg Kroah-Hartman Message-Id: <20230214103304.3689213-1-gregkh@linuxfoundation.org> Tested-by: Xingyuan Mo Signed-off-by: Paolo Bonzini Signed-off-by: Greg Kroah-Hartman Signed-off-by: Lee Jones Change-Id: Iba91db0bd1b8380584f48b0ca94d8c104afcce29 --- arch/x86/kvm/x86.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c index 23d7c563e012..554d37873c25 100644 --- a/arch/x86/kvm/x86.c +++ b/arch/x86/kvm/x86.c @@ -4455,12 +4455,11 @@ static void kvm_vcpu_ioctl_x86_get_debugregs(struct kvm_vcpu *vcpu, { unsigned long val; + memset(dbgregs, 0, sizeof(*dbgregs)); memcpy(dbgregs->db, vcpu->arch.db, sizeof(vcpu->arch.db)); kvm_get_dr(vcpu, 6, &val); dbgregs->dr6 = val; dbgregs->dr7 = vcpu->arch.dr7; - dbgregs->flags = 0; - memset(&dbgregs->reserved, 0, sizeof(dbgregs->reserved)); } static int kvm_vcpu_ioctl_x86_set_debugregs(struct kvm_vcpu *vcpu, From 3641f511eed14ab04cb066e4d7bb56d82e4d1908 Mon Sep 17 00:00:00 2001 From: Udipto Goswami Date: Tue, 9 May 2023 20:18:36 +0530 Subject: [PATCH 57/68] UPSTREAM: usb: dwc3: debugfs: Resume dwc3 before accessing registers When the dwc3 device is runtime suspended, various required clocks are in disabled state and it is not guaranteed that access to any registers would work. Depending on the SoC glue, a register read could be as benign as returning 0 or be fatal enough to hang the system. In order to prevent such scenarios of fatal errors, make sure to resume dwc3 then allow the function to proceed. Fixes: 72246da40f37 ("usb: Introduce DesignWare USB3 DRD Driver") Cc: stable@vger.kernel.org #3.2: 30332eeefec8: debugfs: regset32: Add Runtime PM support Signed-off-by: Udipto Goswami Reviewed-by: Johan Hovold Tested-by: Johan Hovold Acked-by: Thinh Nguyen Link: https://lore.kernel.org/r/20230509144836.6803-1-quic_ugoswami@quicinc.com Signed-off-by: Greg Kroah-Hartman Bug: 282654910 (cherry picked from commit 614ce6a2ea50068b45339257891e51e639ac9001 usb-linus) Change-Id: Ie89d818b2d77681075cc517184ad1a5fa755dd88 Signed-off-by: Udipto Goswami --- drivers/usb/dwc3/debugfs.c | 109 +++++++++++++++++++++++++++++++++++++ 1 file changed, 109 insertions(+) diff --git a/drivers/usb/dwc3/debugfs.c b/drivers/usb/dwc3/debugfs.c index 23f4682ad104..9592875ce835 100644 --- a/drivers/usb/dwc3/debugfs.c +++ b/drivers/usb/dwc3/debugfs.c @@ -327,6 +327,11 @@ static int dwc3_lsp_show(struct seq_file *s, void *unused) unsigned int current_mode; unsigned long flags; u32 reg; + int ret; + + ret = pm_runtime_resume_and_get(dwc->dev); + if (ret < 0) + return ret; spin_lock_irqsave(&dwc->lock, flags); reg = dwc3_readl(dwc->regs, DWC3_GSTS); @@ -345,6 +350,8 @@ static int dwc3_lsp_show(struct seq_file *s, void *unused) } spin_unlock_irqrestore(&dwc->lock, flags); + pm_runtime_put_sync(dwc->dev); + return 0; } @@ -390,6 +397,11 @@ static int dwc3_mode_show(struct seq_file *s, void *unused) struct dwc3 *dwc = s->private; unsigned long flags; u32 reg; + int ret; + + ret = pm_runtime_resume_and_get(dwc->dev); + if (ret < 0) + return ret; spin_lock_irqsave(&dwc->lock, flags); reg = dwc3_readl(dwc->regs, DWC3_GCTL); @@ -409,6 +421,8 @@ static int dwc3_mode_show(struct seq_file *s, void *unused) seq_printf(s, "UNKNOWN %08x\n", DWC3_GCTL_PRTCAP(reg)); } + pm_runtime_put_sync(dwc->dev); + return 0; } @@ -458,6 +472,11 @@ static int dwc3_testmode_show(struct seq_file *s, void *unused) struct dwc3 *dwc = s->private; unsigned long flags; u32 reg; + int ret; + + ret = pm_runtime_resume_and_get(dwc->dev); + if (ret < 0) + return ret; spin_lock_irqsave(&dwc->lock, flags); reg = dwc3_readl(dwc->regs, DWC3_DCTL); @@ -488,6 +507,8 @@ static int dwc3_testmode_show(struct seq_file *s, void *unused) seq_printf(s, "UNKNOWN %d\n", reg); } + pm_runtime_put_sync(dwc->dev); + return 0; } @@ -504,6 +525,7 @@ static ssize_t dwc3_testmode_write(struct file *file, unsigned long flags; u32 testmode = 0; char buf[32]; + int ret; if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count))) return -EFAULT; @@ -521,10 +543,16 @@ static ssize_t dwc3_testmode_write(struct file *file, else testmode = 0; + ret = pm_runtime_resume_and_get(dwc->dev); + if (ret < 0) + return ret; + spin_lock_irqsave(&dwc->lock, flags); dwc3_gadget_set_test_mode(dwc, testmode); spin_unlock_irqrestore(&dwc->lock, flags); + pm_runtime_put_sync(dwc->dev); + return count; } @@ -543,12 +571,18 @@ static int dwc3_link_state_show(struct seq_file *s, void *unused) enum dwc3_link_state state; u32 reg; u8 speed; + int ret; + + ret = pm_runtime_resume_and_get(dwc->dev); + if (ret < 0) + return ret; spin_lock_irqsave(&dwc->lock, flags); reg = dwc3_readl(dwc->regs, DWC3_GSTS); if (DWC3_GSTS_CURMOD(reg) != DWC3_GSTS_CURMOD_DEVICE) { seq_puts(s, "Not available\n"); spin_unlock_irqrestore(&dwc->lock, flags); + pm_runtime_put_sync(dwc->dev); return 0; } @@ -561,6 +595,8 @@ static int dwc3_link_state_show(struct seq_file *s, void *unused) dwc3_gadget_hs_link_string(state)); spin_unlock_irqrestore(&dwc->lock, flags); + pm_runtime_put_sync(dwc->dev); + return 0; } @@ -579,6 +615,7 @@ static ssize_t dwc3_link_state_write(struct file *file, char buf[32]; u32 reg; u8 speed; + int ret; if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count))) return -EFAULT; @@ -598,10 +635,15 @@ static ssize_t dwc3_link_state_write(struct file *file, else return -EINVAL; + ret = pm_runtime_resume_and_get(dwc->dev); + if (ret < 0) + return ret; + spin_lock_irqsave(&dwc->lock, flags); reg = dwc3_readl(dwc->regs, DWC3_GSTS); if (DWC3_GSTS_CURMOD(reg) != DWC3_GSTS_CURMOD_DEVICE) { spin_unlock_irqrestore(&dwc->lock, flags); + pm_runtime_put_sync(dwc->dev); return -EINVAL; } @@ -611,12 +653,15 @@ static ssize_t dwc3_link_state_write(struct file *file, if (speed < DWC3_DSTS_SUPERSPEED && state != DWC3_LINK_STATE_RECOV) { spin_unlock_irqrestore(&dwc->lock, flags); + pm_runtime_put_sync(dwc->dev); return -EINVAL; } dwc3_gadget_set_link_state(dwc, state); spin_unlock_irqrestore(&dwc->lock, flags); + pm_runtime_put_sync(dwc->dev); + return count; } @@ -640,6 +685,11 @@ static int dwc3_tx_fifo_size_show(struct seq_file *s, void *unused) unsigned long flags; u32 mdwidth; u32 val; + int ret; + + ret = pm_runtime_resume_and_get(dwc->dev); + if (ret < 0) + return ret; spin_lock_irqsave(&dwc->lock, flags); val = dwc3_core_fifo_space(dep, DWC3_TXFIFO); @@ -652,6 +702,8 @@ static int dwc3_tx_fifo_size_show(struct seq_file *s, void *unused) seq_printf(s, "%u\n", val); spin_unlock_irqrestore(&dwc->lock, flags); + pm_runtime_put_sync(dwc->dev); + return 0; } @@ -662,6 +714,11 @@ static int dwc3_rx_fifo_size_show(struct seq_file *s, void *unused) unsigned long flags; u32 mdwidth; u32 val; + int ret; + + ret = pm_runtime_resume_and_get(dwc->dev); + if (ret < 0) + return ret; spin_lock_irqsave(&dwc->lock, flags); val = dwc3_core_fifo_space(dep, DWC3_RXFIFO); @@ -674,6 +731,8 @@ static int dwc3_rx_fifo_size_show(struct seq_file *s, void *unused) seq_printf(s, "%u\n", val); spin_unlock_irqrestore(&dwc->lock, flags); + pm_runtime_put_sync(dwc->dev); + return 0; } @@ -683,12 +742,19 @@ static int dwc3_tx_request_queue_show(struct seq_file *s, void *unused) struct dwc3 *dwc = dep->dwc; unsigned long flags; u32 val; + int ret; + + ret = pm_runtime_resume_and_get(dwc->dev); + if (ret < 0) + return ret; spin_lock_irqsave(&dwc->lock, flags); val = dwc3_core_fifo_space(dep, DWC3_TXREQQ); seq_printf(s, "%u\n", val); spin_unlock_irqrestore(&dwc->lock, flags); + pm_runtime_put_sync(dwc->dev); + return 0; } @@ -698,12 +764,19 @@ static int dwc3_rx_request_queue_show(struct seq_file *s, void *unused) struct dwc3 *dwc = dep->dwc; unsigned long flags; u32 val; + int ret; + + ret = pm_runtime_resume_and_get(dwc->dev); + if (ret < 0) + return ret; spin_lock_irqsave(&dwc->lock, flags); val = dwc3_core_fifo_space(dep, DWC3_RXREQQ); seq_printf(s, "%u\n", val); spin_unlock_irqrestore(&dwc->lock, flags); + pm_runtime_put_sync(dwc->dev); + return 0; } @@ -713,12 +786,19 @@ static int dwc3_rx_info_queue_show(struct seq_file *s, void *unused) struct dwc3 *dwc = dep->dwc; unsigned long flags; u32 val; + int ret; + + ret = pm_runtime_resume_and_get(dwc->dev); + if (ret < 0) + return ret; spin_lock_irqsave(&dwc->lock, flags); val = dwc3_core_fifo_space(dep, DWC3_RXINFOQ); seq_printf(s, "%u\n", val); spin_unlock_irqrestore(&dwc->lock, flags); + pm_runtime_put_sync(dwc->dev); + return 0; } @@ -728,12 +808,19 @@ static int dwc3_descriptor_fetch_queue_show(struct seq_file *s, void *unused) struct dwc3 *dwc = dep->dwc; unsigned long flags; u32 val; + int ret; + + ret = pm_runtime_resume_and_get(dwc->dev); + if (ret < 0) + return ret; spin_lock_irqsave(&dwc->lock, flags); val = dwc3_core_fifo_space(dep, DWC3_DESCFETCHQ); seq_printf(s, "%u\n", val); spin_unlock_irqrestore(&dwc->lock, flags); + pm_runtime_put_sync(dwc->dev); + return 0; } @@ -743,12 +830,19 @@ static int dwc3_event_queue_show(struct seq_file *s, void *unused) struct dwc3 *dwc = dep->dwc; unsigned long flags; u32 val; + int ret; + + ret = pm_runtime_resume_and_get(dwc->dev); + if (ret < 0) + return ret; spin_lock_irqsave(&dwc->lock, flags); val = dwc3_core_fifo_space(dep, DWC3_EVENTQ); seq_printf(s, "%u\n", val); spin_unlock_irqrestore(&dwc->lock, flags); + pm_runtime_put_sync(dwc->dev); + return 0; } @@ -793,6 +887,11 @@ static int dwc3_trb_ring_show(struct seq_file *s, void *unused) struct dwc3 *dwc = dep->dwc; unsigned long flags; int i; + int ret; + + ret = pm_runtime_resume_and_get(dwc->dev); + if (ret < 0) + return ret; spin_lock_irqsave(&dwc->lock, flags); if (dep->number <= 1) { @@ -822,6 +921,8 @@ static int dwc3_trb_ring_show(struct seq_file *s, void *unused) out: spin_unlock_irqrestore(&dwc->lock, flags); + pm_runtime_put_sync(dwc->dev); + return 0; } @@ -834,6 +935,11 @@ static int dwc3_ep_info_register_show(struct seq_file *s, void *unused) u32 lower_32_bits; u32 upper_32_bits; u32 reg; + int ret; + + ret = pm_runtime_resume_and_get(dwc->dev); + if (ret < 0) + return ret; spin_lock_irqsave(&dwc->lock, flags); reg = DWC3_GDBGLSPMUX_EPSELECT(dep->number); @@ -846,6 +952,8 @@ static int dwc3_ep_info_register_show(struct seq_file *s, void *unused) seq_printf(s, "0x%016llx\n", ep_info); spin_unlock_irqrestore(&dwc->lock, flags); + pm_runtime_put_sync(dwc->dev); + return 0; } @@ -907,6 +1015,7 @@ void dwc3_debugfs_init(struct dwc3 *dwc) dwc->regset->regs = dwc3_regs; dwc->regset->nregs = ARRAY_SIZE(dwc3_regs); dwc->regset->base = dwc->regs - DWC3_GLOBALS_REGS_START; + dwc->regset->dev = dwc->dev; root = debugfs_create_dir(dev_name(dwc->dev), usb_debug_root); dwc->root = root; From c28be8ff1dd3084e9e1831add480a884ce4182e5 Mon Sep 17 00:00:00 2001 From: tanghuan Date: Tue, 16 May 2023 17:28:21 +0800 Subject: [PATCH 58/68] BACKPORT: scsi: ufs: Fix device management cmd timeout flow In the UFS error handling flow, the host will send a device management cmd(NOP OUT) to the device for link recovery. If this cmd times out and clearing the doorbell fails, ufshcd_wait_for_dev_cmd() will do nothing andreturn. hba->dev_cmd.complete struct is not set to NULL. When this happens, if cmd has been completed by device, then we will call complete() in __ufshcd_transfer_req_compl(). Because the complete struct is allocated on the stack, the following crash will occur: ipanic_die+0x24/0x38 [mrdump] die+0x344/0x748 arm64_notify_die+0x44/0x104 do_debug_exception+0x104/0x1e0 el1_dbg+0x38/0x54 el1_sync_handler+0x40/0x88 el1_sync+0x8c/0x140 queued_spin_lock_slowpath+0x2e4/0x3c0 __ufshcd_transfer_req_compl+0x3b0/0x1164 ufshcd_trc_handler+0x15c/0x308 ufshcd_host_reset_and_restore+0x54/0x260 ufshcd_reset_and_restore+0x28c/0x57c ufshcd_err_handler+0xeb8/0x1b6c process_one_work+0x288/0x964 worker_thread+0x4bc/0xc7c kthread+0x15c/0x264 ret_from_fork+0x10/0x30 Bug:280957963 Change-Id: I1529c332847ace10bf4a6f8c1ec10ea2eb1eea6a (cherry picked from commit 36822124f9de200cedc2f42516301b50d386a6cd) Link: https://lore.kernel.org/r/20221216032532.1280-1-mason.zhang@mediatek.com Signed-off-by: Mason Zhang Reviewed-by: Bart Van Assche Signed-off-by: Martin K. Petersen Signed-off-by: tanghuan --- drivers/scsi/ufs/ufshcd.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c index 625ea25580da..a42e4e96a964 100644 --- a/drivers/scsi/ufs/ufshcd.c +++ b/drivers/scsi/ufs/ufshcd.c @@ -2926,6 +2926,21 @@ retry: } else { dev_err(hba->dev, "%s: failed to clear tag %d\n", __func__, lrbp->task_tag); + spin_lock_irqsave(hba->host->host_lock, flags); + pending = test_bit(lrbp->task_tag, + &hba->outstanding_reqs); + if (pending) + hba->dev_cmd.complete = NULL; + spin_unlock_irqrestore(hba->host->host_lock, flags); + + if (!pending) { + /* + * The completion handler ran while we tried to + * clear the command. + */ + time_left = 1; + goto retry; + } } } From 97aa93c23f62dff5896c6b1b160c353abfb2be71 Mon Sep 17 00:00:00 2001 From: Suren Baghdasaryan Date: Wed, 28 Dec 2022 18:46:51 -0800 Subject: [PATCH 59/68] ANDROID: uid_sys_stats: defer process_notifier work if uid_lock is contended process_notifier() is called every time a process exits. When multiple processes exit roughly at the same time, the uid_lock taken from inside of process_notifier() will create contention which slows down process exit. Defer stats accounting in such case to avoid lock contention. Bug: 261537194 Change-Id: Ia1e9a451eab39eb0dda7eb175bfd71c67f3e0a58 Signed-off-by: Suren Baghdasaryan (cherry picked from commit 5d96c24be923d9011762de19bcfbade68b103759) --- drivers/misc/uid_sys_stats.c | 112 ++++++++++++++++++++++++++++------- 1 file changed, 90 insertions(+), 22 deletions(-) diff --git a/drivers/misc/uid_sys_stats.c b/drivers/misc/uid_sys_stats.c index 47336700f687..985e7b02ab3c 100644 --- a/drivers/misc/uid_sys_stats.c +++ b/drivers/misc/uid_sys_stats.c @@ -77,12 +77,12 @@ struct uid_entry { #endif }; -static u64 compute_write_bytes(struct task_struct *task) +static u64 compute_write_bytes(struct task_io_accounting *ioac) { - if (task->ioac.write_bytes <= task->ioac.cancelled_write_bytes) + if (ioac->write_bytes <= ioac->cancelled_write_bytes) return 0; - return task->ioac.write_bytes - task->ioac.cancelled_write_bytes; + return ioac->write_bytes - ioac->cancelled_write_bytes; } static void compute_io_bucket_stats(struct io_stats *io_bucket, @@ -239,17 +239,16 @@ static void set_io_uid_tasks_zero(struct uid_entry *uid_entry) } } -static void add_uid_tasks_io_stats(struct uid_entry *uid_entry, - struct task_struct *task, int slot) +static void add_uid_tasks_io_stats(struct task_entry *task_entry, + struct task_io_accounting *ioac, int slot) { - struct task_entry *task_entry = find_or_register_task(uid_entry, task); struct io_stats *task_io_slot = &task_entry->io[slot]; - task_io_slot->read_bytes += task->ioac.read_bytes; - task_io_slot->write_bytes += compute_write_bytes(task); - task_io_slot->rchar += task->ioac.rchar; - task_io_slot->wchar += task->ioac.wchar; - task_io_slot->fsync += task->ioac.syscfs; + task_io_slot->read_bytes += ioac->read_bytes; + task_io_slot->write_bytes += compute_write_bytes(ioac); + task_io_slot->rchar += ioac->rchar; + task_io_slot->wchar += ioac->wchar; + task_io_slot->fsync += ioac->syscfs; } static void compute_io_uid_tasks(struct uid_entry *uid_entry) @@ -290,8 +289,6 @@ static void show_io_uid_tasks(struct seq_file *m, struct uid_entry *uid_entry) #else static void remove_uid_tasks(struct uid_entry *uid_entry) {}; static void set_io_uid_tasks_zero(struct uid_entry *uid_entry) {}; -static void add_uid_tasks_io_stats(struct uid_entry *uid_entry, - struct task_struct *task, int slot) {}; static void compute_io_uid_tasks(struct uid_entry *uid_entry) {}; static void show_io_uid_tasks(struct seq_file *m, struct uid_entry *uid_entry) {} @@ -446,23 +443,32 @@ static const struct proc_ops uid_remove_fops = { .proc_write = uid_remove_write, }; +static void __add_uid_io_stats(struct uid_entry *uid_entry, + struct task_io_accounting *ioac, int slot) +{ + struct io_stats *io_slot = &uid_entry->io[slot]; + + io_slot->read_bytes += ioac->read_bytes; + io_slot->write_bytes += compute_write_bytes(ioac); + io_slot->rchar += ioac->rchar; + io_slot->wchar += ioac->wchar; + io_slot->fsync += ioac->syscfs; +} static void add_uid_io_stats(struct uid_entry *uid_entry, struct task_struct *task, int slot) { - struct io_stats *io_slot = &uid_entry->io[slot]; + struct task_entry *task_entry __maybe_unused; /* avoid double accounting of dying threads */ if (slot != UID_STATE_DEAD_TASKS && (task->flags & PF_EXITING)) return; - io_slot->read_bytes += task->ioac.read_bytes; - io_slot->write_bytes += compute_write_bytes(task); - io_slot->rchar += task->ioac.rchar; - io_slot->wchar += task->ioac.wchar; - io_slot->fsync += task->ioac.syscfs; - - add_uid_tasks_io_stats(uid_entry, task, slot); +#ifdef CONFIG_UID_SYS_STATS_DEBUG + task_entry = find_or_register_task(uid_entry, task); + add_uid_tasks_io_stats(task_entry, &task->ioac, slot); +#endif + __add_uid_io_stats(uid_entry, &task->ioac, slot); } static void update_io_stats_all_locked(void) @@ -622,6 +628,48 @@ static const struct proc_ops uid_procstat_fops = { .proc_write = uid_procstat_write, }; +struct update_stats_work { + struct work_struct work; + uid_t uid; +#ifdef CONFIG_UID_SYS_STATS_DEBUG + struct task_struct *task; +#endif + struct task_io_accounting ioac; + u64 utime; + u64 stime; +}; + +static void update_stats_workfn(struct work_struct *work) +{ + struct update_stats_work *usw = + container_of(work, struct update_stats_work, work); + struct uid_entry *uid_entry; + struct task_entry *task_entry __maybe_unused; + + rt_mutex_lock(&uid_lock); + uid_entry = find_uid_entry(usw->uid); + if (!uid_entry) + goto exit; + + uid_entry->utime += usw->utime; + uid_entry->stime += usw->stime; + +#ifdef CONFIG_UID_SYS_STATS_DEBUG + task_entry = find_task_entry(uid_entry, usw->task); + if (!task_entry) + goto exit; + add_uid_tasks_io_stats(task_entry, &usw->ioac, + UID_STATE_DEAD_TASKS); +#endif + __add_uid_io_stats(uid_entry, &usw->ioac, UID_STATE_DEAD_TASKS); +exit: + rt_mutex_unlock(&uid_lock); +#ifdef CONFIG_UID_SYS_STATS_DEBUG + put_task_struct(usw->task); +#endif + kfree(usw); +} + static int process_notifier(struct notifier_block *self, unsigned long cmd, void *v) { @@ -633,8 +681,28 @@ static int process_notifier(struct notifier_block *self, if (!task) return NOTIFY_OK; - rt_mutex_lock(&uid_lock); uid = from_kuid_munged(current_user_ns(), task_uid(task)); + if (!rt_mutex_trylock(&uid_lock)) { + struct update_stats_work *usw; + + usw = kmalloc(sizeof(struct update_stats_work), GFP_KERNEL); + if (usw) { + INIT_WORK(&usw->work, update_stats_workfn); + usw->uid = uid; +#ifdef CONFIG_UID_SYS_STATS_DEBUG + usw->task = get_task_struct(task); +#endif + /* + * Copy task->ioac since task might be destroyed before + * the work is later performed. + */ + usw->ioac = task->ioac; + task_cputime_adjusted(task, &usw->utime, &usw->stime); + schedule_work(&usw->work); + } + return NOTIFY_OK; + } + uid_entry = find_or_register_uid(uid); if (!uid_entry) { pr_err("%s: failed to find uid %d\n", __func__, uid); From 9d8c9d868ed9b83913fa5cc890648d5c43c42f2a Mon Sep 17 00:00:00 2001 From: Theodore Ts'o Date: Sun, 30 Apr 2023 03:04:13 -0400 Subject: [PATCH 60/68] UPSTREAM: ext4: fix invalid free tracking in ext4_xattr_move_to_block() commit b87c7cdf2bed4928b899e1ce91ef0d147017ba45 upstream. In ext4_xattr_move_to_block(), the value of the extended attribute which we need to move to an external block may be allocated by kvmalloc() if the value is stored in an external inode. So at the end of the function the code tried to check if this was the case by testing entry->e_value_inum. However, at this point, the pointer to the xattr entry is no longer valid, because it was removed from the original location where it had been stored. So we could end up calling kvfree() on a pointer which was not allocated by kvmalloc(); or we could also potentially leak memory by not freeing the buffer when it should be freed. Fix this by storing whether it should be freed in a separate variable. Cc: stable@kernel.org Link: https://lore.kernel.org/r/20230430160426.581366-1-tytso@mit.edu Link: https://syzkaller.appspot.com/bug?id=5c2aee8256e30b55ccf57312c16d88417adbd5e1 Link: https://syzkaller.appspot.com/bug?id=41a6b5d4917c0412eb3b3c3c604965bed7d7420b Reported-by: syzbot+64b645917ce07d89bde5@syzkaller.appspotmail.com Reported-by: syzbot+0d042627c4f2ad332195@syzkaller.appspotmail.com Signed-off-by: Theodore Ts'o Signed-off-by: Greg Kroah-Hartman Bug: 281332515 Bug: 281333738 Change-Id: Id1fbcc337821d66df53c2826bf3158963f8b0673 Signed-off-by: Tudor Ambarus --- fs/ext4/xattr.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/fs/ext4/xattr.c b/fs/ext4/xattr.c index 6fee044fd158..36461b86bd39 100644 --- a/fs/ext4/xattr.c +++ b/fs/ext4/xattr.c @@ -2543,6 +2543,7 @@ static int ext4_xattr_move_to_block(handle_t *handle, struct inode *inode, .in_inode = !!entry->e_value_inum, }; struct ext4_xattr_ibody_header *header = IHDR(inode, raw_inode); + int needs_kvfree = 0; int error; is = kzalloc(sizeof(struct ext4_xattr_ibody_find), GFP_NOFS); @@ -2565,7 +2566,7 @@ static int ext4_xattr_move_to_block(handle_t *handle, struct inode *inode, error = -ENOMEM; goto out; } - + needs_kvfree = 1; error = ext4_xattr_inode_get(inode, entry, buffer, value_size); if (error) goto out; @@ -2604,7 +2605,7 @@ static int ext4_xattr_move_to_block(handle_t *handle, struct inode *inode, out: kfree(b_entry_name); - if (entry->e_value_inum && buffer) + if (needs_kvfree && buffer) kvfree(buffer); if (is) brelse(is->iloc.bh); From f03258701de3b1fcb07edeee252d8cd9fe2f9793 Mon Sep 17 00:00:00 2001 From: Seiya Wang Date: Fri, 19 May 2023 10:09:24 +0800 Subject: [PATCH 61/68] ANDROID: GKI: Update symbol list for mtk 3 Added functions: [A] 'function int pci_prepare_to_sleep(pci_dev*)' [A] 'function void phy_ethtool_get_wol(phy_device*, ethtool_wolinfo*)' [A] 'function void phy_support_asym_pause(phy_device*)' Bug: 283291448 Signed-off-by: Seiya Wang Change-Id: I73c677c32326f7ab5db7b7cd1c11d3e7311444ab --- android/abi_gki_aarch64.xml | 232 +++++++++++++++++++----------------- android/abi_gki_aarch64_mtk | 3 + 2 files changed, 127 insertions(+), 108 deletions(-) diff --git a/android/abi_gki_aarch64.xml b/android/abi_gki_aarch64.xml index 94f6ea7547dc..7fd62874c6b4 100644 --- a/android/abi_gki_aarch64.xml +++ b/android/abi_gki_aarch64.xml @@ -4076,6 +4076,7 @@ + @@ -4165,6 +4166,7 @@ + @@ -4211,6 +4213,7 @@ + @@ -130848,10 +130851,10 @@ - - - - + + + + @@ -138932,6 +138935,10 @@ + + + + @@ -139380,6 +139387,11 @@ + + + + + @@ -139613,6 +139625,10 @@ + + + + @@ -147192,28 +147208,28 @@ - - - + + + - - - + + + - - - + + + - - - + + + - - + + @@ -147221,19 +147237,19 @@ - - - - - + + + + + - - - - - - + + + + + + @@ -147243,13 +147259,13 @@ - - - + + + - - + + @@ -147258,31 +147274,31 @@ - - + + - - + + - - - + + + - - + + - - + + - - - - + + + + @@ -147314,91 +147330,91 @@ - - - - - - - + + + + + + + - - - - - - - + + + + + + + - - - - - - - - + + + + + + + + - - - - - - + + + + + + - - - - - - + + + + + + - - - - - - - + + + + + + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - - - + + + + diff --git a/android/abi_gki_aarch64_mtk b/android/abi_gki_aarch64_mtk index 2ac7b11faf77..c27c6a7df54b 100644 --- a/android/abi_gki_aarch64_mtk +++ b/android/abi_gki_aarch64_mtk @@ -1478,6 +1478,7 @@ pci_generic_config_write32 pci_lock_rescan_remove pci_pio_to_address + pci_prepare_to_sleep pci_unlock_rescan_remove PDE_DATA __per_cpu_offset @@ -1499,6 +1500,7 @@ phy_drivers_register phy_drivers_unregister phy_ethtool_get_link_ksettings + phy_ethtool_get_wol phy_ethtool_nway_reset phy_ethtool_set_link_ksettings phy_exit @@ -1518,6 +1520,7 @@ phy_set_mode_ext phy_start phy_stop + phy_support_asym_pause phy_write_paged pid_task pinconf_generic_parse_dt_config From 64c7044d39e4cff7882aa8e2c7c72f624cec9445 Mon Sep 17 00:00:00 2001 From: Peifeng Li Date: Mon, 8 May 2023 14:52:00 +0800 Subject: [PATCH 62/68] ANDROID: vendor_hook: add hooks in dm_bufio.c 1. android_vh_dm_bufio_shrink_scan_bypass To adjust dm_bufio-buffer shrinker's policy in some cases. 2. cleanup_old_buffers_bypass To adjust the policy of dm_bufio-buffer periodic eviction in some cases. Bug: 281467813 Signed-off-by: Peifeng Li Change-Id: I29a9d91d18d2e279170533db83b59cfc3b17ebe2 --- drivers/android/vendor_hooks.c | 2 ++ drivers/md/dm-bufio.c | 17 +++++++++++++++++ include/trace/hooks/mm.h | 8 ++++++++ 3 files changed, 27 insertions(+) diff --git a/drivers/android/vendor_hooks.c b/drivers/android/vendor_hooks.c index 5702bf54e0e6..2ce349294f3d 100644 --- a/drivers/android/vendor_hooks.c +++ b/drivers/android/vendor_hooks.c @@ -275,6 +275,8 @@ EXPORT_TRACEPOINT_SYMBOL_GPL(android_vh_commit_creds); EXPORT_TRACEPOINT_SYMBOL_GPL(android_vh_exit_creds); EXPORT_TRACEPOINT_SYMBOL_GPL(android_vh_override_creds); EXPORT_TRACEPOINT_SYMBOL_GPL(android_vh_revert_creds); +EXPORT_TRACEPOINT_SYMBOL_GPL(android_vh_dm_bufio_shrink_scan_bypass); +EXPORT_TRACEPOINT_SYMBOL_GPL(android_vh_cleanup_old_buffers_bypass); EXPORT_TRACEPOINT_SYMBOL_GPL(android_vh_record_mutex_lock_starttime); EXPORT_TRACEPOINT_SYMBOL_GPL(android_vh_record_rtmutex_lock_starttime); EXPORT_TRACEPOINT_SYMBOL_GPL(android_vh_record_rwsem_lock_starttime); diff --git a/drivers/md/dm-bufio.c b/drivers/md/dm-bufio.c index 50f3e673729c..bb0e3ddde093 100644 --- a/drivers/md/dm-bufio.c +++ b/drivers/md/dm-bufio.c @@ -19,6 +19,8 @@ #include #include +#include + #define DM_MSG_PREFIX "bufio" /* @@ -1683,6 +1685,13 @@ static void shrink_work(struct work_struct *w) static unsigned long dm_bufio_shrink_scan(struct shrinker *shrink, struct shrink_control *sc) { struct dm_bufio_client *c; + bool bypass = false; + + trace_android_vh_dm_bufio_shrink_scan_bypass( + dm_bufio_current_allocated, + &bypass); + if (bypass) + return 0; c = container_of(shrink, struct dm_bufio_client, shrinker); atomic_long_add(sc->nr_to_scan, &c->need_shrink); @@ -2009,6 +2018,14 @@ static void cleanup_old_buffers(void) { unsigned long max_age_hz = get_max_age_hz(); struct dm_bufio_client *c; + bool bypass = false; + + trace_android_vh_cleanup_old_buffers_bypass( + dm_bufio_current_allocated, + &max_age_hz, + &bypass); + if (bypass) + return; mutex_lock(&dm_bufio_clients_lock); diff --git a/include/trace/hooks/mm.h b/include/trace/hooks/mm.h index a4b855e0a81a..8fecbc8b3d5b 100644 --- a/include/trace/hooks/mm.h +++ b/include/trace/hooks/mm.h @@ -126,6 +126,14 @@ DECLARE_HOOK(android_vh_save_track_hash, DECLARE_HOOK(android_vh_vmpressure, TP_PROTO(struct mem_cgroup *memcg, bool *bypass), TP_ARGS(memcg, bypass)); +DECLARE_HOOK(android_vh_dm_bufio_shrink_scan_bypass, + TP_PROTO(unsigned long dm_bufio_current_allocated, bool *bypass), + TP_ARGS(dm_bufio_current_allocated, bypass)); +DECLARE_HOOK(android_vh_cleanup_old_buffers_bypass, + TP_PROTO(unsigned long dm_bufio_current_allocated, + unsigned long *max_age_hz, + bool *bypass), + TP_ARGS(dm_bufio_current_allocated, max_age_hz, bypass)); DECLARE_HOOK(android_vh_mem_cgroup_alloc, TP_PROTO(struct mem_cgroup *memcg), TP_ARGS(memcg)); From f60101a030a87da7f9193358ac6c9a386de761de Mon Sep 17 00:00:00 2001 From: Peifeng Li Date: Tue, 23 May 2023 09:29:29 +0800 Subject: [PATCH 63/68] ANDROID: GKI: Update symbols to symbol list Leaf changes summary: 4 artifacts changed Changed leaf types summary: 0 leaf type changed Removed/Changed/Added functions summary: 0 Removed, 0 Changed, 2 Added functions Removed/Changed/Added variables summary: 0 Removed, 0 Changed, 2 Added variables 2 Added functions: [A] 'function int __traceiter_android_vh_cleanup_old_buffers_bypass(void*, unsigned long int, unsigned long int*, bool*)' [A] 'function int __traceiter_android_vh_dm_bufio_shrink_scan_bypass(void*, unsigned long int, bool*)' 2 Added variables: [A] 'tracepoint __tracepoint_android_vh_cleanup_old_buffers_bypass' [A] 'tracepoint __tracepoint_android_vh_dm_bufio_shrink_scan_bypass' Bug: 281467813 Signed-off-by: Peifeng Li Change-Id: I804fcea959bc982934002056e09aaabe26ac1ea0 --- android/abi_gki_aarch64.xml | 631 +++++++++++++++++----------------- android/abi_gki_aarch64_oplus | 4 + 2 files changed, 329 insertions(+), 306 deletions(-) diff --git a/android/abi_gki_aarch64.xml b/android/abi_gki_aarch64.xml index 7fd62874c6b4..736c2e117d48 100644 --- a/android/abi_gki_aarch64.xml +++ b/android/abi_gki_aarch64.xml @@ -464,6 +464,7 @@ + @@ -485,6 +486,7 @@ + @@ -6518,6 +6520,7 @@ + @@ -6539,6 +6542,7 @@ + @@ -116456,9 +116460,9 @@ - + - + @@ -118215,17 +118219,17 @@ - - - - + + + + - - - - - + + + + + @@ -118406,12 +118410,12 @@ - - - - - - + + + + + + @@ -118492,19 +118496,19 @@ - - - - - + + + + + - - - - - - + + + + + + @@ -118516,10 +118520,10 @@ - - - - + + + + @@ -118932,10 +118936,10 @@ - - - - + + + + @@ -118945,11 +118949,11 @@ - - - - - + + + + + @@ -118976,22 +118980,22 @@ - - - - - - - + + + + + + + - - - - - - - + + + + + + + @@ -119008,17 +119012,17 @@ - - - - + + + + - - - - - + + + + + @@ -119272,6 +119276,13 @@ + + + + + + + @@ -119299,10 +119310,10 @@ - - - - + + + + @@ -119311,27 +119322,27 @@ - - - + + + - - - + + + - - - - - + + + + + - - - - + + + + @@ -119391,11 +119402,11 @@ - - - - - + + + + + @@ -119404,6 +119415,12 @@ + + + + + + @@ -119411,12 +119428,12 @@ - - - - - - + + + + + + @@ -119426,9 +119443,9 @@ - - - + + + @@ -119437,22 +119454,22 @@ - - - - - - - - + + + + + + + + - - - - - - + + + + + + @@ -119533,17 +119550,17 @@ - - - - + + + + - - - - - + + + + + @@ -119651,12 +119668,12 @@ - - - - - - + + + + + + @@ -119675,10 +119692,10 @@ - - - - + + + + @@ -119703,10 +119720,10 @@ - - - - + + + + @@ -119786,11 +119803,11 @@ - - - - - + + + + + @@ -119805,24 +119822,24 @@ - - - - - - + + + + + + - - - - + + + + - - - - + + + + @@ -119835,9 +119852,9 @@ - - - + + + @@ -119847,31 +119864,31 @@ - - - + + + - - - - + + + + - - - - + + + + - - - + + + - - - + + + @@ -119879,10 +119896,10 @@ - - - - + + + + @@ -119895,10 +119912,10 @@ - - - - + + + + @@ -119989,10 +120006,10 @@ - - - - + + + + @@ -120003,17 +120020,17 @@ - - - - - + + + + + - - - - + + + + @@ -120041,10 +120058,10 @@ - - - - + + + + @@ -120080,10 +120097,10 @@ - - - - + + + + @@ -120110,9 +120127,9 @@ - - - + + + @@ -120360,9 +120377,9 @@ - - - + + + @@ -120391,9 +120408,9 @@ - - - + + + @@ -120440,10 +120457,10 @@ - - - - + + + + @@ -120469,22 +120486,22 @@ - - - - - + + + + + - - - + + + - - - - + + + + @@ -120499,9 +120516,9 @@ - - - + + + @@ -120534,12 +120551,12 @@ - - - - - - + + + + + + @@ -120661,19 +120678,19 @@ - - - - + + + + - - - - - - - + + + + + + + @@ -120724,9 +120741,9 @@ - - - + + + @@ -121166,8 +121183,8 @@ - - + + @@ -121194,7 +121211,7 @@ - + @@ -121207,10 +121224,10 @@ - - + + - + @@ -121276,18 +121293,18 @@ - + - + - - + + - - + + @@ -121325,16 +121342,17 @@ + - + - - - - + + + + @@ -121344,15 +121362,16 @@ - + + - + - + - - + + @@ -121365,8 +121384,8 @@ - - + + @@ -121384,15 +121403,15 @@ - + - + - + @@ -121405,24 +121424,24 @@ - + - - - + + + - + - - - - - + + + + + - + - + @@ -121438,27 +121457,27 @@ - + - - + + - + - + - + @@ -121502,12 +121521,12 @@ - + - + @@ -121515,23 +121534,23 @@ - + - - - + + + - + - + @@ -121550,8 +121569,8 @@ - - + + @@ -121559,7 +121578,7 @@ - + diff --git a/android/abi_gki_aarch64_oplus b/android/abi_gki_aarch64_oplus index 9544ea84c8f1..bd21cf7d3005 100644 --- a/android/abi_gki_aarch64_oplus +++ b/android/abi_gki_aarch64_oplus @@ -2793,6 +2793,7 @@ __traceiter_android_vh_clear_mask_adjust __traceiter_android_vh_clear_reserved_fmt_fields __traceiter_android_vh_cma_drain_all_pages_bypass + __traceiter_android_vh_cleanup_old_buffers_bypass __traceiter_android_vh_commit_creds __traceiter_android_vh_cpufreq_acct_update_power __traceiter_android_vh_cpufreq_fast_switch @@ -2806,6 +2807,7 @@ __traceiter_android_vh_do_page_trylock __traceiter_android_vh_do_send_sig_info __traceiter_android_vh_do_traversal_lruvec + __traceiter_android_vh_dm_bufio_shrink_scan_bypass __traceiter_android_vh_drain_all_pages_bypass __traceiter_android_vh_em_cpu_energy __traceiter_android_vh_exclude_reserved_zone @@ -3047,6 +3049,7 @@ __tracepoint_android_vh_clear_mask_adjust __tracepoint_android_vh_clear_reserved_fmt_fields __tracepoint_android_vh_cma_drain_all_pages_bypass + __tracepoint_android_vh_cleanup_old_buffers_bypass __tracepoint_android_vh_commit_creds __tracepoint_android_vh_cpufreq_acct_update_power __tracepoint_android_vh_cpufreq_fast_switch @@ -3056,6 +3059,7 @@ __tracepoint_android_vh_cpu_idle_exit __tracepoint_android_vh_cpu_up __tracepoint_android_vh_del_page_from_lrulist + __tracepoint_android_vh_dm_bufio_shrink_scan_bypass __tracepoint_android_vh_do_futex __tracepoint_android_vh_do_page_trylock __tracepoint_android_vh_do_send_sig_info From 948b2a120560fe65be16202edf43744e33a61928 Mon Sep 17 00:00:00 2001 From: Tudor Ambarus Date: Thu, 4 May 2023 12:15:25 +0000 Subject: [PATCH 64/68] UPSTREAM: ext4: avoid a potential slab-out-of-bounds in ext4_group_desc_csum commit 4f04351888a83e595571de672e0a4a8b74f4fb31 upstream. When modifying the block device while it is mounted by the filesystem, syzbot reported the following: BUG: KASAN: slab-out-of-bounds in crc16+0x206/0x280 lib/crc16.c:58 Read of size 1 at addr ffff888075f5c0a8 by task syz-executor.2/15586 CPU: 1 PID: 15586 Comm: syz-executor.2 Not tainted 6.2.0-rc5-syzkaller-00205-gc96618275234 #0 Hardware name: Google Google Compute Engine/Google Compute Engine, BIOS Google 01/12/2023 Call Trace: __dump_stack lib/dump_stack.c:88 [inline] dump_stack_lvl+0x1b1/0x290 lib/dump_stack.c:106 print_address_description+0x74/0x340 mm/kasan/report.c:306 print_report+0x107/0x1f0 mm/kasan/report.c:417 kasan_report+0xcd/0x100 mm/kasan/report.c:517 crc16+0x206/0x280 lib/crc16.c:58 ext4_group_desc_csum+0x81b/0xb20 fs/ext4/super.c:3187 ext4_group_desc_csum_set+0x195/0x230 fs/ext4/super.c:3210 ext4_mb_clear_bb fs/ext4/mballoc.c:6027 [inline] ext4_free_blocks+0x191a/0x2810 fs/ext4/mballoc.c:6173 ext4_remove_blocks fs/ext4/extents.c:2527 [inline] ext4_ext_rm_leaf fs/ext4/extents.c:2710 [inline] ext4_ext_remove_space+0x24ef/0x46a0 fs/ext4/extents.c:2958 ext4_ext_truncate+0x177/0x220 fs/ext4/extents.c:4416 ext4_truncate+0xa6a/0xea0 fs/ext4/inode.c:4342 ext4_setattr+0x10c8/0x1930 fs/ext4/inode.c:5622 notify_change+0xe50/0x1100 fs/attr.c:482 do_truncate+0x200/0x2f0 fs/open.c:65 handle_truncate fs/namei.c:3216 [inline] do_open fs/namei.c:3561 [inline] path_openat+0x272b/0x2dd0 fs/namei.c:3714 do_filp_open+0x264/0x4f0 fs/namei.c:3741 do_sys_openat2+0x124/0x4e0 fs/open.c:1310 do_sys_open fs/open.c:1326 [inline] __do_sys_creat fs/open.c:1402 [inline] __se_sys_creat fs/open.c:1396 [inline] __x64_sys_creat+0x11f/0x160 fs/open.c:1396 do_syscall_x64 arch/x86/entry/common.c:50 [inline] do_syscall_64+0x3d/0xb0 arch/x86/entry/common.c:80 entry_SYSCALL_64_after_hwframe+0x63/0xcd RIP: 0033:0x7f72f8a8c0c9 Code: 28 00 00 00 75 05 48 83 c4 28 c3 e8 f1 19 00 00 90 48 89 f8 48 89 f7 48 89 d6 48 89 ca 4d 89 c2 4d 89 c8 4c 8b 4c 24 08 0f 05 <48> 3d 01 f0 ff ff 73 01 c3 48 c7 c1 b8 ff ff ff f7 d8 64 89 01 48 RSP: 002b:00007f72f97e3168 EFLAGS: 00000246 ORIG_RAX: 0000000000000055 RAX: ffffffffffffffda RBX: 00007f72f8bac050 RCX: 00007f72f8a8c0c9 RDX: 0000000000000000 RSI: 0000000000000000 RDI: 0000000020000280 RBP: 00007f72f8ae7ae9 R08: 0000000000000000 R09: 0000000000000000 R10: 0000000000000000 R11: 0000000000000246 R12: 0000000000000000 R13: 00007ffd165348bf R14: 00007f72f97e3300 R15: 0000000000022000 Replace le16_to_cpu(sbi->s_es->s_desc_size) with sbi->s_desc_size It reduces ext4's compiled text size, and makes the code more efficient (we remove an extra indirect reference and a potential byte swap on big endian systems), and there is no downside. It also avoids the potential KASAN / syzkaller failure, as a bonus. Reported-by: syzbot+fc51227e7100c9294894@syzkaller.appspotmail.com Reported-by: syzbot+8785e41224a3afd04321@syzkaller.appspotmail.com Link: https://syzkaller.appspot.com/bug?id=70d28d11ab14bd7938f3e088365252aa923cff42 Link: https://syzkaller.appspot.com/bug?id=b85721b38583ecc6b5e72ff524c67302abbc30f3 Link: https://lore.kernel.org/all/000000000000ece18705f3b20934@google.com/ Fixes: 717d50e4971b ("Ext4: Uninitialized Block Groups") Cc: stable@vger.kernel.org Signed-off-by: Tudor Ambarus Link: https://lore.kernel.org/r/20230504121525.3275886-1-tudor.ambarus@linaro.org Signed-off-by: Theodore Ts'o Signed-off-by: Greg Kroah-Hartman Bug: 269155298 Bug: 270466805 Change-Id: Id14192ab0905c36e154d07d461afb56af7b61488 Signed-off-by: Tudor Ambarus --- fs/ext4/super.c | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/fs/ext4/super.c b/fs/ext4/super.c index 10b9b4421b7f..4bd045296ebf 100644 --- a/fs/ext4/super.c +++ b/fs/ext4/super.c @@ -2831,11 +2831,9 @@ static __le16 ext4_group_desc_csum(struct super_block *sb, __u32 block_group, crc = crc16(crc, (__u8 *)gdp, offset); offset += sizeof(gdp->bg_checksum); /* skip checksum */ /* for checksum of struct ext4_group_desc do the rest...*/ - if (ext4_has_feature_64bit(sb) && - offset < le16_to_cpu(sbi->s_es->s_desc_size)) + if (ext4_has_feature_64bit(sb) && offset < sbi->s_desc_size) crc = crc16(crc, (__u8 *)gdp + offset, - le16_to_cpu(sbi->s_es->s_desc_size) - - offset); + sbi->s_desc_size - offset); out: return cpu_to_le16(crc); From f27e7efdc69fce98455bde3929fb17a064216b49 Mon Sep 17 00:00:00 2001 From: Udipto Goswami Date: Thu, 23 Mar 2023 18:43:15 +0530 Subject: [PATCH 65/68] FROMLIST: usb: xhci: Remove unused udev from xhci_log_ctx trace event xhci_log_ctx event is not utilizing the extracted udev to print out anything, hence removing it. Fixes: 1d27fabec068 ("xhci: add xhci_address_ctx trace event") Signed-off-by: Udipto Goswami Bug: 278637066 Bug: 283906700 Link: https://lore.kernel.org/all/20230323131315.21764-1-quic_ugoswami@quicinc.com/ Change-Id: I359a050ff411ede5bc2c3ba1d1d68550773fa0a6 Signed-off-by: Udipto Goswami (cherry picked from commit d3e95905cee3c94c0d16f392c2e8e7b475540d0e) --- drivers/usb/host/xhci-trace.h | 4 ---- 1 file changed, 4 deletions(-) diff --git a/drivers/usb/host/xhci-trace.h b/drivers/usb/host/xhci-trace.h index a5da02077297..5daf41ba80a5 100644 --- a/drivers/usb/host/xhci-trace.h +++ b/drivers/usb/host/xhci-trace.h @@ -80,20 +80,16 @@ DECLARE_EVENT_CLASS(xhci_log_ctx, __field(dma_addr_t, ctx_dma) __field(u8 *, ctx_va) __field(unsigned, ctx_ep_num) - __field(int, slot_id) __dynamic_array(u32, ctx_data, ((HCC_64BYTE_CONTEXT(xhci->hcc_params) + 1) * 8) * ((ctx->type == XHCI_CTX_TYPE_INPUT) + ep_num + 1)) ), TP_fast_assign( - struct usb_device *udev; - udev = to_usb_device(xhci_to_hcd(xhci)->self.controller); __entry->ctx_64 = HCC_64BYTE_CONTEXT(xhci->hcc_params); __entry->ctx_type = ctx->type; __entry->ctx_dma = ctx->dma; __entry->ctx_va = ctx->bytes; - __entry->slot_id = udev->slot_id; __entry->ctx_ep_num = ep_num; memcpy(__get_dynamic_array(ctx_data), ctx->bytes, ((HCC_64BYTE_CONTEXT(xhci->hcc_params) + 1) * 32) * From 21a4564a6c763a4af738dd8f04af1e81dcb9e53e Mon Sep 17 00:00:00 2001 From: Jamal Hadi Salim Date: Tue, 14 Feb 2023 08:49:14 -0500 Subject: [PATCH 66/68] BACKPORT: net/sched: Retire tcindex classifier commit 8c710f75256bb3cf05ac7b1672c82b92c43f3d28 upstream. The tcindex classifier has served us well for about a quarter of a century but has not been getting much TLC due to lack of known users. Most recently it has become easy prey to syzkaller. For this reason, we are retiring it. Bug: 274008928 Signed-off-by: Jamal Hadi Salim Acked-by: Jiri Pirko Signed-off-by: Paolo Abeni Signed-off-by: Greg Kroah-Hartman Signed-off-by: Lee Jones Change-Id: I00dac08e63c5cc260c12cfa8934e50913280e898 --- net/sched/Kconfig | 11 - net/sched/Makefile | 1 - net/sched/cls_tcindex.c | 756 ---------------------------------------- 3 files changed, 768 deletions(-) delete mode 100644 net/sched/cls_tcindex.c diff --git a/net/sched/Kconfig b/net/sched/Kconfig index bc4e5da76fa6..697522371914 100644 --- a/net/sched/Kconfig +++ b/net/sched/Kconfig @@ -503,17 +503,6 @@ config NET_CLS_BASIC To compile this code as a module, choose M here: the module will be called cls_basic. -config NET_CLS_TCINDEX - tristate "Traffic-Control Index (TCINDEX)" - select NET_CLS - help - Say Y here if you want to be able to classify packets based on - traffic control indices. You will want this feature if you want - to implement Differentiated Services together with DSMARK. - - To compile this code as a module, choose M here: the - module will be called cls_tcindex. - config NET_CLS_ROUTE4 tristate "Routing decision (ROUTE)" depends on INET diff --git a/net/sched/Makefile b/net/sched/Makefile index 66bbf9a98f9e..4311fdb21119 100644 --- a/net/sched/Makefile +++ b/net/sched/Makefile @@ -69,7 +69,6 @@ obj-$(CONFIG_NET_CLS_U32) += cls_u32.o obj-$(CONFIG_NET_CLS_ROUTE4) += cls_route.o obj-$(CONFIG_NET_CLS_FW) += cls_fw.o obj-$(CONFIG_NET_CLS_RSVP) += cls_rsvp.o -obj-$(CONFIG_NET_CLS_TCINDEX) += cls_tcindex.o obj-$(CONFIG_NET_CLS_RSVP6) += cls_rsvp6.o obj-$(CONFIG_NET_CLS_BASIC) += cls_basic.o obj-$(CONFIG_NET_CLS_FLOW) += cls_flow.o diff --git a/net/sched/cls_tcindex.c b/net/sched/cls_tcindex.c deleted file mode 100644 index 50bf7ec4b5b2..000000000000 --- a/net/sched/cls_tcindex.c +++ /dev/null @@ -1,756 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-only -/* - * net/sched/cls_tcindex.c Packet classifier for skb->tc_index - * - * Written 1998,1999 by Werner Almesberger, EPFL ICA - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -/* - * Passing parameters to the root seems to be done more awkwardly than really - * necessary. At least, u32 doesn't seem to use such dirty hacks. To be - * verified. FIXME. - */ - -#define PERFECT_HASH_THRESHOLD 64 /* use perfect hash if not bigger */ -#define DEFAULT_HASH_SIZE 64 /* optimized for diffserv */ - - -struct tcindex_data; - -struct tcindex_filter_result { - struct tcf_exts exts; - struct tcf_result res; - struct tcindex_data *p; - struct rcu_work rwork; -}; - -struct tcindex_filter { - u16 key; - struct tcindex_filter_result result; - struct tcindex_filter __rcu *next; - struct rcu_work rwork; -}; - - -struct tcindex_data { - struct tcindex_filter_result *perfect; /* perfect hash; NULL if none */ - struct tcindex_filter __rcu **h; /* imperfect hash; */ - struct tcf_proto *tp; - u16 mask; /* AND key with mask */ - u32 shift; /* shift ANDed key to the right */ - u32 hash; /* hash table size; 0 if undefined */ - u32 alloc_hash; /* allocated size */ - u32 fall_through; /* 0: only classify if explicit match */ - refcount_t refcnt; /* a temporary refcnt for perfect hash */ - struct rcu_work rwork; -}; - -static inline int tcindex_filter_is_set(struct tcindex_filter_result *r) -{ - return tcf_exts_has_actions(&r->exts) || r->res.classid; -} - -static void tcindex_data_get(struct tcindex_data *p) -{ - refcount_inc(&p->refcnt); -} - -static void tcindex_data_put(struct tcindex_data *p) -{ - if (refcount_dec_and_test(&p->refcnt)) { - kfree(p->perfect); - kfree(p->h); - kfree(p); - } -} - -static struct tcindex_filter_result *tcindex_lookup(struct tcindex_data *p, - u16 key) -{ - if (p->perfect) { - struct tcindex_filter_result *f = p->perfect + key; - - return tcindex_filter_is_set(f) ? f : NULL; - } else if (p->h) { - struct tcindex_filter __rcu **fp; - struct tcindex_filter *f; - - fp = &p->h[key % p->hash]; - for (f = rcu_dereference_bh_rtnl(*fp); - f; - fp = &f->next, f = rcu_dereference_bh_rtnl(*fp)) - if (f->key == key) - return &f->result; - } - - return NULL; -} - - -static int tcindex_classify(struct sk_buff *skb, const struct tcf_proto *tp, - struct tcf_result *res) -{ - struct tcindex_data *p = rcu_dereference_bh(tp->root); - struct tcindex_filter_result *f; - int key = (skb->tc_index & p->mask) >> p->shift; - - pr_debug("tcindex_classify(skb %p,tp %p,res %p),p %p\n", - skb, tp, res, p); - - f = tcindex_lookup(p, key); - if (!f) { - struct Qdisc *q = tcf_block_q(tp->chain->block); - - if (!p->fall_through) - return -1; - res->classid = TC_H_MAKE(TC_H_MAJ(q->handle), key); - res->class = 0; - pr_debug("alg 0x%x\n", res->classid); - return 0; - } - *res = f->res; - pr_debug("map 0x%x\n", res->classid); - - return tcf_exts_exec(skb, &f->exts, res); -} - - -static void *tcindex_get(struct tcf_proto *tp, u32 handle) -{ - struct tcindex_data *p = rtnl_dereference(tp->root); - struct tcindex_filter_result *r; - - pr_debug("tcindex_get(tp %p,handle 0x%08x)\n", tp, handle); - if (p->perfect && handle >= p->alloc_hash) - return NULL; - r = tcindex_lookup(p, handle); - return r && tcindex_filter_is_set(r) ? r : NULL; -} - -static int tcindex_init(struct tcf_proto *tp) -{ - struct tcindex_data *p; - - pr_debug("tcindex_init(tp %p)\n", tp); - p = kzalloc(sizeof(struct tcindex_data), GFP_KERNEL); - if (!p) - return -ENOMEM; - - p->mask = 0xffff; - p->hash = DEFAULT_HASH_SIZE; - p->fall_through = 1; - refcount_set(&p->refcnt, 1); /* Paired with tcindex_destroy_work() */ - - rcu_assign_pointer(tp->root, p); - return 0; -} - -static void __tcindex_destroy_rexts(struct tcindex_filter_result *r) -{ - tcf_exts_destroy(&r->exts); - tcf_exts_put_net(&r->exts); - tcindex_data_put(r->p); -} - -static void tcindex_destroy_rexts_work(struct work_struct *work) -{ - struct tcindex_filter_result *r; - - r = container_of(to_rcu_work(work), - struct tcindex_filter_result, - rwork); - rtnl_lock(); - __tcindex_destroy_rexts(r); - rtnl_unlock(); -} - -static void __tcindex_destroy_fexts(struct tcindex_filter *f) -{ - tcf_exts_destroy(&f->result.exts); - tcf_exts_put_net(&f->result.exts); - kfree(f); -} - -static void tcindex_destroy_fexts_work(struct work_struct *work) -{ - struct tcindex_filter *f = container_of(to_rcu_work(work), - struct tcindex_filter, - rwork); - - rtnl_lock(); - __tcindex_destroy_fexts(f); - rtnl_unlock(); -} - -static int tcindex_delete(struct tcf_proto *tp, void *arg, bool *last, - bool rtnl_held, struct netlink_ext_ack *extack) -{ - struct tcindex_data *p = rtnl_dereference(tp->root); - struct tcindex_filter_result *r = arg; - struct tcindex_filter __rcu **walk; - struct tcindex_filter *f = NULL; - - pr_debug("tcindex_delete(tp %p,arg %p),p %p\n", tp, arg, p); - if (p->perfect) { - if (!r->res.class) - return -ENOENT; - } else { - int i; - - for (i = 0; i < p->hash; i++) { - walk = p->h + i; - for (f = rtnl_dereference(*walk); f; - walk = &f->next, f = rtnl_dereference(*walk)) { - if (&f->result == r) - goto found; - } - } - return -ENOENT; - -found: - rcu_assign_pointer(*walk, rtnl_dereference(f->next)); - } - tcf_unbind_filter(tp, &r->res); - /* all classifiers are required to call tcf_exts_destroy() after rcu - * grace period, since converted-to-rcu actions are relying on that - * in cleanup() callback - */ - if (f) { - if (tcf_exts_get_net(&f->result.exts)) - tcf_queue_work(&f->rwork, tcindex_destroy_fexts_work); - else - __tcindex_destroy_fexts(f); - } else { - tcindex_data_get(p); - - if (tcf_exts_get_net(&r->exts)) - tcf_queue_work(&r->rwork, tcindex_destroy_rexts_work); - else - __tcindex_destroy_rexts(r); - } - - *last = false; - return 0; -} - -static void tcindex_destroy_work(struct work_struct *work) -{ - struct tcindex_data *p = container_of(to_rcu_work(work), - struct tcindex_data, - rwork); - - tcindex_data_put(p); -} - -static inline int -valid_perfect_hash(struct tcindex_data *p) -{ - return p->hash > (p->mask >> p->shift); -} - -static const struct nla_policy tcindex_policy[TCA_TCINDEX_MAX + 1] = { - [TCA_TCINDEX_HASH] = { .type = NLA_U32 }, - [TCA_TCINDEX_MASK] = { .type = NLA_U16 }, - [TCA_TCINDEX_SHIFT] = { .type = NLA_U32 }, - [TCA_TCINDEX_FALL_THROUGH] = { .type = NLA_U32 }, - [TCA_TCINDEX_CLASSID] = { .type = NLA_U32 }, -}; - -static int tcindex_filter_result_init(struct tcindex_filter_result *r, - struct tcindex_data *p, - struct net *net) -{ - memset(r, 0, sizeof(*r)); - r->p = p; - return tcf_exts_init(&r->exts, net, TCA_TCINDEX_ACT, - TCA_TCINDEX_POLICE); -} - -static void tcindex_free_perfect_hash(struct tcindex_data *cp); - -static void tcindex_partial_destroy_work(struct work_struct *work) -{ - struct tcindex_data *p = container_of(to_rcu_work(work), - struct tcindex_data, - rwork); - - rtnl_lock(); - if (p->perfect) - tcindex_free_perfect_hash(p); - kfree(p); - rtnl_unlock(); -} - -static void tcindex_free_perfect_hash(struct tcindex_data *cp) -{ - int i; - - for (i = 0; i < cp->hash; i++) - tcf_exts_destroy(&cp->perfect[i].exts); - kfree(cp->perfect); -} - -static int tcindex_alloc_perfect_hash(struct net *net, struct tcindex_data *cp) -{ - int i, err = 0; - - cp->perfect = kcalloc(cp->hash, sizeof(struct tcindex_filter_result), - GFP_KERNEL | __GFP_NOWARN); - if (!cp->perfect) - return -ENOMEM; - - for (i = 0; i < cp->hash; i++) { - err = tcf_exts_init(&cp->perfect[i].exts, net, - TCA_TCINDEX_ACT, TCA_TCINDEX_POLICE); - if (err < 0) - goto errout; - cp->perfect[i].p = cp; - } - - return 0; - -errout: - tcindex_free_perfect_hash(cp); - return err; -} - -static int -tcindex_set_parms(struct net *net, struct tcf_proto *tp, unsigned long base, - u32 handle, struct tcindex_data *p, - struct tcindex_filter_result *r, struct nlattr **tb, - struct nlattr *est, bool ovr, struct netlink_ext_ack *extack) -{ - struct tcindex_filter_result new_filter_result; - struct tcindex_data *cp = NULL, *oldp; - struct tcindex_filter *f = NULL; /* make gcc behave */ - struct tcf_result cr = {}; - int err, balloc = 0; - struct tcf_exts e; - bool update_h = false; - - err = tcf_exts_init(&e, net, TCA_TCINDEX_ACT, TCA_TCINDEX_POLICE); - if (err < 0) - return err; - err = tcf_exts_validate(net, tp, tb, est, &e, ovr, true, extack); - if (err < 0) - goto errout; - - err = -ENOMEM; - /* tcindex_data attributes must look atomic to classifier/lookup so - * allocate new tcindex data and RCU assign it onto root. Keeping - * perfect hash and hash pointers from old data. - */ - cp = kzalloc(sizeof(*cp), GFP_KERNEL); - if (!cp) - goto errout; - - cp->mask = p->mask; - cp->shift = p->shift; - cp->hash = p->hash; - cp->alloc_hash = p->alloc_hash; - cp->fall_through = p->fall_through; - cp->tp = tp; - refcount_set(&cp->refcnt, 1); /* Paired with tcindex_destroy_work() */ - - if (tb[TCA_TCINDEX_HASH]) - cp->hash = nla_get_u32(tb[TCA_TCINDEX_HASH]); - - if (tb[TCA_TCINDEX_MASK]) - cp->mask = nla_get_u16(tb[TCA_TCINDEX_MASK]); - - if (tb[TCA_TCINDEX_SHIFT]) { - cp->shift = nla_get_u32(tb[TCA_TCINDEX_SHIFT]); - if (cp->shift > 16) { - err = -EINVAL; - goto errout; - } - } - if (!cp->hash) { - /* Hash not specified, use perfect hash if the upper limit - * of the hashing index is below the threshold. - */ - if ((cp->mask >> cp->shift) < PERFECT_HASH_THRESHOLD) - cp->hash = (cp->mask >> cp->shift) + 1; - else - cp->hash = DEFAULT_HASH_SIZE; - } - - if (p->perfect) { - int i; - - if (tcindex_alloc_perfect_hash(net, cp) < 0) - goto errout; - cp->alloc_hash = cp->hash; - for (i = 0; i < min(cp->hash, p->hash); i++) - cp->perfect[i].res = p->perfect[i].res; - balloc = 1; - } - cp->h = p->h; - - err = tcindex_filter_result_init(&new_filter_result, cp, net); - if (err < 0) - goto errout_alloc; - if (r) - cr = r->res; - - err = -EBUSY; - - /* Hash already allocated, make sure that we still meet the - * requirements for the allocated hash. - */ - if (cp->perfect) { - if (!valid_perfect_hash(cp) || - cp->hash > cp->alloc_hash) - goto errout_alloc; - } else if (cp->h && cp->hash != cp->alloc_hash) { - goto errout_alloc; - } - - err = -EINVAL; - if (tb[TCA_TCINDEX_FALL_THROUGH]) - cp->fall_through = nla_get_u32(tb[TCA_TCINDEX_FALL_THROUGH]); - - if (!cp->perfect && !cp->h) - cp->alloc_hash = cp->hash; - - /* Note: this could be as restrictive as if (handle & ~(mask >> shift)) - * but then, we'd fail handles that may become valid after some future - * mask change. While this is extremely unlikely to ever matter, - * the check below is safer (and also more backwards-compatible). - */ - if (cp->perfect || valid_perfect_hash(cp)) - if (handle >= cp->alloc_hash) - goto errout_alloc; - - - err = -ENOMEM; - if (!cp->perfect && !cp->h) { - if (valid_perfect_hash(cp)) { - if (tcindex_alloc_perfect_hash(net, cp) < 0) - goto errout_alloc; - balloc = 1; - } else { - struct tcindex_filter __rcu **hash; - - hash = kcalloc(cp->hash, - sizeof(struct tcindex_filter *), - GFP_KERNEL); - - if (!hash) - goto errout_alloc; - - cp->h = hash; - balloc = 2; - } - } - - if (cp->perfect) { - r = cp->perfect + handle; - } else { - /* imperfect area is updated in-place using rcu */ - update_h = !!tcindex_lookup(cp, handle); - r = &new_filter_result; - } - - if (r == &new_filter_result) { - f = kzalloc(sizeof(*f), GFP_KERNEL); - if (!f) - goto errout_alloc; - f->key = handle; - f->next = NULL; - err = tcindex_filter_result_init(&f->result, cp, net); - if (err < 0) { - kfree(f); - goto errout_alloc; - } - } - - if (tb[TCA_TCINDEX_CLASSID]) { - cr.classid = nla_get_u32(tb[TCA_TCINDEX_CLASSID]); - tcf_bind_filter(tp, &cr, base); - } - - oldp = p; - r->res = cr; - tcf_exts_change(&r->exts, &e); - - rcu_assign_pointer(tp->root, cp); - - if (update_h) { - struct tcindex_filter __rcu **fp; - struct tcindex_filter *cf; - - f->result.res = r->res; - tcf_exts_change(&f->result.exts, &r->exts); - - /* imperfect area bucket */ - fp = cp->h + (handle % cp->hash); - - /* lookup the filter, guaranteed to exist */ - for (cf = rcu_dereference_bh_rtnl(*fp); cf; - fp = &cf->next, cf = rcu_dereference_bh_rtnl(*fp)) - if (cf->key == handle) - break; - - f->next = cf->next; - - cf = rcu_replace_pointer(*fp, f, 1); - tcf_exts_get_net(&cf->result.exts); - tcf_queue_work(&cf->rwork, tcindex_destroy_fexts_work); - } else if (r == &new_filter_result) { - struct tcindex_filter *nfp; - struct tcindex_filter __rcu **fp; - - f->result.res = r->res; - tcf_exts_change(&f->result.exts, &r->exts); - - fp = cp->h + (handle % cp->hash); - for (nfp = rtnl_dereference(*fp); - nfp; - fp = &nfp->next, nfp = rtnl_dereference(*fp)) - ; /* nothing */ - - rcu_assign_pointer(*fp, f); - } else { - tcf_exts_destroy(&new_filter_result.exts); - } - - if (oldp) - tcf_queue_work(&oldp->rwork, tcindex_partial_destroy_work); - return 0; - -errout_alloc: - if (balloc == 1) - tcindex_free_perfect_hash(cp); - else if (balloc == 2) - kfree(cp->h); - tcf_exts_destroy(&new_filter_result.exts); -errout: - kfree(cp); - tcf_exts_destroy(&e); - return err; -} - -static int -tcindex_change(struct net *net, struct sk_buff *in_skb, - struct tcf_proto *tp, unsigned long base, u32 handle, - struct nlattr **tca, void **arg, bool ovr, - bool rtnl_held, struct netlink_ext_ack *extack) -{ - struct nlattr *opt = tca[TCA_OPTIONS]; - struct nlattr *tb[TCA_TCINDEX_MAX + 1]; - struct tcindex_data *p = rtnl_dereference(tp->root); - struct tcindex_filter_result *r = *arg; - int err; - - pr_debug("tcindex_change(tp %p,handle 0x%08x,tca %p,arg %p),opt %p," - "p %p,r %p,*arg %p\n", - tp, handle, tca, arg, opt, p, r, *arg); - - if (!opt) - return 0; - - err = nla_parse_nested_deprecated(tb, TCA_TCINDEX_MAX, opt, - tcindex_policy, NULL); - if (err < 0) - return err; - - return tcindex_set_parms(net, tp, base, handle, p, r, tb, - tca[TCA_RATE], ovr, extack); -} - -static void tcindex_walk(struct tcf_proto *tp, struct tcf_walker *walker, - bool rtnl_held) -{ - struct tcindex_data *p = rtnl_dereference(tp->root); - struct tcindex_filter *f, *next; - int i; - - pr_debug("tcindex_walk(tp %p,walker %p),p %p\n", tp, walker, p); - if (p->perfect) { - for (i = 0; i < p->hash; i++) { - if (!p->perfect[i].res.class) - continue; - if (walker->count >= walker->skip) { - if (walker->fn(tp, p->perfect + i, walker) < 0) { - walker->stop = 1; - return; - } - } - walker->count++; - } - } - if (!p->h) - return; - for (i = 0; i < p->hash; i++) { - for (f = rtnl_dereference(p->h[i]); f; f = next) { - next = rtnl_dereference(f->next); - if (walker->count >= walker->skip) { - if (walker->fn(tp, &f->result, walker) < 0) { - walker->stop = 1; - return; - } - } - walker->count++; - } - } -} - -static void tcindex_destroy(struct tcf_proto *tp, bool rtnl_held, - struct netlink_ext_ack *extack) -{ - struct tcindex_data *p = rtnl_dereference(tp->root); - int i; - - pr_debug("tcindex_destroy(tp %p),p %p\n", tp, p); - - if (p->perfect) { - for (i = 0; i < p->hash; i++) { - struct tcindex_filter_result *r = p->perfect + i; - - /* tcf_queue_work() does not guarantee the ordering we - * want, so we have to take this refcnt temporarily to - * ensure 'p' is freed after all tcindex_filter_result - * here. Imperfect hash does not need this, because it - * uses linked lists rather than an array. - */ - tcindex_data_get(p); - - tcf_unbind_filter(tp, &r->res); - if (tcf_exts_get_net(&r->exts)) - tcf_queue_work(&r->rwork, - tcindex_destroy_rexts_work); - else - __tcindex_destroy_rexts(r); - } - } - - for (i = 0; p->h && i < p->hash; i++) { - struct tcindex_filter *f, *next; - bool last; - - for (f = rtnl_dereference(p->h[i]); f; f = next) { - next = rtnl_dereference(f->next); - tcindex_delete(tp, &f->result, &last, rtnl_held, NULL); - } - } - - tcf_queue_work(&p->rwork, tcindex_destroy_work); -} - - -static int tcindex_dump(struct net *net, struct tcf_proto *tp, void *fh, - struct sk_buff *skb, struct tcmsg *t, bool rtnl_held) -{ - struct tcindex_data *p = rtnl_dereference(tp->root); - struct tcindex_filter_result *r = fh; - struct nlattr *nest; - - pr_debug("tcindex_dump(tp %p,fh %p,skb %p,t %p),p %p,r %p\n", - tp, fh, skb, t, p, r); - pr_debug("p->perfect %p p->h %p\n", p->perfect, p->h); - - nest = nla_nest_start_noflag(skb, TCA_OPTIONS); - if (nest == NULL) - goto nla_put_failure; - - if (!fh) { - t->tcm_handle = ~0; /* whatever ... */ - if (nla_put_u32(skb, TCA_TCINDEX_HASH, p->hash) || - nla_put_u16(skb, TCA_TCINDEX_MASK, p->mask) || - nla_put_u32(skb, TCA_TCINDEX_SHIFT, p->shift) || - nla_put_u32(skb, TCA_TCINDEX_FALL_THROUGH, p->fall_through)) - goto nla_put_failure; - nla_nest_end(skb, nest); - } else { - if (p->perfect) { - t->tcm_handle = r - p->perfect; - } else { - struct tcindex_filter *f; - struct tcindex_filter __rcu **fp; - int i; - - t->tcm_handle = 0; - for (i = 0; !t->tcm_handle && i < p->hash; i++) { - fp = &p->h[i]; - for (f = rtnl_dereference(*fp); - !t->tcm_handle && f; - fp = &f->next, f = rtnl_dereference(*fp)) { - if (&f->result == r) - t->tcm_handle = f->key; - } - } - } - pr_debug("handle = %d\n", t->tcm_handle); - if (r->res.class && - nla_put_u32(skb, TCA_TCINDEX_CLASSID, r->res.classid)) - goto nla_put_failure; - - if (tcf_exts_dump(skb, &r->exts) < 0) - goto nla_put_failure; - nla_nest_end(skb, nest); - - if (tcf_exts_dump_stats(skb, &r->exts) < 0) - goto nla_put_failure; - } - - return skb->len; - -nla_put_failure: - nla_nest_cancel(skb, nest); - return -1; -} - -static void tcindex_bind_class(void *fh, u32 classid, unsigned long cl, - void *q, unsigned long base) -{ - struct tcindex_filter_result *r = fh; - - if (r && r->res.classid == classid) { - if (cl) - __tcf_bind_filter(q, &r->res, base); - else - __tcf_unbind_filter(q, &r->res); - } -} - -static struct tcf_proto_ops cls_tcindex_ops __read_mostly = { - .kind = "tcindex", - .classify = tcindex_classify, - .init = tcindex_init, - .destroy = tcindex_destroy, - .get = tcindex_get, - .change = tcindex_change, - .delete = tcindex_delete, - .walk = tcindex_walk, - .dump = tcindex_dump, - .bind_class = tcindex_bind_class, - .owner = THIS_MODULE, -}; - -static int __init init_tcindex(void) -{ - return register_tcf_proto_ops(&cls_tcindex_ops); -} - -static void __exit exit_tcindex(void) -{ - unregister_tcf_proto_ops(&cls_tcindex_ops); -} - -module_init(init_tcindex) -module_exit(exit_tcindex) -MODULE_LICENSE("GPL"); From 7c835be7ec6ea55d7535f2bf8e0cbb1e64b45699 Mon Sep 17 00:00:00 2001 From: Greg Kroah-Hartman Date: Mon, 13 Mar 2023 15:39:31 +0000 Subject: [PATCH 67/68] ANDROID: remove CONFIG_NET_CLS_TCINDEX from gki_defconfig The tcindex code was removed from the tree in 5.10.173, so remove the config option from the gki_defconfig files to fix up the build. Fixes: 18c3fa7a7fdb ("net/sched: Retire tcindex classifier") Change-Id: Id4927815ec2fd0ebc8065d891dfb721551f3dbc6 Signed-off-by: Greg Kroah-Hartman (cherry picked from commit a880d7ebc53ec8595200175f860f35ef8755e91f) Signed-off-by: Lee Jones --- arch/arm64/configs/gki_defconfig | 1 - arch/x86/configs/gki_defconfig | 1 - 2 files changed, 2 deletions(-) diff --git a/arch/arm64/configs/gki_defconfig b/arch/arm64/configs/gki_defconfig index 8fa037f86347..e238ccdcafe1 100644 --- a/arch/arm64/configs/gki_defconfig +++ b/arch/arm64/configs/gki_defconfig @@ -245,7 +245,6 @@ CONFIG_NET_SCH_FQ_CODEL=y CONFIG_NET_SCH_FQ=y CONFIG_NET_SCH_INGRESS=y CONFIG_NET_CLS_BASIC=y -CONFIG_NET_CLS_TCINDEX=y CONFIG_NET_CLS_FW=y CONFIG_NET_CLS_U32=y CONFIG_CLS_U32_MARK=y diff --git a/arch/x86/configs/gki_defconfig b/arch/x86/configs/gki_defconfig index 9507ff815d82..9c6d1a0e661d 100644 --- a/arch/x86/configs/gki_defconfig +++ b/arch/x86/configs/gki_defconfig @@ -220,7 +220,6 @@ CONFIG_NET_SCH_FQ_CODEL=y CONFIG_NET_SCH_FQ=y CONFIG_NET_SCH_INGRESS=y CONFIG_NET_CLS_BASIC=y -CONFIG_NET_CLS_TCINDEX=y CONFIG_NET_CLS_FW=y CONFIG_NET_CLS_U32=y CONFIG_CLS_U32_MARK=y From 7f9a9a8fe43d84f93726bf3505174b3203b623a8 Mon Sep 17 00:00:00 2001 From: Paolo Bonzini Date: Tue, 7 Jun 2022 10:09:03 -0400 Subject: [PATCH 68/68] UPSTREAM: KVM: x86: do not report a vCPU as preempted outside instruction boundaries commit 6cd88243c7e03845a450795e134b488fc2afb736 upstream. If a vCPU is outside guest mode and is scheduled out, it might be in the process of making a memory access. A problem occurs if another vCPU uses the PV TLB flush feature during the period when the vCPU is scheduled out, and a virtual address has already been translated but has not yet been accessed, because this is equivalent to using a stale TLB entry. To avoid this, only report a vCPU as preempted if sure that the guest is at an instruction boundary. A rescheduling request will be delivered to the host physical CPU as an external interrupt, so for simplicity consider any vmexit *not* instruction boundary except for external interrupts. It would in principle be okay to report the vCPU as preempted also if it is sleeping in kvm_vcpu_block(): a TLB flush IPI will incur the vmentry/vmexit overhead unnecessarily, and optimistic spinning is also unlikely to succeed. However, leave it for later because right now kvm_vcpu_check_block() is doing memory accesses. Even though the TLB flush issue only applies to virtual memory address, it's very much preferrable to be conservative. Bug: 245869446 Bug: 278120352 Reported-by: Jann Horn Signed-off-by: Paolo Bonzini [OP: use VCPU_STAT() for debugfs entries] Signed-off-by: Ovidiu Panait Signed-off-by: Greg Kroah-Hartman (cherry picked from commit 529f41f0eb1ef995bfa83c121c3cfe3a0720119a) Signed-off-by: Lee Jones Change-Id: Ie9c597eecb619d12a714a0d0722d34e855e97b14 --- arch/x86/include/asm/kvm_host.h | 3 +++ arch/x86/kvm/svm/svm.c | 2 ++ arch/x86/kvm/vmx/vmx.c | 1 + arch/x86/kvm/x86.c | 22 ++++++++++++++++++++++ 4 files changed, 28 insertions(+) diff --git a/arch/x86/include/asm/kvm_host.h b/arch/x86/include/asm/kvm_host.h index 660012ab7bfa..af4b4d3c6ff6 100644 --- a/arch/x86/include/asm/kvm_host.h +++ b/arch/x86/include/asm/kvm_host.h @@ -553,6 +553,7 @@ struct kvm_vcpu_arch { u64 ia32_misc_enable_msr; u64 smbase; u64 smi_count; + bool at_instruction_boundary; bool tpr_access_reporting; bool xsaves_enabled; u64 ia32_xss; @@ -1061,6 +1062,8 @@ struct kvm_vcpu_stat { u64 req_event; u64 halt_poll_success_ns; u64 halt_poll_fail_ns; + u64 preemption_reported; + u64 preemption_other; }; struct x86_instruction_info; diff --git a/arch/x86/kvm/svm/svm.c b/arch/x86/kvm/svm/svm.c index c34ba034ca11..ef5a72d80f54 100644 --- a/arch/x86/kvm/svm/svm.c +++ b/arch/x86/kvm/svm/svm.c @@ -3977,6 +3977,8 @@ out: static void svm_handle_exit_irqoff(struct kvm_vcpu *vcpu) { + if (to_svm(vcpu)->vmcb->control.exit_code == SVM_EXIT_INTR) + vcpu->arch.at_instruction_boundary = true; } static void svm_sched_in(struct kvm_vcpu *vcpu, int cpu) diff --git a/arch/x86/kvm/vmx/vmx.c b/arch/x86/kvm/vmx/vmx.c index c37cbd3fdd85..5f6f926b02a9 100644 --- a/arch/x86/kvm/vmx/vmx.c +++ b/arch/x86/kvm/vmx/vmx.c @@ -6505,6 +6505,7 @@ static void handle_external_interrupt_irqoff(struct kvm_vcpu *vcpu) return; handle_interrupt_nmi_irqoff(vcpu, gate_offset(desc)); + vcpu->arch.at_instruction_boundary = true; } static void vmx_handle_exit_irqoff(struct kvm_vcpu *vcpu) diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c index 554d37873c25..fb5a10c70beb 100644 --- a/arch/x86/kvm/x86.c +++ b/arch/x86/kvm/x86.c @@ -231,6 +231,8 @@ struct kvm_stats_debugfs_item debugfs_entries[] = { VCPU_STAT("l1d_flush", l1d_flush), VCPU_STAT("halt_poll_success_ns", halt_poll_success_ns), VCPU_STAT("halt_poll_fail_ns", halt_poll_fail_ns), + VCPU_STAT("preemption_reported", preemption_reported), + VCPU_STAT("preemption_other", preemption_other), VM_STAT("mmu_shadow_zapped", mmu_shadow_zapped), VM_STAT("mmu_pte_write", mmu_pte_write), VM_STAT("mmu_pde_zapped", mmu_pde_zapped), @@ -4052,6 +4054,19 @@ static void kvm_steal_time_set_preempted(struct kvm_vcpu *vcpu) struct kvm_host_map map; struct kvm_steal_time *st; + /* + * The vCPU can be marked preempted if and only if the VM-Exit was on + * an instruction boundary and will not trigger guest emulation of any + * kind (see vcpu_run). Vendor specific code controls (conservatively) + * when this is true, for example allowing the vCPU to be marked + * preempted if and only if the VM-Exit was due to a host interrupt. + */ + if (!vcpu->arch.at_instruction_boundary) { + vcpu->stat.preemption_other++; + return; + } + + vcpu->stat.preemption_reported++; if (!(vcpu->arch.st.msr_val & KVM_MSR_ENABLED)) return; @@ -9355,6 +9370,13 @@ static int vcpu_run(struct kvm_vcpu *vcpu) vcpu->arch.l1tf_flush_l1d = true; for (;;) { + /* + * If another guest vCPU requests a PV TLB flush in the middle + * of instruction emulation, the rest of the emulation could + * use a stale page translation. Assume that any code after + * this point can start executing an instruction. + */ + vcpu->arch.at_instruction_boundary = false; if (kvm_vcpu_running(vcpu)) { r = vcpu_enter_guest(vcpu); } else {