diff --git a/BUILD.bazel b/BUILD.bazel
index 0c18efb28df2..466f1d0e3334 100644
--- a/BUILD.bazel
+++ b/BUILD.bazel
@@ -99,6 +99,7 @@ filegroup(
     name = "aarch64_additional_kmi_symbol_lists",
     srcs = [
         # keep sorted
+        "android/abi_gki_aarch64_arg",
         "android/abi_gki_aarch64_asr",
         "android/abi_gki_aarch64_asus",
         "android/abi_gki_aarch64_bcmstb",
diff --git a/android/abi_gki_aarch64.stg b/android/abi_gki_aarch64.stg
index 110d1680df50..b7c163a79abb 100644
--- a/android/abi_gki_aarch64.stg
+++ b/android/abi_gki_aarch64.stg
@@ -314436,6 +314436,12 @@ function {
   parameter_id: 0x4585663f
   parameter_id: 0x1bf16028
 }
+function {
+  id: 0x915108e4
+  return_type_id: 0x6720d32f
+  parameter_id: 0x33f8b54b
+  parameter_id: 0x0bf1a65b
+}
 function {
   id: 0x91523c59
   return_type_id: 0x6720d32f
@@ -324321,6 +324327,13 @@ function {
   parameter_id: 0x00c72527
   parameter_id: 0xf435685e
 }
+function {
+  id: 0x9a1f3564
+  return_type_id: 0x6720d32f
+  parameter_id: 0x18bd6530
+  parameter_id: 0x6720d32f
+  parameter_id: 0xb0312d5a
+}
 function {
   id: 0x9a20634b
   return_type_id: 0x6720d32f
@@ -346769,6 +346782,15 @@ elf_symbol {
   type_id: 0x9bdbdcc4
   full_name: "__traceiter_android_rvh_wake_up_new_task"
 }
+elf_symbol {
+  id: 0xfd00ed2d
+  name: "__traceiter_android_trigger_vendor_lmk_kill"
+  is_defined: true
+  symbol_type: FUNCTION
+  crc: 0x867c2cff
+  type_id: 0x9a1f3564
+  full_name: "__traceiter_android_trigger_vendor_lmk_kill"
+}
 elf_symbol {
   id: 0xa3af7947
   name: "__traceiter_android_vh_account_process_tick_gran"
@@ -351782,6 +351804,15 @@ elf_symbol {
   type_id: 0x18ccbd2c
   full_name: "__tracepoint_android_rvh_wake_up_new_task"
 }
+elf_symbol {
+  id: 0xb59c7c3f
+  name: "__tracepoint_android_trigger_vendor_lmk_kill"
+  is_defined: true
+  symbol_type: OBJECT
+  crc: 0xb3afb377
+  type_id: 0x18ccbd2c
+  full_name: "__tracepoint_android_trigger_vendor_lmk_kill"
+}
 elf_symbol {
   id: 0x4f980315
   name: "__tracepoint_android_vh_account_process_tick_gran"
@@ -379633,6 +379664,33 @@ elf_symbol {
   type_id: 0x16bab633
   full_name: "iio_device_unregister"
 }
+elf_symbol {
+  id: 0xe5481ec8
+  name: "iio_enum_available_read"
+  is_defined: true
+  symbol_type: FUNCTION
+  crc: 0xcb388b01
+  type_id: 0x13641115
+  full_name: "iio_enum_available_read"
+}
+elf_symbol {
+  id: 0x2bfd6710
+  name: "iio_enum_read"
+  is_defined: true
+  symbol_type: FUNCTION
+  crc: 0x1972438f
+  type_id: 0x13641115
+  full_name: "iio_enum_read"
+}
+elf_symbol {
+  id: 0xbd0b946f
+  name: "iio_enum_write"
+  is_defined: true
+  symbol_type: FUNCTION
+  crc: 0xafda2d93
+  type_id: 0x1364c655
+  full_name: "iio_enum_write"
+}
 elf_symbol {
   id: 0xef661661
   name: "iio_format_value"
@@ -402467,6 +402525,15 @@ elf_symbol {
   type_id: 0x91d0f233
   full_name: "snd_ctl_remove"
 }
+elf_symbol {
+  id: 0x6095200b
+  name: "snd_ctl_remove_id"
+  is_defined: true
+  symbol_type: FUNCTION
+  crc: 0x8e2ca218
+  type_id: 0x915108e4
+  full_name: "snd_ctl_remove_id"
+}
 elf_symbol {
   id: 0xe3942db0
   name: "snd_device_free"
@@ -417752,6 +417819,7 @@ interface {
   symbol_id: 0x915194c4
   symbol_id: 0xdb6d278a
   symbol_id: 0xebcd0234
+  symbol_id: 0xfd00ed2d
   symbol_id: 0xa3af7947
   symbol_id: 0x86527a4e
   symbol_id: 0xf71b3e6c
@@ -418309,6 +418377,7 @@ interface {
   symbol_id: 0xd1be5d26
   symbol_id: 0xe1b78c30
   symbol_id: 0xdcf22716
+  symbol_id: 0xb59c7c3f
   symbol_id: 0x4f980315
   symbol_id: 0xe1489e0c
   symbol_id: 0x8f23a62a
@@ -421402,6 +421471,9 @@ interface {
   symbol_id: 0x49e3dfdd
   symbol_id: 0x7a6b0e4c
   symbol_id: 0xe0909072
+  symbol_id: 0xe5481ec8
+  symbol_id: 0x2bfd6710
+  symbol_id: 0xbd0b946f
   symbol_id: 0xef661661
   symbol_id: 0x83815ff1
   symbol_id: 0x01f28688
@@ -423939,6 +424011,7 @@ interface {
   symbol_id: 0x6b08a95c
   symbol_id: 0x238c5442
   symbol_id: 0x20fc506b
+  symbol_id: 0x6095200b
   symbol_id: 0xe3942db0
   symbol_id: 0xb87d5cd6
   symbol_id: 0x74d92df1
diff --git a/android/abi_gki_aarch64_arg b/android/abi_gki_aarch64_arg
new file mode 100644
index 000000000000..af0ba5573234
--- /dev/null
+++ b/android/abi_gki_aarch64_arg
@@ -0,0 +1,2565 @@
+[abi_symbol_list]
+  activate_task
+  add_cpu
+  add_device_randomness
+  add_taint
+  add_timer
+  add_timer_on
+  add_uevent_var
+  adjust_managed_page_count
+  aes_encrypt
+  aes_expandkey
+  alloc_chrdev_region
+  alloc_io_pgtable_ops
+  alloc_netdev_mqs
+  __alloc_pages
+  __alloc_percpu
+  __alloc_percpu_gfp
+  __alloc_skb
+  alloc_skb_with_frags
+  alloc_workqueue
+  alt_cb_patch_nops
+  amba_bustype
+  amba_driver_register
+  amba_driver_unregister
+  android_rvh_probe_register
+  anon_inode_getfile
+  arc4_crypt
+  arc4_setkey
+  __arch_copy_from_user
+  __arch_copy_to_user
+  arch_freq_scale
+  arch_timer_read_counter
+  argv_free
+  argv_split
+  arm64_use_ng_mappings
+  __arm_smccc_smc
+  __arm_smccc_sve_check
+  atomic_notifier_call_chain
+  atomic_notifier_chain_register
+  atomic_notifier_chain_unregister
+  autoremove_wake_function
+  __auxiliary_driver_register
+  auxiliary_driver_unregister
+  available_idle_cpu
+  backlight_device_get_by_type
+  backlight_device_register
+  backlight_device_set_brightness
+  backlight_device_unregister
+  __balance_callbacks
+  balance_push_callback
+  bcmp
+  bin2hex
+  bitmap_allocate_region
+  __bitmap_and
+  __bitmap_andnot
+  __bitmap_clear
+  __bitmap_complement
+  __bitmap_equal
+  bitmap_find_next_zero_area_off
+  bitmap_free
+  __bitmap_intersects
+  __bitmap_or
+  bitmap_print_to_pagebuf
+  bitmap_release_region
+  __bitmap_replace
+  __bitmap_set
+  __bitmap_subset
+  __bitmap_weight
+  bitmap_zalloc
+  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_run2
+  bpf_trace_run3
+  bpf_trace_run4
+  bpf_trace_run5
+  bpf_trace_run6
+  bpf_trace_run7
+  bpf_trace_run8
+  bpf_trace_run9
+  build_skb
+  bus_find_device
+  bus_for_each_dev
+  bus_register
+  bus_register_notifier
+  bus_unregister
+  bus_unregister_notifier
+  call_rcu
+  cancel_delayed_work
+  cancel_delayed_work_sync
+  cancel_work_sync
+  capable
+  cdev_add
+  cdev_del
+  cdev_device_add
+  cdev_device_del
+  cdev_init
+  cgroup_path_ns
+  cgroup_taskset_first
+  cgroup_taskset_next
+  __check_object_size
+  check_preempt_curr
+  check_zeroed_user
+  __class_create
+  class_destroy
+  class_find_device
+  class_for_each_device
+  __class_register
+  class_unregister
+  cleanup_srcu_struct
+  clear_page
+  clk_bulk_disable
+  clk_bulk_enable
+  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_get_rate_range
+  clk_hw_is_enabled
+  clk_hw_is_prepared
+  clk_hw_register
+  clk_hw_round_rate
+  clk_hw_unregister
+  __clk_is_enabled
+  __clk_mux_determine_rate_closest
+  clk_prepare
+  clk_put
+  clk_restore_context
+  clk_round_rate
+  clk_set_parent
+  clk_set_rate
+  clk_sync_state
+  clk_unprepare
+  close_fd
+  cma_alloc
+  cma_get_name
+  cma_release
+  compat_ptr_ioctl
+  complete
+  complete_all
+  completion_done
+  component_add
+  component_bind_all
+  component_del
+  component_master_add_with_match
+  component_master_del
+  component_match_add_release
+  component_unbind_all
+  config_ep_by_speed
+  configfs_register_group
+  configfs_register_subsystem
+  configfs_unregister_group
+  configfs_unregister_subsystem
+  config_group_init
+  config_group_init_type_name
+  config_item_get
+  config_item_put
+  config_item_set_name
+  console_stop
+  console_suspend_enabled
+  __const_udelay
+  consume_skb
+  contig_page_data
+  __copy_overflow
+  __cpu_active_mask
+  cpu_all_bits
+  cpu_bit_bitmap
+  cpu_busy_with_softirqs
+  __cpu_dying_mask
+  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_generic_frequency_table_verify
+  cpufreq_get_driver_data
+  cpufreq_quick_get_max
+  cpufreq_register_driver
+  cpufreq_register_governor
+  cpufreq_register_notifier
+  cpufreq_unregister_driver
+  __cpuhp_remove_state
+  __cpuhp_setup_state
+  __cpuhp_setup_state_cpuslocked
+  cpu_hwcaps
+  cpuidle_governor_latency_req
+  cpuidle_register_governor
+  cpu_irqtime
+  cpu_latency_qos_add_request
+  cpu_latency_qos_remove_request
+  cpu_latency_qos_update_request
+  cpumask_any_and_distribute
+  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
+  crc32_be
+  crc32_le
+  crc8
+  crc8_populate_msb
+  crypto_aead_decrypt
+  crypto_aead_encrypt
+  crypto_aead_setauthsize
+  crypto_aead_setkey
+  crypto_ahash_digest
+  crypto_ahash_setkey
+  crypto_alloc_aead
+  crypto_alloc_ahash
+  crypto_alloc_shash
+  crypto_alloc_skcipher
+  crypto_alloc_sync_skcipher
+  crypto_dequeue_request
+  crypto_destroy_tfm
+  crypto_enqueue_request
+  crypto_init_queue
+  __crypto_memneq
+  crypto_register_aead
+  crypto_register_ahash
+  crypto_register_rngs
+  crypto_register_skcipher
+  crypto_shash_digest
+  crypto_shash_final
+  crypto_shash_finup
+  crypto_shash_setkey
+  crypto_shash_update
+  crypto_skcipher_decrypt
+  crypto_skcipher_encrypt
+  crypto_skcipher_setkey
+  crypto_unregister_aead
+  crypto_unregister_ahash
+  crypto_unregister_rngs
+  crypto_unregister_skcipher
+  __crypto_xor
+  css_next_child
+  csum_partial
+  csum_tcpudp_nofold
+  _ctype
+  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_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_remove
+  debugfs_rename
+  dec_node_page_state
+  default_llseek
+  deferred_free
+  delayed_work_timer_fn
+  del_timer
+  del_timer_sync
+  destroy_workqueue
+  dev_addr_mod
+  dev_alloc_name
+  __dev_change_net_namespace
+  dev_close
+  dev_coredumpm
+  dev_coredumpv
+  _dev_crit
+  dev_driver_string
+  _dev_emerg
+  _dev_err
+  dev_err_probe
+  dev_fetch_sw_netstats
+  devfreq_add_device
+  devfreq_add_governor
+  devfreq_get_devfreq_by_node
+  devfreq_remove_device
+  devfreq_remove_governor
+  devfreq_resume_device
+  devfreq_suspend_device
+  dev_fwnode
+  __dev_get_by_index
+  dev_get_by_index
+  dev_get_regmap
+  device_add
+  device_add_groups
+  device_create
+  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_match_data
+  device_get_named_child_node
+  device_get_next_child_node
+  device_initialize
+  device_link_add
+  device_match_fwnode
+  device_match_name
+  device_property_match_string
+  device_property_present
+  device_property_read_string
+  device_property_read_string_array
+  device_property_read_u16_array
+  device_property_read_u32_array
+  device_register
+  device_remove_file
+  device_rename
+  device_set_wakeup_capable
+  device_show_int
+  device_store_int
+  device_unregister
+  device_wakeup_disable
+  device_wakeup_enable
+  _dev_info
+  __dev_kfree_skb_any
+  devm_add_action
+  devm_backlight_device_register
+  devm_bitmap_zalloc
+  devm_blk_crypto_profile_init
+  devm_clk_bulk_get
+  devm_clk_bulk_get_all
+  devm_clk_get
+  devm_clk_get_optional
+  devm_clk_hw_register
+  devm_clk_put
+  devm_clk_register
+  devm_device_add_group
+  devm_device_remove_group
+  devm_extcon_dev_allocate
+  devm_extcon_dev_register
+  devm_free_irq
+  devm_fwnode_gpiod_get_index
+  devm_fwnode_iio_channel_get_by_name
+  devm_gen_pool_create
+  devm_gpiochip_add_data_with_key
+  devm_gpiod_get
+  devm_gpiod_get_index
+  devm_gpiod_get_optional
+  devm_gpio_request_one
+  devm_hwspin_lock_register
+  devm_iio_channel_get
+  devm_iio_device_alloc
+  __devm_iio_device_register
+  __devm_iio_trigger_alloc
+  devm_iio_trigger_register
+  devm_input_allocate_device
+  devm_ioremap
+  devm_ioremap_resource
+  devm_ioremap_wc
+  devm_iounmap
+  devm_kasprintf
+  devm_kfree
+  devm_kmalloc
+  devm_kmemdup
+  devm_krealloc
+  devm_kstrdup
+  devm_led_classdev_multicolor_register_ext
+  devm_led_classdev_register_ext
+  devm_mbox_controller_register
+  devm_mfd_add_devices
+  devm_nvmem_register
+  devm_of_clk_add_hw_provider
+  devm_of_icc_get
+  devm_of_platform_populate
+  devm_pci_alloc_host_bridge
+  devm_pinctrl_get
+  devm_pinctrl_put
+  devm_pinctrl_register
+  devm_platform_get_and_ioremap_resource
+  devm_platform_ioremap_resource
+  devm_platform_ioremap_resource_byname
+  devm_power_supply_get_by_phandle
+  devm_power_supply_register
+  devm_pwm_get
+  devm_qcom_smem_state_get
+  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_spmi_ext
+  devm_regulator_bulk_get
+  devm_regulator_get
+  devm_regulator_get_optional
+  devm_regulator_put
+  devm_regulator_register
+  devm_regulator_register_notifier
+  devm_request_any_context_irq
+  __devm_request_region
+  devm_request_threaded_irq
+  __devm_reset_control_get
+  devm_reset_controller_register
+  devm_rtc_allocate_device
+  __devm_rtc_register_device
+  devm_snd_soc_register_card
+  devm_tegra_memory_controller_get
+  devm_thermal_of_cooling_device_register
+  devm_thermal_of_zone_register
+  devm_usb_get_phy
+  devm_usb_get_phy_by_node
+  _dev_notice
+  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_clear_config
+  dev_pm_opp_disable
+  dev_pm_opp_enable
+  dev_pm_opp_find_freq_ceil
+  dev_pm_opp_find_freq_exact
+  dev_pm_opp_find_freq_floor
+  dev_pm_opp_get_opp_count
+  dev_pm_opp_get_voltage
+  dev_pm_opp_of_add_table
+  dev_pm_opp_of_cpumask_remove_table
+  dev_pm_opp_of_find_icc_paths
+  dev_pm_opp_of_register_em
+  dev_pm_opp_of_remove_table
+  dev_pm_opp_put
+  dev_pm_opp_remove_all_dynamic
+  dev_pm_opp_set_config
+  dev_pm_opp_set_opp
+  dev_pm_opp_set_rate
+  dev_pm_opp_set_sharing_cpus
+  dev_pm_qos_add_notifier
+  dev_pm_qos_add_request
+  dev_pm_qos_remove_notifier
+  dev_pm_qos_remove_request
+  dev_pm_qos_update_request
+  dev_pm_set_wake_irq
+  _dev_printk
+  __dev_queue_xmit
+  devres_add
+  __devres_alloc_node
+  devres_free
+  devres_release
+  dev_set_name
+  _dev_warn
+  disable_irq
+  disable_irq_nosync
+  disable_percpu_irq
+  divider_get_val
+  divider_recalc_rate
+  divider_ro_round_rate_parent
+  divider_round_rate_parent
+  dma_alloc_attrs
+  dma_alloc_noncontiguous
+  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_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_put
+  dma_buf_unmap_attachment
+  dma_buf_vmap
+  dma_buf_vunmap
+  dma_fence_add_callback
+  dma_fence_array_create
+  dma_fence_array_ops
+  dma_fence_chain_init
+  dma_fence_context_alloc
+  dma_fence_default_wait
+  dma_fence_enable_sw_signaling
+  dma_fence_free
+  dma_fence_get_status
+  dma_fence_init
+  dma_fence_release
+  dma_fence_remove_callback
+  dma_fence_signal
+  dma_fence_signal_locked
+  dma_fence_signal_timestamp_locked
+  dma_fence_wait_timeout
+  dma_free_attrs
+  dma_free_noncontiguous
+  dma_get_sgtable_attrs
+  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
+  dmam_alloc_attrs
+  dma_map_page_attrs
+  dma_map_resource
+  dma_map_sg_attrs
+  dma_map_sgtable
+  dmam_free_coherent
+  dma_release_channel
+  dma_request_chan
+  dma_resv_fini
+  dma_resv_get_singleton
+  dma_resv_init
+  dma_resv_wait_timeout
+  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
+  dma_vmap_noncontiguous
+  dma_vunmap_noncontiguous
+  do_trace_netlink_extack
+  double_rq_lock
+  do_wait_intr
+  down
+  down_read
+  down_write
+  d_path
+  dput
+  driver_find_device
+  driver_register
+  driver_set_override
+  driver_unregister
+  drm_add_edid_modes
+  drm_add_modes_noedid
+  drm_atomic_commit
+  drm_atomic_get_connector_state
+  drm_atomic_get_crtc_state
+  drm_atomic_get_plane_state
+  drm_atomic_helper_check
+  drm_atomic_helper_cleanup_planes
+  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_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_dirtyfb
+  drm_atomic_helper_disable_plane
+  drm_atomic_helper_duplicate_state
+  drm_atomic_helper_page_flip
+  __drm_atomic_helper_plane_duplicate_state
+  drm_atomic_helper_prepare_planes
+  drm_atomic_helper_set_config
+  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_fences
+  drm_atomic_helper_wait_for_vblanks
+  drm_atomic_set_crtc_for_connector
+  drm_atomic_set_crtc_for_plane
+  drm_atomic_set_fb_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_remove
+  drm_client_init
+  drm_client_modeset_commit_locked
+  drm_client_register
+  drm_compat_ioctl
+  drm_connector_attach_encoder
+  drm_connector_cleanup
+  drm_connector_init
+  drm_connector_list_iter_begin
+  drm_connector_list_iter_end
+  drm_connector_list_iter_next
+  drm_connector_unregister
+  drm_connector_update_edid_property
+  drm_crtc_cleanup
+  drm_crtc_handle_vblank
+  drm_crtc_init_with_planes
+  drm_crtc_send_vblank_event
+  drm_crtc_set_max_vblank_count
+  drm_crtc_vblank_get
+  drm_crtc_vblank_off
+  drm_crtc_vblank_on
+  drm_crtc_vblank_put
+  drm_crtc_vblank_reset
+  drm_crtc_wait_one_vblank
+  ___drm_dbg
+  __drm_debug
+  drm_detect_hdmi_monitor
+  drm_dev_alloc
+  __drm_dev_dbg
+  drm_dev_printk
+  drm_dev_put
+  drm_dev_register
+  drm_dev_unregister
+  drm_encoder_cleanup
+  drm_encoder_init
+  __drm_err
+  drm_event_reserve_init_locked
+  drm_format_info
+  drm_framebuffer_init
+  drm_framebuffer_lookup
+  drm_framebuffer_remove
+  drm_framebuffer_unregister_private
+  drm_gem_create_mmap_offset
+  drm_gem_fb_create_handle
+  drm_gem_fb_destroy
+  drm_gem_fb_get_obj
+  drm_gem_get_pages
+  drm_gem_handle_create
+  drm_gem_mmap
+  drm_gem_mmap_obj
+  drm_gem_object_free
+  drm_gem_object_init
+  drm_gem_object_lookup
+  drm_gem_object_release
+  drm_gem_prime_fd_to_handle
+  drm_gem_prime_handle_to_fd
+  drm_gem_private_object_init
+  drm_gem_put_pages
+  drm_gem_vm_close
+  drm_gem_vm_open
+  drm_get_edid
+  drm_get_format_info
+  drm_helper_hpd_irq_event
+  drm_helper_mode_fill_fb_struct
+  drm_helper_probe_single_connector_modes
+  drm_ioctl
+  drm_is_current_master
+  drm_kms_helper_poll_disable
+  drm_kms_helper_poll_enable
+  drm_kms_helper_poll_fini
+  drm_kms_helper_poll_init
+  drm_mm_init
+  drm_mm_insert_node_in_range
+  drmm_mode_config_init
+  drm_mm_remove_node
+  drm_mm_takedown
+  drm_mode_config_cleanup
+  drm_mode_config_reset
+  drm_mode_convert_umode
+  drm_mode_copy
+  drm_mode_create
+  drm_mode_debug_printmodeline
+  drm_mode_duplicate
+  drm_mode_equal
+  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_ctx
+  drm_mode_vrefresh
+  drm_object_attach_property
+  drm_object_property_set_value
+  drm_of_component_match_add
+  drm_open
+  drm_panel_add
+  drm_panel_init
+  drm_panel_remove
+  drm_plane_cleanup
+  drm_plane_create_rotation_property
+  drm_poll
+  drm_prime_gem_destroy
+  drm_prime_pages_to_sg
+  drm_printf
+  __drm_printfn_coredump
+  drm_property_blob_get
+  drm_property_blob_put
+  drm_property_create
+  drm_property_create_bitmask
+  drm_property_create_blob
+  drm_property_create_enum
+  drm_property_create_range
+  drm_property_lookup_blob
+  __drm_puts_coredump
+  drm_read
+  drm_release
+  drm_rotation_simplify
+  drm_send_event_locked
+  drm_set_preferred_mode
+  drm_universal_plane_init
+  drm_vblank_init
+  drm_wait_one_vblank
+  dump_stack
+  __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
+  enable_irq
+  enable_percpu_irq
+  ether_setup
+  eth_mac_addr
+  ethtool_op_get_link
+  eth_type_trans
+  extcon_get_edev_by_phandle
+  extcon_get_edev_name
+  extcon_get_property
+  extcon_get_state
+  extcon_register_notifier
+  extcon_set_state
+  extcon_set_state_sync
+  fd_install
+  fget
+  _find_first_bit
+  _find_first_zero_bit
+  find_get_pid
+  _find_last_bit
+  _find_next_and_bit
+  _find_next_bit
+  _find_next_zero_bit
+  find_task_by_vpid
+  find_vma
+  find_vma_intersection
+  find_vpid
+  finish_wait
+  firmware_request_nowarn
+  flush_delayed_work
+  flush_work
+  __flush_workqueue
+  __folio_put
+  fortify_panic
+  fput
+  free_io_pgtable_ops
+  free_irq
+  free_netdev
+  __free_pages
+  free_pages
+  free_percpu
+  free_percpu_irq
+  freezer_active
+  freezing_slow_path
+  freq_qos_add_request
+  freq_qos_remove_request
+  freq_qos_update_request
+  fwnode_find_reference
+  fwnode_get_name
+  fwnode_get_named_child_node
+  fwnode_get_next_child_node
+  fwnode_handle_get
+  fwnode_handle_put
+  fwnode_property_present
+  fwnode_property_read_string
+  fwnode_property_read_u32_array
+  gcd
+  generic_device_group
+  generic_file_llseek
+  generic_handle_domain_irq
+  generic_handle_irq
+  geni_icc_disable
+  geni_icc_enable
+  geni_icc_get
+  geni_icc_set_bw
+  geni_se_clk_freq_match
+  geni_se_config_packing
+  geni_se_get_qup_hw_version
+  geni_se_init
+  geni_se_resources_off
+  geni_se_resources_on
+  geni_se_rx_dma_prep
+  geni_se_rx_dma_unprep
+  geni_se_select_mode
+  geni_se_tx_dma_prep
+  geni_se_tx_dma_unprep
+  genlmsg_multicast_allns
+  genlmsg_put
+  genl_register_family
+  genl_unregister_family
+  gen_pool_add_owner
+  gen_pool_alloc_algo_owner
+  gen_pool_avail
+  gen_pool_best_fit
+  gen_pool_create
+  gen_pool_destroy
+  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_device
+  __get_free_pages
+  get_governor_parent_kobj
+  get_net_ns_by_fd
+  get_net_ns_by_pid
+  get_option
+  get_pid_task
+  get_random_bytes
+  get_random_u16
+  get_random_u32
+  __get_task_comm
+  get_task_mm
+  get_task_pid
+  get_unmapped_area
+  get_unused_fd_flags
+  get_user_ifreq
+  get_user_pages
+  get_zeroed_page
+  gh_rm_call
+  gh_rm_notifier_register
+  gh_rm_notifier_unregister
+  gic_nonsecure_priorities
+  gic_v3_cpu_init
+  gic_v3_dist_init
+  gic_v3_dist_wait_for_rwp
+  gov_attr_set_init
+  gov_attr_set_put
+  governor_sysfs_ops
+  gpiochip_add_data_with_key
+  gpiochip_add_pin_range
+  gpiochip_disable_irq
+  gpiochip_enable_irq
+  gpiochip_generic_free
+  gpiochip_generic_request
+  gpiochip_get_data
+  gpiochip_irq_relres
+  gpiochip_irq_reqres
+  gpiochip_line_is_valid
+  gpiochip_lock_as_irq
+  gpiochip_remove
+  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_cansleep
+  gpiod_is_active_low
+  gpiod_set_array_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_irq
+  gpio_free
+  gpio_free_array
+  gpio_request
+  gpio_request_one
+  gpio_to_desc
+  handle_bad_irq
+  handle_edge_irq
+  handle_fasteoi_ack_irq
+  handle_fasteoi_irq
+  handle_level_irq
+  handle_nested_irq
+  handle_simple_irq
+  handle_sysrq
+  hashlen_string
+  hex2bin
+  hex_dump_to_buffer
+  hex_to_bin
+  housekeeping_cpumask
+  housekeeping_overridden
+  housekeeping_test_cpu
+  hrtimer_active
+  hrtimer_cancel
+  hrtimer_forward
+  __hrtimer_get_remaining
+  hrtimer_init
+  hrtimer_start_range_ns
+  hrtimer_try_to_cancel
+  __hw_addr_init
+  __hw_addr_sync
+  __hw_addr_unsync
+  hwrng_register
+  hwrng_unregister
+  hwspin_lock_free
+  hwspin_lock_request_specific
+  __hwspin_lock_timeout
+  __hwspin_unlock
+  i2c_adapter_type
+  i2c_add_adapter
+  i2c_add_numbered_adapter
+  i2c_bus_type
+  i2c_del_adapter
+  i2c_del_driver
+  i2c_for_each_dev
+  i2c_get_adapter
+  i2c_get_dma_safe_msg_buf
+  i2c_new_ancillary_device
+  i2c_new_client_device
+  i2c_put_adapter
+  i2c_put_dma_safe_msg_buf
+  i2c_register_driver
+  i2c_smbus_read_byte_data
+  i2c_smbus_read_i2c_block_data
+  i2c_smbus_write_byte_data
+  __i2c_smbus_xfer
+  i2c_smbus_xfer
+  __i2c_transfer
+  i2c_transfer
+  i2c_transfer_buffer_flags
+  i2c_unregister_device
+  i2c_verify_client
+  icc_get
+  icc_link_create
+  icc_node_add
+  icc_node_create
+  icc_nodes_remove
+  icc_provider_deregister
+  icc_provider_init
+  icc_provider_register
+  icc_put
+  icc_set_bw
+  icc_set_tag
+  ida_alloc_range
+  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
+  iio_alloc_pollfunc
+  iio_buffer_enabled
+  iio_buffer_init
+  iio_buffer_put
+  iio_dealloc_pollfunc
+  iio_device_alloc
+  iio_device_attach_buffer
+  iio_device_claim_direct_mode
+  iio_device_free
+  iio_device_id
+  __iio_device_register
+  iio_device_release_direct_mode
+  iio_device_unregister
+  iio_enum_available_read
+  iio_enum_read
+  iio_enum_write
+  iio_get_channel_type
+  iio_get_time_ns
+  iio_pollfunc_store_time
+  iio_push_event
+  iio_push_to_buffers
+  iio_read_channel_processed
+  iio_read_const_attr
+  iio_read_mount_matrix
+  iio_show_mount_matrix
+  __iio_trigger_alloc
+  iio_trigger_free
+  iio_trigger_generic_data_rdy_poll
+  iio_trigger_notify_done
+  iio_trigger_poll_chained
+  iio_trigger_register
+  iio_trigger_unregister
+  inc_node_page_state
+  in_egroup_p
+  inet_csk_get_port
+  init_dummy_netdev
+  init_iova_domain
+  init_net
+  __init_rwsem
+  init_srcu_struct
+  __init_swait_queue_head
+  init_task
+  init_timer_key
+  init_uts_ns
+  init_wait_entry
+  __init_waitqueue_head
+  input_allocate_device
+  input_close_device
+  input_event
+  input_free_device
+  input_mt_init_slots
+  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_unregister_device
+  input_unregister_handle
+  input_unregister_handler
+  interval_tree_insert
+  interval_tree_iter_first
+  interval_tree_iter_next
+  interval_tree_remove
+  int_sqrt
+  iomem_resource
+  iommu_alloc_resv_region
+  iommu_attach_device
+  iommu_detach_device
+  iommu_device_register
+  iommu_device_sysfs_add
+  iommu_device_sysfs_remove
+  iommu_device_unregister
+  iommu_dma_get_resv_regions
+  iommu_domain_alloc
+  iommu_domain_free
+  iommu_fwspec_add_ids
+  iommu_fwspec_free
+  iommu_get_domain_for_dev
+  iommu_get_msi_cookie
+  iommu_group_for_each_dev
+  iommu_group_get
+  iommu_group_get_iommudata
+  iommu_group_put
+  iommu_group_ref_get
+  iommu_group_set_iommudata
+  iommu_iova_to_phys
+  iommu_map
+  iommu_map_sg
+  iommu_present
+  iommu_put_resv_regions
+  iommu_set_fault_handler
+  iommu_set_pgtable_quirks
+  iommu_unmap
+  ioremap_prot
+  iounmap
+  __iowrite32_copy
+  ip_send_check
+  __ipv6_addr_type
+  ipv6_skip_exthdr
+  __irq_apply_affinity_hint
+  irq_check_status_bit
+  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_mapping_affinity
+  irq_dispose_mapping
+  __irq_domain_add
+  irq_domain_alloc_irqs_parent
+  irq_domain_create_hierarchy
+  irq_domain_disconnect_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_translate_twocell
+  irq_domain_update_bus_token
+  irq_domain_xlate_onecell
+  irq_domain_xlate_twocell
+  irq_find_matching_fwspec
+  irq_get_irqchip_state
+  irq_get_irq_data
+  irq_modify_status
+  irq_of_parse_and_map
+  __irq_resolve_mapping
+  irq_set_affinity_notifier
+  irq_set_chained_handler_and_data
+  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_vmalloc_addr
+  iterate_fd
+  jiffies
+  jiffies_to_msecs
+  jiffies_to_usecs
+  kasan_flag_enabled
+  kasprintf
+  kernel_bind
+  kernel_connect
+  kernel_getsockname
+  kernel_kobj
+  kernel_param_lock
+  kernel_param_unlock
+  kernel_recvmsg
+  kernel_sendmsg
+  kernfs_find_and_get_ns
+  kernfs_notify
+  kernfs_put
+  key_create_or_update
+  key_put
+  keyring_alloc
+  __kfifo_alloc
+  __kfifo_free
+  __kfifo_from_user
+  __kfifo_in
+  __kfifo_out
+  __kfifo_to_user
+  kfree
+  kfree_const
+  kfree_sensitive
+  kfree_skb_list_reason
+  kfree_skb_reason
+  kimage_vaddr
+  kimage_voffset
+  __kmalloc
+  kmalloc_caches
+  kmalloc_large
+  kmalloc_node_trace
+  kmalloc_trace
+  kmem_cache_alloc
+  kmem_cache_create
+  kmem_cache_create_usercopy
+  kmem_cache_destroy
+  kmem_cache_free
+  kmemdup
+  kobject_add
+  kobject_create_and_add
+  kobject_del
+  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_find_obj
+  kset_unregister
+  ksize
+  ksoftirqd
+  kstat_irqs_usr
+  kstrdup
+  kstrdup_const
+  kstrdup_quotable_cmdline
+  kstrndup
+  kstrtobool
+  kstrtoint
+  kstrtoll
+  kstrtos16
+  kstrtos8
+  kstrtou16
+  kstrtou8
+  kstrtouint
+  kstrtouint_from_user
+  kstrtoull
+  kstrtoull_from_user
+  kswapd
+  kthread_bind_mask
+  kthread_cancel_delayed_work_sync
+  kthread_cancel_work_sync
+  kthread_complete_and_exit
+  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_queue_delayed_work
+  kthread_queue_work
+  kthread_should_stop
+  kthread_stop
+  kthread_worker_fn
+  ktime_get
+  ktime_get_coarse_with_offset
+  ktime_get_mono_fast_ns
+  ktime_get_raw
+  ktime_get_real_seconds
+  ktime_get_real_ts64
+  ktime_get_seconds
+  ktime_get_with_offset
+  kvfree
+  kvfree_call_rcu
+  kvmalloc_node
+  led_classdev_register_ext
+  led_classdev_unregister
+  led_init_default_state_get
+  led_mc_calc_color_components
+  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_sock_nested
+  log_post_read_mmio
+  log_post_write_mmio
+  log_read_mmio
+  log_write_mmio
+  mac_pton
+  mas_find
+  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
+  media_device_cleanup
+  media_device_init
+  __media_device_register
+  media_device_unregister
+  media_entity_pads_init
+  memblock_free
+  __memcat_p
+  memchr
+  memcmp
+  memcpy
+  __memcpy_fromio
+  __memcpy_toio
+  memdup_user
+  memmove
+  memory_read_from_buffer
+  memparse
+  mempool_alloc
+  mempool_alloc_slab
+  mempool_create
+  mempool_destroy
+  mempool_free
+  mempool_free_slab
+  memremap
+  mem_section
+  memset
+  __memset_io
+  memstart_addr
+  memunmap
+  migrate_swap
+  __migrate_task
+  mipi_dsi_create_packet
+  mipi_dsi_dcs_set_display_brightness
+  mipi_dsi_dcs_set_tear_off
+  mipi_dsi_host_register
+  mipi_dsi_host_unregister
+  misc_deregister
+  misc_register
+  __mmap_lock_do_trace_acquire_returned
+  __mmap_lock_do_trace_released
+  __mmap_lock_do_trace_start_locking
+  mmc_cqe_request_done
+  mmc_execute_tuning
+  mmc_get_card
+  mmc_get_ext_csd
+  mmc_of_parse
+  __mmc_poll_for_busy
+  mmc_prepare_busy_cmd
+  mmc_put_card
+  mmc_regulator_get_supply
+  mmc_regulator_set_ocr
+  mmc_regulator_set_vqmmc
+  mmc_retune_hold
+  mmc_retune_release
+  mmc_select_card
+  mmc_send_tuning
+  mmc_set_bus_mode
+  mmc_set_bus_width
+  mmc_set_clock
+  mmc_set_timing
+  mmc_wait_for_cmd
+  mmput
+  mod_delayed_work_on
+  mod_node_page_state
+  mod_timer
+  __module_get
+  module_layout
+  module_put
+  __msecs_to_jiffies
+  msleep
+  msleep_interruptible
+  mtree_load
+  __mutex_init
+  mutex_is_locked
+  mutex_lock
+  mutex_lock_interruptible
+  mutex_trylock
+  mutex_unlock
+  napi_complete_done
+  napi_disable
+  napi_enable
+  napi_gro_flush
+  napi_gro_receive
+  __napi_schedule
+  napi_schedule_prep
+  __ndelay
+  __netdev_alloc_skb
+  netdev_err
+  netdev_info
+  netdev_set_default_ethtool_ops
+  netdev_update_features
+  netif_carrier_off
+  netif_carrier_on
+  netif_napi_add_weight
+  __netif_napi_del
+  netif_receive_skb
+  netif_receive_skb_list
+  netif_rx
+  netif_tx_lock
+  netif_tx_stop_all_queues
+  netif_tx_unlock
+  netif_tx_wake_queue
+  netlink_broadcast
+  __netlink_kernel_create
+  netlink_kernel_release
+  netlink_register_notifier
+  netlink_unicast
+  netlink_unregister_notifier
+  net_ns_type_operations
+  net_ratelimit
+  nla_find
+  nla_memcpy
+  __nla_parse
+  nla_put
+  nla_put_64bit
+  nla_reserve
+  nla_reserve_64bit
+  nla_strscpy
+  __nla_validate
+  __nlmsg_put
+  nonseekable_open
+  noop_llseek
+  nr_cpu_ids
+  nr_ipi_get
+  nr_irqs
+  nsecs_to_jiffies
+  ns_to_timespec64
+  __num_online_cpus
+  nvmem_cell_get
+  nvmem_cell_put
+  nvmem_cell_read
+  nvmem_cell_read_u32
+  nvmem_cell_read_variable_le_u32
+  nvmem_cell_write
+  of_address_to_resource
+  of_alias_get_id
+  of_clk_add_hw_provider
+  of_clk_add_provider
+  of_clk_del_provider
+  of_clk_get_from_provider
+  of_clk_get_parent_name
+  of_clk_hw_simple_get
+  of_clk_src_onecell_get
+  of_clk_src_simple_get
+  of_count_phandle_with_args
+  of_cpu_node_to_id
+  of_device_get_match_data
+  of_device_is_available
+  of_device_is_compatible
+  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_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_node_by_name
+  of_find_node_by_phandle
+  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_cpu_node
+  of_get_i2c_adapter_by_node
+  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_get_required_opp_performance_state
+  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_parent
+  of_graph_is_present
+  of_graph_parse_endpoint
+  of_hwspin_lock_get_id
+  of_icc_get
+  of_iomap
+  of_irq_find_parent
+  of_irq_get
+  of_irq_get_byname
+  of_irq_parse_one
+  of_match_device
+  of_match_node
+  of_modalias_node
+  of_n_addr_cells
+  of_node_name_eq
+  of_n_size_cells
+  __of_parse_phandle_with_args
+  of_phandle_iterator_init
+  of_phandle_iterator_next
+  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_variable_u16_array
+  of_property_read_variable_u32_array
+  of_property_read_variable_u8_array
+  of_prop_next_string
+  of_prop_next_u32
+  of_regulator_match
+  of_reserved_mem_device_init_by_idx
+  of_reserved_mem_device_release
+  of_reserved_mem_lookup
+  of_thermal_get_ntrips
+  of_thermal_get_trip_points
+  of_thermal_is_trip_valid
+  of_translate_address
+  on_each_cpu_cond_mask
+  overflowuid
+  page_frag_alloc_align
+  page_frag_free
+  page_owner_inited
+  page_pinner_inited
+  __page_pinner_put_page
+  panic
+  panic_notifier_list
+  panic_timeout
+  param_array_ops
+  param_get_int
+  param_get_string
+  param_get_uint
+  param_ops_bool
+  param_ops_charp
+  param_ops_int
+  param_ops_string
+  param_ops_uint
+  param_ops_ullong
+  param_set_bool
+  param_set_copystring
+  param_set_int
+  param_set_uint
+  pci_alloc_irq_vectors_affinity
+  pci_assign_resource
+  pci_bus_type
+  pci_clear_master
+  pci_dev_get
+  pci_device_group
+  pci_device_is_present
+  pci_dev_present
+  pci_dev_put
+  pci_disable_device
+  pci_disable_msi
+  pcie_capability_clear_and_set_word
+  pcie_capability_read_word
+  pci_enable_device
+  pci_enable_pcie_error_reporting
+  pci_find_ext_capability
+  pci_free_irq_vectors
+  pci_get_device
+  pci_host_probe
+  pci_iomap
+  pci_iounmap
+  pci_irq_vector
+  pci_load_and_free_saved_state
+  pci_load_saved_state
+  pci_msi_create_irq_domain
+  pci_msi_mask_irq
+  pci_msi_unmask_irq
+  pci_read_config_dword
+  pci_read_config_word
+  __pci_register_driver
+  pci_release_region
+  pci_remove_root_bus
+  pci_request_region
+  pci_restore_state
+  pci_save_state
+  pci_set_master
+  pci_set_power_state
+  pci_stop_root_bus
+  pci_store_saved_state
+  pci_unregister_driver
+  pci_walk_bus
+  pci_write_config_dword
+  pci_write_config_word
+  __per_cpu_offset
+  per_cpu_ptr_to_phys
+  perf_aux_output_begin
+  perf_aux_output_end
+  perf_aux_output_flag
+  perf_event_create_kernel_counter
+  perf_event_enable
+  perf_event_read_local
+  perf_event_read_value
+  perf_event_release_kernel
+  perf_get_aux
+  perf_pmu_register
+  perf_pmu_unregister
+  perf_trace_buf_alloc
+  perf_trace_run_bpf_submit
+  pick_highest_pushable_task
+  pick_migrate_task
+  pid_nr_ns
+  pid_task
+  pinconf_generic_dt_node_to_map
+  pinctrl_dev_get_drvdata
+  pinctrl_force_default
+  pinctrl_force_sleep
+  pinctrl_lookup_state
+  pinctrl_pm_select_default_state
+  pinctrl_pm_select_sleep_state
+  pinctrl_select_state
+  pinctrl_utils_free_map
+  platform_bus_type
+  platform_device_add
+  platform_device_add_data
+  platform_device_alloc
+  platform_device_put
+  platform_device_register_full
+  platform_device_unregister
+  __platform_driver_register
+  platform_driver_unregister
+  platform_get_irq
+  platform_get_irq_byname
+  platform_get_irq_byname_optional
+  platform_get_irq_optional
+  platform_get_resource
+  platform_get_resource_byname
+  platform_irqchip_probe
+  platform_irq_count
+  pm_clk_add
+  pm_clk_create
+  pm_clk_destroy
+  pm_clk_resume
+  pm_clk_suspend
+  pm_generic_resume
+  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_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_suspend_target_state
+  pm_system_wakeup
+  pm_wakeup_dev_event
+  pm_wakeup_ws_event
+  policy_has_boost_freq
+  power_supply_changed
+  power_supply_get_battery_info
+  power_supply_get_by_name
+  power_supply_get_drvdata
+  power_supply_get_property
+  power_supply_put
+  power_supply_put_battery_info
+  power_supply_register
+  power_supply_register_no_ws
+  power_supply_reg_notifier
+  power_supply_set_property
+  power_supply_unregister
+  power_supply_unreg_notifier
+  preempt_schedule
+  preempt_schedule_notrace
+  prepare_to_wait_event
+  print_hex_dump
+  _printk
+  _printk_deferred
+  proc_create_data
+  proc_dointvec
+  proc_dointvec_minmax
+  proc_dostring
+  proc_douintvec_minmax
+  proc_mkdir
+  proto_register
+  proto_unregister
+  pskb_expand_head
+  __pskb_pull_tail
+  ___pskb_trim
+  put_device
+  put_iova_domain
+  __put_net
+  put_pid
+  __put_task_struct
+  put_unused_fd
+  put_user_ifreq
+  pwm_apply_state
+  qcom_icc_xlate_extended
+  qcom_smem_state_get
+  qcom_smem_state_register
+  qcom_smem_state_unregister
+  qcom_smem_state_update_bits
+  queue_delayed_work_on
+  queue_work_on
+  radix_tree_delete
+  radix_tree_insert
+  radix_tree_iter_delete
+  radix_tree_lookup
+  radix_tree_next_chunk
+  ___ratelimit
+  rational_best_approximation
+  _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_rq_lock_nested
+  raw_spin_rq_unlock
+  _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_first
+  rb_insert_color
+  rb_last
+  rb_next
+  rb_prev
+  rcu_barrier
+  __rcu_read_lock
+  __rcu_read_unlock
+  rdev_get_drvdata
+  rdev_get_regmap
+  reboot_mode
+  rebuild_sched_domains
+  refcount_dec_and_lock
+  refcount_dec_not_one
+  refcount_warn_saturate
+  regcache_cache_only
+  regcache_mark_dirty
+  regcache_sync
+  regcache_sync_region
+  __register_chrdev
+  register_chrdev_region
+  register_console
+  register_die_notifier
+  register_ftrace_export
+  register_inet6addr_notifier
+  register_inetaddr_notifier
+  register_kretprobe
+  register_module_notifier
+  register_netdev
+  register_netdevice
+  register_netdevice_notifier
+  register_netevent_notifier
+  register_pernet_device
+  register_pm_notifier
+  register_reboot_notifier
+  register_restart_handler
+  __register_rpmsg_driver
+  register_shrinker
+  register_syscore_ops
+  register_sysctl_table
+  regmap_bulk_read
+  regmap_bulk_write
+  regmap_check_range_table
+  regmap_field_read
+  regmap_field_update_bits_base
+  __regmap_init
+  regmap_irq_get_virq
+  regmap_mmio_detach_clk
+  regmap_multi_reg_write
+  regmap_read
+  regmap_update_bits_base
+  regmap_write
+  regulator_allow_bypass
+  regulator_bulk_disable
+  regulator_count_voltages
+  regulator_disable
+  regulator_disable_regmap
+  regulator_enable
+  regulator_enable_regmap
+  regulator_force_disable
+  regulator_get
+  regulator_get_mode
+  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_map_voltage_linear
+  regulator_map_voltage_linear_range
+  regulator_notifier_call_chain
+  regulator_put
+  regulator_register_notifier
+  regulator_set_active_discharge_regmap
+  regulator_set_load
+  regulator_set_mode
+  regulator_set_voltage
+  regulator_set_voltage_sel_regmap
+  regulator_sync_voltage
+  regulator_unregister_notifier
+  release_firmware
+  __release_region
+  release_sock
+  remap_pfn_range
+  remove_cpu
+  remove_proc_entry
+  report_iommu_fault
+  request_firmware
+  request_firmware_into_buf
+  request_firmware_nowait
+  __request_module
+  __request_percpu_irq
+  __request_region
+  request_threaded_irq
+  resched_curr
+  reset_control_assert
+  reset_control_deassert
+  reset_control_reset
+  return_address
+  rfkill_alloc
+  rfkill_blocked
+  rfkill_destroy
+  rfkill_init_sw_state
+  rfkill_register
+  rfkill_resume_polling
+  rfkill_set_hw_state_reason
+  rfkill_unregister
+  rhashtable_free_and_destroy
+  rhashtable_insert_slow
+  rhltable_init
+  __rht_bucket_nested
+  rht_bucket_nested
+  rht_bucket_nested_insert
+  root_task_group
+  round_jiffies
+  round_jiffies_relative
+  round_jiffies_up
+  rpmsg_poll
+  rpmsg_register_device
+  rpmsg_register_device_override
+  rpmsg_send
+  rpmsg_trysend
+  rpmsg_unregister_device
+  rproc_add
+  rproc_add_subdev
+  rproc_alloc
+  rproc_boot
+  rproc_coredump
+  rproc_coredump_add_custom_segment
+  rproc_coredump_add_segment
+  rproc_coredump_cleanup
+  rproc_coredump_set_elf_info
+  rproc_del
+  rproc_free
+  rproc_get_by_child
+  rproc_get_by_phandle
+  rproc_put
+  rproc_remove_subdev
+  rproc_report_crash
+  rproc_set_firmware
+  rproc_shutdown
+  rtc_time64_to_tm
+  rtc_tm_to_time64
+  rtc_update_irq
+  rt_mutex_lock
+  rt_mutex_trylock
+  rt_mutex_unlock
+  rtnl_is_locked
+  rtnl_lock
+  rtnl_trylock
+  rtnl_unlock
+  runqueues
+  scatterwalk_ffwd
+  scatterwalk_map_and_copy
+  sched_clock
+  sched_feat_keys
+  sched_feat_names
+  sched_setattr
+  sched_set_fifo
+  sched_set_normal
+  sched_setscheduler
+  sched_setscheduler_nocheck
+  sched_uclamp_used
+  schedule
+  schedule_timeout
+  schedule_timeout_interruptible
+  scnprintf
+  __sdhci_add_host
+  sdhci_add_host
+  sdhci_cleanup_host
+  sdhci_cqe_disable
+  sdhci_cqe_enable
+  sdhci_cqe_irq
+  sdhci_dumpregs
+  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_set_timeout
+  sdhci_setup_host
+  select_fallback_rq
+  send_sig_info
+  seq_buf_printf
+  seq_hex_dump
+  seq_lseek
+  seq_open
+  seq_printf
+  seq_putc
+  seq_puts
+  seq_read
+  seq_release
+  seq_vprintf
+  seq_write
+  set_cpus_allowed_ptr
+  set_next_entity
+  set_normalized_timespec64
+  set_page_dirty_lock
+  __set_page_owner
+  set_task_cpu
+  set_user_nice
+  sg_alloc_table
+  sg_alloc_table_from_pages_segment
+  sg_copy_from_buffer
+  sg_copy_to_buffer
+  sg_free_table
+  sg_init_one
+  sg_init_table
+  sg_miter_next
+  sg_miter_start
+  sg_miter_stop
+  sg_next
+  __sg_page_iter_dma_next
+  __sg_page_iter_next
+  __sg_page_iter_start
+  shmem_read_mapping_page_gfp
+  show_regs
+  si_meminfo
+  simple_attr_open
+  simple_attr_read
+  simple_attr_release
+  simple_attr_write
+  simple_open
+  simple_read_from_buffer
+  simple_write_to_buffer
+  single_open
+  single_release
+  si_swapinfo
+  sk_alloc
+  skb_add_rx_frag
+  skb_checksum_help
+  skb_clone
+  skb_clone_sk
+  skb_coalesce_rx_frag
+  skb_complete_wifi_ack
+  skb_copy
+  skb_copy_bits
+  skb_copy_datagram_from_iter
+  skb_copy_datagram_iter
+  skb_copy_expand
+  skb_dequeue
+  skb_ensure_writable
+  skb_free_datagram
+  __skb_get_hash
+  __skb_gso_segment
+  __skb_pad
+  skb_pull
+  skb_push
+  skb_put
+  skb_queue_head
+  skb_queue_purge
+  skb_queue_tail
+  skb_recv_datagram
+  skb_set_owner_w
+  skb_store_bits
+  skb_trim
+  skb_unlink
+  sk_error_report
+  sk_free
+  skip_spaces
+  smp_call_function_single
+  smp_call_function_single_async
+  snd_info_create_card_entry
+  snd_info_create_module_entry
+  snd_info_free_entry
+  snd_info_register
+  snd_jack_set_key
+  snd_pcm_format_width
+  snd_soc_add_component_controls
+  snd_soc_card_get_kcontrol
+  snd_soc_card_jack_new
+  snd_soc_component_exit_regmap
+  snd_soc_component_init_regmap
+  snd_soc_component_read
+  snd_soc_component_update_bits
+  snd_soc_component_write
+  snd_soc_dai_get_channel_map
+  snd_soc_dai_set_channel_map
+  snd_soc_dapm_add_routes
+  snd_soc_dapm_disable_pin
+  snd_soc_dapm_force_enable_pin
+  snd_soc_dapm_get_enum_double
+  snd_soc_dapm_get_volsw
+  snd_soc_dapm_ignore_suspend
+  snd_soc_dapm_kcontrol_widget
+  snd_soc_dapm_mixer_update_power
+  snd_soc_dapm_mux_update_power
+  snd_soc_dapm_new_controls
+  snd_soc_dapm_new_widgets
+  snd_soc_dapm_put_enum_double
+  snd_soc_dapm_put_volsw
+  snd_soc_dapm_sync
+  snd_soc_get_enum_double
+  snd_soc_get_pcm_runtime
+  snd_soc_get_volsw
+  snd_soc_info_enum_double
+  snd_soc_info_volsw
+  snd_soc_jack_report
+  snd_soc_lookup_component
+  snd_soc_of_parse_audio_routing
+  snd_soc_of_parse_card_name
+  snd_soc_pm_ops
+  snd_soc_put_enum_double
+  snd_soc_put_volsw
+  snd_soc_register_component
+  snd_soc_rtdcom_lookup
+  snd_soc_set_runtime_hwparams
+  snd_soc_unregister_card
+  snd_soc_unregister_component
+  snprintf
+  soc_device_register
+  soc_device_unregister
+  sock_alloc_send_pskb
+  __sock_create
+  sock_create_kern
+  sock_gettstamp
+  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_reason
+  sock_register
+  sock_release
+  sock_setsockopt
+  sock_unregister
+  sort
+  __spi_alloc_controller
+  spi_get_device_id
+  spi_register_controller
+  __spi_register_driver
+  spi_setup
+  spi_sync
+  spi_unregister_controller
+  spmi_controller_add
+  spmi_controller_alloc
+  spmi_controller_remove
+  spmi_device_from_of
+  __spmi_driver_register
+  sprintf
+  sprint_symbol
+  srcu_init_notifier_head
+  srcu_notifier_call_chain
+  srcu_notifier_chain_register
+  srcu_notifier_chain_unregister
+  __srcu_read_lock
+  __srcu_read_unlock
+  sscanf
+  __stack_chk_fail
+  stack_trace_print
+  stack_trace_save_tsk
+  static_key_disable
+  stop_machine
+  stop_one_cpu
+  stop_one_cpu_nowait
+  strcasecmp
+  strchr
+  strchrnul
+  strcmp
+  strcpy
+  strcspn
+  stream_open
+  strim
+  strlcat
+  strlcpy
+  strlen
+  strncasecmp
+  strnchr
+  strncmp
+  strncpy
+  strnlen
+  strnstr
+  strpbrk
+  strrchr
+  strreplace
+  strscpy
+  strscpy_pad
+  strsep
+  strstr
+  __sw_hweight16
+  __sw_hweight32
+  __sw_hweight64
+  __sw_hweight8
+  sync_file_create
+  sync_file_get_fence
+  synchronize_irq
+  synchronize_net
+  synchronize_rcu
+  synchronize_srcu
+  syscon_node_to_regmap
+  syscon_regmap_lookup_by_phandle
+  sysctl_sched_features
+  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_32bit_el0_cpumask
+  system_freezable_wq
+  system_highpri_wq
+  system_power_efficient_wq
+  system_state
+  system_unbound_wq
+  system_wq
+  sys_tz
+  task_active_pid_ns
+  __tasklet_hi_schedule
+  tasklet_init
+  tasklet_kill
+  __tasklet_schedule
+  tasklet_setup
+  tasklet_unlock_wait
+  tasklist_lock
+  __task_pid_nr_ns
+  __task_rq_lock
+  task_rq_lock
+  tegra_mc_probe_device
+  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_register
+  thermal_zone_device_unregister
+  thermal_zone_device_update
+  thermal_zone_get_temp
+  thermal_zone_get_zone_by_name
+  tick_nohz_get_sleep_length
+  time64_to_tm
+  topology_clear_scale_freq_source
+  topology_update_done
+  topology_update_thermal_pressure
+  _totalram_pages
+  touchscreen_parse_properties
+  touchscreen_report_pos
+  trace_array_put
+  __trace_bprintk
+  trace_event_buffer_commit
+  trace_event_buffer_reserve
+  trace_event_printf
+  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
+  __traceiter_android_rvh_cgroup_force_kthread_migration
+  __traceiter_android_rvh_check_preempt_wakeup
+  __traceiter_android_rvh_cpu_cgroup_attach
+  __traceiter_android_rvh_cpu_cgroup_online
+  __traceiter_android_rvh_dequeue_task
+  __traceiter_android_rvh_do_sched_yield
+  __traceiter_android_rvh_enqueue_task
+  __traceiter_android_rvh_find_busiest_queue
+  __traceiter_android_rvh_find_lowest_rq
+  __traceiter_android_rvh_flush_task
+  __traceiter_android_rvh_get_nohz_timer_target
+  __traceiter_android_rvh_iommu_alloc_insert_iova
+  __traceiter_android_rvh_iommu_iovad_init_alloc_algo
+  __traceiter_android_rvh_iommu_limit_align_shift
+  __traceiter_android_rvh_iommu_setup_dma_ops
+  __traceiter_android_rvh_is_cpu_allowed
+  __traceiter_android_rvh_mmc_resume
+  __traceiter_android_rvh_mmc_suspend
+  __traceiter_android_rvh_new_task_stats
+  __traceiter_android_rvh_replace_next_task_fair
+  __traceiter_android_rvh_rto_next_cpu
+  __traceiter_android_rvh_sched_cpu_dying
+  __traceiter_android_rvh_sched_cpu_starting
+  __traceiter_android_rvh_sched_exec
+  __traceiter_android_rvh_sched_fork_init
+  __traceiter_android_rvh_sched_newidle_balance
+  __traceiter_android_rvh_sched_nohz_balancer_kick
+  __traceiter_android_rvh_schedule
+  __traceiter_android_rvh_select_task_rq_fair
+  __traceiter_android_rvh_select_task_rq_rt
+  __traceiter_android_rvh_set_balance_anon_file_reclaim
+  __traceiter_android_rvh_set_cpus_allowed_by_task
+  __traceiter_android_rvh_set_task_cpu
+  __traceiter_android_rvh_show_max_freq
+  __traceiter_android_rvh_tick_entry
+  __traceiter_android_rvh_try_to_wake_up
+  __traceiter_android_rvh_ttwu_cond
+  __traceiter_android_rvh_update_cpu_capacity
+  __traceiter_android_rvh_update_misfit_status
+  __traceiter_android_rvh_update_thermal_stats
+  __traceiter_android_rvh_wake_up_new_task
+  __traceiter_android_vh_alter_mutex_list_add
+  __traceiter_android_vh_binder_restore_priority
+  __traceiter_android_vh_binder_set_priority
+  __traceiter_android_vh_binder_wakeup_ilocked
+  __traceiter_android_vh_cpufreq_fast_switch
+  __traceiter_android_vh_cpufreq_resolve_freq
+  __traceiter_android_vh_cpufreq_target
+  __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_ftrace_dump_buffer
+  __traceiter_android_vh_ftrace_format_check
+  __traceiter_android_vh_ftrace_oops_enter
+  __traceiter_android_vh_ftrace_oops_exit
+  __traceiter_android_vh_ftrace_size_check
+  __traceiter_android_vh_gic_v3_suspend
+  __traceiter_android_vh_ipi_stop
+  __traceiter_android_vh_jiffies_update
+  __traceiter_android_vh_kswapd_per_node
+  __traceiter_android_vh_printk_hotplug
+  __traceiter_android_vh_rproc_recovery
+  __traceiter_android_vh_rproc_recovery_set
+  __traceiter_android_vh_scan_abort_check_wmarks
+  __traceiter_android_vh_scheduler_tick
+  __traceiter_android_vh_timer_calc_index
+  __traceiter_android_vh_try_fixup_sea
+  __traceiter_android_vh_update_topology_flags_workfn
+  __traceiter_cpu_frequency_limits
+  __traceiter_gpu_mem_total
+  __traceiter_ipi_entry
+  __traceiter_ipi_raise
+  __traceiter_mmap_lock_acquire_returned
+  __traceiter_mmap_lock_released
+  __traceiter_mmap_lock_start_locking
+  __traceiter_sched_overutilized_tp
+  __traceiter_sched_switch
+  __traceiter_suspend_resume
+  __tracepoint_android_rvh_account_irq
+  __tracepoint_android_rvh_build_perf_domains
+  __tracepoint_android_rvh_can_migrate_task
+  __tracepoint_android_rvh_cgroup_force_kthread_migration
+  __tracepoint_android_rvh_check_preempt_wakeup
+  __tracepoint_android_rvh_cpu_cgroup_attach
+  __tracepoint_android_rvh_cpu_cgroup_online
+  __tracepoint_android_rvh_dequeue_task
+  __tracepoint_android_rvh_do_sched_yield
+  __tracepoint_android_rvh_enqueue_task
+  __tracepoint_android_rvh_find_busiest_queue
+  __tracepoint_android_rvh_find_lowest_rq
+  __tracepoint_android_rvh_flush_task
+  __tracepoint_android_rvh_get_nohz_timer_target
+  __tracepoint_android_rvh_iommu_alloc_insert_iova
+  __tracepoint_android_rvh_iommu_iovad_init_alloc_algo
+  __tracepoint_android_rvh_iommu_limit_align_shift
+  __tracepoint_android_rvh_iommu_setup_dma_ops
+  __tracepoint_android_rvh_is_cpu_allowed
+  __tracepoint_android_rvh_mmc_resume
+  __tracepoint_android_rvh_mmc_suspend
+  __tracepoint_android_rvh_new_task_stats
+  __tracepoint_android_rvh_replace_next_task_fair
+  __tracepoint_android_rvh_rto_next_cpu
+  __tracepoint_android_rvh_sched_cpu_dying
+  __tracepoint_android_rvh_sched_cpu_starting
+  __tracepoint_android_rvh_sched_exec
+  __tracepoint_android_rvh_sched_fork_init
+  __tracepoint_android_rvh_sched_newidle_balance
+  __tracepoint_android_rvh_sched_nohz_balancer_kick
+  __tracepoint_android_rvh_schedule
+  __tracepoint_android_rvh_select_task_rq_fair
+  __tracepoint_android_rvh_select_task_rq_rt
+  __tracepoint_android_rvh_set_balance_anon_file_reclaim
+  __tracepoint_android_rvh_set_cpus_allowed_by_task
+  __tracepoint_android_rvh_set_task_cpu
+  __tracepoint_android_rvh_show_max_freq
+  __tracepoint_android_rvh_tick_entry
+  __tracepoint_android_rvh_try_to_wake_up
+  __tracepoint_android_rvh_ttwu_cond
+  __tracepoint_android_rvh_update_cpu_capacity
+  __tracepoint_android_rvh_update_misfit_status
+  __tracepoint_android_rvh_update_thermal_stats
+  __tracepoint_android_rvh_wake_up_new_task
+  __tracepoint_android_vh_alter_mutex_list_add
+  __tracepoint_android_vh_binder_restore_priority
+  __tracepoint_android_vh_binder_set_priority
+  __tracepoint_android_vh_binder_wakeup_ilocked
+  __tracepoint_android_vh_cpufreq_fast_switch
+  __tracepoint_android_vh_cpufreq_resolve_freq
+  __tracepoint_android_vh_cpufreq_target
+  __tracepoint_android_vh_cpu_idle_enter
+  __tracepoint_android_vh_cpu_idle_exit
+  __tracepoint_android_vh_cpuidle_psci_enter
+  __tracepoint_android_vh_cpuidle_psci_exit
+  __tracepoint_android_vh_disable_thermal_cooling_stats
+  __tracepoint_android_vh_ftrace_dump_buffer
+  __tracepoint_android_vh_ftrace_format_check
+  __tracepoint_android_vh_ftrace_oops_enter
+  __tracepoint_android_vh_ftrace_oops_exit
+  __tracepoint_android_vh_ftrace_size_check
+  __tracepoint_android_vh_gic_v3_suspend
+  __tracepoint_android_vh_ipi_stop
+  __tracepoint_android_vh_jiffies_update
+  __tracepoint_android_vh_kswapd_per_node
+  __tracepoint_android_vh_printk_hotplug
+  __tracepoint_android_vh_rproc_recovery
+  __tracepoint_android_vh_rproc_recovery_set
+  __tracepoint_android_vh_scan_abort_check_wmarks
+  __tracepoint_android_vh_scheduler_tick
+  __tracepoint_android_vh_timer_calc_index
+  __tracepoint_android_vh_try_fixup_sea
+  __tracepoint_android_vh_update_topology_flags_workfn
+  __tracepoint_cpu_frequency_limits
+  __tracepoint_gpu_mem_total
+  __tracepoint_ipi_entry
+  __tracepoint_ipi_raise
+  __tracepoint_mmap_lock_acquire_returned
+  __tracepoint_mmap_lock_released
+  __tracepoint_mmap_lock_start_locking
+  tracepoint_probe_register
+  tracepoint_probe_register_prio
+  tracepoint_probe_unregister
+  __tracepoint_sched_overutilized_tp
+  __tracepoint_sched_switch
+  __tracepoint_suspend_resume
+  trace_print_array_seq
+  trace_print_flags_seq
+  trace_print_symbols_seq
+  trace_raw_output_prep
+  trace_seq_printf
+  trace_seq_putc
+  __trace_trigger_soft_disabled
+  tracing_off
+  try_module_get
+  try_wait_for_completion
+  tty_flip_buffer_push
+  __tty_insert_flip_char
+  tty_insert_flip_string_fixed_flag
+  uart_add_one_port
+  uart_get_baud_rate
+  uart_insert_char
+  uart_register_driver
+  uart_remove_one_port
+  uart_resume_port
+  uart_suspend_port
+  uart_try_toggle_sysrq
+  uart_unregister_driver
+  uart_update_timeout
+  uart_write_wakeup
+  uclamp_eff_value
+  __udelay
+  __uio_register_device
+  __unregister_chrdev
+  unregister_chrdev_region
+  unregister_console
+  unregister_die_notifier
+  unregister_ftrace_export
+  unregister_inet6addr_notifier
+  unregister_inetaddr_notifier
+  unregister_kretprobe
+  unregister_netdev
+  unregister_netdevice_many
+  unregister_netdevice_notifier
+  unregister_netdevice_queue
+  unregister_netevent_notifier
+  unregister_pernet_device
+  unregister_pm_notifier
+  unregister_reboot_notifier
+  unregister_restart_handler
+  unregister_rpmsg_driver
+  unregister_shrinker
+  unregister_syscore_ops
+  up
+  update_devfreq
+  update_rq_clock
+  up_read
+  up_write
+  usb_add_phy_dev
+  usb_assign_descriptors
+  usb_decode_ctrl
+  usb_ep_alloc_request
+  usb_ep_autoconfig
+  usb_ep_dequeue
+  usb_ep_disable
+  usb_ep_enable
+  usb_ep_free_request
+  usb_ep_queue
+  usb_free_all_descriptors
+  usb_function_register
+  usb_function_unregister
+  usb_gadget_connect
+  usb_gadget_disconnect
+  usb_gadget_wakeup
+  usb_hcd_is_primary_hcd
+  usb_interface_id
+  usb_phy_set_charger_current
+  usb_put_function_instance
+  usb_register_notify
+  usb_remove_phy
+  usb_role_switch_find_by_fwnode
+  usb_role_switch_get_drvdata
+  usb_role_switch_register
+  usb_role_switch_set_role
+  usb_role_switch_unregister
+  usb_speed_string
+  usb_string_id
+  usb_unregister_notify
+  __usecs_to_jiffies
+  usleep_range_state
+  uuid_gen
+  uuid_parse
+  v4l2_ctrl_find
+  v4l2_ctrl_handler_free
+  v4l2_ctrl_handler_init_class
+  v4l2_ctrl_new_custom
+  v4l2_ctrl_new_std
+  v4l2_ctrl_new_std_menu
+  v4l2_device_register
+  v4l2_device_register_subdev
+  __v4l2_device_register_subdev_nodes
+  v4l2_device_unregister
+  v4l2_device_unregister_subdev
+  v4l2_event_dequeue
+  v4l2_event_pending
+  v4l2_event_queue
+  v4l2_event_queue_fh
+  v4l2_event_subscribe
+  v4l2_event_unsubscribe
+  v4l2_fh_add
+  v4l2_fh_del
+  v4l2_fh_exit
+  v4l2_fh_init
+  v4l2_fh_open
+  v4l2_fh_release
+  v4l2_s_ctrl
+  v4l2_subdev_call_wrappers
+  v4l2_subdev_init
+  vb2_buffer_done
+  vb2_dqbuf
+  vb2_qbuf
+  vb2_queue_init
+  vb2_queue_release
+  vb2_reqbufs
+  vb2_streamoff
+  vb2_streamon
+  vchan_dma_desc_free_list
+  vchan_find_desc
+  vchan_init
+  vchan_tx_desc_free
+  vchan_tx_submit
+  verify_pkcs7_signature
+  vfree
+  video_devdata
+  video_device_alloc
+  video_device_release
+  video_device_release_empty
+  video_ioctl2
+  __video_register_device
+  video_unregister_device
+  vmalloc
+  vmalloc_nr_pages
+  vmalloc_to_page
+  vmalloc_to_pfn
+  vmap
+  vmemdup_user
+  vmf_insert_mixed
+  vmf_insert_pfn
+  vm_get_page_prot
+  vm_insert_page
+  vm_iomap_memory
+  vm_map_pages
+  vm_node_stat
+  vm_zone_stat
+  vprintk
+  vscnprintf
+  vsnprintf
+  vunmap
+  vzalloc
+  wait_for_completion
+  wait_for_completion_interruptible
+  wait_for_completion_interruptible_timeout
+  wait_for_completion_killable
+  wait_for_completion_timeout
+  __wake_up
+  wake_up_if_idle
+  __wake_up_locked
+  wake_up_process
+  wakeup_source_add
+  wakeup_source_create
+  wakeup_source_destroy
+  wakeup_source_register
+  wakeup_source_unregister
+  __warn_printk
+  wireless_nlevent_flush
+  wireless_send_event
+  ww_mutex_lock
+  ww_mutex_trylock
+  ww_mutex_unlock
+  __xa_alloc
+  __xa_alloc_cyclic
+  xa_destroy
+  xa_erase
+  xa_find
+  xa_find_after
+  __xa_insert
+  xa_load
+  xa_store
+  zap_vma_ptes
diff --git a/android/abi_gki_aarch64_galaxy b/android/abi_gki_aarch64_galaxy
index 041e1433b520..064f2b307565 100644
--- a/android/abi_gki_aarch64_galaxy
+++ b/android/abi_gki_aarch64_galaxy
@@ -289,6 +289,7 @@
   smpboot_register_percpu_thread
   smpboot_unregister_percpu_thread
   snd_card_ref
+  snd_ctl_remove_id
   snd_soc_add_card_controls
   snd_soc_find_dai
   snd_soc_info_volsw_sx
diff --git a/android/abi_gki_aarch64_pixel b/android/abi_gki_aarch64_pixel
index 3e87a62e12b5..4d0add3e28dd 100644
--- a/android/abi_gki_aarch64_pixel
+++ b/android/abi_gki_aarch64_pixel
@@ -2399,6 +2399,7 @@
   __traceiter_android_rvh_util_fits_cpu
   __traceiter_android_rvh_vmscan_kswapd_done
   __traceiter_android_rvh_vmscan_kswapd_wake
+  __traceiter_android_trigger_vendor_lmk_kill
   __traceiter_android_vh_arch_set_freq_scale
   __traceiter_android_vh_audio_usb_offload_connect
   __traceiter_android_vh_binder_proc_transaction_finish
@@ -2538,6 +2539,7 @@
   __tracepoint_android_rvh_util_fits_cpu
   __tracepoint_android_rvh_vmscan_kswapd_done
   __tracepoint_android_rvh_vmscan_kswapd_wake
+  __tracepoint_android_trigger_vendor_lmk_kill
   __tracepoint_android_vh_arch_set_freq_scale
   __tracepoint_android_vh_audio_usb_offload_connect
   __tracepoint_android_vh_binder_proc_transaction_finish
diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h
index 94baa907d1ef..1ad2a045f8e7 100644
--- a/arch/arm64/include/asm/kvm_host.h
+++ b/arch/arm64/include/asm/kvm_host.h
@@ -91,7 +91,7 @@ static inline void push_hyp_memcache(struct kvm_hyp_memcache *mc,
 static inline void *pop_hyp_memcache(struct kvm_hyp_memcache *mc,
 				     void *(*to_va)(phys_addr_t phys))
 {
-	phys_addr_t *p = to_va(mc->head);
+	phys_addr_t *p = to_va(mc->head & PAGE_MASK);
 
 	if (!mc->nr_pages)
 		return NULL;
diff --git a/drivers/android/binder.c b/drivers/android/binder.c
index eee3faaeee41..7811ced3ac50 100644
--- a/drivers/android/binder.c
+++ b/drivers/android/binder.c
@@ -4023,13 +4023,13 @@ err_invalid_target_handle:
 	}
 
 	binder_debug(BINDER_DEBUG_FAILED_TRANSACTION,
-		     "%d:%d transaction %s to %d:%d failed %d/%d/%d, size %lld-%lld line %d\n",
+		     "%d:%d transaction %s to %d:%d failed %d/%d/%d, code %u size %lld-%lld line %d\n",
 		     proc->pid, thread->pid, reply ? "reply" :
 		     (tr->flags & TF_ONE_WAY ? "async" : "call"),
 		     target_proc ? target_proc->pid : 0,
 		     target_thread ? target_thread->pid : 0,
 		     t_debug_id, return_error, return_error_param,
-		     (u64)tr->data_size, (u64)tr->offsets_size,
+		     tr->code, (u64)tr->data_size, (u64)tr->offsets_size,
 		     return_error_line);
 
 	if (target_thread)
diff --git a/drivers/android/vendor_hooks.c b/drivers/android/vendor_hooks.c
index 6da9ef6372b2..27a420dce9a5 100644
--- a/drivers/android/vendor_hooks.c
+++ b/drivers/android/vendor_hooks.c
@@ -75,6 +75,7 @@
 #include <trace/hooks/usb.h>
 #include <trace/hooks/sound.h>
 #include <trace/hooks/fuse.h>
+#include <trace/events/android_vendor_lmk.h>
 
 /*
  * Export tracepoints that act as a bare tracehook (ie: have no trace event
@@ -470,3 +471,4 @@ EXPORT_TRACEPOINT_SYMBOL_GPL(android_vh_mmc_blk_reset);
 EXPORT_TRACEPOINT_SYMBOL_GPL(android_vh_mmc_attach_sd);
 EXPORT_TRACEPOINT_SYMBOL_GPL(android_vh_sdhci_get_cd);
 EXPORT_TRACEPOINT_SYMBOL_GPL(android_vh_mmc_gpio_cd_irqt);
+EXPORT_TRACEPOINT_SYMBOL_GPL(android_trigger_vendor_lmk_kill);
diff --git a/drivers/md/dm-bow.c b/drivers/md/dm-bow.c
index a9764ea8940f..e12b8f986686 100644
--- a/drivers/md/dm-bow.c
+++ b/drivers/md/dm-bow.c
@@ -612,6 +612,7 @@ static void dm_bow_dtr(struct dm_target *ti)
 		wait_for_completion(dm_get_completion_from_kobject(kobj));
 	}
 
+	mutex_lock(&bc->ranges_lock);
 	while (rb_first(&bc->ranges)) {
 		struct bow_range *br = container_of(rb_first(&bc->ranges),
 					      struct bow_range, node);
@@ -619,6 +620,7 @@ static void dm_bow_dtr(struct dm_target *ti)
 		rb_erase(&br->node, &bc->ranges);
 		kfree(br);
 	}
+	mutex_unlock(&bc->ranges_lock);
 
 	mutex_destroy(&bc->ranges_lock);
 	kfree(bc->log_sector);
@@ -1191,6 +1193,7 @@ static void dm_bow_tablestatus(struct dm_target *ti, char *result,
 		return;
 	}
 
+	mutex_lock(&bc->ranges_lock);
 	for (i = rb_first(&bc->ranges); i; i = rb_next(i)) {
 		struct bow_range *br = container_of(i, struct bow_range, node);
 
@@ -1198,11 +1201,11 @@ static void dm_bow_tablestatus(struct dm_target *ti, char *result,
 				    readable_type[br->type],
 				    (unsigned long long)br->sector);
 		if (result >= end)
-			return;
+			goto unlock;
 
 		result += scnprintf(result, end - result, "\n");
 		if (result >= end)
-			return;
+			goto unlock;
 
 		if (br->type == TRIMMED)
 			++trimmed_range_count;
@@ -1224,19 +1227,22 @@ static void dm_bow_tablestatus(struct dm_target *ti, char *result,
 		if (!rb_next(i)) {
 			scnprintf(result, end - result,
 				  "\nERROR: Last range not of type TOP");
-			return;
+			goto unlock;
 		}
 
 		if (br->sector > range_top(br)) {
 			scnprintf(result, end - result,
 				  "\nERROR: sectors out of order");
-			return;
+			goto unlock;
 		}
 	}
 
 	if (trimmed_range_count != trimmed_list_length)
 		scnprintf(result, end - result,
 			  "\nERROR: not all trimmed ranges in trimmed list");
+
+unlock:
+	mutex_unlock(&bc->ranges_lock);
 }
 
 static void dm_bow_status(struct dm_target *ti, status_type_t type,
diff --git a/drivers/opp/core.c b/drivers/opp/core.c
index 5dd9ae2f3489..37702dc41532 100644
--- a/drivers/opp/core.c
+++ b/drivers/opp/core.c
@@ -1024,11 +1024,18 @@ static int _set_opp_level(struct device *dev, struct opp_table *opp_table,
 		level = opp->level;
 	}
 
-	/* Request a new performance state through the device's PM domain. */
-	ret = dev_pm_genpd_set_performance_state(dev, level);
-	if (ret)
-		dev_err(dev, "Failed to set performance state %u (%d)\n", level,
-			ret);
+	/*
+	 * This function should be a nop for devices without a PM domain. However,
+	 * dev_pm_genpd_set_performance_state() returns an error for devices without a PM domain
+	 * instead of returning immediately.
+	 */
+	if (dev->pm_domain) {
+		/* Request a new performance state through the device's PM domain. */
+		ret = dev_pm_genpd_set_performance_state(dev, level);
+		if (ret)
+			dev_err(dev, "Failed to set performance state %u (%d)\n", level,
+				ret);
+	}
 
 	return ret;
 }
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 3300a4dbc891..56ce11b450b0 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -380,7 +380,8 @@ static void xhci_handle_stopped_cmd_ring(struct xhci_hcd *xhci,
 	if ((xhci->cmd_ring->dequeue != xhci->cmd_ring->enqueue) &&
 	    !(xhci->xhc_state & XHCI_STATE_DYING)) {
 		xhci->current_cmd = cur_cmd;
-		xhci_mod_cmd_timer(xhci, XHCI_CMD_DEFAULT_TIMEOUT);
+		if (cur_cmd)
+			xhci_mod_cmd_timer(xhci, XHCI_CMD_DEFAULT_TIMEOUT);
 		xhci_ring_cmd_db(xhci);
 	}
 }
diff --git a/drivers/usb/typec/tcpm/tcpci.c b/drivers/usb/typec/tcpm/tcpci.c
index a68562476788..c6f846fbe69e 100644
--- a/drivers/usb/typec/tcpm/tcpci.c
+++ b/drivers/usb/typec/tcpm/tcpci.c
@@ -27,6 +27,7 @@
 #define	VPPS_NEW_MIN_PERCENT			95
 #define	VPPS_VALID_MIN_MV			100
 #define	VSINKDISCONNECT_PD_MIN_PERCENT		90
+#define	VPPS_SHUTDOWN_MIN_PERCENT		85
 
 struct tcpci {
 	struct device *dev;
@@ -362,9 +363,12 @@ static int tcpci_set_auto_vbus_discharge_threshold(struct tcpc_dev *dev, enum ty
 		threshold = AUTO_DISCHARGE_DEFAULT_THRESHOLD_MV;
 	} else if (mode == TYPEC_PWR_MODE_PD) {
 		if (pps_active)
-			threshold = ((VPPS_NEW_MIN_PERCENT * requested_vbus_voltage_mv / 100) -
-				     VSINKPD_MIN_IR_DROP_MV - VPPS_VALID_MIN_MV) *
-				     VSINKDISCONNECT_PD_MIN_PERCENT / 100;
+			/*
+			 * To prevent disconnect when the source is in Current Limit Mode.
+			 * Set the threshold to the lowest possible voltage vPpsShutdown (min)
+			 */
+			threshold = VPPS_SHUTDOWN_MIN_PERCENT * requested_vbus_voltage_mv / 100 -
+				    VSINKPD_MIN_IR_DROP_MV;
 		else
 			threshold = ((VSRC_NEW_MIN_PERCENT * requested_vbus_voltage_mv / 100) -
 				     VSINKPD_MIN_IR_DROP_MV - VSRC_VALID_MIN_MV) *
diff --git a/drivers/usb/typec/tcpm/tcpm.c b/drivers/usb/typec/tcpm/tcpm.c
index ae20a892eca5..13c6f78ae4cc 100644
--- a/drivers/usb/typec/tcpm/tcpm.c
+++ b/drivers/usb/typec/tcpm/tcpm.c
@@ -2342,16 +2342,22 @@ static int tcpm_set_auto_vbus_discharge_threshold(struct tcpm_port *port,
 						  enum typec_pwr_opmode mode, bool pps_active,
 						  u32 requested_vbus_voltage)
 {
+	u32 voltage;
 	int ret;
 
 	if (!port->tcpc->set_auto_vbus_discharge_threshold)
 		return 0;
 
-	ret = port->tcpc->set_auto_vbus_discharge_threshold(port->tcpc, mode, pps_active,
-							    requested_vbus_voltage);
+	if (mode == TYPEC_PWR_MODE_PD && pps_active)
+		voltage = port->pps_data.min_volt;
+	else
+		voltage = requested_vbus_voltage;
+
+	ret = port->tcpc->set_auto_vbus_discharge_threshold(port->tcpc, mode, pps_active, voltage);
 	tcpm_log_force(port,
-		       "set_auto_vbus_discharge_threshold mode:%d pps_active:%c vbus:%u ret:%d",
-		       mode, pps_active ? 'y' : 'n', requested_vbus_voltage, ret);
+		       "set_auto_vbus_discharge_threshold mode:%d pps_active:%c vbus:%u pps_apdo_min_volt:%u ret:%d",
+		       mode, pps_active ? 'y' : 'n', requested_vbus_voltage,
+		       port->pps_data.min_volt, ret);
 
 	return ret;
 }
diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c
index 4686f6d0c9cf..f7677843407b 100644
--- a/fs/f2fs/checkpoint.c
+++ b/fs/f2fs/checkpoint.c
@@ -1598,8 +1598,9 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
 	 */
 	if (f2fs_sb_has_encrypt(sbi) || f2fs_sb_has_verity(sbi) ||
 		f2fs_sb_has_compression(sbi))
-		invalidate_mapping_pages(META_MAPPING(sbi),
-				MAIN_BLKADDR(sbi), MAX_BLKADDR(sbi) - 1);
+		f2fs_bug_on(sbi,
+			invalidate_inode_pages2_range(META_MAPPING(sbi),
+				MAIN_BLKADDR(sbi), MAX_BLKADDR(sbi) - 1));
 
 	f2fs_release_ino_entry(sbi, false);
 
diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c
index 4b6ad2e41541..2ca8cb607c12 100644
--- a/fs/f2fs/compress.c
+++ b/fs/f2fs/compress.c
@@ -1381,7 +1381,7 @@ static int f2fs_write_compressed_pages(struct compress_ctx *cc,
 			if (blkaddr == COMPRESS_ADDR)
 				fio.compr_blocks++;
 			if (__is_valid_data_blkaddr(blkaddr))
-				f2fs_invalidate_blocks(sbi, blkaddr);
+				f2fs_invalidate_blocks(sbi, blkaddr, 1);
 			f2fs_update_data_blkaddr(&dn, COMPRESS_ADDR);
 			goto unlock_continue;
 		}
@@ -1391,7 +1391,7 @@ static int f2fs_write_compressed_pages(struct compress_ctx *cc,
 
 		if (i > cc->valid_nr_cpages) {
 			if (__is_valid_data_blkaddr(blkaddr)) {
-				f2fs_invalidate_blocks(sbi, blkaddr);
+				f2fs_invalidate_blocks(sbi, blkaddr, 1);
 				f2fs_update_data_blkaddr(&dn, NEW_ADDR);
 			}
 			goto unlock_continue;
@@ -1916,11 +1916,12 @@ struct address_space *COMPRESS_MAPPING(struct f2fs_sb_info *sbi)
 	return sbi->compress_inode->i_mapping;
 }
 
-void f2fs_invalidate_compress_page(struct f2fs_sb_info *sbi, block_t blkaddr)
+void f2fs_invalidate_compress_pages_range(struct f2fs_sb_info *sbi,
+				block_t blkaddr, unsigned int len)
 {
 	if (!sbi->compress_inode)
 		return;
-	invalidate_mapping_pages(COMPRESS_MAPPING(sbi), blkaddr, blkaddr);
+	invalidate_mapping_pages(COMPRESS_MAPPING(sbi), blkaddr, blkaddr + len - 1);
 }
 
 void f2fs_cache_compressed_page(struct f2fs_sb_info *sbi, struct page *page,
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 3647eea60ef9..2ebcb4f1b5c9 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -1490,11 +1490,8 @@ static int __allocate_data_block(struct dnode_of_data *dn, int seg_type)
 	if (err)
 		return err;
 
-	if (GET_SEGNO(sbi, old_blkaddr) != NULL_SEGNO) {
-		invalidate_mapping_pages(META_MAPPING(sbi),
-					old_blkaddr, old_blkaddr);
-		f2fs_invalidate_compress_page(sbi, old_blkaddr);
-	}
+	if (GET_SEGNO(sbi, old_blkaddr) != NULL_SEGNO)
+		f2fs_invalidate_internal_cache(sbi, old_blkaddr, 1);
 
 	f2fs_update_data_blkaddr(dn, dn->data_blkaddr);
 	return 0;
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 720242bda64f..aa2f0ea6b4ae 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -3635,7 +3635,8 @@ int f2fs_issue_flush(struct f2fs_sb_info *sbi, nid_t ino);
 int f2fs_create_flush_cmd_control(struct f2fs_sb_info *sbi);
 int f2fs_flush_device_cache(struct f2fs_sb_info *sbi);
 void f2fs_destroy_flush_cmd_control(struct f2fs_sb_info *sbi, bool free);
-void f2fs_invalidate_blocks(struct f2fs_sb_info *sbi, block_t addr);
+void f2fs_invalidate_blocks(struct f2fs_sb_info *sbi, block_t addr,
+						unsigned int len);
 bool f2fs_is_checkpointed_data(struct f2fs_sb_info *sbi, block_t blkaddr);
 int f2fs_start_discard_thread(struct f2fs_sb_info *sbi);
 void f2fs_drop_discard_cmd(struct f2fs_sb_info *sbi);
@@ -4287,7 +4288,8 @@ void f2fs_destroy_page_array_cache(struct f2fs_sb_info *sbi);
 int __init f2fs_init_compress_cache(void);
 void f2fs_destroy_compress_cache(void);
 struct address_space *COMPRESS_MAPPING(struct f2fs_sb_info *sbi);
-void f2fs_invalidate_compress_page(struct f2fs_sb_info *sbi, block_t blkaddr);
+void f2fs_invalidate_compress_pages_range(struct f2fs_sb_info *sbi,
+					block_t blkaddr, unsigned int len);
 void f2fs_cache_compressed_page(struct f2fs_sb_info *sbi, struct page *page,
 						nid_t ino, block_t blkaddr);
 bool f2fs_load_compressed_page(struct f2fs_sb_info *sbi, struct page *page,
@@ -4342,8 +4344,8 @@ static inline int f2fs_init_page_array_cache(struct f2fs_sb_info *sbi) { return
 static inline void f2fs_destroy_page_array_cache(struct f2fs_sb_info *sbi) { }
 static inline int __init f2fs_init_compress_cache(void) { return 0; }
 static inline void f2fs_destroy_compress_cache(void) { }
-static inline void f2fs_invalidate_compress_page(struct f2fs_sb_info *sbi,
-				block_t blkaddr) { }
+static inline void f2fs_invalidate_compress_pages_range(struct f2fs_sb_info *sbi,
+				block_t blkaddr, unsigned int len) { }
 static inline void f2fs_cache_compressed_page(struct f2fs_sb_info *sbi,
 				struct page *page, nid_t ino, block_t blkaddr) { }
 static inline bool f2fs_load_compressed_page(struct f2fs_sb_info *sbi,
@@ -4606,6 +4608,39 @@ static inline bool f2fs_is_readonly(struct f2fs_sb_info *sbi)
 	return f2fs_sb_has_readonly(sbi) || f2fs_readonly(sbi->sb);
 }
 
+static inline void f2fs_truncate_meta_inode_pages(struct f2fs_sb_info *sbi,
+					block_t blkaddr, unsigned int cnt)
+{
+	bool need_submit = false;
+	int i = 0;
+
+	do {
+		struct page *page;
+
+		page = find_get_page(META_MAPPING(sbi), blkaddr + i);
+		if (page) {
+			if (PageWriteback(page))
+				need_submit = true;
+			f2fs_put_page(page, 0);
+		}
+	} while (++i < cnt && !need_submit);
+
+	if (need_submit)
+		f2fs_submit_merged_write_cond(sbi, sbi->meta_inode,
+							NULL, 0, DATA);
+
+	truncate_inode_pages_range(META_MAPPING(sbi),
+			F2FS_BLK_TO_BYTES((loff_t)blkaddr),
+			F2FS_BLK_END_BYTES((loff_t)(blkaddr + cnt - 1)));
+}
+
+static inline void f2fs_invalidate_internal_cache(struct f2fs_sb_info *sbi,
+						block_t blkaddr, unsigned int len)
+{
+	f2fs_truncate_meta_inode_pages(sbi, blkaddr, len);
+	f2fs_invalidate_compress_pages_range(sbi, blkaddr, len);
+}
+
 #define EFSBADCRC	EBADMSG		/* Bad CRC detected */
 #define EFSCORRUPTED	EUCLEAN		/* Filesystem is corrupted */
 
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 5dd99242408e..48a04475102c 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -621,8 +621,11 @@ void f2fs_truncate_data_blocks_range(struct dnode_of_data *dn, int count)
 	int cluster_index = 0, valid_blocks = 0;
 	int cluster_size = F2FS_I(dn->inode)->i_cluster_size;
 	bool released = !atomic_read(&F2FS_I(dn->inode)->i_compr_blocks);
+	block_t blkstart;
+	int blklen = 0;
 
 	addr = get_dnode_addr(dn->inode, dn->node_page) + ofs;
+	blkstart = le32_to_cpu(*addr);
 
 	/* Assumption: truncation starts with cluster */
 	for (; count > 0; count--, addr++, dn->ofs_in_node++, cluster_index++) {
@@ -638,28 +641,46 @@ void f2fs_truncate_data_blocks_range(struct dnode_of_data *dn, int count)
 		}
 
 		if (blkaddr == NULL_ADDR)
-			continue;
+			goto next;
 
 		f2fs_set_data_blkaddr(dn, NULL_ADDR);
 
 		if (__is_valid_data_blkaddr(blkaddr)) {
 			if (time_to_inject(sbi, FAULT_BLKADDR_CONSISTENCE))
-				continue;
+				goto next;
 			if (!f2fs_is_valid_blkaddr_raw(sbi, blkaddr,
 						DATA_GENERIC_ENHANCE)) {
 				f2fs_handle_error(sbi, ERROR_INVALID_BLKADDR);
-				continue;
+				goto next;
 			}
 			if (compressed_cluster)
 				valid_blocks++;
 		}
 
-		f2fs_invalidate_blocks(sbi, blkaddr);
+		if (blkstart + blklen == blkaddr) {
+			blklen++;
+		} else {
+			f2fs_invalidate_blocks(sbi, blkstart, blklen);
+			blkstart = blkaddr;
+			blklen = 1;
+		}
 
 		if (!released || blkaddr != COMPRESS_ADDR)
 			nr_free++;
+
+		continue;
+
+next:
+		if (blklen)
+			f2fs_invalidate_blocks(sbi, blkstart, blklen);
+
+		blkstart = le32_to_cpu(*(addr + 1));
+		blklen = 0;
 	}
 
+	if (blklen)
+		f2fs_invalidate_blocks(sbi, blkstart, blklen);
+
 	if (compressed_cluster)
 		f2fs_i_compr_blocks_update(dn->inode, valid_blocks, false);
 
@@ -1300,7 +1321,7 @@ static int __roll_back_blkaddrs(struct inode *inode, block_t *blkaddr,
 		ret = f2fs_get_dnode_of_data(&dn, off + i, LOOKUP_NODE_RA);
 		if (ret) {
 			dec_valid_block_count(sbi, inode, 1);
-			f2fs_invalidate_blocks(sbi, *blkaddr);
+			f2fs_invalidate_blocks(sbi, *blkaddr, 1);
 		} else {
 			f2fs_update_data_blkaddr(&dn, *blkaddr);
 		}
@@ -1549,7 +1570,7 @@ static int f2fs_do_zero_range(struct dnode_of_data *dn, pgoff_t start,
 			break;
 		}
 
-		f2fs_invalidate_blocks(sbi, dn->data_blkaddr);
+		f2fs_invalidate_blocks(sbi, dn->data_blkaddr, 1);
 		f2fs_set_data_blkaddr(dn, NEW_ADDR);
 	}
 
diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index 60e02fdfffa4..e5e20b7c6093 100644
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -1389,9 +1389,8 @@ static int move_data_block(struct inode *inode, block_t bidx,
 	memcpy(page_address(fio.encrypted_page),
 				page_address(mpage), PAGE_SIZE);
 	f2fs_put_page(mpage, 1);
-	invalidate_mapping_pages(META_MAPPING(fio.sbi),
-				fio.old_blkaddr, fio.old_blkaddr);
-	f2fs_invalidate_compress_page(fio.sbi, fio.old_blkaddr);
+
+	f2fs_invalidate_internal_cache(fio.sbi, fio.old_blkaddr, 1);
 
 	set_page_dirty(fio.encrypted_page);
 	if (clear_page_dirty_for_io(fio.encrypted_page))
diff --git a/fs/f2fs/namei.c b/fs/f2fs/namei.c
index 19449320687c..92419d2726a0 100644
--- a/fs/f2fs/namei.c
+++ b/fs/f2fs/namei.c
@@ -325,6 +325,7 @@ fail_drop:
 	trace_f2fs_new_inode(inode, err);
 	dquot_drop(inode);
 	inode->i_flags |= S_NOQUOTA;
+	make_bad_inode(inode);
 	if (nid_free)
 		set_inode_flag(inode, FI_FREE_NID);
 	clear_nlink(inode);
diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c
index 0d0c2105ae25..06ec3ffa141e 100644
--- a/fs/f2fs/node.c
+++ b/fs/f2fs/node.c
@@ -906,7 +906,7 @@ static int truncate_node(struct dnode_of_data *dn)
 		return err;
 
 	/* Deallocate node address */
-	f2fs_invalidate_blocks(sbi, ni.blk_addr);
+	f2fs_invalidate_blocks(sbi, ni.blk_addr, 1);
 	dec_valid_node_count(sbi, dn->inode, dn->nid == dn->inode->i_ino);
 	set_node_addr(sbi, &ni, NULL_ADDR, false);
 
@@ -2723,7 +2723,7 @@ int f2fs_recover_xattr_data(struct inode *inode, struct page *page)
 	if (err)
 		return err;
 
-	f2fs_invalidate_blocks(sbi, ni.blk_addr);
+	f2fs_invalidate_blocks(sbi, ni.blk_addr, 1);
 	dec_valid_node_count(sbi, inode, false);
 	set_node_addr(sbi, &ni, NULL_ADDR, false);
 
diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 100913a484d2..6b6baf8b64ae 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -245,7 +245,7 @@ retry:
 		if (!__is_valid_data_blkaddr(new_addr)) {
 			if (new_addr == NULL_ADDR)
 				dec_valid_block_count(sbi, inode, 1);
-			f2fs_invalidate_blocks(sbi, dn.data_blkaddr);
+			f2fs_invalidate_blocks(sbi, dn.data_blkaddr, 1);
 			f2fs_update_data_blkaddr(&dn, new_addr);
 		} else {
 			f2fs_replace_block(sbi, &dn, dn.data_blkaddr,
@@ -2304,15 +2304,117 @@ static void update_segment_mtime(struct f2fs_sb_info *sbi, block_t blkaddr,
 		SIT_I(sbi)->max_mtime = ctime;
 }
 
+/*
+ * NOTE: when updating multiple blocks at the same time, please ensure
+ * that the consecutive input blocks belong to the same segment.
+ */
+static int update_sit_entry_for_release(struct f2fs_sb_info *sbi, struct seg_entry *se,
+				block_t blkaddr, unsigned int offset, int del)
+{
+	bool exist;
+#ifdef CONFIG_F2FS_CHECK_FS
+	bool mir_exist;
+#endif
+	int i;
+	int del_count = -del;
+
+	f2fs_bug_on(sbi, GET_SEGNO(sbi, blkaddr) != GET_SEGNO(sbi, blkaddr + del_count - 1));
+
+	for (i = 0; i < del_count; i++) {
+		exist = f2fs_test_and_clear_bit(offset + i, se->cur_valid_map);
+#ifdef CONFIG_F2FS_CHECK_FS
+		mir_exist = f2fs_test_and_clear_bit(offset + i,
+						se->cur_valid_map_mir);
+		if (unlikely(exist != mir_exist)) {
+			f2fs_err(sbi, "Inconsistent error when clearing bitmap, blk:%u, old bit:%d",
+				blkaddr + i, exist);
+			f2fs_bug_on(sbi, 1);
+		}
+#endif
+		if (unlikely(!exist)) {
+			f2fs_err(sbi, "Bitmap was wrongly cleared, blk:%u", blkaddr + i);
+			f2fs_bug_on(sbi, 1);
+			se->valid_blocks++;
+			del += 1;
+		} else if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {
+			/*
+			 * If checkpoints are off, we must not reuse data that
+			 * was used in the previous checkpoint. If it was used
+			 * before, we must track that to know how much space we
+			 * really have.
+			 */
+			if (f2fs_test_bit(offset + i, se->ckpt_valid_map)) {
+				spin_lock(&sbi->stat_lock);
+				sbi->unusable_block_count++;
+				spin_unlock(&sbi->stat_lock);
+			}
+		}
+
+		if (f2fs_block_unit_discard(sbi) &&
+				f2fs_test_and_clear_bit(offset + i, se->discard_map))
+			sbi->discard_blks++;
+
+		if (!f2fs_test_bit(offset + i, se->ckpt_valid_map))
+			se->ckpt_valid_blocks -= 1;
+	}
+
+	return del;
+}
+
+static int update_sit_entry_for_alloc(struct f2fs_sb_info *sbi, struct seg_entry *se,
+				block_t blkaddr, unsigned int offset, int del)
+{
+	bool exist;
+#ifdef CONFIG_F2FS_CHECK_FS
+	bool mir_exist;
+#endif
+
+	exist = f2fs_test_and_set_bit(offset, se->cur_valid_map);
+#ifdef CONFIG_F2FS_CHECK_FS
+	mir_exist = f2fs_test_and_set_bit(offset,
+					se->cur_valid_map_mir);
+	if (unlikely(exist != mir_exist)) {
+		f2fs_err(sbi, "Inconsistent error when setting bitmap, blk:%u, old bit:%d",
+			blkaddr, exist);
+		f2fs_bug_on(sbi, 1);
+	}
+#endif
+	if (unlikely(exist)) {
+		f2fs_err(sbi, "Bitmap was wrongly set, blk:%u", blkaddr);
+		f2fs_bug_on(sbi, 1);
+		se->valid_blocks--;
+		del = 0;
+	}
+
+	if (f2fs_block_unit_discard(sbi) &&
+			!f2fs_test_and_set_bit(offset, se->discard_map))
+		sbi->discard_blks--;
+
+	/*
+	 * SSR should never reuse block which is checkpointed
+	 * or newly invalidated.
+	 */
+	if (!is_sbi_flag_set(sbi, SBI_CP_DISABLED)) {
+		if (!f2fs_test_and_set_bit(offset, se->ckpt_valid_map))
+			se->ckpt_valid_blocks++;
+	}
+
+	if (!f2fs_test_bit(offset, se->ckpt_valid_map))
+		se->ckpt_valid_blocks += del;
+
+	return del;
+}
+
+/*
+ * If releasing blocks, this function supports updating multiple consecutive blocks
+ * at one time, but please note that these consecutive blocks need to belong to the
+ * same segment.
+ */
 static void update_sit_entry(struct f2fs_sb_info *sbi, block_t blkaddr, int del)
 {
 	struct seg_entry *se;
 	unsigned int segno, offset;
 	long int new_vblocks;
-	bool exist;
-#ifdef CONFIG_F2FS_CHECK_FS
-	bool mir_exist;
-#endif
 
 	segno = GET_SEGNO(sbi, blkaddr);
 	if (segno == NULL_SEGNO)
@@ -2329,73 +2431,10 @@ static void update_sit_entry(struct f2fs_sb_info *sbi, block_t blkaddr, int del)
 
 	/* Update valid block bitmap */
 	if (del > 0) {
-		exist = f2fs_test_and_set_bit(offset, se->cur_valid_map);
-#ifdef CONFIG_F2FS_CHECK_FS
-		mir_exist = f2fs_test_and_set_bit(offset,
-						se->cur_valid_map_mir);
-		if (unlikely(exist != mir_exist)) {
-			f2fs_err(sbi, "Inconsistent error when setting bitmap, blk:%u, old bit:%d",
-				 blkaddr, exist);
-			f2fs_bug_on(sbi, 1);
-		}
-#endif
-		if (unlikely(exist)) {
-			f2fs_err(sbi, "Bitmap was wrongly set, blk:%u",
-				 blkaddr);
-			f2fs_bug_on(sbi, 1);
-			se->valid_blocks--;
-			del = 0;
-		}
-
-		if (f2fs_block_unit_discard(sbi) &&
-				!f2fs_test_and_set_bit(offset, se->discard_map))
-			sbi->discard_blks--;
-
-		/*
-		 * SSR should never reuse block which is checkpointed
-		 * or newly invalidated.
-		 */
-		if (!is_sbi_flag_set(sbi, SBI_CP_DISABLED)) {
-			if (!f2fs_test_and_set_bit(offset, se->ckpt_valid_map))
-				se->ckpt_valid_blocks++;
-		}
+		del = update_sit_entry_for_alloc(sbi, se, blkaddr, offset, del);
 	} else {
-		exist = f2fs_test_and_clear_bit(offset, se->cur_valid_map);
-#ifdef CONFIG_F2FS_CHECK_FS
-		mir_exist = f2fs_test_and_clear_bit(offset,
-						se->cur_valid_map_mir);
-		if (unlikely(exist != mir_exist)) {
-			f2fs_err(sbi, "Inconsistent error when clearing bitmap, blk:%u, old bit:%d",
-				 blkaddr, exist);
-			f2fs_bug_on(sbi, 1);
-		}
-#endif
-		if (unlikely(!exist)) {
-			f2fs_err(sbi, "Bitmap was wrongly cleared, blk:%u",
-				 blkaddr);
-			f2fs_bug_on(sbi, 1);
-			se->valid_blocks++;
-			del = 0;
-		} else if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {
-			/*
-			 * If checkpoints are off, we must not reuse data that
-			 * was used in the previous checkpoint. If it was used
-			 * before, we must track that to know how much space we
-			 * really have.
-			 */
-			if (f2fs_test_bit(offset, se->ckpt_valid_map)) {
-				spin_lock(&sbi->stat_lock);
-				sbi->unusable_block_count++;
-				spin_unlock(&sbi->stat_lock);
-			}
-		}
-
-		if (f2fs_block_unit_discard(sbi) &&
-			f2fs_test_and_clear_bit(offset, se->discard_map))
-			sbi->discard_blks++;
+		del = update_sit_entry_for_release(sbi, se, blkaddr, offset, del);
 	}
-	if (!f2fs_test_bit(offset, se->ckpt_valid_map))
-		se->ckpt_valid_blocks += del;
 
 	__mark_sit_entry_dirty(sbi, segno);
 
@@ -2406,26 +2445,43 @@ static void update_sit_entry(struct f2fs_sb_info *sbi, block_t blkaddr, int del)
 		get_sec_entry(sbi, segno)->valid_blocks += del;
 }
 
-void f2fs_invalidate_blocks(struct f2fs_sb_info *sbi, block_t addr)
+void f2fs_invalidate_blocks(struct f2fs_sb_info *sbi, block_t addr,
+				unsigned int len)
 {
 	unsigned int segno = GET_SEGNO(sbi, addr);
 	struct sit_info *sit_i = SIT_I(sbi);
+	block_t addr_start = addr, addr_end = addr + len - 1;
+	unsigned int seg_num = GET_SEGNO(sbi, addr_end) - segno + 1;
+	unsigned int i = 1, max_blocks = sbi->blocks_per_seg, cnt;
 
 	f2fs_bug_on(sbi, addr == NULL_ADDR);
 	if (addr == NEW_ADDR || addr == COMPRESS_ADDR)
 		return;
 
-	invalidate_mapping_pages(META_MAPPING(sbi), addr, addr);
-	f2fs_invalidate_compress_page(sbi, addr);
+	f2fs_invalidate_internal_cache(sbi, addr, len);
 
 	/* add it into sit main buffer */
 	down_write(&sit_i->sentry_lock);
 
-	update_segment_mtime(sbi, addr, 0);
-	update_sit_entry(sbi, addr, -1);
+	if (seg_num == 1)
+		cnt = len;
+	else
+		cnt = max_blocks - GET_BLKOFF_FROM_SEG0(sbi, addr);
 
-	/* add it into dirty seglist */
-	locate_dirty_segment(sbi, segno);
+	do {
+		update_segment_mtime(sbi, addr_start, 0);
+		update_sit_entry(sbi, addr_start, -cnt);
+
+		/* add it into dirty seglist */
+		locate_dirty_segment(sbi, segno);
+
+		/* update @addr_start and @cnt and @segno */
+		addr_start = START_BLOCK(sbi, ++segno);
+		if (++i == seg_num)
+			cnt = GET_BLKOFF_FROM_SEG0(sbi, addr_end) + 1;
+		else
+			cnt = max_blocks;
+	} while (i <= seg_num);
 
 	up_write(&sit_i->sentry_lock);
 }
@@ -3478,11 +3534,8 @@ reallocate:
 		goto out;
 	}
 
-	if (GET_SEGNO(fio->sbi, fio->old_blkaddr) != NULL_SEGNO) {
-		invalidate_mapping_pages(META_MAPPING(fio->sbi),
-					fio->old_blkaddr, fio->old_blkaddr);
-		f2fs_invalidate_compress_page(fio->sbi, fio->old_blkaddr);
-	}
+	if (GET_SEGNO(fio->sbi, fio->old_blkaddr) != NULL_SEGNO)
+		f2fs_invalidate_internal_cache(fio->sbi, fio->old_blkaddr, 1);
 
 	/* writeout dirty page into bdev */
 	f2fs_submit_page_write(fio);
@@ -3576,8 +3629,7 @@ int f2fs_inplace_write_data(struct f2fs_io_info *fio)
 	}
 
 	if (fio->meta_gc)
-		invalidate_mapping_pages(META_MAPPING(sbi),
-				fio->new_blkaddr, fio->new_blkaddr);
+		f2fs_truncate_meta_inode_pages(sbi, fio->new_blkaddr, 1);
 
 	stat_inc_inplace_blocks(fio->sbi);
 
@@ -3678,9 +3730,7 @@ void f2fs_do_replace_block(struct f2fs_sb_info *sbi, struct f2fs_summary *sum,
 		update_sit_entry(sbi, new_blkaddr, 1);
 	}
 	if (GET_SEGNO(sbi, old_blkaddr) != NULL_SEGNO) {
-		invalidate_mapping_pages(META_MAPPING(sbi),
-					old_blkaddr, old_blkaddr);
-		f2fs_invalidate_compress_page(sbi, old_blkaddr);
+		f2fs_invalidate_internal_cache(sbi, old_blkaddr, 1);
 		if (!from_gc)
 			update_segment_mtime(sbi, old_blkaddr, 0);
 		update_sit_entry(sbi, old_blkaddr, -1);
@@ -3769,7 +3819,7 @@ void f2fs_wait_on_block_writeback_range(struct inode *inode, block_t blkaddr,
 	for (i = 0; i < len; i++)
 		f2fs_wait_on_block_writeback(inode, blkaddr + i);
 
-	invalidate_mapping_pages(META_MAPPING(sbi), blkaddr, blkaddr + len - 1);
+	f2fs_truncate_meta_inode_pages(sbi, blkaddr, len);
 }
 
 static int read_compacted_summaries(struct f2fs_sb_info *sbi)
diff --git a/include/linux/android_kabi.h b/include/linux/android_kabi.h
index 1fa329ee4d73..02ba25dbfdbf 100644
--- a/include/linux/android_kabi.h
+++ b/include/linux/android_kabi.h
@@ -90,6 +90,14 @@
 #define ANDROID_KABI_RESERVE(number)
 #endif
 
+/*
+ * ANDROID_KABI_BACKPORT_OK
+ *   Used to allow padding originally reserved with ANDROID_KABI_RESERVE
+ *   to be used for backports of non-LTS patches by partners. These
+ *   fields can by used by replacing with ANDROID_KABI_BACKPORT_USE()
+ *   for partner backports.
+ */
+#define ANDROID_KABI_BACKPORT_OK(number) ANDROID_KABI_RESERVE(number)
 
 /*
  * Macros to use _after_ the ABI is frozen
@@ -104,6 +112,17 @@
 #define ANDROID_KABI_USE(number, _new)		\
 	_ANDROID_KABI_REPLACE(_ANDROID_KABI_RESERVE(number), _new)
 
+/*
+ * ANDROID_KABI_BACKPORT_USE(number, _new)
+ *   Use a previous padding entry that was defined with
+ *   ANDROID_KABI_BACKPORT_OK(). This is functionally identical
+ *   to ANDROID_KABI_USE() except that it differentiates the
+ *   normal use of KABI fields for LTS from KABI fields that
+ *   were released for use with other backports from upstream.
+ */
+#define ANDROID_KABI_BACKPORT_USE(number, _new) \
+	ANDROID_KABI_USE(number, _new)
+
 /*
  * ANDROID_KABI_USE2(number, _new1, _new2)
  *   Use a previous padding entry that was defined with ANDROID_KABI_RESERVE for
diff --git a/include/linux/f2fs_fs.h b/include/linux/f2fs_fs.h
index 7a1f60df0fce..e5951002ea60 100644
--- a/include/linux/f2fs_fs.h
+++ b/include/linux/f2fs_fs.h
@@ -27,6 +27,7 @@
 
 #define F2FS_BYTES_TO_BLK(bytes)	((bytes) >> F2FS_BLKSIZE_BITS)
 #define F2FS_BLK_TO_BYTES(blk)		((blk) << F2FS_BLKSIZE_BITS)
+#define F2FS_BLK_END_BYTES(blk)		(F2FS_BLK_TO_BYTES(blk + 1) - 1)
 
 /* 0, 1(node nid), 2(meta nid) are reserved node id */
 #define F2FS_RESERVED_NODE_NUM		3
diff --git a/include/trace/events/android_vendor_lmk.h b/include/trace/events/android_vendor_lmk.h
new file mode 100644
index 000000000000..ad6b18ca0b4b
--- /dev/null
+++ b/include/trace/events/android_vendor_lmk.h
@@ -0,0 +1,32 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright (C) 2025 Google, Inc.
+ */
+
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM android_vendor_lmk
+#undef TRACE_INCLUDE_PATH
+#define TRACE_INCLUDE_PATH trace/events
+#if !defined(_ANDROID_VENDOR_LMK_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _ANDROID_VENDOR_LMK_H
+
+#include <linux/tracepoint.h>
+
+TRACE_EVENT(android_trigger_vendor_lmk_kill,
+	TP_PROTO(int reason, short min_oom_score_adj),
+	TP_ARGS(reason, min_oom_score_adj),
+
+	TP_STRUCT__entry(
+		__field(int, reason)
+		__field(short, min_oom_score_adj)
+	),
+	TP_fast_assign(
+		__entry->reason = reason;
+		__entry->min_oom_score_adj = min_oom_score_adj;
+	),
+	TP_printk("reason=%u min_oom_score_adj=%hd", __entry->reason, __entry->min_oom_score_adj)
+);
+
+#endif /* _ANDROID_VENDOR_LMK_H */
+/* This part must be outside protection */
+#include <trace/define_trace.h>
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index f33cb1cbe677..28004c549031 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -211,6 +211,38 @@ EXPORT_PER_CPU_SYMBOL(numa_node);
 
 DEFINE_STATIC_KEY_TRUE(vm_numa_stat_key);
 
+/*
+ * By default, restrict_cma_redirect is set to true, so only MOVABLE allocations
+ * marked __GFP_CMA are eligible to be redirected to CMA region. These allocations
+ * are redirected if *any* free space is available in the CMA region.
+ * When restrict_cma_redirect is false, all movable allocations
+ * are eligible for redirection to CMA region (i.e movable allocations are
+ * not restricted from CMA region), when there is sufficient space there.
+ * (see __rmqueue()).
+ *
+ */
+DEFINE_STATIC_KEY_TRUE(restrict_cma_redirect);
+
+static int __init restrict_cma_redirect_setup(char *str)
+{
+#ifdef CONFIG_CMA
+	bool res;
+	int ret;
+	ret = kstrtobool(str, &res);
+	if (!ret && res == false)
+		static_branch_disable(&restrict_cma_redirect);
+#else
+	pr_warn("CONFIG_CMA not set. Ignoring restrict_cma_redirect option\n");
+#endif
+	return 1;
+}
+__setup("restrict_cma_redirect=", restrict_cma_redirect_setup);
+
+static inline bool cma_redirect_restricted(void)
+{
+	return static_branch_likely(&restrict_cma_redirect);
+}
+
 #ifdef CONFIG_HAVE_MEMORYLESS_NODES
 /*
  * N.B., Do NOT reference the '_numa_mem_' per cpu variable directly.
@@ -3177,6 +3209,21 @@ __rmqueue(struct zone *zone, unsigned int order, int migratetype,
 	if (page)
 		return page;
 
+	if (IS_ENABLED(CONFIG_CMA)) {
+		/*
+		 * Balance movable allocations between regular and CMA areas by
+		 * allocating from CMA when over half of the zone's free memory
+		 * is in the CMA area.
+		 */
+		if (!cma_redirect_restricted() && alloc_flags & ALLOC_CMA &&
+			zone_page_state(zone, NR_FREE_CMA_PAGES) >
+			zone_page_state(zone, NR_FREE_PAGES) / 2) {
+				page = __rmqueue_cma_fallback(zone, order);
+				if (page)
+					return page;
+		}
+	}
+
 retry:
 	page = __rmqueue_smallest(zone, order, migratetype);
 
@@ -3186,6 +3233,9 @@ retry:
 	if (unlikely(!page) && (migratetype == MIGRATE_MOVABLE))
 		trace_android_vh_rmqueue_cma_fallback(zone, order, &page);
 
+	if (!cma_redirect_restricted() && !page && alloc_flags & ALLOC_CMA)
+		page = __rmqueue_cma_fallback(zone, order);
+
 	if (unlikely(!page) && __rmqueue_fallback(zone, order, migratetype,
 						  alloc_flags))
 		goto retry;
@@ -3231,7 +3281,12 @@ static int rmqueue_bulk(struct zone *zone, unsigned int order,
 	for (i = 0; i < count; ++i) {
 		struct page *page;
 
-		if (is_migrate_cma(migratetype))
+		/*
+		 * If CMA redirect is restricted, use CMA region only for
+		 * MIGRATE_CMA pages. cma_rediret_restricted() is false
+		 * if CONFIG_CMA is not set.
+		 */
+		if (cma_redirect_restricted() && is_migrate_cma(migratetype))
 			page = __rmqueue_cma(zone, order, migratetype,
 					     alloc_flags);
 		else
@@ -3880,7 +3935,8 @@ struct page *rmqueue_buddy(struct zone *preferred_zone, struct zone *zone,
 		if (alloc_flags & ALLOC_HIGHATOMIC)
 			page = __rmqueue_smallest(zone, order, MIGRATE_HIGHATOMIC);
 		if (!page) {
-			if (alloc_flags & ALLOC_CMA && migratetype == MIGRATE_MOVABLE)
+			if (cma_redirect_restricted() && alloc_flags & ALLOC_CMA &&
+					migratetype == MIGRATE_MOVABLE)
 				page = __rmqueue_cma(zone, order, migratetype,
 						     alloc_flags);
 			else
@@ -3924,7 +3980,8 @@ struct page *__rmqueue_pcplist(struct zone *zone, unsigned int order,
 
 	do {
 		/* First try to get CMA pages */
-		if (migratetype == MIGRATE_MOVABLE && alloc_flags & ALLOC_CMA)
+		if (cma_redirect_restricted() && migratetype == MIGRATE_MOVABLE &&
+				alloc_flags & ALLOC_CMA)
 			list = get_populated_pcp_list(zone, order, pcp, get_cma_migrate_type(),
 						      alloc_flags);
 		if (list == NULL) {
@@ -4344,7 +4401,12 @@ static inline unsigned int gfp_to_alloc_flags_cma(gfp_t gfp_mask,
 						  unsigned int alloc_flags)
 {
 #ifdef CONFIG_CMA
-	if (gfp_migratetype(gfp_mask) == MIGRATE_MOVABLE && gfp_mask & __GFP_CMA)
+	/*
+	 * If cma_redirect_restricted is true, set ALLOC_CMA only for
+	 * movable allocations that have __GFP_CMA.
+	 */
+	if ((!cma_redirect_restricted() || gfp_mask & __GFP_CMA) &&
+			gfp_migratetype(gfp_mask) == MIGRATE_MOVABLE)
 		alloc_flags |= ALLOC_CMA;
 	trace_android_vh_alloc_flags_cma_adjust(gfp_mask, &alloc_flags);
 #endif