From 773ad7ab13978037ca43303c881d8ad7eb27ff06 Mon Sep 17 00:00:00 2001 From: Rishi Sikka Date: Tue, 28 Jan 2025 04:27:15 +0000 Subject: [PATCH 01/24] ANDROID: GKI: Add new symbol list for arg Adds a new symbol list for android aarch64. ``` 3 function symbol(s) added 'ssize_t iio_enum_available_read(struct iio_dev*, uintptr_t, const struct iio_chan_spec*, char*)' 'ssize_t iio_enum_read(struct iio_dev*, uintptr_t, const struct iio_chan_spec*, char*)' 'ssize_t iio_enum_write(struct iio_dev*, uintptr_t, const struct iio_chan_spec*, const char*, size_t)' ``` Bug: 386822958 Change-Id: I43b8c50200006f93404c12be546304eb71858334 Signed-off-by: Rishi Sikka --- BUILD.bazel | 1 + android/abi_gki_aarch64.stg | 30 + android/abi_gki_aarch64_arg | 2564 +++++++++++++++++++++++++++++++++++ 3 files changed, 2595 insertions(+) create mode 100644 android/abi_gki_aarch64_arg 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..34fe57c7ae53 100644 --- a/android/abi_gki_aarch64.stg +++ b/android/abi_gki_aarch64.stg @@ -379633,6 +379633,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" @@ -421402,6 +421429,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 diff --git a/android/abi_gki_aarch64_arg b/android/abi_gki_aarch64_arg new file mode 100644 index 000000000000..8bf65775f170 --- /dev/null +++ b/android/abi_gki_aarch64_arg @@ -0,0 +1,2564 @@ +[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_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 From 554eb9d61ac0a26a19ab5837f9d0daf83c9e3fa3 Mon Sep 17 00:00:00 2001 From: Todd Kjos Date: Mon, 27 Jan 2025 20:53:47 +0000 Subject: [PATCH 02/24] ANDROID: KABI macros to release excess KABI fields for use with backports With KMI freeze, we reserve padding in structs to be exclusively used for LTS updates that would otherwise break the KMI. These fields are reserved via the ANDROID_KABI_RESERVE() macro that adds a u64 field to the struct. The ANDROID_KABI_USE() macro is used when the field is needed for an LTS patch backport. Since these fields must be reserved at KMI freeze time, we have make our best guess at what might be needed - and sometimes reserve too many fields. An example of this is the 8 ANDROID_KABI_RESERVE() fields in `struct net_device` for android13-5.15. We are now 3 years into the 6 year lifetime for android13-5.15 and none of those 8 padding fields have been used. At this point it is reasonable to allow 1 or 2 of those fields to be used for non-LTS backports. We won't relax the rule that ANDROID_KABI_RESERVE() is exclusively for LTS backports, Instead we'll introduce a new macro, ANDROID_KABI_BACKPORT_OK() to release some KABI fields for general use as the branches age and the use of padding for LTS becomes unlikely. We release the field for use by replacing the ANDROID_KABI_RESERVE() with the new ANDROID_KABI_BACKPORT_OK() macro, which has the exact same implementation, but allows others to use it for backporting features from upstream. When an ANDROID_KABI_BACKPORT_OK() field is going to be used, the ANDROID_KABI_BACKPORT_USE() macro is used to indicate that the field was used for a feature backport, not an LTS patch. This patch adds the two new macros: ANDROID_KABI_BACKPORT_OK() : exactly the same as ANDROID_KABI_RESERVE() ANDROID_KABI_BACKPORT_USE() ; exacly the same as ANDROID_KABI_USE() Patches that change an ANDROID_KABI_RESERVE() to ANDROID_KABI_BACKPORT_OK() must be reviewed and get a CR+1 from gregkh@, joneslee@ or tkjos@ to make sure it really is acceptable to reduce the padding for LTS merges. Bug: 392673958 Signed-off-by: Todd Kjos Change-Id: I19b9dfc16d891fb6fe48ec4379c6fa3dcb6adf24 (cherry picked from commit f1954b6e6cba2533beb6dff539b9d0b079ceb665) --- include/linux/android_kabi.h | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) 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 From 2055772eada08d49b00e82e7f2825294fad47eaf Mon Sep 17 00:00:00 2001 From: Jaegeuk Kim Date: Fri, 17 Jan 2025 21:38:22 +0000 Subject: [PATCH 03/24] UPSTREAM: f2fs: avoid trying to get invalid block address In f2fs_new_inode(), if we fail to get a new inode, we go iput(), followed by f2fs_evict_inode(). If the inode is not marked as bad, it'll try to call f2fs_remove_inode_page() which tries to read the inode block given node id. But, there's no block address allocated yet, which gives a chance to access a wrong block address, if the block device has some garbage data in NAT table. We need to make sure NAT table should have zero data for all the unallocated node ids, but also would be better to take this unnecessary path as well. Let's mark the faild inode as bad. Bug: 383968963 Fixes: 0abd675e97e6 ("f2fs: support plain user/group quota") Reviewed-by: Chao Yu Change-Id: I37bfd94f0612e1521ae43fe529fd186954f3dece Signed-off-by: Jaegeuk Kim (cherry picked from commit e02938613eb206ebf788e2d3d4fccf534e4ea12e) (cherry picked from commit 444939d3b27bb3857a7cc3e37595e794eef07db4) --- fs/f2fs/namei.c | 1 + 1 file changed, 1 insertion(+) 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); From 1cf6be70924cc63bce9ea25910ac234367a8b4c9 Mon Sep 17 00:00:00 2001 From: Pavel Begunkov Date: Mon, 9 Jan 2023 14:46:10 +0000 Subject: [PATCH 04/24] UPSTREAM: io_uring: fix waiters missing wake ups There are reports of mariadb hangs, which is caused by a missing barrier in the waking code resulting in waiters losing events. The problem was introduced in a backport 3ab9326f93ec4 ("io_uring: wake up optimisations"), and the change restores the barrier present in the original commit 3ab9326f93ec4 ("io_uring: wake up optimisations") Reported by: Xan Charbonnet Fixes: 3ab9326f93ec4 ("io_uring: wake up optimisations") Link: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=1093243#99 Link: https://lore.kernel.org/io-uring/760086647776a5aebfa77cfff728837d476a4fd8.1737718881.git.asml.silence@gmail.com/ (cherry picked from commit 74a37ce697f3fa393324990c872a3a8933344f64 https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/commit/?h=v6.1.128) Reviewed-by: Li Zetao Change-Id: Ib21c4cb9a135fb58188dadfb7996afcca93bb5e1 Signed-off-by: Pavel Begunkov Signed-off-by: Greg Kroah-Hartman Signed-off-by: Akilesh Kailash --- io_uring/io_uring.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/io_uring/io_uring.c b/io_uring/io_uring.c index e16f3b70141d..0944f3fb375e 100644 --- a/io_uring/io_uring.c +++ b/io_uring/io_uring.c @@ -592,8 +592,10 @@ static inline void __io_cq_unlock_post_flush(struct io_ring_ctx *ctx) io_commit_cqring(ctx); spin_unlock(&ctx->completion_lock); io_commit_cqring_flush(ctx); - if (!(ctx->flags & IORING_SETUP_DEFER_TASKRUN)) + if (!(ctx->flags & IORING_SETUP_DEFER_TASKRUN)) { + smp_mb(); __io_cqring_wake(ctx); + } } void io_cq_unlock_post(struct io_ring_ctx *ctx) From 4033df202b20e77a0c2bc913467c29fad9e2b311 Mon Sep 17 00:00:00 2001 From: "Isaac J. Manjarres" Date: Mon, 3 Feb 2025 17:21:21 -0800 Subject: [PATCH 05/24] ANDROID: OPP: Fix incorrectly backported logic in _set_opp_level() Commit b50a013d3317 ("BACKPORT: OPP: Extend support for the opp-level beyond required-opps") used dev_pm_genpd_set_performance_state() as a substitute for dev_pm_domain_set_performance_state(), since introducing dev_pm_domain_set_performance_state() required breaking the ABI on this branch. However, directly invoking dev_pm_genpd_set_performance_state() is not equivalent to dev_pm_domain_set_performance_state(), as the latter only invokes a PM domain's set_performance_state callback if the device it is invoked on uses a PM domain, and if that PM domain supports that callback. If that check fails, then the invocation is simply a nop, and no error code is returned. In contrast, dev_pm_genpd_set_performance_state() checks to ensure that the device uses a PM domain, and that the PM domain is a generic PM domain. If that is not the case, then the invocation returns an error which is then propagated up the call chain. Therefore, fix _set_opp_level() to function as a nop for devices without PM domains to align it to its original intent. Bug: 394178898 Fixes: b50a013d3317 ("BACKPORT: OPP: Extend support for the opp-level beyond required-opps") Change-Id: I664d45168404d62aecf59a0afcd2e001d6b7a247 Signed-off-by: Isaac J. Manjarres --- drivers/opp/core.c | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) 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; } From 7658169f5f5f923490921ce2092c559acd69a148 Mon Sep 17 00:00:00 2001 From: Michal Pecio Date: Fri, 27 Dec 2024 14:01:40 +0200 Subject: [PATCH 06/24] BACKPORT: usb: xhci: Fix NULL pointer dereference on certain command aborts If a command is queued to the final usable TRB of a ring segment, the enqueue pointer is advanced to the subsequent link TRB and no further. If the command is later aborted, when the abort completion is handled the dequeue pointer is advanced to the first TRB of the next segment. If no further commands are queued, xhci_handle_stopped_cmd_ring() sees the ring pointers unequal and assumes that there is a pending command, so it calls xhci_mod_cmd_timer() which crashes if cur_cmd was NULL. Don't attempt timer setup if cur_cmd is NULL. The subsequent doorbell ring likely is unnecessary too, but it's harmless. Leave it alone. This is probably Bug 219532, but no confirmation has been received. The issue has been independently reproduced and confirmed fixed using a USB MCU programmed to NAK the Status stage of SET_ADDRESS forever. Everything continued working normally after several prevented crashes. Link: https://bugzilla.kernel.org/show_bug.cgi?id=219532 Fixes: c311e391a7ef ("xhci: rework command timeout and cancellation,") CC: stable@vger.kernel.org Signed-off-by: Michal Pecio Signed-off-by: Mathias Nyman Link: https://lore.kernel.org/r/20241227120142.1035206-4-mathias.nyman@linux.intel.com Signed-off-by: Greg Kroah-Hartman Bug: 393469846 (cherry picked from commit 1e0a19912adb68a4b2b74fd77001c96cd83eb073) [Sriram: Resolved minor conflict drivers/usb/host/xhci-ring.c ] Change-Id: I0228fb40e139eb06b9ab68fd3e66ca3444da7077 Signed-off-by: Sriram Dash --- drivers/usb/host/xhci-ring.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) 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); } } From 3031fa181796e0a4818d7ff6bdc75b0f49b0576e Mon Sep 17 00:00:00 2001 From: Martin Liu Date: Sun, 19 Jan 2025 14:51:51 +0000 Subject: [PATCH 07/24] ANDROID: Adding an Android vendor LMK event This change adds an android_trigger_vendor_lmk_kill() trace event which can be used by vendor modules to send LMKD kill requests. LMKD attaches a BPF program to this trace event if it exists and expects it to be in a particular format. To provide a standardized definition for this event, we define and export it inside the GKI even though there are no users. Android vendors can use this event to emit this trace event inside their modules and experiment with different kill strategies before upstreaming them into LMKD. Bug: 385050909 Test: build and check the ftrace event Change-Id: Ida4d9202675a90d6cc891e242c0621c5386df8cc Signed-off-by: Martin Liu --- drivers/android/vendor_hooks.c | 2 ++ include/trace/events/android_vendor_lmk.h | 32 +++++++++++++++++++++++ 2 files changed, 34 insertions(+) create mode 100644 include/trace/events/android_vendor_lmk.h 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 #include #include +#include /* * 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/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 + +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 From 09717ac61c876ecfea72385c1caae6b31983ae3d Mon Sep 17 00:00:00 2001 From: Martin Liu Date: Wed, 29 Jan 2025 12:15:12 +0000 Subject: [PATCH 08/24] ANDROID: Update the ABI symbol list Adding the following symbols: - __traceiter_android_trigger_vendor_lmk_kill - __tracepoint_android_trigger_vendor_lmk_kill Bug: 385050909 Change-Id: I82e202177d870fe0a55c69172817c260ece41ff6 Signed-off-by: Martin Liu --- android/abi_gki_aarch64.stg | 27 +++++++++++++++++++++++++++ android/abi_gki_aarch64_pixel | 2 ++ 2 files changed, 29 insertions(+) diff --git a/android/abi_gki_aarch64.stg b/android/abi_gki_aarch64.stg index 34fe57c7ae53..edc24600efd0 100644 --- a/android/abi_gki_aarch64.stg +++ b/android/abi_gki_aarch64.stg @@ -324321,6 +324321,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 +346776,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 +351798,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" @@ -417779,6 +417804,7 @@ interface { symbol_id: 0x915194c4 symbol_id: 0xdb6d278a symbol_id: 0xebcd0234 + symbol_id: 0xfd00ed2d symbol_id: 0xa3af7947 symbol_id: 0x86527a4e symbol_id: 0xf71b3e6c @@ -418336,6 +418362,7 @@ interface { symbol_id: 0xd1be5d26 symbol_id: 0xe1b78c30 symbol_id: 0xdcf22716 + symbol_id: 0xb59c7c3f symbol_id: 0x4f980315 symbol_id: 0xe1489e0c symbol_id: 0x8f23a62a 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 From e5f309b277075f8e39639847892a068e7e008464 Mon Sep 17 00:00:00 2001 From: Lee Jones Date: Fri, 11 Mar 2022 14:19:59 +0000 Subject: [PATCH 09/24] ANDROID: dm-bow: Protect Ranges fetched and erased from the RB tree Bug: 195565510 Signed-off-by: Lee Jones (cherry picked from commit 98c15b2bad1a277da43c65c642f8c3c3ee07bacc) Signed-off-by: Lee Jones (cherry picked from https://android-review.googlesource.com/q/commit:5188b662614e86d094e09571e5853f910e9c9404) Merged-In: Ic8134eb902aa7d929e3121b2f69b1d258f570652 Change-Id: Ic8134eb902aa7d929e3121b2f69b1d258f570652 --- drivers/md/dm-bow.c | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) 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, From 1ac09f5c057146455dc10fccd52a8f5f34039fb0 Mon Sep 17 00:00:00 2001 From: Rishi Sikka Date: Thu, 6 Feb 2025 23:04:48 +0000 Subject: [PATCH 10/24] ANDROID: GKI: Update symbol list for arg These symbols are missing from the symbol list and are not available at runtime for unsigned modules: iio_get_channel_type Bug: 386822958 Change-Id: I188d191a5a23451f155584e86d66ae56c235ad64 Signed-off-by: Rishi Sikka --- android/abi_gki_aarch64_arg | 1 + 1 file changed, 1 insertion(+) diff --git a/android/abi_gki_aarch64_arg b/android/abi_gki_aarch64_arg index 8bf65775f170..af0ba5573234 100644 --- a/android/abi_gki_aarch64_arg +++ b/android/abi_gki_aarch64_arg @@ -1012,6 +1012,7 @@ 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 From 4e534b8a5871c5249612638ee6fa318dd81ca970 Mon Sep 17 00:00:00 2001 From: Injune Choi Date: Mon, 10 Feb 2025 19:21:15 +0900 Subject: [PATCH 11/24] ANDROID: GKI: Galaxy android14-6.1 update symbol for alsa audio device INFO: 1 function symbol(s) added 'int snd_ctl_remove_id(struct snd_card*, struct snd_ctl_elem_id*)' snd_ctl_remove_id: remove the control of the given id and release it audio amp driver need to remove kcontrol when reload dapm control. Bug: 391517506 Change-Id: Ic8641be7a06d2dfcacd93e1c065f71704690a5bb Signed-off-by: Injune Choi --- android/abi_gki_aarch64.stg | 16 ++++++++++++++++ android/abi_gki_aarch64_galaxy | 1 + 2 files changed, 17 insertions(+) diff --git a/android/abi_gki_aarch64.stg b/android/abi_gki_aarch64.stg index edc24600efd0..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 @@ -402519,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" @@ -423996,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_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 From c93dcf3b53582bed590ff23c9d56da8b509c9345 Mon Sep 17 00:00:00 2001 From: Carlos Llamas Date: Fri, 10 Jan 2025 17:50:50 +0000 Subject: [PATCH 12/24] UPSTREAM: binder: log transaction code on failure When a transaction fails, log the 'tr->code' to help indentify the problematic userspace call path. This additional information will simplify debugging efforts. Cc: Steven Moreland Signed-off-by: Carlos Llamas Reviewed-by: Alice Ryhl Link: https://lore.kernel.org/r/20250110175051.2656975-1-cmllamas@google.com Signed-off-by: Greg Kroah-Hartman Bug: 388902813 (cherry picked from commit 48dc1c3608befa1ede8465805ca5cbc2ddf5df8a) Change-Id: Icd0364386e28b28fe6b32d1cf4f3c76a66215853 Signed-off-by: Carlos Llamas --- drivers/android/binder.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) 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) From 34a86330cc0aa26d3e2c0bd7c5cb1f38a556d953 Mon Sep 17 00:00:00 2001 From: Quentin Perret Date: Thu, 13 Feb 2025 15:36:14 +0000 Subject: [PATCH 13/24] FROMLIST: KVM: arm64: Fix alignment of kvm_hyp_memcache allocations When allocating guest stage-2 page-table pages at EL2, pKVM can consume pages from the host-provided kvm_hyp_memcache. As pgtable.c expects zeroed pages, guest_s2_zalloc_page() actively implements this zeroing with a PAGE_SIZE memset. Unfortunately, we don't check the page alignment of the host-provided address before doing so, which could lead to the memset overrunning the page if the host was malicious. Fix this by simply force-aligning all kvm_hyp_memcache allocations to page boundaries. Bug: 396116221 Fixes: 60dfe093ec13 ("KVM: arm64: Instantiate guest stage-2 page-tables at EL2") Reported-by: Ben Simner Link: https://lore.kernel.org/r/20250213153615.3642515-1-qperret@google.com Change-Id: Icd8c79495a28c014aa3b320ca44a03ee46ede2ce Signed-off-by: Quentin Perret --- arch/arm64/include/asm/kvm_host.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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; From ccc915784332a8717d3fef84283c416c0e57d3d6 Mon Sep 17 00:00:00 2001 From: Sebastian Achim Date: Thu, 14 Nov 2024 14:23:03 +0100 Subject: [PATCH 14/24] ANDROID: cma: Add restrict_cma_redirect boot parameter Commit "mm,page_alloc,cma: conditionally prefer cma pageblocks for movable allocations" (16867664936e) introduced balancing of movable allocations between CMA and normal areas. Commit "ANDROID: cma: redirect page allocation to CMA" (f60c5572d20a) removes it, making allocations go in CMA area first. 1. Reintroduce the condition, so that CMA and normal area are used in a balanced way(as it used to be), so it prevents depleting of CMA region; 2. Back-port a command line option(from 6.6), "restrict_cma_redirect", that can be used if only MOVABLE allocations marked as __GFP_CMA are eligible to be redirected to CMA region. By default it is true. The purpose of this change is to keep using CMA for movable allocations, but at the same time, to have enough free CMA pages for critical system areas such as modem initialization, GPU initialization and so on. Bug: 381168812 Signed-off-by: Sebastian Achim Signed-off-by: Uladzislau Rezki Signed-off-by: Oleksiy Avramchenko Change-Id: I5fd6d022340715e27754c687189c5ea0e56d9ee6 --- mm/page_alloc.c | 70 ++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 66 insertions(+), 4 deletions(-) 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 From 3812bc69b2e29240e434174a385c2e1a477c1f7e Mon Sep 17 00:00:00 2001 From: Chao Yu Date: Sun, 10 Dec 2023 17:20:39 +0800 Subject: [PATCH 15/24] BACKPORT: f2fs: introduce f2fs_invalidate_internal_cache() for cleanup Just cleanup, no logic changes. Bug: 394006856 Signed-off-by: Chao Yu Signed-off-by: Jaegeuk Kim (cherry picked from commit 4e4f1eb9949b10cb7d76370fd27d41f20ef2b32b) Change-Id: I66352c13dcdcd7f145cfd0e54464feac882009be --- fs/f2fs/data.c | 7 ++----- fs/f2fs/f2fs.h | 7 +++++++ fs/f2fs/gc.c | 5 ++--- fs/f2fs/segment.c | 14 ++++---------- 4 files changed, 15 insertions(+), 18 deletions(-) diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c index 3647eea60ef9..deb083bb5d3b 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); f2fs_update_data_blkaddr(dn, dn->data_blkaddr); return 0; diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h index 720242bda64f..cd4225e62b99 100644 --- a/fs/f2fs/f2fs.h +++ b/fs/f2fs/f2fs.h @@ -4606,6 +4606,13 @@ 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_invalidate_internal_cache(struct f2fs_sb_info *sbi, + block_t blkaddr) +{ + invalidate_mapping_pages(META_MAPPING(sbi), blkaddr, blkaddr); + f2fs_invalidate_compress_page(sbi, blkaddr); +} + #define EFSBADCRC EBADMSG /* Bad CRC detected */ #define EFSCORRUPTED EUCLEAN /* Filesystem is corrupted */ diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c index 60e02fdfffa4..48d057e20c1b 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); set_page_dirty(fio.encrypted_page); if (clear_page_dirty_for_io(fio.encrypted_page)) diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c index 100913a484d2..1685c17ff6e0 100644 --- a/fs/f2fs/segment.c +++ b/fs/f2fs/segment.c @@ -2415,8 +2415,7 @@ void f2fs_invalidate_blocks(struct f2fs_sb_info *sbi, block_t 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); /* add it into sit main buffer */ down_write(&sit_i->sentry_lock); @@ -3478,11 +3477,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); /* writeout dirty page into bdev */ f2fs_submit_page_write(fio); @@ -3678,9 +3674,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); if (!from_gc) update_segment_mtime(sbi, old_blkaddr, 0); update_sit_entry(sbi, old_blkaddr, -1); From edcfc793f8a4ab8a505bb1a228c2b19a3874381d Mon Sep 17 00:00:00 2001 From: Chao Yu Date: Fri, 8 Mar 2024 09:08:34 +0800 Subject: [PATCH 16/24] UPSTREAM: f2fs: fix to truncate meta inode pages forcely Below race case can cause data corruption: Thread A GC thread - gc_data_segment - ra_data_block - locked meta_inode page - f2fs_inplace_write_data - invalidate_mapping_pages : fail to invalidate meta_inode page due to lock failure or dirty|writeback status - f2fs_submit_page_bio : write last dirty data to old blkaddr - move_data_block - load old data from meta_inode page - f2fs_submit_page_write : write old data to new blkaddr Because invalidate_mapping_pages() will skip invalidating page which has unclear status including locked, dirty, writeback and so on, so we need to use truncate_inode_pages_range() instead of invalidate_mapping_pages() to make sure meta_inode page will be dropped. Fixes: 6aa58d8ad20a ("f2fs: readahead encrypted block during GC") Fixes: e3b49ea36802 ("f2fs: invalidate META_MAPPING before IPU/DIO write") Bug: 394006856 Signed-off-by: Chao Yu Signed-off-by: Jaegeuk Kim (cherry picked from commit 7bb861b0b15b42d58669a0a23ce0b7efb1b6c6e5) Change-Id: I4ba1f509a7257dd5a6636d22a0908edd91318dd8 --- fs/f2fs/checkpoint.c | 5 +++-- fs/f2fs/f2fs.h | 28 +++++++++++++++++++++++++++- fs/f2fs/segment.c | 5 ++--- include/linux/f2fs_fs.h | 1 + 4 files changed, 33 insertions(+), 6 deletions(-) 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/f2fs.h b/fs/f2fs/f2fs.h index cd4225e62b99..56244e00b92e 100644 --- a/fs/f2fs/f2fs.h +++ b/fs/f2fs/f2fs.h @@ -4606,10 +4606,36 @@ 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) { - invalidate_mapping_pages(META_MAPPING(sbi), blkaddr, blkaddr); + f2fs_truncate_meta_inode_pages(sbi, blkaddr, 1); f2fs_invalidate_compress_page(sbi, blkaddr); } diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c index 1685c17ff6e0..7539a44415a3 100644 --- a/fs/f2fs/segment.c +++ b/fs/f2fs/segment.c @@ -3572,8 +3572,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); @@ -3763,7 +3762,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/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 From 187a48cb98b165e32311ef19a90869d0a4f2104c Mon Sep 17 00:00:00 2001 From: Yi Sun Date: Mon, 4 Nov 2024 11:45:41 +0800 Subject: [PATCH 17/24] UPSTREAM: f2fs: expand f2fs_invalidate_compress_page() to f2fs_invalidate_compress_pages_range() New function f2fs_invalidate_compress_pages_range() adds the @len parameter. So it can process some consecutive blocks at a time. Bug: 394006856 Change-Id: I3b30396567771e1d3608395fa0b7e5e379ddc805 Signed-off-by: Yi Sun Signed-off-by: Jaegeuk Kim (cherry picked from commit 3d56fbb1f03f2abf8c806aee14df2f462350dfba) --- fs/f2fs/compress.c | 5 +++-- fs/f2fs/f2fs.h | 9 +++++---- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c index 4b6ad2e41541..13aacc9342fe 100644 --- a/fs/f2fs/compress.c +++ b/fs/f2fs/compress.c @@ -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/f2fs.h b/fs/f2fs/f2fs.h index 56244e00b92e..6fb7ea0cf8e0 100644 --- a/fs/f2fs/f2fs.h +++ b/fs/f2fs/f2fs.h @@ -4287,7 +4287,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 +4343,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, @@ -4636,7 +4637,7 @@ static inline void f2fs_invalidate_internal_cache(struct f2fs_sb_info *sbi, block_t blkaddr) { f2fs_truncate_meta_inode_pages(sbi, blkaddr, 1); - f2fs_invalidate_compress_page(sbi, blkaddr); + f2fs_invalidate_compress_pages_range(sbi, blkaddr, 1); } #define EFSBADCRC EBADMSG /* Bad CRC detected */ From 600d7eac2761a4894d6b585d06050d3f38920530 Mon Sep 17 00:00:00 2001 From: Yi Sun Date: Mon, 4 Nov 2024 11:45:42 +0800 Subject: [PATCH 18/24] BACKPORT: f2fs: add parameter @len to f2fs_invalidate_internal_cache() New function can process some consecutive blocks at a time. Bug: 394006856 Change-Id: I6741915ec3fba137ae6295688b6c4f8474411177 Signed-off-by: Yi Sun Reviewed-by: Chao Yu Signed-off-by: Jaegeuk Kim (cherry picked from commit d217b5cea488c0f644c189f91b636aeefa12deb9) --- fs/f2fs/data.c | 2 +- fs/f2fs/f2fs.h | 6 +++--- fs/f2fs/gc.c | 2 +- fs/f2fs/segment.c | 6 +++--- 4 files changed, 8 insertions(+), 8 deletions(-) diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c index deb083bb5d3b..2ebcb4f1b5c9 100644 --- a/fs/f2fs/data.c +++ b/fs/f2fs/data.c @@ -1491,7 +1491,7 @@ static int __allocate_data_block(struct dnode_of_data *dn, int seg_type) return err; if (GET_SEGNO(sbi, old_blkaddr) != NULL_SEGNO) - f2fs_invalidate_internal_cache(sbi, old_blkaddr); + 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 6fb7ea0cf8e0..b7c560e9f1e0 100644 --- a/fs/f2fs/f2fs.h +++ b/fs/f2fs/f2fs.h @@ -4634,10 +4634,10 @@ static inline void f2fs_truncate_meta_inode_pages(struct f2fs_sb_info *sbi, } static inline void f2fs_invalidate_internal_cache(struct f2fs_sb_info *sbi, - block_t blkaddr) + block_t blkaddr, unsigned int len) { - f2fs_truncate_meta_inode_pages(sbi, blkaddr, 1); - f2fs_invalidate_compress_pages_range(sbi, blkaddr, 1); + f2fs_truncate_meta_inode_pages(sbi, blkaddr, len); + f2fs_invalidate_compress_pages_range(sbi, blkaddr, len); } #define EFSBADCRC EBADMSG /* Bad CRC detected */ diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c index 48d057e20c1b..e5e20b7c6093 100644 --- a/fs/f2fs/gc.c +++ b/fs/f2fs/gc.c @@ -1390,7 +1390,7 @@ static int move_data_block(struct inode *inode, block_t bidx, page_address(mpage), PAGE_SIZE); f2fs_put_page(mpage, 1); - f2fs_invalidate_internal_cache(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/segment.c b/fs/f2fs/segment.c index 7539a44415a3..2e71661883c1 100644 --- a/fs/f2fs/segment.c +++ b/fs/f2fs/segment.c @@ -2415,7 +2415,7 @@ void f2fs_invalidate_blocks(struct f2fs_sb_info *sbi, block_t addr) if (addr == NEW_ADDR || addr == COMPRESS_ADDR) return; - f2fs_invalidate_internal_cache(sbi, addr); + f2fs_invalidate_internal_cache(sbi, addr, 1); /* add it into sit main buffer */ down_write(&sit_i->sentry_lock); @@ -3478,7 +3478,7 @@ reallocate: } if (GET_SEGNO(fio->sbi, fio->old_blkaddr) != NULL_SEGNO) - f2fs_invalidate_internal_cache(fio->sbi, fio->old_blkaddr); + f2fs_invalidate_internal_cache(fio->sbi, fio->old_blkaddr, 1); /* writeout dirty page into bdev */ f2fs_submit_page_write(fio); @@ -3673,7 +3673,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) { - f2fs_invalidate_internal_cache(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); From 80b35f89f02e86fcbf6bed41b0d4a38a3b62dbc5 Mon Sep 17 00:00:00 2001 From: Yi Sun Date: Mon, 23 Dec 2024 16:10:41 +0800 Subject: [PATCH 19/24] BACKPORT: f2fs: introduce update_sit_entry_for_release/alloc() No logical changes, just for cleanliness. Bug: 394006856 Change-Id: I4dddab6be974476879af46cda814dee2223ed21d Signed-off-by: Yi Sun Reviewed-by: Chao Yu [Dylan: Resolved minor conflict in fs/f2fs/segment.c ] Signed-off-by: Jaegeuk Kim (cherry picked from commit 66baee2b886d72ab6be11a08d4c7897f9612e25b) --- fs/f2fs/segment.c | 162 ++++++++++++++++++++++++++-------------------- 1 file changed, 93 insertions(+), 69 deletions(-) diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c index 2e71661883c1..e1a5264d4c07 100644 --- a/fs/f2fs/segment.c +++ b/fs/f2fs/segment.c @@ -2304,15 +2304,102 @@ static void update_segment_mtime(struct f2fs_sb_info *sbi, block_t blkaddr, SIT_I(sbi)->max_mtime = ctime; } +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 + + 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++; + + if (!f2fs_test_bit(offset, se->ckpt_valid_map)) + se->ckpt_valid_blocks += del; + + 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; +} + 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 +2416,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); From 2e7c1f7a45476ae729368939c6f31fc49db9d968 Mon Sep 17 00:00:00 2001 From: Yi Sun Date: Mon, 23 Dec 2024 16:10:42 +0800 Subject: [PATCH 20/24] UPSTREAM: f2fs: update_sit_entry_for_release() supports consecutive blocks. This function can process some consecutive blocks at a time. When using update_sit_entry() to release consecutive blocks, ensure that the consecutive blocks belong to the same segment. Because after update_sit_entry_for_realese(), @segno is still in use in update_sit_entry(). Bug: 394006856 Change-Id: Ia6be213c3838351292d1000a52bd54a1090f1137 Signed-off-by: Yi Sun Reviewed-by: Chao Yu Signed-off-by: Jaegeuk Kim (cherry picked from commit 81ffbd224e5f926bf8df01d6107db9c8779f7d57) --- fs/f2fs/segment.c | 79 ++++++++++++++++++++++++++++------------------- 1 file changed, 47 insertions(+), 32 deletions(-) diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c index e1a5264d4c07..f6efa44fe9a9 100644 --- a/fs/f2fs/segment.c +++ b/fs/f2fs/segment.c @@ -2304,6 +2304,10 @@ 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) { @@ -2311,43 +2315,49 @@ static int update_sit_entry_for_release(struct f2fs_sb_info *sbi, struct seg_ent #ifdef CONFIG_F2FS_CHECK_FS bool mir_exist; #endif + int i; + int del_count = -del; - exist = f2fs_test_and_clear_bit(offset, se->cur_valid_map); + 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, - 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); + 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; } - if (f2fs_block_unit_discard(sbi) && - f2fs_test_and_clear_bit(offset, se->discard_map)) - sbi->discard_blks++; - - if (!f2fs_test_bit(offset, se->ckpt_valid_map)) - se->ckpt_valid_blocks += del; - return del; } @@ -2395,6 +2405,11 @@ static int update_sit_entry_for_alloc(struct f2fs_sb_info *sbi, struct seg_entry 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; From 8171ecc314b920f762891be36ed319cdb8fbafb4 Mon Sep 17 00:00:00 2001 From: Yi Sun Date: Mon, 23 Dec 2024 16:10:43 +0800 Subject: [PATCH 21/24] BACKPORT: f2fs: add parameter @len to f2fs_invalidate_blocks() New function can process some consecutive blocks at a time. Function f2fs_invalidate_blocks()->down_write() and up_write() are very time-consuming, so if f2fs_invalidate_blocks() can process consecutive blocks at one time, it will save a lot of time. Bug: 394006856 Change-Id: I6600c5be55f0261b142285fc45212921da8121fb Signed-off-by: Yi Sun Reviewed-by: Chao Yu Signed-off-by: Jaegeuk Kim (cherry picked from commit e53c568f4603e997426712146dce0bc194c1db12) --- fs/f2fs/compress.c | 4 ++-- fs/f2fs/f2fs.h | 3 ++- fs/f2fs/file.c | 6 +++--- fs/f2fs/node.c | 4 ++-- fs/f2fs/segment.c | 32 +++++++++++++++++++++++++------- 5 files changed, 34 insertions(+), 15 deletions(-) diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c index 13aacc9342fe..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; diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h index b7c560e9f1e0..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); diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c index 5dd99242408e..4828d44435df 100644 --- a/fs/f2fs/file.c +++ b/fs/f2fs/file.c @@ -654,7 +654,7 @@ void f2fs_truncate_data_blocks_range(struct dnode_of_data *dn, int count) valid_blocks++; } - f2fs_invalidate_blocks(sbi, blkaddr); + f2fs_invalidate_blocks(sbi, blkaddr, 1); if (!released || blkaddr != COMPRESS_ADDR) nr_free++; @@ -1300,7 +1300,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 +1549,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/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 f6efa44fe9a9..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, @@ -2445,25 +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; - f2fs_invalidate_internal_cache(sbi, addr, 1); + 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); } From a5f88b6529479f8f962494838ed261acc16c64c4 Mon Sep 17 00:00:00 2001 From: Yi Sun Date: Wed, 15 Jan 2025 13:39:43 +0800 Subject: [PATCH 22/24] UPSTREAM: f2fs: Optimize f2fs_truncate_data_blocks_range() Function f2fs_invalidate_blocks() can process consecutive blocks at a time, so f2fs_truncate_data_blocks_range() is optimized to use the new functionality of f2fs_invalidate_blocks(). Add two variables @blkstart and @blklen, @blkstart records the first address of the consecutive blocks, and @blkstart records the number of consecutive blocks. Bug: 394006856 Change-Id: I219866b6c60a8f23f92aee64429064a04e7282d2 Signed-off-by: Yi Sun Reviewed-by: Chao Yu Signed-off-by: Jaegeuk Kim (cherry picked from commit 120ac1dc322f402544423582234f441d98ea4a6e) --- fs/f2fs/file.c | 29 +++++++++++++++++++++++++---- 1 file changed, 25 insertions(+), 4 deletions(-) diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c index 4828d44435df..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, 1); + 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); From f84d5a5fadca1cde33b96df87cd522344298fb45 Mon Sep 17 00:00:00 2001 From: Kyle Tso Date: Tue, 14 Jan 2025 22:24:35 +0800 Subject: [PATCH 23/24] FROMGIT: usb: typec: tcpci: Prevent Sink disconnection before vPpsShutdown in SPR PPS The Source can drop its output voltage to the minimum of the requested PPS APDO voltage range when it is in Current Limit Mode. If this voltage falls within the range of vPpsShutdown, the Source initiates a Hard Reset and discharges Vbus. However, currently the Sink may disconnect before the voltage reaches vPpsShutdown, leading to unexpected behavior. Prevent premature disconnection by setting the Sink's disconnect threshold to the minimum vPpsShutdown value. Additionally, consider the voltage drop due to IR drop when calculating the appropriate threshold. This ensures a robust and reliable interaction between the Source and Sink during SPR PPS Current Limit Mode operation. Fixes: 4288debeaa4e ("usb: typec: tcpci: Fix up sink disconnect thresholds for PD") Cc: stable Signed-off-by: Kyle Tso Reviewed-by: Heikki Krogerus Reviewed-by: Badhri Jagan Sridharan Link: https://lore.kernel.org/r/20250114142435.2093857-1-kyletso@google.com Signed-off-by: Greg Kroah-Hartman Bug: 388029777 (cherry picked from commit 4d27afbf256028a1f54363367f30efc8854433c3 https: //git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb.git/ usb-next) Change-Id: Ifdb1ba19f7147da286ea5e044e84dfb679050a94 Signed-off-by: Kyle Tso --- drivers/usb/typec/tcpm/tcpci.c | 13 +++++++++---- drivers/usb/typec/tcpm/tcpm.c | 8 +++++--- include/linux/usb/tcpm.h | 3 ++- 3 files changed, 16 insertions(+), 8 deletions(-) diff --git a/drivers/usb/typec/tcpm/tcpci.c b/drivers/usb/typec/tcpm/tcpci.c index a68562476788..0169dfe4ac55 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; @@ -340,7 +341,8 @@ static int tcpci_enable_auto_vbus_discharge(struct tcpc_dev *dev, bool enable) } static int tcpci_set_auto_vbus_discharge_threshold(struct tcpc_dev *dev, enum typec_pwr_opmode mode, - bool pps_active, u32 requested_vbus_voltage_mv) + bool pps_active, u32 requested_vbus_voltage_mv, + u32 apdo_min_voltage_mv) { struct tcpci *tcpci = tcpc_to_tcpci(dev); unsigned int pwr_ctrl, threshold = 0; @@ -362,9 +364,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 * apdo_min_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..9f3826158cc5 100644 --- a/drivers/usb/typec/tcpm/tcpm.c +++ b/drivers/usb/typec/tcpm/tcpm.c @@ -2348,10 +2348,12 @@ static int tcpm_set_auto_vbus_discharge_threshold(struct tcpm_port *port, return 0; ret = port->tcpc->set_auto_vbus_discharge_threshold(port->tcpc, mode, pps_active, - requested_vbus_voltage); + requested_vbus_voltage, + port->pps_data.min_volt); 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/include/linux/usb/tcpm.h b/include/linux/usb/tcpm.h index ab7ca872950b..0bdb4f565d0f 100644 --- a/include/linux/usb/tcpm.h +++ b/include/linux/usb/tcpm.h @@ -150,7 +150,8 @@ struct tcpc_dev { void (*frs_sourcing_vbus)(struct tcpc_dev *dev); int (*enable_auto_vbus_discharge)(struct tcpc_dev *dev, bool enable); int (*set_auto_vbus_discharge_threshold)(struct tcpc_dev *dev, enum typec_pwr_opmode mode, - bool pps_active, u32 requested_vbus_voltage); + bool pps_active, u32 requested_vbus_voltage, + u32 pps_apdo_min_voltage); bool (*is_vbus_vsafe0v)(struct tcpc_dev *dev); void (*set_partner_usb_comm_capable)(struct tcpc_dev *dev, bool enable); void (*check_contaminant)(struct tcpc_dev *dev); From 52a41f0bf15cddb56577b6b5ae22bfbfaee022e2 Mon Sep 17 00:00:00 2001 From: Kyle Tso Date: Wed, 22 Jan 2025 22:17:16 +0800 Subject: [PATCH 24/24] ANDROID: usb: typec: tcpci: Combine the parameters of set_auto_vbus_discharge_threshold The change Ifdb1ba19f7147da286ea5e044e84dfb679050a94 ("FROMGIT: usb: typec: tcpci: Prevent Sink disconnection before vPpsShutdown in SPR PPS") breaks the KMI. Prevent the breakage by combining the parameters "requested_vbus_voltage" and "pps_apdo_min_voltage" to a single u32 variable whose value is selected according to the values of parameter "mode" and parameter "pps_active". Bug: 388029777 Change-Id: I85872b9490561d248169bc8e008f3d907cc6c3c0 Signed-off-by: Kyle Tso --- drivers/usb/typec/tcpm/tcpci.c | 5 ++--- drivers/usb/typec/tcpm/tcpm.c | 10 +++++++--- include/linux/usb/tcpm.h | 3 +-- 3 files changed, 10 insertions(+), 8 deletions(-) diff --git a/drivers/usb/typec/tcpm/tcpci.c b/drivers/usb/typec/tcpm/tcpci.c index 0169dfe4ac55..c6f846fbe69e 100644 --- a/drivers/usb/typec/tcpm/tcpci.c +++ b/drivers/usb/typec/tcpm/tcpci.c @@ -341,8 +341,7 @@ static int tcpci_enable_auto_vbus_discharge(struct tcpc_dev *dev, bool enable) } static int tcpci_set_auto_vbus_discharge_threshold(struct tcpc_dev *dev, enum typec_pwr_opmode mode, - bool pps_active, u32 requested_vbus_voltage_mv, - u32 apdo_min_voltage_mv) + bool pps_active, u32 requested_vbus_voltage_mv) { struct tcpci *tcpci = tcpc_to_tcpci(dev); unsigned int pwr_ctrl, threshold = 0; @@ -368,7 +367,7 @@ static int tcpci_set_auto_vbus_discharge_threshold(struct tcpc_dev *dev, enum ty * 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 * apdo_min_voltage_mv / 100 - + 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) - diff --git a/drivers/usb/typec/tcpm/tcpm.c b/drivers/usb/typec/tcpm/tcpm.c index 9f3826158cc5..13c6f78ae4cc 100644 --- a/drivers/usb/typec/tcpm/tcpm.c +++ b/drivers/usb/typec/tcpm/tcpm.c @@ -2342,14 +2342,18 @@ 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, - port->pps_data.min_volt); + 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 pps_apdo_min_volt:%u ret:%d", mode, pps_active ? 'y' : 'n', requested_vbus_voltage, diff --git a/include/linux/usb/tcpm.h b/include/linux/usb/tcpm.h index 0bdb4f565d0f..ab7ca872950b 100644 --- a/include/linux/usb/tcpm.h +++ b/include/linux/usb/tcpm.h @@ -150,8 +150,7 @@ struct tcpc_dev { void (*frs_sourcing_vbus)(struct tcpc_dev *dev); int (*enable_auto_vbus_discharge)(struct tcpc_dev *dev, bool enable); int (*set_auto_vbus_discharge_threshold)(struct tcpc_dev *dev, enum typec_pwr_opmode mode, - bool pps_active, u32 requested_vbus_voltage, - u32 pps_apdo_min_voltage); + bool pps_active, u32 requested_vbus_voltage); bool (*is_vbus_vsafe0v)(struct tcpc_dev *dev); void (*set_partner_usb_comm_capable)(struct tcpc_dev *dev, bool enable); void (*check_contaminant)(struct tcpc_dev *dev);