From 37485a30251f6b72ad7f5e236eb4804762e56f9b Mon Sep 17 00:00:00 2001 From: Greg Kroah-Hartman Date: Fri, 2 Jul 2021 15:58:26 +0200 Subject: [PATCH] ANDROID: add kabi padding for structures for the android12 release There are a lot of different structures that need to have a "frozen" abi for the next 5+ years. Add padding to a lot of them in order to be able to handle any future changes that might be needed due to LTS and security fixes that might come up. It's a best guess, based on what has happened in the past from the 5.4.0..5.4.129 release (1 1/2 years). Yes, past changes do not mean that future changes will also be needed in the same area, but that is a hint that those areas are both well maintained and looked after, and there have been previous problems found in them. Also the list of structures that are being required based on OEM usage in the android/ symbol lists were consulted as that's a larger list than what has been changed in the past. Hopefully we caught everything we need to worry about, only time will tell... Bug: 151154716 Signed-off-by: Greg Kroah-Hartman Change-Id: I880bbcda0628a7459988eeb49d18655522697664 --- drivers/mmc/host/sdhci.h | 5 +++ drivers/scsi/ufs/ufs.h | 2 ++ drivers/scsi/ufs/ufshcd.h | 6 ++++ drivers/usb/typec/class.c | 5 +++ include/linux/amba/bus.h | 5 +++ include/linux/backing-dev-defs.h | 7 ++++ include/linux/blkdev.h | 12 +++++++ include/linux/bpf.h | 9 ++++++ include/linux/bpf_verifier.h | 6 ++++ include/linux/cgroup.h | 3 ++ include/linux/cpuhotplug.h | 4 +++ include/linux/cpuidle.h | 5 +++ include/linux/device-mapper.h | 7 ++++ include/linux/dma-buf.h | 13 ++++++++ include/linux/dmaengine.h | 6 ++++ include/linux/fs.h | 3 ++ include/linux/gpio/driver.h | 7 ++++ include/linux/input.h | 13 ++++++++ include/linux/iomap.h | 2 ++ include/linux/kernfs.h | 6 ++++ include/linux/key-type.h | 4 +++ include/linux/mm_types.h | 2 ++ include/linux/mmc/card.h | 5 +++ include/linux/mmc/host.h | 9 ++++++ include/linux/netfilter.h | 9 ++++++ include/linux/netfilter/ipset/ip_set.h | 7 ++++ include/linux/netfilter/nfnetlink.h | 5 +++ include/linux/netfilter_ipv6.h | 3 ++ include/linux/pci.h | 8 +++++ include/linux/platform_device.h | 8 +++++ include/linux/pm.h | 8 +++++ include/linux/power_supply.h | 9 ++++++ include/linux/pwm.h | 7 ++++ include/linux/regmap.h | 7 ++++ include/linux/regulator/driver.h | 7 ++++ include/linux/rtc.h | 5 +++ include/linux/scmi_protocol.h | 17 ++++++++++ include/linux/serial_core.h | 9 ++++++ include/linux/serio.h | 5 +++ include/linux/spi/spi.h | 15 +++++++++ include/linux/spmi.h | 3 ++ include/linux/suspend.h | 7 ++++ include/linux/tcp.h | 3 ++ include/linux/thermal.h | 16 ++++++++++ include/linux/tty.h | 8 +++++ include/linux/tty_driver.h | 7 ++++ include/linux/tty_ldisc.h | 4 +++ include/linux/uio_driver.h | 4 +++ include/linux/usb/gadget.h | 11 +++++++ include/linux/usb/otg.h | 2 ++ include/linux/usb/phy.h | 3 ++ include/linux/usb/typec.h | 3 ++ include/linux/usb/typec_altmode.h | 2 ++ include/media/v4l2-ctrls.h | 16 ++++++++++ include/media/v4l2-dev.h | 6 ++++ include/media/videobuf2-v4l2.h | 3 ++ include/net/bluetooth/hci_core.h | 19 +++++++++++ include/net/bluetooth/l2cap.h | 10 ++++++ include/net/bluetooth/rfcomm.h | 6 ++++ include/net/cfg80211.h | 44 ++++++++++++++++++++++++++ include/net/genetlink.h | 5 +++ include/net/inet_connection_sock.h | 5 +++ include/net/ip6_fib.h | 10 ++++++ include/net/mac80211.h | 24 ++++++++++++++ include/net/neighbour.h | 8 +++++ include/net/netns/can.h | 3 ++ include/net/netns/ipv4.h | 3 ++ include/net/netns/ipv6.h | 3 ++ include/net/netns/netfilter.h | 3 ++ include/net/netns/nftables.h | 3 ++ include/net/netns/xfrm.h | 3 ++ include/net/page_pool.h | 3 ++ include/net/sch_generic.h | 7 ++++ include/net/tls.h | 7 ++++ include/scsi/scsi_host.h | 2 ++ include/sound/compress_driver.h | 8 +++++ include/sound/core.h | 10 ++++++ include/sound/hwdep.h | 5 +++ include/sound/info.h | 5 +++ include/sound/jack.h | 3 ++ include/sound/soc.h | 15 +++++++++ include/sound/timer.h | 7 ++++ sound/usb/card.h | 2 ++ sound/usb/usbaudio.h | 10 ++++++ 84 files changed, 606 insertions(+) diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h index 0770c036e2ff..63f51491fffe 100644 --- a/drivers/mmc/host/sdhci.h +++ b/drivers/mmc/host/sdhci.h @@ -16,6 +16,7 @@ #include #include #include +#include #include @@ -605,6 +606,8 @@ struct sdhci_host { u64 data_timeout; + ANDROID_KABI_RESERVE(1); + unsigned long private[] ____cacheline_aligned; }; @@ -652,6 +655,8 @@ struct sdhci_ops { void (*request_done)(struct sdhci_host *host, struct mmc_request *mrq); void (*dump_vendor_regs)(struct sdhci_host *host); + + ANDROID_KABI_RESERVE(1); }; #ifdef CONFIG_MMC_SDHCI_IO_ACCESSORS diff --git a/drivers/scsi/ufs/ufs.h b/drivers/scsi/ufs/ufs.h index d69032d65463..1ee80cda3d01 100644 --- a/drivers/scsi/ufs/ufs.h +++ b/drivers/scsi/ufs/ufs.h @@ -13,6 +13,7 @@ #include #include +#include #include #define GENERAL_UPIU_REQUEST_SIZE (sizeof(struct utp_upiu_req)) @@ -594,6 +595,7 @@ struct ufs_dev_info { u8 b_presrv_uspc_en; /* UFS HPB related flag */ bool hpb_enabled; + ANDROID_KABI_RESERVE(1); }; /** diff --git a/drivers/scsi/ufs/ufshcd.h b/drivers/scsi/ufs/ufshcd.h index 6577dc68ec6e..f4d0fb6fdd97 100644 --- a/drivers/scsi/ufs/ufshcd.h +++ b/drivers/scsi/ufs/ufshcd.h @@ -218,6 +218,8 @@ struct ufshcd_lrb { #endif bool req_abort_skip; + + ANDROID_KABI_RESERVE(1); }; /** @@ -398,6 +400,8 @@ struct ufs_clk_gating { bool is_initialized; int active_reqs; struct workqueue_struct *clk_gating_workq; + + ANDROID_KABI_RESERVE(1); }; struct ufs_saved_pwr_info { @@ -444,6 +448,8 @@ struct ufs_clk_scaling { bool is_initialized; bool is_busy_started; bool is_suspended; + + ANDROID_KABI_RESERVE(1); }; #define UFS_EVENT_HIST_LENGTH 8 diff --git a/drivers/usb/typec/class.c b/drivers/usb/typec/class.c index bca461ea6456..8277c2907b8e 100644 --- a/drivers/usb/typec/class.c +++ b/drivers/usb/typec/class.c @@ -12,6 +12,7 @@ #include #include #include +#include #include "bus.h" @@ -20,6 +21,7 @@ struct typec_plug { enum typec_plug_index index; struct ida mode_ids; int num_altmodes; + ANDROID_KABI_RESERVE(1); }; struct typec_cable { @@ -28,6 +30,7 @@ struct typec_cable { struct usb_pd_identity *identity; unsigned int active:1; u16 pd_revision; /* 0300H = "3.0" */ + ANDROID_KABI_RESERVE(1); }; struct typec_partner { @@ -39,6 +42,7 @@ struct typec_partner { int num_altmodes; u16 pd_revision; /* 0300H = "3.0" */ enum usb_pd_svdm_ver svdm_version; + ANDROID_KABI_RESERVE(1); }; struct typec_port { @@ -60,6 +64,7 @@ struct typec_port { const struct typec_capability *cap; const struct typec_operations *ops; + ANDROID_KABI_RESERVE(1); }; #define to_typec_port(_dev_) container_of(_dev_, struct typec_port, dev) diff --git a/include/linux/amba/bus.h b/include/linux/amba/bus.h index 6cc93ab5b809..55e2f02bd45a 100644 --- a/include/linux/amba/bus.h +++ b/include/linux/amba/bus.h @@ -17,6 +17,7 @@ #include #include #include +#include #define AMBA_NR_IRQS 9 #define AMBA_CID 0xb105f00d @@ -71,6 +72,8 @@ struct amba_device { struct amba_cs_uci_id uci; unsigned int irq[AMBA_NR_IRQS]; char *driver_override; + + ANDROID_KABI_RESERVE(1); }; struct amba_driver { @@ -79,6 +82,8 @@ struct amba_driver { void (*remove)(struct amba_device *); void (*shutdown)(struct amba_device *); const struct amba_id *id_table; + + ANDROID_KABI_RESERVE(1); }; /* diff --git a/include/linux/backing-dev-defs.h b/include/linux/backing-dev-defs.h index fff9367a6348..f3314adb6a8d 100644 --- a/include/linux/backing-dev-defs.h +++ b/include/linux/backing-dev-defs.h @@ -13,6 +13,7 @@ #include #include #include +#include struct page; struct device; @@ -160,6 +161,9 @@ struct bdi_writeback { struct rcu_head rcu; }; #endif + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; struct backing_dev_info { @@ -198,6 +202,9 @@ struct backing_dev_info { #ifdef CONFIG_DEBUG_FS struct dentry *debug_dir; #endif + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; enum { diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h index 433ae2605277..cdd5a0e2ec6a 100644 --- a/include/linux/blkdev.h +++ b/include/linux/blkdev.h @@ -26,6 +26,7 @@ #include #include #include +#include struct module; struct scsi_ioctl_command; @@ -242,6 +243,8 @@ struct request { */ rq_end_io_fn *end_io; void *end_io_data; + + ANDROID_KABI_RESERVE(1); }; static inline bool blk_op_is_scsi(unsigned int op) @@ -346,6 +349,8 @@ struct queue_limits { unsigned char discard_misaligned; unsigned char raid_partial_stripes_expensive; enum blk_zoned_model zoned; + + ANDROID_KABI_RESERVE(1); }; typedef int (*report_zones_cb)(struct blk_zone *zone, unsigned int idx, @@ -589,6 +594,10 @@ struct request_queue { #define BLK_MAX_WRITE_HINTS 5 u64 write_hints[BLK_MAX_WRITE_HINTS]; + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); + ANDROID_KABI_RESERVE(3); + ANDROID_KABI_RESERVE(4); ANDROID_OEM_DATA(1); }; @@ -1858,6 +1867,9 @@ struct block_device_operations { char *(*devnode)(struct gendisk *disk, umode_t *mode); struct module *owner; const struct pr_ops *pr_ops; + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; #ifdef CONFIG_COMPAT diff --git a/include/linux/bpf.h b/include/linux/bpf.h index 6460b57b4b79..62ff6b56a929 100644 --- a/include/linux/bpf.h +++ b/include/linux/bpf.h @@ -21,6 +21,7 @@ #include #include #include +#include struct bpf_verifier_env; struct bpf_verifier_log; @@ -132,6 +133,9 @@ struct bpf_map_ops { /* bpf_iter info used to open a seq_file */ const struct bpf_iter_seq_info *iter_seq_info; + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; struct bpf_map_memory { @@ -218,6 +222,8 @@ struct bpf_map_dev_ops { int (*map_update_elem)(struct bpf_offloaded_map *map, void *key, void *value, u64 flags); int (*map_delete_elem)(struct bpf_offloaded_map *map, void *key); + + ANDROID_KABI_RESERVE(1); }; struct bpf_offloaded_map { @@ -459,6 +465,7 @@ struct bpf_verifier_ops { const struct btf_type *t, int off, int size, enum bpf_access_type atype, u32 *next_btf_id); + ANDROID_KABI_RESERVE(1); }; struct bpf_prog_offload_ops { @@ -474,6 +481,7 @@ struct bpf_prog_offload_ops { int (*prepare)(struct bpf_prog *prog); int (*translate)(struct bpf_prog *prog); void (*destroy)(struct bpf_prog *prog); + ANDROID_KABI_RESERVE(1); }; struct bpf_prog_offload { @@ -851,6 +859,7 @@ struct bpf_prog_aux { struct work_struct work; struct rcu_head rcu; }; + ANDROID_KABI_RESERVE(1); }; struct bpf_array_aux { diff --git a/include/linux/bpf_verifier.h b/include/linux/bpf_verifier.h index 2739a6431b9e..b83f1dd5c719 100644 --- a/include/linux/bpf_verifier.h +++ b/include/linux/bpf_verifier.h @@ -7,6 +7,7 @@ #include /* for enum bpf_reg_type */ #include /* for MAX_BPF_STACK */ #include +#include /* Maximum variable offset umax_value permitted when resolving memory accesses. * In practice this is far bigger than any realistic pointer offset; this limit @@ -370,6 +371,8 @@ struct bpf_subprog_info { bool has_tail_call; bool tail_call_reachable; bool has_ld_abs; + + ANDROID_KABI_RESERVE(1); }; /* single container for all structs @@ -425,6 +428,9 @@ struct bpf_verifier_env { u32 peak_states; /* longest register parentage chain walked for liveness marking */ u32 longest_mark_read_walk; + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; __printf(2, 0) void bpf_verifier_vlog(struct bpf_verifier_log *log, diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h index 14b808b02872..67b2190b1dae 100644 --- a/include/linux/cgroup.h +++ b/include/linux/cgroup.h @@ -24,6 +24,7 @@ #include #include #include +#include #include @@ -66,6 +67,8 @@ struct css_task_iter { struct css_set *cur_dcset; struct task_struct *cur_task; struct list_head iters_node; /* css_set->task_iters */ + + ANDROID_KABI_RESERVE(1); }; extern struct cgroup_root cgrp_dfl_root; diff --git a/include/linux/cpuhotplug.h b/include/linux/cpuhotplug.h index 1366cfbfdc78..843bb056b8c6 100644 --- a/include/linux/cpuhotplug.h +++ b/include/linux/cpuhotplug.h @@ -195,6 +195,10 @@ enum cpuhp_state { CPUHP_AP_X86_KVM_CLK_ONLINE, CPUHP_AP_DTPM_CPU_ONLINE, CPUHP_AP_ACTIVE, + CPUHP_ANDROID_RESERVED_1, + CPUHP_ANDROID_RESERVED_2, + CPUHP_ANDROID_RESERVED_3, + CPUHP_ANDROID_RESERVED_4, CPUHP_ONLINE, }; diff --git a/include/linux/cpuidle.h b/include/linux/cpuidle.h index bd605b5585cf..4b51019dd2b8 100644 --- a/include/linux/cpuidle.h +++ b/include/linux/cpuidle.h @@ -14,6 +14,7 @@ #include #include #include +#include #define CPUIDLE_STATE_MAX 10 #define CPUIDLE_NAME_LEN 16 @@ -110,6 +111,8 @@ struct cpuidle_device { cpumask_t coupled_cpus; struct cpuidle_coupled *coupled; #endif + + ANDROID_KABI_RESERVE(1); }; DECLARE_PER_CPU(struct cpuidle_device *, cpuidle_devices); @@ -135,6 +138,8 @@ struct cpuidle_driver { /* preferred governor to switch at register time */ const char *governor; + + ANDROID_KABI_RESERVE(1); }; #ifdef CONFIG_CPU_IDLE diff --git a/include/linux/device-mapper.h b/include/linux/device-mapper.h index 8858ffd6fb10..ccb909edca38 100644 --- a/include/linux/device-mapper.h +++ b/include/linux/device-mapper.h @@ -13,6 +13,7 @@ #include #include #include +#include struct dm_dev; struct dm_target; @@ -198,6 +199,9 @@ struct target_type { dm_dax_copy_iter_fn dax_copy_to_iter; dm_dax_zero_page_range_fn dax_zero_page_range; + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); + /* For internal device-mapper use. */ struct list_head list; }; @@ -349,6 +353,9 @@ struct dm_target { * Set if we need to limit the number of in-flight bios when swapping. */ bool limit_swap_bios:1; + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; void *dm_per_bio_data(struct bio *bio, size_t data_size); diff --git a/include/linux/dma-buf.h b/include/linux/dma-buf.h index 303f559d7b30..bddf8b8f2347 100644 --- a/include/linux/dma-buf.h +++ b/include/linux/dma-buf.h @@ -21,6 +21,7 @@ #include #include #include +#include struct device; struct dma_buf; @@ -353,6 +354,9 @@ struct dma_buf_ops { * will be populated with the buffer's flags. */ int (*get_flags)(struct dma_buf *dmabuf, unsigned long *flags); + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; /** @@ -425,6 +429,9 @@ struct dma_buf { struct kset *attach_stats_kset; } *sysfs_entry; #endif + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; /** @@ -505,6 +512,9 @@ struct dma_buf_attachment { unsigned int map_counter; } *sysfs_entry; #endif + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; /** @@ -528,6 +538,9 @@ struct dma_buf_export_info { int flags; struct dma_resv *resv; void *priv; + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; /** diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h index 493a047ed0a2..3f8dcaa83a49 100644 --- a/include/linux/dmaengine.h +++ b/include/linux/dmaengine.h @@ -12,6 +12,7 @@ #include #include #include +#include #include /** @@ -941,6 +942,11 @@ struct dma_device { void (*dbg_summary_show)(struct seq_file *s, struct dma_device *dev); struct dentry *dbg_dev_root; #endif + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); + ANDROID_KABI_RESERVE(3); + ANDROID_KABI_RESERVE(4); }; static inline int dmaengine_slave_config(struct dma_chan *chan, diff --git a/include/linux/fs.h b/include/linux/fs.h index d3a1342281dd..ff841fa9ea35 100644 --- a/include/linux/fs.h +++ b/include/linux/fs.h @@ -966,6 +966,9 @@ struct file { struct address_space *f_mapping; errseq_t f_wb_err; errseq_t f_sb_err; /* for syncfs */ + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); } __randomize_layout __attribute__((aligned(4))); /* lest something weird decides that 2 is OK */ diff --git a/include/linux/gpio/driver.h b/include/linux/gpio/driver.h index 8e144306e262..ff3e6e3eb9c1 100644 --- a/include/linux/gpio/driver.h +++ b/include/linux/gpio/driver.h @@ -10,6 +10,7 @@ #include #include #include +#include struct gpio_desc; struct of_phandle_args; @@ -266,6 +267,9 @@ struct gpio_irq_chip { * Store old irq_chip irq_mask callback */ void (*irq_mask)(struct irq_data *data); + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; /** @@ -469,6 +473,9 @@ struct gpio_chip { int (*of_xlate)(struct gpio_chip *gc, const struct of_phandle_args *gpiospec, u32 *flags); #endif /* CONFIG_OF_GPIO */ + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; extern const char *gpiochip_is_requested(struct gpio_chip *gc, diff --git a/include/linux/input.h b/include/linux/input.h index 56f2fd32e609..4d752cedf581 100644 --- a/include/linux/input.h +++ b/include/linux/input.h @@ -7,6 +7,7 @@ #include #include +#include #include /* Implementation details, userspace should not care about these */ #define ABS_MT_FIRST ABS_MT_TOUCH_MAJOR @@ -201,6 +202,11 @@ struct input_dev { bool devres_managed; ktime_t timestamp[INPUT_CLK_MAX]; + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); + ANDROID_KABI_RESERVE(3); + ANDROID_KABI_RESERVE(4); }; #define to_input_dev(d) container_of(d, struct input_dev, dev) @@ -320,6 +326,8 @@ struct input_handler { struct list_head h_list; struct list_head node; + + ANDROID_KABI_RESERVE(1); }; /** @@ -346,6 +354,8 @@ struct input_handle { struct list_head d_node; struct list_head h_node; + + ANDROID_KABI_RESERVE(1); }; struct input_dev __must_check *input_allocate_device(void); @@ -550,6 +560,9 @@ struct ff_device { int max_effects; struct ff_effect *effects; + + ANDROID_KABI_RESERVE(1); + struct file *effect_owners[]; }; diff --git a/include/linux/iomap.h b/include/linux/iomap.h index 8a6add3abb3f..257ffd4d921f 100644 --- a/include/linux/iomap.h +++ b/include/linux/iomap.h @@ -89,6 +89,8 @@ struct iomap { void *inline_data; void *private; /* filesystem private */ const struct iomap_page_ops *page_ops; + + ANDROID_KABI_RESERVE(1); }; static inline sector_t diff --git a/include/linux/kernfs.h b/include/linux/kernfs.h index c8529e9fa8de..44349791737a 100644 --- a/include/linux/kernfs.h +++ b/include/linux/kernfs.h @@ -157,6 +157,8 @@ struct kernfs_node { unsigned short flags; umode_t mode; struct kernfs_iattrs *iattr; + + ANDROID_KABI_RESERVE(1); }; /* @@ -198,6 +200,8 @@ struct kernfs_root { struct list_head supers; wait_queue_head_t deactivate_waitq; + + ANDROID_KABI_RESERVE(1); }; struct kernfs_open_file { @@ -218,6 +222,8 @@ struct kernfs_open_file { bool mmapped:1; bool released:1; const struct vm_operations_struct *vm_ops; + + ANDROID_KABI_RESERVE(1); }; struct kernfs_ops { diff --git a/include/linux/key-type.h b/include/linux/key-type.h index 2ab2d6d6aeab..5e85fe05c7b1 100644 --- a/include/linux/key-type.h +++ b/include/linux/key-type.h @@ -10,6 +10,7 @@ #include #include +#include #ifdef CONFIG_KEYS @@ -155,6 +156,9 @@ struct key_type { int (*asym_verify_signature)(struct kernel_pkey_params *params, const void *in, const void *in2); + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); + /* internal fields */ struct list_head link; /* link in types list */ struct lock_class_key lock_class; /* key->sem lock class */ diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h index 4398d84d2f8b..c853f612a815 100644 --- a/include/linux/mm_types.h +++ b/include/linux/mm_types.h @@ -598,6 +598,8 @@ struct mm_struct { #ifdef CONFIG_IOMMU_SUPPORT u32 pasid; #endif + + ANDROID_KABI_RESERVE(1); } __randomize_layout; /* diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h index 6f13f15e95f0..bb62eae4d88a 100644 --- a/include/linux/mmc/card.h +++ b/include/linux/mmc/card.h @@ -9,6 +9,7 @@ #include #include +#include struct mmc_cid { unsigned int manfid; @@ -236,6 +237,8 @@ struct mmc_part { #define MMC_BLK_DATA_AREA_BOOT (1<<1) #define MMC_BLK_DATA_AREA_GP (1<<2) #define MMC_BLK_DATA_AREA_RPMB (1<<3) + + ANDROID_KABI_RESERVE(1); }; /* @@ -314,6 +317,8 @@ struct mmc_card { unsigned int bouncesz; /* Bounce buffer size */ struct workqueue_struct *complete_wq; /* Private workqueue */ + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); ANDROID_VENDOR_DATA(1); }; diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h index 7891e314599d..6fa9e476e778 100644 --- a/include/linux/mmc/host.h +++ b/include/linux/mmc/host.h @@ -16,6 +16,7 @@ #include #include #include +#include #include @@ -176,6 +177,9 @@ struct mmc_host_ops { */ int (*multi_io_quirk)(struct mmc_card *card, unsigned int direction, int blk_size); + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; struct mmc_cqe_ops { @@ -220,6 +224,9 @@ struct mmc_cqe_ops { * will have zero data bytes transferred. */ void (*cqe_recovery_finish)(struct mmc_host *host); + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; struct mmc_async_req { @@ -485,6 +492,8 @@ struct mmc_host { /* Host Software Queue support */ bool hsq_enabled; + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); ANDROID_VENDOR_DATA(1); ANDROID_OEM_DATA(1); diff --git a/include/linux/netfilter.h b/include/linux/netfilter.h index 0101747de549..a12c285222a8 100644 --- a/include/linux/netfilter.h +++ b/include/linux/netfilter.h @@ -14,6 +14,7 @@ #include #include #include +#include #include static inline int NF_DROP_GETERR(int verdict) @@ -171,6 +172,8 @@ struct nf_sockopt_ops { int (*get)(struct sock *sk, int optval, void __user *user, int *len); /* Use the module struct to lock set/get code in place */ struct module *owner; + + ANDROID_KABI_RESERVE(1); }; /* Function to register/unregister hook points. */ @@ -373,6 +376,8 @@ struct nf_nat_hook { unsigned int (*manip_pkt)(struct sk_buff *skb, struct nf_conn *ct, enum nf_nat_manip_type mtype, enum ip_conntrack_dir dir); + + ANDROID_KABI_RESERVE(1); }; extern struct nf_nat_hook __rcu *nf_nat_hook; @@ -457,6 +462,8 @@ struct nf_ct_hook { void (*destroy)(struct nf_conntrack *); bool (*get_tuple_skb)(struct nf_conntrack_tuple *, const struct sk_buff *); + + ANDROID_KABI_RESERVE(1); }; extern struct nf_ct_hook __rcu *nf_ct_hook; @@ -474,6 +481,8 @@ struct nfnl_ct_hook { u32 portid, u32 report); void (*seq_adjust)(struct sk_buff *skb, struct nf_conn *ct, enum ip_conntrack_info ctinfo, s32 off); + + ANDROID_KABI_RESERVE(1); }; extern struct nfnl_ct_hook __rcu *nfnl_ct_hook; diff --git a/include/linux/netfilter/ipset/ip_set.h b/include/linux/netfilter/ipset/ip_set.h index ab192720e2d6..5206d0991022 100644 --- a/include/linux/netfilter/ipset/ip_set.h +++ b/include/linux/netfilter/ipset/ip_set.h @@ -14,6 +14,7 @@ #include #include #include +#include #include #include @@ -190,6 +191,8 @@ struct ip_set_type_variant { bool (*same_set)(const struct ip_set *a, const struct ip_set *b); /* Region-locking is used */ bool region_lock; + + ANDROID_KABI_RESERVE(1); }; struct ip_set_region { @@ -228,6 +231,8 @@ struct ip_set_type { /* Set this to THIS_MODULE if you are a module, otherwise NULL */ struct module *me; + + ANDROID_KABI_RESERVE(1); }; /* register and unregister set type */ @@ -270,6 +275,8 @@ struct ip_set { size_t offset[IPSET_EXT_ID_MAX]; /* The type specific data */ void *data; + + ANDROID_KABI_RESERVE(1); }; static inline void diff --git a/include/linux/netfilter/nfnetlink.h b/include/linux/netfilter/nfnetlink.h index f6267e2883f2..15775bc5b174 100644 --- a/include/linux/netfilter/nfnetlink.h +++ b/include/linux/netfilter/nfnetlink.h @@ -4,6 +4,7 @@ #include #include +#include #include #include @@ -22,6 +23,8 @@ struct nfnl_callback { struct netlink_ext_ack *extack); const struct nla_policy *policy; /* netlink attribute policy */ const u_int16_t attr_count; /* number of nlattr's */ + + ANDROID_KABI_RESERVE(1); }; enum nfnl_abort_action { @@ -41,6 +44,8 @@ struct nfnetlink_subsystem { enum nfnl_abort_action action); void (*cleanup)(struct net *net); bool (*valid_genid)(struct net *net, u32 genid); + + ANDROID_KABI_RESERVE(1); }; int nfnetlink_subsys_register(const struct nfnetlink_subsystem *n); diff --git a/include/linux/netfilter_ipv6.h b/include/linux/netfilter_ipv6.h index 48314ade1506..c3d17fe68426 100644 --- a/include/linux/netfilter_ipv6.h +++ b/include/linux/netfilter_ipv6.h @@ -7,6 +7,7 @@ #ifndef __LINUX_IP6_NETFILTER_H #define __LINUX_IP6_NETFILTER_H +#include #include #include @@ -65,6 +66,8 @@ struct nf_ipv6_ops { const struct nf_bridge_frag_data *data, struct sk_buff *)); #endif + + ANDROID_KABI_RESERVE(1); }; #ifdef CONFIG_NETFILTER diff --git a/include/linux/pci.h b/include/linux/pci.h index cc772efa9713..76ea634f24a7 100644 --- a/include/linux/pci.h +++ b/include/linux/pci.h @@ -558,6 +558,10 @@ struct pci_host_bridge { resource_size_t start, resource_size_t size, resource_size_t align); + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); + unsigned long private[] ____cacheline_aligned; }; @@ -745,6 +749,8 @@ struct pci_ops { void __iomem *(*map_bus)(struct pci_bus *bus, unsigned int devfn, int where); int (*read)(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 *val); int (*write)(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 val); + + ANDROID_KABI_RESERVE(1); }; /* @@ -820,6 +826,8 @@ struct pci_error_handlers { /* Device driver may resume normal operations */ void (*resume)(struct pci_dev *dev); + + ANDROID_KABI_RESERVE(1); }; diff --git a/include/linux/platform_device.h b/include/linux/platform_device.h index 17f9cd5626c8..72b8a954e6bb 100644 --- a/include/linux/platform_device.h +++ b/include/linux/platform_device.h @@ -11,6 +11,7 @@ #define _PLATFORM_DEVICE_H_ #include +#include #define PLATFORM_DEVID_NONE (-1) #define PLATFORM_DEVID_AUTO (-2) @@ -37,6 +38,9 @@ struct platform_device { /* arch specific additions */ struct pdev_archdata archdata; + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; #define platform_get_device_id(pdev) ((pdev)->id_entry) @@ -94,6 +98,8 @@ struct platform_device_info { u64 dma_mask; const struct property_entry *properties; + + ANDROID_KABI_RESERVE(1); }; extern struct platform_device *platform_device_register_full( const struct platform_device_info *pdevinfo); @@ -206,6 +212,8 @@ struct platform_driver { struct device_driver driver; const struct platform_device_id *id_table; bool prevent_deferred_probe; + + ANDROID_KABI_RESERVE(1); }; #define to_platform_driver(drv) (container_of((drv), struct platform_driver, \ diff --git a/include/linux/pm.h b/include/linux/pm.h index 52d9724db9dc..8b174a8f9f04 100644 --- a/include/linux/pm.h +++ b/include/linux/pm.h @@ -15,6 +15,7 @@ #include #include #include +#include /* * Callbacks for platform drivers to implement. @@ -299,6 +300,8 @@ struct dev_pm_ops { int (*runtime_suspend)(struct device *dev); int (*runtime_resume)(struct device *dev); int (*runtime_idle)(struct device *dev); + + ANDROID_KABI_RESERVE(1); }; #ifdef CONFIG_PM_SLEEP @@ -621,6 +624,9 @@ struct dev_pm_info { struct pm_subsys_data *subsys_data; /* Owned by the subsystem. */ void (*set_latency_tolerance)(struct device *, s32); struct dev_pm_qos *qos; + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; extern int dev_pm_get_subsys_data(struct device *dev); @@ -647,6 +653,8 @@ struct dev_pm_domain { int (*activate)(struct device *dev); void (*sync)(struct device *dev); void (*dismiss)(struct device *dev); + + ANDROID_KABI_RESERVE(1); }; /* diff --git a/include/linux/power_supply.h b/include/linux/power_supply.h index aefa0b0bc4c4..a8fa073a09b6 100644 --- a/include/linux/power_supply.h +++ b/include/linux/power_supply.h @@ -17,6 +17,7 @@ #include #include #include +#include /* * All voltages, currents, charges, energies, time and temperatures in uV, @@ -233,6 +234,8 @@ struct power_supply_config { char **supplied_to; size_t num_supplicants; + + ANDROID_KABI_RESERVE(1); }; /* Description of power supply */ @@ -274,6 +277,8 @@ struct power_supply_desc { bool no_thermal; /* For APM emulation, think legacy userspace. */ int use_for_apm; + + ANDROID_KABI_RESERVE(1); }; struct power_supply { @@ -315,6 +320,8 @@ struct power_supply { struct led_trigger *charging_blink_full_solid_trig; char *charging_blink_full_solid_trig_name; #endif + + ANDROID_KABI_RESERVE(1); }; /* @@ -382,6 +389,8 @@ struct power_supply_battery_info { int ocv_table_size[POWER_SUPPLY_OCV_TEMP_MAX]; struct power_supply_resistance_temp_table *resist_table; int resist_table_size; + + ANDROID_KABI_RESERVE(1); }; extern struct atomic_notifier_head power_supply_notifier; diff --git a/include/linux/pwm.h b/include/linux/pwm.h index f0a7329ba3b2..72fe459f0267 100644 --- a/include/linux/pwm.h +++ b/include/linux/pwm.h @@ -5,6 +5,7 @@ #include #include #include +#include struct pwm_capture; struct seq_file; @@ -97,6 +98,8 @@ struct pwm_device { struct pwm_args args; struct pwm_state state; struct pwm_state last; + + ANDROID_KABI_RESERVE(1); }; /** @@ -298,6 +301,8 @@ struct pwm_ops { enum pwm_polarity polarity); int (*enable)(struct pwm_chip *chip, struct pwm_device *pwm); void (*disable)(struct pwm_chip *chip, struct pwm_device *pwm); + + ANDROID_KABI_RESERVE(1); }; /** @@ -324,6 +329,8 @@ struct pwm_chip { /* only used internally by the PWM framework */ struct list_head list; struct pwm_device *pwms; + + ANDROID_KABI_RESERVE(1); }; /** diff --git a/include/linux/regmap.h b/include/linux/regmap.h index e7834d98207f..751ca3869307 100644 --- a/include/linux/regmap.h +++ b/include/linux/regmap.h @@ -19,6 +19,7 @@ #include #include #include +#include struct module; struct clk; @@ -401,6 +402,8 @@ struct regmap_config { unsigned int hwlock_mode; bool can_sleep; + + ANDROID_KABI_RESERVE(1); }; /** @@ -438,6 +441,8 @@ struct regmap_range_cfg { /* Data window (per each page) */ unsigned int window_start; unsigned int window_len; + + ANDROID_KABI_RESERVE(1); }; struct regmap_async; @@ -514,6 +519,8 @@ struct regmap_bus { enum regmap_endian val_format_endian_default; size_t max_raw_read; size_t max_raw_write; + + ANDROID_KABI_RESERVE(1); }; /* diff --git a/include/linux/regulator/driver.h b/include/linux/regulator/driver.h index d7c77ee370f3..4d73dc580d75 100644 --- a/include/linux/regulator/driver.h +++ b/include/linux/regulator/driver.h @@ -17,6 +17,7 @@ #include #include #include +#include struct gpio_desc; struct regmap; @@ -202,6 +203,8 @@ struct regulator_ops { int (*resume)(struct regulator_dev *rdev); int (*set_pull_down) (struct regulator_dev *); + + ANDROID_KABI_RESERVE(1); }; /* @@ -381,6 +384,8 @@ struct regulator_desc { unsigned int poll_enabled_time; unsigned int (*of_map_mode)(unsigned int mode); + + ANDROID_KABI_RESERVE(1); }; /** @@ -473,6 +478,8 @@ struct regulator_dev { /* time when this regulator was disabled last time */ unsigned long last_off_jiffy; + + ANDROID_KABI_RESERVE(1); }; struct regulator_dev * diff --git a/include/linux/rtc.h b/include/linux/rtc.h index 22d1575e4991..d51770334160 100644 --- a/include/linux/rtc.h +++ b/include/linux/rtc.h @@ -16,6 +16,7 @@ #include #include #include +#include #include extern int rtc_month_days(unsigned int month, unsigned int year); @@ -66,6 +67,8 @@ struct rtc_class_ops { int (*alarm_irq_enable)(struct device *, unsigned int enabled); int (*read_offset)(struct device *, long *offset); int (*set_offset)(struct device *, long offset); + + ANDROID_KABI_RESERVE(1); }; struct rtc_device; @@ -140,6 +143,8 @@ struct rtc_device { unsigned int uie_task_active:1; unsigned int uie_timer_active:1; #endif + + ANDROID_KABI_RESERVE(1); }; #define to_rtc_device(d) container_of(d, struct rtc_device, dev) diff --git a/include/linux/scmi_protocol.h b/include/linux/scmi_protocol.h index fb8c8f16a49b..57d23fae3781 100644 --- a/include/linux/scmi_protocol.h +++ b/include/linux/scmi_protocol.h @@ -12,6 +12,7 @@ #include #include #include +#include #define SCMI_MAX_STR_SIZE 16 #define SCMI_MAX_NUM_RATES 16 @@ -82,6 +83,8 @@ struct scmi_clk_proto_ops { u64 rate); int (*enable)(const struct scmi_protocol_handle *ph, u32 clk_id); int (*disable)(const struct scmi_protocol_handle *ph, u32 clk_id); + + ANDROID_KABI_RESERVE(1); }; /** @@ -125,6 +128,8 @@ struct scmi_perf_proto_ops { bool (*fast_switch_possible)(const struct scmi_protocol_handle *ph, struct device *dev); bool (*power_scale_mw_get)(const struct scmi_protocol_handle *ph); + + ANDROID_KABI_RESERVE(1); }; /** @@ -150,6 +155,8 @@ struct scmi_power_proto_ops { u32 state); int (*state_get)(const struct scmi_protocol_handle *ph, u32 domain, u32 *state); + + ANDROID_KABI_RESERVE(1); }; /** @@ -326,6 +333,8 @@ struct scmi_sensor_info { unsigned int resolution; int exponent; struct scmi_range_attrs scalar_attrs; + + ANDROID_KABI_RESERVE(1); }; /* @@ -461,6 +470,8 @@ struct scmi_sensor_proto_ops { u32 sensor_id, u32 *sensor_config); int (*config_set)(const struct scmi_protocol_handle *ph, u32 sensor_id, u32 sensor_config); + + ANDROID_KABI_RESERVE(1); }; /** @@ -481,6 +492,8 @@ struct scmi_reset_proto_ops { int (*reset)(const struct scmi_protocol_handle *ph, u32 domain); int (*assert)(const struct scmi_protocol_handle *ph, u32 domain); int (*deassert)(const struct scmi_protocol_handle *ph, u32 domain); + + ANDROID_KABI_RESERVE(1); }; /** @@ -625,6 +638,8 @@ struct scmi_handle { void (*devm_put_protocol)(struct scmi_device *sdev, u8 proto); const struct scmi_notify_ops *notify_ops; + + ANDROID_KABI_RESERVE(1); }; enum scmi_std_protocol { @@ -653,6 +668,8 @@ struct scmi_device { const char *name; struct device dev; struct scmi_handle *handle; + + ANDROID_KABI_RESERVE(1); }; #define to_scmi_dev(d) container_of(d, struct scmi_device, dev) diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h index ff63c2963359..0a361d4b58de 100644 --- a/include/linux/serial_core.h +++ b/include/linux/serial_core.h @@ -17,6 +17,7 @@ #include #include #include +#include #include #ifdef CONFIG_SERIAL_CORE_CONSOLE @@ -80,6 +81,9 @@ struct uart_ops { void (*poll_put_char)(struct uart_port *, unsigned char); int (*poll_get_char)(struct uart_port *); #endif + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; #define NO_POLL_CHAR 0x00ff0000 @@ -256,6 +260,9 @@ struct uart_port { struct gpio_desc *rs485_term_gpio; /* enable RS485 bus termination */ struct serial_iso7816 iso7816; void *private_data; /* generic platform data pointer */ + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; static inline int serial_port_in(struct uart_port *up, int offset) @@ -318,6 +325,8 @@ struct uart_driver { */ struct uart_state *state; struct tty_driver *tty_driver; + + ANDROID_KABI_RESERVE(1); }; void uart_write_wakeup(struct uart_port *port); diff --git a/include/linux/serio.h b/include/linux/serio.h index 6c27d413da92..25d638f584a6 100644 --- a/include/linux/serio.h +++ b/include/linux/serio.h @@ -13,6 +13,7 @@ #include #include #include +#include #include extern struct bus_type serio_bus; @@ -61,6 +62,8 @@ struct serio { * may get indigestion when exposed to concurrent access (i8042). */ struct mutex *ps2_cmd_mutex; + + ANDROID_KABI_RESERVE(1); }; #define to_serio_port(d) container_of(d, struct serio, dev) @@ -79,6 +82,8 @@ struct serio_driver { void (*cleanup)(struct serio *); struct device_driver driver; + + ANDROID_KABI_RESERVE(1); }; #define to_serio_driver(d) container_of(d, struct serio_driver, driver) diff --git a/include/linux/spi/spi.h b/include/linux/spi/spi.h index b390fdac1587..f47b06683b36 100644 --- a/include/linux/spi/spi.h +++ b/include/linux/spi/spi.h @@ -14,6 +14,7 @@ #include #include #include +#include struct dma_chan; struct property_entry; @@ -197,6 +198,9 @@ struct spi_device { /* the statistics */ struct spi_statistics statistics; + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); + /* * likely need more hooks for more protocol options affecting how * the controller talks to each chip, like: @@ -281,6 +285,8 @@ struct spi_driver { int (*remove)(struct spi_device *spi); void (*shutdown)(struct spi_device *spi); struct device_driver driver; + + ANDROID_KABI_RESERVE(1); }; static inline struct spi_driver *to_spi_driver(struct device_driver *drv) @@ -667,6 +673,9 @@ struct spi_controller { /* Interrupt enable state during PTP system timestamping */ unsigned long irq_flags; + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; static inline void *spi_controller_get_devdata(struct spi_controller *ctlr) @@ -964,6 +973,8 @@ struct spi_transfer { #define SPI_TRANS_FAIL_NO_START BIT(0) u16 error; + + ANDROID_KABI_RESERVE(1); }; /** @@ -1030,6 +1041,8 @@ struct spi_message { /* list of spi_res reources when the spi message is processed */ struct list_head resources; + + ANDROID_KABI_RESERVE(1); }; static inline void spi_message_init_no_memset(struct spi_message *m) @@ -1468,6 +1481,8 @@ struct spi_board_info { */ u32 mode; + ANDROID_KABI_RESERVE(1); + /* ... may need additional spi_device chip config data here. * avoid stuff protocol drivers can set; but include stuff * needed to behave without being bound to a driver: diff --git a/include/linux/spmi.h b/include/linux/spmi.h index 394a3f68bad5..6744f7cfadaf 100644 --- a/include/linux/spmi.h +++ b/include/linux/spmi.h @@ -7,6 +7,7 @@ #include #include #include +#include /* Maximum slave identifier */ #define SPMI_MAX_SLAVE_ID 16 @@ -85,6 +86,7 @@ struct spmi_controller { u8 sid, u16 addr, u8 *buf, size_t len); int (*write_cmd)(struct spmi_controller *ctrl, u8 opcode, u8 sid, u16 addr, const u8 *buf, size_t len); + ANDROID_KABI_RESERVE(1); }; static inline struct spmi_controller *to_spmi_controller(struct device *d) @@ -138,6 +140,7 @@ struct spmi_driver { struct device_driver driver; int (*probe)(struct spmi_device *sdev); void (*remove)(struct spmi_device *sdev); + ANDROID_KABI_RESERVE(1); }; static inline struct spmi_driver *to_spmi_driver(struct device_driver *d) diff --git a/include/linux/suspend.h b/include/linux/suspend.h index 04b337d3a3cb..fa2ea36a7bd7 100644 --- a/include/linux/suspend.h +++ b/include/linux/suspend.h @@ -8,6 +8,7 @@ #include #include #include +#include #include #ifdef CONFIG_VT @@ -185,6 +186,8 @@ struct platform_suspend_ops { bool (*suspend_again)(void); void (*end)(void); void (*recover)(void); + + ANDROID_KABI_RESERVE(1); }; struct platform_s2idle_ops { @@ -195,6 +198,8 @@ struct platform_s2idle_ops { void (*restore_early)(void); void (*restore)(void); void (*end)(void); + + ANDROID_KABI_RESERVE(1); }; #ifdef CONFIG_SUSPEND @@ -426,6 +431,8 @@ struct platform_hibernation_ops { int (*pre_restore)(void); void (*restore_cleanup)(void); void (*recover)(void); + + ANDROID_KABI_RESERVE(1); }; #ifdef CONFIG_HIBERNATION diff --git a/include/linux/tcp.h b/include/linux/tcp.h index 2f87377e9af7..b163dbd6875c 100644 --- a/include/linux/tcp.h +++ b/include/linux/tcp.h @@ -16,6 +16,7 @@ #include #include +#include #include #include #include @@ -412,6 +413,8 @@ struct tcp_sock { */ struct request_sock __rcu *fastopen_rsk; struct saved_syn *saved_syn; + + ANDROID_KABI_RESERVE(1); }; enum tsq_enum { diff --git a/include/linux/thermal.h b/include/linux/thermal.h index fa9c9eae22a0..a7c121d53960 100644 --- a/include/linux/thermal.h +++ b/include/linux/thermal.h @@ -15,6 +15,7 @@ #include #include #include +#include #include #define THERMAL_TRIPS_NONE -1 @@ -79,6 +80,7 @@ struct thermal_zone_device_ops { enum thermal_trend *); int (*notify) (struct thermal_zone_device *, int, enum thermal_trip_type); + ANDROID_KABI_RESERVE(1); }; struct thermal_cooling_device_ops { @@ -88,6 +90,8 @@ struct thermal_cooling_device_ops { int (*get_requested_power)(struct thermal_cooling_device *, u32 *); int (*state2power)(struct thermal_cooling_device *, unsigned long, u32 *); int (*power2state)(struct thermal_cooling_device *, u32, unsigned long *); + + ANDROID_KABI_RESERVE(1); }; struct thermal_cooling_device { @@ -102,6 +106,8 @@ struct thermal_cooling_device { struct mutex lock; /* protect thermal_instances list */ struct list_head thermal_instances; struct list_head node; + + ANDROID_KABI_RESERVE(1); }; /** @@ -179,6 +185,8 @@ struct thermal_zone_device { struct list_head node; struct delayed_work poll_queue; enum thermal_notify_event notify_event; + + ANDROID_KABI_RESERVE(1); }; /** @@ -199,6 +207,8 @@ struct thermal_governor { void (*unbind_from_tz)(struct thermal_zone_device *tz); int (*throttle)(struct thermal_zone_device *tz, int trip); struct list_head governor_list; + + ANDROID_KABI_RESERVE(1); }; /* Structure that holds binding parameters for a zone */ @@ -234,6 +244,8 @@ struct thermal_bind_params { unsigned long *binding_limits; int (*match) (struct thermal_zone_device *tz, struct thermal_cooling_device *cdev); + + ANDROID_KABI_RESERVE(1); }; /* Structure to define Thermal Zone parameters */ @@ -287,6 +299,8 @@ struct thermal_zone_params { * Used by thermal zone drivers (default 0). */ int offset; + + ANDROID_KABI_RESERVE(1); }; /** @@ -311,6 +325,8 @@ struct thermal_zone_of_device_ops { int (*set_trips)(void *, int, int); int (*set_emul_temp)(void *, int); int (*set_trip_temp)(void *, int, int); + + ANDROID_KABI_RESERVE(1); }; /* Function declarations */ diff --git a/include/linux/tty.h b/include/linux/tty.h index 94fa384a650b..bd76f2f1cde0 100644 --- a/include/linux/tty.h +++ b/include/linux/tty.h @@ -14,6 +14,7 @@ #include #include #include +#include /* @@ -218,6 +219,8 @@ struct tty_port_operations { int (*activate)(struct tty_port *port, struct tty_struct *tty); /* Called on the final put of a port */ void (*destruct)(struct tty_port *port); + + ANDROID_KABI_RESERVE(1); }; struct tty_port_client_operations { @@ -252,6 +255,8 @@ struct tty_port { set to size of fifo */ struct kref kref; /* Ref counter */ void *client_data; + + ANDROID_KABI_RESERVE(1); }; /* tty_port::iflags bits -- use atomic bit ops */ @@ -345,6 +350,9 @@ struct tty_struct { /* If the tty has a pending do_SAK, queue it here - akpm */ struct work_struct SAK_work; struct tty_port *port; + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); } __randomize_layout; /* Each of a tty's open files has private_data pointing to tty_file_private */ diff --git a/include/linux/tty_driver.h b/include/linux/tty_driver.h index 5d509c125171..61f29370e1c3 100644 --- a/include/linux/tty_driver.h +++ b/include/linux/tty_driver.h @@ -237,6 +237,7 @@ #include #include #include +#include struct tty_struct; struct tty_driver; @@ -292,6 +293,9 @@ struct tty_operations { void (*poll_put_char)(struct tty_driver *driver, int line, char ch); #endif int (*proc_show)(struct seq_file *, void *); + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); } __randomize_layout; struct tty_driver { @@ -326,6 +330,9 @@ struct tty_driver { const struct tty_operations *ops; struct list_head tty_drivers; + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); } __randomize_layout; extern struct list_head tty_drivers; diff --git a/include/linux/tty_ldisc.h b/include/linux/tty_ldisc.h index 572a07976116..689ba487e752 100644 --- a/include/linux/tty_ldisc.h +++ b/include/linux/tty_ldisc.h @@ -126,6 +126,7 @@ #include #include #include +#include /* * the semaphore definition @@ -211,6 +212,9 @@ struct tty_ldisc_ops { struct module *owner; int refcount; + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; struct tty_ldisc { diff --git a/include/linux/uio_driver.h b/include/linux/uio_driver.h index 54bf6b118401..77131e8fefcc 100644 --- a/include/linux/uio_driver.h +++ b/include/linux/uio_driver.h @@ -16,6 +16,7 @@ #include #include #include +#include struct module; struct uio_map; @@ -77,6 +78,8 @@ struct uio_device { struct mutex info_lock; struct kobject *map_dir; struct kobject *portio_dir; + + ANDROID_KABI_RESERVE(1); }; /** @@ -109,6 +112,7 @@ struct uio_info { int (*open)(struct uio_info *info, struct inode *inode); int (*release)(struct uio_info *info, struct inode *inode); int (*irqcontrol)(struct uio_info *info, s32 irq_on); + ANDROID_KABI_RESERVE(1); }; extern int __must_check diff --git a/include/linux/usb/gadget.h b/include/linux/usb/gadget.h index ea02847923bf..cf14bb3912f0 100644 --- a/include/linux/usb/gadget.h +++ b/include/linux/usb/gadget.h @@ -123,6 +123,8 @@ struct usb_request { int status; unsigned actual; + + ANDROID_KABI_RESERVE(1); }; /*-------------------------------------------------------------------------*/ @@ -153,6 +155,8 @@ struct usb_ep_ops { int (*fifo_status) (struct usb_ep *ep); void (*fifo_flush) (struct usb_ep *ep); + + ANDROID_KABI_RESERVE(1); }; /** @@ -241,6 +245,8 @@ struct usb_ep { u8 address; const struct usb_endpoint_descriptor *desc; const struct usb_ss_ep_comp_descriptor *comp_desc; + + ANDROID_KABI_RESERVE(1); }; /*-------------------------------------------------------------------------*/ @@ -329,6 +335,11 @@ struct usb_gadget_ops { struct usb_ep *(*match_ep)(struct usb_gadget *, struct usb_endpoint_descriptor *, struct usb_ss_ep_comp_descriptor *); + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); + ANDROID_KABI_RESERVE(3); + ANDROID_KABI_RESERVE(4); }; /** diff --git a/include/linux/usb/otg.h b/include/linux/usb/otg.h index 69f1b6328532..10cb3d193d77 100644 --- a/include/linux/usb/otg.h +++ b/include/linux/usb/otg.h @@ -12,6 +12,7 @@ #include #include +#include struct usb_otg { u8 default_a; @@ -40,6 +41,7 @@ struct usb_otg { /* start or continue HNP role switch */ int (*start_hnp)(struct usb_otg *otg); + ANDROID_KABI_RESERVE(1); }; /** diff --git a/include/linux/usb/phy.h b/include/linux/usb/phy.h index e4de6bc1f69b..888d2fdb662f 100644 --- a/include/linux/usb/phy.h +++ b/include/linux/usb/phy.h @@ -13,6 +13,7 @@ #include #include #include +#include #include enum usb_phy_interface { @@ -155,6 +156,8 @@ struct usb_phy { * manually detect the charger type. */ enum usb_charger_type (*charger_detect)(struct usb_phy *x); + + ANDROID_KABI_RESERVE(1); }; /* for board-specific init logic */ diff --git a/include/linux/usb/typec.h b/include/linux/usb/typec.h index 91b4303ca305..b2e2c302caa6 100644 --- a/include/linux/usb/typec.h +++ b/include/linux/usb/typec.h @@ -4,6 +4,7 @@ #define __LINUX_USB_TYPEC_H #include +#include /* USB Type-C Specification releases */ #define USB_TYPEC_REV_1_0 0x100 /* 1.0 */ @@ -215,6 +216,7 @@ struct typec_operations { int (*vconn_set)(struct typec_port *port, enum typec_role role); int (*port_type_set)(struct typec_port *port, enum typec_port_type type); + ANDROID_KABI_RESERVE(1); }; enum usb_pd_svdm_ver { @@ -252,6 +254,7 @@ struct typec_capability { void *driver_data; const struct typec_operations *ops; + ANDROID_KABI_RESERVE(1); }; /* Specific to try_role(). Indicates the user want's to clear the preference. */ diff --git a/include/linux/usb/typec_altmode.h b/include/linux/usb/typec_altmode.h index 65933cbe9129..60531284df7c 100644 --- a/include/linux/usb/typec_altmode.h +++ b/include/linux/usb/typec_altmode.h @@ -30,6 +30,7 @@ struct typec_altmode { char *desc; const struct typec_altmode_ops *ops; + ANDROID_KABI_RESERVE(1); }; #define to_typec_altmode(d) container_of(d, struct typec_altmode, dev) @@ -63,6 +64,7 @@ struct typec_altmode_ops { int (*notify)(struct typec_altmode *altmode, unsigned long conf, void *data); int (*activate)(struct typec_altmode *altmode, int activate); + ANDROID_KABI_RESERVE(1); }; int typec_altmode_enter(struct typec_altmode *altmode, u32 *vdo); diff --git a/include/media/v4l2-ctrls.h b/include/media/v4l2-ctrls.h index ead627c00655..113d39905b8c 100644 --- a/include/media/v4l2-ctrls.h +++ b/include/media/v4l2-ctrls.h @@ -11,6 +11,7 @@ #include #include #include +#include #include /* @@ -87,6 +88,9 @@ union v4l2_ctrl_ptr { struct v4l2_area *p_area; void *p; const void *p_const; + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; /** @@ -119,6 +123,8 @@ struct v4l2_ctrl_ops { int (*g_volatile_ctrl)(struct v4l2_ctrl *ctrl); int (*try_ctrl)(struct v4l2_ctrl *ctrl); int (*s_ctrl)(struct v4l2_ctrl *ctrl); + + ANDROID_KABI_RESERVE(1); }; /** @@ -140,6 +146,8 @@ struct v4l2_ctrl_type_ops { void (*log)(const struct v4l2_ctrl *ctrl); int (*validate)(const struct v4l2_ctrl *ctrl, u32 idx, union v4l2_ctrl_ptr ptr); + + ANDROID_KABI_RESERVE(1); }; /** @@ -290,6 +298,8 @@ struct v4l2_ctrl { union v4l2_ctrl_ptr p_def; union v4l2_ctrl_ptr p_new; union v4l2_ctrl_ptr p_cur; + + ANDROID_KABI_RESERVE(1); }; /** @@ -329,6 +339,8 @@ struct v4l2_ctrl_ref { bool req_done; bool valid_p_req; union v4l2_ctrl_ptr p_req; + + ANDROID_KABI_RESERVE(1); }; /** @@ -379,6 +391,8 @@ struct v4l2_ctrl_handler { struct list_head requests; struct list_head requests_queued; struct media_request_object req_obj; + + ANDROID_KABI_RESERVE(1); }; /** @@ -430,6 +444,8 @@ struct v4l2_ctrl_config { const char * const *qmenu; const s64 *qmenu_int; unsigned int is_private:1; + + ANDROID_KABI_RESERVE(1); }; /** diff --git a/include/media/v4l2-dev.h b/include/media/v4l2-dev.h index ad2d41952442..3a66e78e8e3b 100644 --- a/include/media/v4l2-dev.h +++ b/include/media/v4l2-dev.h @@ -16,6 +16,7 @@ #include #include #include +#include #include @@ -211,6 +212,8 @@ struct v4l2_file_operations { int (*mmap) (struct file *, struct vm_area_struct *); int (*open) (struct file *); int (*release) (struct file *); + + ANDROID_KABI_RESERVE(1); }; /* @@ -307,6 +310,9 @@ struct video_device DECLARE_BITMAP(valid_ioctls, BASE_VIDIOC_PRIVATE); struct mutex *lock; + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; /** diff --git a/include/media/videobuf2-v4l2.h b/include/media/videobuf2-v4l2.h index c203047eb834..1c59f0951b3b 100644 --- a/include/media/videobuf2-v4l2.h +++ b/include/media/videobuf2-v4l2.h @@ -13,6 +13,7 @@ #define _MEDIA_VIDEOBUF2_V4L2_H #include +#include #include #if VB2_MAX_FRAME != VIDEO_MAX_FRAME @@ -51,6 +52,8 @@ struct vb2_v4l2_buffer { __s32 request_fd; bool is_held; struct vb2_plane planes[VB2_MAX_PLANES]; + + ANDROID_KABI_RESERVE(1); }; /* VB2 V4L2 flags as set in vb2_queue.subsystem_flags */ diff --git a/include/net/bluetooth/hci_core.h b/include/net/bluetooth/hci_core.h index df611c8b6b59..36a6f84c5c49 100644 --- a/include/net/bluetooth/hci_core.h +++ b/include/net/bluetooth/hci_core.h @@ -28,6 +28,7 @@ #include #include #include +#include #include #include @@ -564,6 +565,11 @@ struct hci_dev { int (*set_bdaddr)(struct hci_dev *hdev, const bdaddr_t *bdaddr); void (*cmd_timeout)(struct hci_dev *hdev); bool (*prevent_wake)(struct hci_dev *hdev); + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); + ANDROID_KABI_RESERVE(3); + ANDROID_KABI_RESERVE(4); }; #define HCI_PHY_HANDLE(handle) (handle & 0xff) @@ -660,6 +666,11 @@ struct hci_conn { void (*connect_cfm_cb) (struct hci_conn *conn, u8 status); void (*security_cfm_cb) (struct hci_conn *conn, u8 status); void (*disconn_cfm_cb) (struct hci_conn *conn, u8 reason); + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); + ANDROID_KABI_RESERVE(3); + ANDROID_KABI_RESERVE(4); }; struct hci_chan { @@ -670,6 +681,8 @@ struct hci_chan { unsigned int sent; __u8 state; bool amp; + + ANDROID_KABI_RESERVE(1); }; struct hci_conn_params { @@ -696,6 +709,8 @@ struct hci_conn_params { struct hci_conn *conn; bool explicit_connect; u32 current_flags; + + ANDROID_KABI_RESERVE(1); }; extern struct list_head hci_dev_list; @@ -1415,6 +1430,8 @@ struct hci_cb { __u8 encrypt); void (*key_change_cfm) (struct hci_conn *conn, __u8 status); void (*role_switch_cfm) (struct hci_conn *conn, __u8 status, __u8 role); + + ANDROID_KABI_RESERVE(1); }; static inline void hci_connect_cfm(struct hci_conn *conn, __u8 status) @@ -1675,6 +1692,8 @@ struct hci_mgmt_chan { size_t handler_count; const struct hci_mgmt_handler *handlers; void (*hdev_init) (struct sock *sk, struct hci_dev *hdev); + + ANDROID_KABI_RESERVE(1); }; int hci_mgmt_chan_register(struct hci_mgmt_chan *c); diff --git a/include/net/bluetooth/l2cap.h b/include/net/bluetooth/l2cap.h index 1d1232917de7..8c99677077b6 100644 --- a/include/net/bluetooth/l2cap.h +++ b/include/net/bluetooth/l2cap.h @@ -29,6 +29,7 @@ #include #include +#include /* L2CAP defaults */ #define L2CAP_DEFAULT_MTU 672 @@ -643,6 +644,9 @@ struct l2cap_chan { void *data; const struct l2cap_ops *ops; struct mutex lock; + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; struct l2cap_ops { @@ -667,6 +671,9 @@ struct l2cap_ops { unsigned long len, int nb); int (*filter) (struct l2cap_chan * chan, struct sk_buff *skb); + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; struct l2cap_conn { @@ -702,6 +709,9 @@ struct l2cap_conn { struct mutex chan_lock; struct kref ref; struct list_head users; + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; struct l2cap_user { diff --git a/include/net/bluetooth/rfcomm.h b/include/net/bluetooth/rfcomm.h index 99d26879b02a..d8f4e835ede8 100644 --- a/include/net/bluetooth/rfcomm.h +++ b/include/net/bluetooth/rfcomm.h @@ -22,6 +22,7 @@ */ #include +#include #ifndef __RFCOMM_H #define __RFCOMM_H @@ -164,6 +165,8 @@ struct rfcomm_session { uint mtu; struct list_head dlcs; + + ANDROID_KABI_RESERVE(1); }; struct rfcomm_dlc { @@ -197,6 +200,9 @@ struct rfcomm_dlc { void (*data_ready)(struct rfcomm_dlc *d, struct sk_buff *skb); void (*state_change)(struct rfcomm_dlc *d, int err); void (*modem_status)(struct rfcomm_dlc *d, u8 v24_sig); + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; /* DLC and session flags */ diff --git a/include/net/cfg80211.h b/include/net/cfg80211.h index fab23df83050..81d5b2486c04 100644 --- a/include/net/cfg80211.h +++ b/include/net/cfg80211.h @@ -20,6 +20,7 @@ #include #include #include +#include #include /** @@ -1042,6 +1043,8 @@ struct cfg80211_crypto_settings { const u8 *sae_pwd; u8 sae_pwd_len; enum nl80211_sae_pwe_mechanism sae_pwe; + + ANDROID_KABI_RESERVE(1); }; /** @@ -1088,6 +1091,8 @@ struct cfg80211_beacon_data { size_t probe_resp_len; size_t lci_len; size_t civicloc_len; + + ANDROID_KABI_RESERVE(1); }; struct mac_address { @@ -1224,6 +1229,8 @@ struct cfg80211_ap_settings { struct cfg80211_he_bss_color he_bss_color; struct cfg80211_fils_discovery fils_discovery; struct cfg80211_unsol_bcast_probe_resp unsol_bcast_probe_resp; + + ANDROID_KABI_RESERVE(1); }; /** @@ -1253,6 +1260,8 @@ struct cfg80211_csa_settings { bool radar_required; bool block_tx; u8 count; + + ANDROID_KABI_RESERVE(1); }; #define CFG80211_MAX_NUM_DIFFERENT_CHANNELS 10 @@ -1395,6 +1404,8 @@ struct station_parameters { u16 airtime_weight; struct sta_txpwr txpwr; const struct ieee80211_he_6ghz_capa *he_6ghz_capa; + + ANDROID_KABI_RESERVE(1); }; /** @@ -1741,6 +1752,8 @@ struct station_info { u32 airtime_link_metric; u8 connected_to_as; + + ANDROID_KABI_RESERVE(1); }; #if IS_ENABLED(CONFIG_CFG80211) @@ -1995,6 +2008,8 @@ struct mesh_config { u16 dot11MeshAwakeWindowDuration; u32 plink_timeout; bool dot11MeshNolearn; + + ANDROID_KABI_RESERVE(1); }; /** @@ -2044,6 +2059,8 @@ struct mesh_setup { struct cfg80211_bitrate_mask beacon_rate; bool userspace_handles_dfs; bool control_port_over_nl80211; + + ANDROID_KABI_RESERVE(1); }; /** @@ -2205,6 +2222,8 @@ struct cfg80211_scan_request { u32 n_6ghz_params; struct cfg80211_scan_6ghz_params *scan_6ghz_params; + ANDROID_KABI_RESERVE(1); + /* keep last */ struct ieee80211_channel *channels[]; }; @@ -2351,6 +2370,8 @@ struct cfg80211_sched_scan_request { bool nl_owner_dead; struct list_head list; + ANDROID_KABI_RESERVE(1); + /* keep last */ struct ieee80211_channel *channels[]; }; @@ -2474,6 +2495,8 @@ struct cfg80211_bss { u8 bssid_index; u8 max_bssid_indicator; + ANDROID_KABI_RESERVE(1); + u8 priv[] __aligned(sizeof(void *)); }; @@ -2600,6 +2623,8 @@ struct cfg80211_assoc_request { size_t fils_kek_len; const u8 *fils_nonces; struct ieee80211_s1g_cap s1g_capa, s1g_capa_mask; + + ANDROID_KABI_RESERVE(1); }; /** @@ -2698,6 +2723,8 @@ struct cfg80211_ibss_params { struct ieee80211_ht_cap ht_capa_mask; struct key_params *wep_keys; int wep_tx_key; + + ANDROID_KABI_RESERVE(1); }; /** @@ -2812,6 +2839,8 @@ struct cfg80211_connect_params { size_t fils_erp_rrk_len; bool want_1x; struct ieee80211_edmg edmg; + + ANDROID_KABI_RESERVE(1); }; /** @@ -3269,6 +3298,8 @@ struct cfg80211_nan_func { u8 num_rx_filters; u8 instance_id; u64 cookie; + + ANDROID_KABI_RESERVE(1); }; /** @@ -3429,6 +3460,8 @@ struct cfg80211_pmsr_ftm_result { dist_avg_valid:1, dist_variance_valid:1, dist_spread_valid:1; + + ANDROID_KABI_RESERVE(1); }; /** @@ -4265,6 +4298,10 @@ struct cfg80211_ops { struct cfg80211_tid_config *tid_conf); int (*reset_tid_config)(struct wiphy *wiphy, struct net_device *dev, const u8 *peer, u8 tids); + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); + ANDROID_KABI_RESERVE(3); + ANDROID_KABI_RESERVE(4); }; /* @@ -4628,6 +4665,8 @@ struct wiphy_vendor_command { unsigned long *storage); const struct nla_policy *policy; unsigned int maxattr; + + ANDROID_KABI_RESERVE(1); }; /** @@ -5033,6 +5072,8 @@ struct wiphy { u8 max_data_retry_count; + ANDROID_KABI_RESERVE(1); + char priv[] __aligned(NETDEV_ALIGN); }; @@ -5332,6 +5373,9 @@ struct wireless_dev { struct work_struct pmsr_free_wk; unsigned long unprot_beacon_reported; + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; static inline u8 *wdev_address(struct wireless_dev *wdev) diff --git a/include/net/genetlink.h b/include/net/genetlink.h index e55ec1597ce7..d66f0f397f2e 100644 --- a/include/net/genetlink.h +++ b/include/net/genetlink.h @@ -3,6 +3,7 @@ #define __NET_GENERIC_NETLINK_H #include +#include #include #include @@ -67,6 +68,8 @@ struct genl_family { const struct genl_small_ops *small_ops; const struct genl_multicast_group *mcgrps; struct module *module; + + ANDROID_KABI_RESERVE(1); }; /** @@ -158,6 +161,8 @@ struct genl_ops { u8 internal_flags; u8 flags; u8 validate; + + ANDROID_KABI_RESERVE(1); }; /** diff --git a/include/net/inet_connection_sock.h b/include/net/inet_connection_sock.h index aa92af3dd444..8177cb94958c 100644 --- a/include/net/inet_connection_sock.h +++ b/include/net/inet_connection_sock.h @@ -17,6 +17,7 @@ #include #include #include +#include #include #include @@ -51,6 +52,8 @@ struct inet_connection_sock_af_ops { char __user *optval, int __user *optlen); void (*addr2sockaddr)(struct sock *sk, struct sockaddr *); void (*mtu_reduced)(struct sock *sk); + + ANDROID_KABI_RESERVE(1); }; /** inet_connection_sock - INET connection oriented sock @@ -134,6 +137,8 @@ struct inet_connection_sock { u32 icsk_probes_tstamp; u32 icsk_user_timeout; + ANDROID_KABI_RESERVE(1); + u64 icsk_ca_priv[104 / sizeof(u64)]; #define ICSK_CA_PRIV_SIZE (13 * sizeof(u64)) }; diff --git a/include/net/ip6_fib.h b/include/net/ip6_fib.h index ac5ff3c3afb1..bd4bfdd30e28 100644 --- a/include/net/ip6_fib.h +++ b/include/net/ip6_fib.h @@ -13,6 +13,7 @@ #include #include #include +#include #include #include #include @@ -67,6 +68,8 @@ struct fib6_config { struct nlattr *fc_encap; u16 fc_encap_type; bool fc_is_fdb; + + ANDROID_KABI_RESERVE(1); }; struct fib6_node { @@ -83,6 +86,8 @@ struct fib6_node { int fn_sernum; struct fib6_info __rcu *rr_ptr; struct rcu_head rcu; + + ANDROID_KABI_RESERVE(1); }; struct fib6_gc_args { @@ -199,6 +204,9 @@ struct fib6_info { struct rcu_head rcu; struct nexthop *nh; + + ANDROID_KABI_RESERVE(1); + struct fib6_nh fib6_nh[]; }; @@ -218,6 +226,8 @@ struct rt6_info { /* more non-fragment space at head required */ unsigned short rt6i_nfheader_len; + + ANDROID_KABI_RESERVE(1); }; struct fib6_result { diff --git a/include/net/mac80211.h b/include/net/mac80211.h index dcdba96814a2..0f701f9a8d79 100644 --- a/include/net/mac80211.h +++ b/include/net/mac80211.h @@ -18,6 +18,7 @@ #include #include #include +#include #include #include #include @@ -701,6 +702,8 @@ struct ieee80211_bss_conf { u32 unsol_bcast_probe_resp_interval; bool s1g; struct cfg80211_bitrate_mask beacon_tx_rate; + + ANDROID_KABI_RESERVE(1); }; /** @@ -1097,6 +1100,9 @@ struct ieee80211_tx_info { void *rate_driver_data[ IEEE80211_TX_INFO_RATE_DRIVER_DATA_SIZE / sizeof(void *)]; }; + + ANDROID_KABI_RESERVE(1); + void *driver_data[ IEEE80211_TX_INFO_DRIVER_DATA_SIZE / sizeof(void *)]; }; @@ -1583,6 +1589,8 @@ struct ieee80211_conf { struct cfg80211_chan_def chandef; bool radar_enabled; enum ieee80211_smps_mode smps_mode; + + ANDROID_KABI_RESERVE(1); }; /** @@ -1727,6 +1735,8 @@ struct ieee80211_vif { bool txqs_stopped[IEEE80211_NUM_ACS]; + ANDROID_KABI_RESERVE(1); + /* must be last */ u8 drv_priv[] __aligned(sizeof(void *)); }; @@ -2112,6 +2122,8 @@ struct ieee80211_sta { struct ieee80211_txq *txq[IEEE80211_NUM_TIDS + 1]; + ANDROID_KABI_RESERVE(1); + /* must be last */ u8 drv_priv[] __aligned(sizeof(void *)); }; @@ -2606,6 +2618,8 @@ struct ieee80211_hw { u8 tx_sk_pacing_shift; u8 weight_multiplier; u32 max_mtu; + + ANDROID_KABI_RESERVE(1); }; static inline bool _ieee80211_hw_check(struct ieee80211_hw *hw, @@ -4192,6 +4206,11 @@ struct ieee80211_ops { struct ieee80211_vif *vif); void (*sta_set_4addr)(struct ieee80211_hw *hw, struct ieee80211_vif *vif, struct ieee80211_sta *sta, bool enabled); + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); + ANDROID_KABI_RESERVE(3); + ANDROID_KABI_RESERVE(4); }; /** @@ -6161,6 +6180,11 @@ struct rate_control_ops { struct dentry *dir); u32 (*get_expected_throughput)(void *priv_sta); + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); + ANDROID_KABI_RESERVE(3); + ANDROID_KABI_RESERVE(4); }; static inline int rate_supported(struct ieee80211_sta *sta, diff --git a/include/net/neighbour.h b/include/net/neighbour.h index 22ced1381ede..8a26efdadbbc 100644 --- a/include/net/neighbour.h +++ b/include/net/neighbour.h @@ -28,6 +28,7 @@ #include #include #include +#include #include /* @@ -83,6 +84,8 @@ struct neigh_parms { int reachable_time; int data[NEIGH_VAR_DATA_MAX]; DECLARE_BITMAP(data_state, NEIGH_VAR_DATA_MAX); + + ANDROID_KABI_RESERVE(1); }; static inline void neigh_var_set(struct neigh_parms *p, int index, int val) @@ -157,6 +160,9 @@ struct neighbour { struct list_head gc_list; struct rcu_head rcu; struct net_device *dev; + + ANDROID_KABI_RESERVE(1); + u8 primary_key[0]; } __randomize_layout; @@ -226,6 +232,8 @@ struct neigh_table { struct neigh_statistics __percpu *stats; struct neigh_hash_table __rcu *nht; struct pneigh_entry **phash_buckets; + + ANDROID_KABI_RESERVE(1); }; enum { diff --git a/include/net/netns/can.h b/include/net/netns/can.h index 52fbd8291a96..d075f610e647 100644 --- a/include/net/netns/can.h +++ b/include/net/netns/can.h @@ -7,6 +7,7 @@ #define __NETNS_CAN_H__ #include +#include struct can_dev_rcv_lists; struct can_pkg_stats; @@ -35,6 +36,8 @@ struct netns_can { /* CAN GW per-net gateway jobs */ struct hlist_head cgw_list; + + ANDROID_KABI_RESERVE(1); }; #endif /* __NETNS_CAN_H__ */ diff --git a/include/net/netns/ipv4.h b/include/net/netns/ipv4.h index 175206956080..13b3defd5cb0 100644 --- a/include/net/netns/ipv4.h +++ b/include/net/netns/ipv4.h @@ -10,6 +10,7 @@ #include #include #include +#include struct tcpm_hash_bucket; struct ctl_table_header; @@ -228,5 +229,7 @@ struct netns_ipv4 { atomic_t rt_genid; siphash_key_t ip_id_key; + + ANDROID_KABI_RESERVE(1); }; #endif diff --git a/include/net/netns/ipv6.h b/include/net/netns/ipv6.h index 5ec054473d81..213e96241e76 100644 --- a/include/net/netns/ipv6.h +++ b/include/net/netns/ipv6.h @@ -7,6 +7,7 @@ #ifndef __NETNS_IPV6_H__ #define __NETNS_IPV6_H__ +#include #include #include @@ -115,6 +116,8 @@ struct netns_ipv6 { spinlock_t lock; u32 seq; } ip6addrlbl_table; + + ANDROID_KABI_RESERVE(1); }; #if IS_ENABLED(CONFIG_NF_DEFRAG_IPV6) diff --git a/include/net/netns/netfilter.h b/include/net/netns/netfilter.h index ca043342c0eb..fa2663747a85 100644 --- a/include/net/netns/netfilter.h +++ b/include/net/netns/netfilter.h @@ -3,6 +3,7 @@ #define __NETNS_NETFILTER_H #include +#include struct proc_dir_entry; struct nf_logger; @@ -34,5 +35,7 @@ struct netns_nf { #if IS_ENABLED(CONFIG_NF_DEFRAG_IPV6) bool defrag_ipv6; #endif + + ANDROID_KABI_RESERVE(1); }; #endif diff --git a/include/net/netns/nftables.h b/include/net/netns/nftables.h index 6c0806bd8d1e..ccb84b7dadce 100644 --- a/include/net/netns/nftables.h +++ b/include/net/netns/nftables.h @@ -3,6 +3,7 @@ #define _NETNS_NFTABLES_H_ #include +#include struct netns_nftables { struct list_head tables; @@ -13,6 +14,8 @@ struct netns_nftables { unsigned int base_seq; u8 gencursor; u8 validate_state; + + ANDROID_KABI_RESERVE(1); }; #endif diff --git a/include/net/netns/xfrm.h b/include/net/netns/xfrm.h index b59d73d529ba..93d74c68d87e 100644 --- a/include/net/netns/xfrm.h +++ b/include/net/netns/xfrm.h @@ -7,6 +7,7 @@ #include #include #include +#include #include struct ctl_table_header; @@ -77,6 +78,8 @@ struct netns_xfrm { spinlock_t xfrm_policy_lock; struct mutex xfrm_cfg_mutex; + + ANDROID_KABI_RESERVE(1); }; #endif diff --git a/include/net/page_pool.h b/include/net/page_pool.h index b139e7bf45fe..6c469951e589 100644 --- a/include/net/page_pool.h +++ b/include/net/page_pool.h @@ -33,6 +33,7 @@ #include /* Needed by ptr_ring */ #include #include +#include #define PP_FLAG_DMA_MAP BIT(0) /* Should page_pool do the DMA * map/unmap @@ -126,6 +127,8 @@ struct page_pool { refcount_t user_cnt; u64 destroy_cnt; + + ANDROID_KABI_RESERVE(1); }; struct page *page_pool_alloc_pages(struct page_pool *pool, gfp_t gfp); diff --git a/include/net/sch_generic.h b/include/net/sch_generic.h index 4dd2c9e34976..a33c35133840 100644 --- a/include/net/sch_generic.h +++ b/include/net/sch_generic.h @@ -16,6 +16,7 @@ #include #include #include +#include #include #include #include @@ -114,6 +115,8 @@ struct Qdisc { bool empty; struct rcu_head rcu; + ANDROID_KABI_RESERVE(1); + /* private data */ long privdata[] ____cacheline_aligned; }; @@ -259,6 +262,8 @@ struct Qdisc_class_ops { struct sk_buff *skb, struct tcmsg*); int (*dump_stats)(struct Qdisc *, unsigned long, struct gnet_dump *); + + ANDROID_KABI_RESERVE(1); }; /* Qdisc_class_ops flag values */ @@ -302,6 +307,8 @@ struct Qdisc_ops { u32 (*egress_block_get)(struct Qdisc *sch); struct module *owner; + + ANDROID_KABI_RESERVE(1); }; diff --git a/include/net/tls.h b/include/net/tls.h index 624864c2dcfb..b0d953be977e 100644 --- a/include/net/tls.h +++ b/include/net/tls.h @@ -116,6 +116,9 @@ struct tls_rec { char aad_space[TLS_AAD_SPACE_SIZE]; u8 iv_data[MAX_IV_SIZE]; struct aead_request aead_req; + + ANDROID_KABI_RESERVE(1); + u8 aead_req_ctx[]; }; @@ -144,6 +147,8 @@ struct tls_sw_context_tx { #define BIT_TX_SCHEDULED 0 #define BIT_TX_CLOSING 1 unsigned long tx_bitmask; + + ANDROID_KABI_RESERVE(1); }; struct tls_sw_context_rx { @@ -161,6 +166,8 @@ struct tls_sw_context_rx { /* protect crypto_wait with decrypt_pending*/ spinlock_t decrypt_compl_lock; bool async_notify; + + ANDROID_KABI_RESERVE(1); }; struct tls_record_info { diff --git a/include/scsi/scsi_host.h b/include/scsi/scsi_host.h index cfc0cfde98f0..8c0d37f389df 100644 --- a/include/scsi/scsi_host.h +++ b/include/scsi/scsi_host.h @@ -698,6 +698,8 @@ struct Scsi_Host { */ struct device *dma_dev; + ANDROID_KABI_RESERVE(1); + /* * We should ensure that this is aligned, both for better performance * and also because some compilers (m68k) don't automatically force diff --git a/include/sound/compress_driver.h b/include/sound/compress_driver.h index 70cbc5095e72..82417ce70d62 100644 --- a/include/sound/compress_driver.h +++ b/include/sound/compress_driver.h @@ -12,6 +12,7 @@ #include #include +#include #include #include #include @@ -54,6 +55,8 @@ struct snd_compr_runtime { dma_addr_t dma_addr; size_t dma_bytes; struct snd_dma_buffer *dma_buffer_p; + + ANDROID_KABI_RESERVE(1); }; /** @@ -82,6 +85,8 @@ struct snd_compr_stream { bool partial_drain; void *private_data; struct snd_dma_buffer dma_buffer; + + ANDROID_KABI_RESERVE(1); }; /** @@ -130,6 +135,8 @@ struct snd_compr_ops { struct snd_compr_caps *caps); int (*get_codec_caps) (struct snd_compr_stream *stream, struct snd_compr_codec_caps *codec); + + ANDROID_KABI_RESERVE(1); }; /** @@ -158,6 +165,7 @@ struct snd_compr { struct snd_info_entry *proc_root; struct snd_info_entry *proc_info_entry; #endif + ANDROID_KABI_RESERVE(1); }; /* compress device register APIs */ diff --git a/include/sound/core.h b/include/sound/core.h index 0462c577d7a3..b5ecbf936ffb 100644 --- a/include/sound/core.h +++ b/include/sound/core.h @@ -14,6 +14,7 @@ #include /* pm_message_t */ #include #include +#include /* number of supported soundcards */ #ifdef CONFIG_SND_DYNAMIC_MINORS @@ -61,6 +62,8 @@ struct snd_device_ops { int (*dev_free)(struct snd_device *dev); int (*dev_register)(struct snd_device *dev); int (*dev_disconnect)(struct snd_device *dev); + + ANDROID_KABI_RESERVE(1); }; struct snd_device { @@ -70,6 +73,8 @@ struct snd_device { enum snd_device_type type; /* device type */ void *device_data; /* device structure */ const struct snd_device_ops *ops; /* operations */ + + ANDROID_KABI_RESERVE(1); }; #define snd_device(n) list_entry(n, struct snd_device, list) @@ -132,6 +137,9 @@ struct snd_card { struct snd_mixer_oss *mixer_oss; int mixer_oss_change_count; #endif + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; #define dev_to_snd_card(p) container_of(p, struct snd_card, card_dev) @@ -167,6 +175,8 @@ struct snd_minor { void *private_data; /* private data for f_ops->open */ struct device *dev; /* device for sysfs */ struct snd_card *card_ptr; /* assigned card instance */ + + ANDROID_KABI_RESERVE(1); }; /* return a device pointer linked to each sound device as a parent */ diff --git a/include/sound/hwdep.h b/include/sound/hwdep.h index 8d6cdb254039..d99a53025ff0 100644 --- a/include/sound/hwdep.h +++ b/include/sound/hwdep.h @@ -9,6 +9,7 @@ #include #include +#include struct snd_hwdep; @@ -34,6 +35,8 @@ struct snd_hwdep_ops { struct snd_hwdep_dsp_status *status); int (*dsp_load)(struct snd_hwdep *hw, struct snd_hwdep_dsp_image *image); + + ANDROID_KABI_RESERVE(1); }; struct snd_hwdep { @@ -59,6 +62,8 @@ struct snd_hwdep { int used; /* reference counter */ unsigned int dsp_loaded; /* bit fields of loaded dsp indices */ unsigned int exclusive:1; /* exclusive access mode */ + + ANDROID_KABI_RESERVE(1); }; extern int snd_hwdep_new(struct snd_card *card, char *id, int device, diff --git a/include/sound/info.h b/include/sound/info.h index 7c13bf52cc81..25af5d8d1527 100644 --- a/include/sound/info.h +++ b/include/sound/info.h @@ -9,6 +9,7 @@ #include #include +#include #include /* buffer for information */ @@ -55,6 +56,8 @@ struct snd_info_entry_ops { int (*mmap)(struct snd_info_entry *entry, void *file_private_data, struct inode *inode, struct file *file, struct vm_area_struct *vma); + + ANDROID_KABI_RESERVE(1); }; struct snd_info_entry { @@ -74,6 +77,8 @@ struct snd_info_entry { struct mutex access; struct list_head children; struct list_head list; + + ANDROID_KABI_RESERVE(1); }; #if defined(CONFIG_SND_OSSEMUL) && defined(CONFIG_SND_PROC_FS) diff --git a/include/sound/jack.h b/include/sound/jack.h index 9eb2b5ec1ec4..70400b20e952 100644 --- a/include/sound/jack.h +++ b/include/sound/jack.h @@ -9,6 +9,7 @@ */ #include +#include struct input_dev; @@ -69,6 +70,8 @@ struct snd_jack { #endif /* CONFIG_SND_JACK_INPUT_DEV */ void *private_data; void (*private_free)(struct snd_jack *); + + ANDROID_KABI_RESERVE(1); }; #ifdef CONFIG_SND_JACK diff --git a/include/sound/soc.h b/include/sound/soc.h index f7fabb9d1c83..63338f68de48 100644 --- a/include/sound/soc.h +++ b/include/sound/soc.h @@ -19,6 +19,7 @@ #include #include #include +#include #include #include #include @@ -846,6 +847,8 @@ struct snd_soc_dai_link { #ifdef CONFIG_SND_SOC_TOPOLOGY struct snd_soc_dobj dobj; /* For topology */ #endif + + ANDROID_KABI_RESERVE(1); }; #define for_each_link_codecs(link, i, codec) \ for ((i) = 0; \ @@ -1096,6 +1099,11 @@ struct snd_soc_card { unsigned int probed:1; void *drvdata; + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); + ANDROID_KABI_RESERVE(3); + ANDROID_KABI_RESERVE(4); }; #define for_each_card_prelinks(card, i, link) \ for ((i) = 0; \ @@ -1177,6 +1185,9 @@ struct snd_soc_pcm_runtime { unsigned int fe_compr:1; /* for Dynamic PCM */ int num_components; + + ANDROID_KABI_RESERVE(1); + struct snd_soc_component *components[]; /* CPU/Codec/Platform */ }; /* see soc_new_pcm_runtime() */ @@ -1222,6 +1233,8 @@ struct soc_mixer_control { #ifdef CONFIG_SND_SOC_TOPOLOGY struct snd_soc_dobj dobj; #endif + + ANDROID_KABI_RESERVE(1); }; struct soc_bytes { @@ -1266,6 +1279,8 @@ struct soc_enum { #ifdef CONFIG_SND_SOC_TOPOLOGY struct snd_soc_dobj dobj; #endif + + ANDROID_KABI_RESERVE(1); }; static inline bool snd_soc_volsw_is_stereo(struct soc_mixer_control *mc) diff --git a/include/sound/timer.h b/include/sound/timer.h index 760e132cc0cd..b7695e4dcca0 100644 --- a/include/sound/timer.h +++ b/include/sound/timer.h @@ -10,6 +10,7 @@ #include #include +#include #define snd_timer_chip(timer) ((timer)->private_data) @@ -52,6 +53,8 @@ struct snd_timer_hardware { int (*stop) (struct snd_timer * timer); int (*set_period) (struct snd_timer * timer, unsigned long period_num, unsigned long period_den); int (*precise_resolution) (struct snd_timer * timer, unsigned long *num, unsigned long *den); + + ANDROID_KABI_RESERVE(1); }; struct snd_timer { @@ -77,6 +80,8 @@ struct snd_timer { struct work_struct task_work; int max_instances; /* upper limit of timer instances */ int num_instances; /* current number of timer instances */ + + ANDROID_KABI_RESERVE(1); }; struct snd_timer_instance { @@ -106,6 +111,8 @@ struct snd_timer_instance { struct list_head slave_list_head; struct list_head slave_active_head; struct snd_timer_instance *master; + + ANDROID_KABI_RESERVE(1); }; /* diff --git a/sound/usb/card.h b/sound/usb/card.h index e3a59455f71c..3683f10ff542 100644 --- a/sound/usb/card.h +++ b/sound/usb/card.h @@ -178,6 +178,8 @@ struct snd_usb_substream { bool trigger_tstamp_pending_update; /* trigger timestamp being updated from initial estimate */ struct media_ctl *media_ctl; + + ANDROID_KABI_RESERVE(1); }; struct snd_usb_stream { diff --git a/sound/usb/usbaudio.h b/sound/usb/usbaudio.h index 47f56e0354cc..6d40b46c3c13 100644 --- a/sound/usb/usbaudio.h +++ b/sound/usb/usbaudio.h @@ -12,6 +12,8 @@ #define USB_ID_VENDOR(id) ((id) >> 16) #define USB_ID_PRODUCT(id) ((u16)(id)) +#include + /* * */ @@ -64,6 +66,11 @@ struct snd_usb_audio { struct mutex dev_lock; /* to protect any race with disconnect */ int card_num; /* cache pcm card number to use upon disconnect */ void (*disconnect_cb)(struct snd_usb_audio *chip); + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); + ANDROID_KABI_RESERVE(3); + ANDROID_KABI_RESERVE(4); }; #define USB_AUDIO_IFACE_UNUSED ((void *)-1L) @@ -176,6 +183,9 @@ struct snd_usb_audio_vendor_ops { struct audioformat *found, int *cur_attr, int *attr); int (*usb_add_ctls)(struct snd_usb_audio *chip); + + ANDROID_KABI_RESERVE(1); + ANDROID_KABI_RESERVE(2); }; #endif /* __USBAUDIO_H */