diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
index 6c689be3e48f..efac6925e5d4 100644
--- a/drivers/mmc/host/sdhci.h
+++ b/drivers/mmc/host/sdhci.h
@@ -16,6 +16,7 @@
 #include <linux/io.h>
 #include <linux/leds.h>
 #include <linux/interrupt.h>
+#include <linux/android_kabi.h>
 
 #include <linux/mmc/host.h>
 
@@ -611,6 +612,8 @@ struct sdhci_host {
 
 	u64			data_timeout;
 
+	ANDROID_KABI_RESERVE(1);
+
 	unsigned long private[] ____cacheline_aligned;
 };
 
@@ -658,6 +661,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 8c6b38b1b142..47805bbc7ac6 100644
--- a/drivers/scsi/ufs/ufs.h
+++ b/drivers/scsi/ufs/ufs.h
@@ -13,6 +13,7 @@
 
 #include <linux/mutex.h>
 #include <linux/types.h>
+#include <linux/android_kabi.h>
 #include <uapi/scsi/scsi_bsg_ufs.h>
 
 #define GENERAL_UPIU_REQUEST_SIZE (sizeof(struct utp_upiu_req))
@@ -604,6 +605,7 @@ struct ufs_dev_info {
 
 	bool	b_rpm_dev_flush_capable;
 	u8	b_presrv_uspc_en;
+	ANDROID_KABI_RESERVE(1);
 };
 
 /*
diff --git a/drivers/scsi/ufs/ufshcd.h b/drivers/scsi/ufs/ufshcd.h
index 63eaedcfb318..3b8dd8eace93 100644
--- a/drivers/scsi/ufs/ufshcd.h
+++ b/drivers/scsi/ufs/ufshcd.h
@@ -223,6 +223,8 @@ struct ufshcd_lrb {
 #endif
 
 	bool req_abort_skip;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /**
@@ -402,6 +404,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 {
@@ -448,6 +452,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/bus.h b/drivers/usb/typec/bus.h
index 56dec268d4dd..fa021ed928a7 100644
--- a/drivers/usb/typec/bus.h
+++ b/drivers/usb/typec/bus.h
@@ -4,6 +4,7 @@
 #define __USB_TYPEC_ALTMODE_H__
 
 #include <linux/usb/typec_altmode.h>
+#include <linux/android_kabi.h>
 
 struct bus_type;
 struct typec_mux;
@@ -22,6 +23,7 @@ struct altmode {
 
 	struct altmode			*partner;
 	struct altmode			*plug[2];
+	ANDROID_KABI_RESERVE(1);
 };
 
 #define to_altmode(d) container_of(d, struct altmode, adev)
diff --git a/drivers/usb/typec/class.h b/drivers/usb/typec/class.h
index aef03eb7e152..fa08d5c00c8d 100644
--- a/drivers/usb/typec/class.h
+++ b/drivers/usb/typec/class.h
@@ -5,6 +5,7 @@
 
 #include <linux/device.h>
 #include <linux/usb/typec.h>
+#include <linux/android_kabi.h>
 
 struct typec_mux;
 struct typec_switch;
@@ -14,6 +15,7 @@ struct typec_plug {
 	enum typec_plug_index		index;
 	struct ida			mode_ids;
 	int				num_altmodes;
+	ANDROID_KABI_RESERVE(1);
 };
 
 struct typec_cable {
@@ -22,6 +24,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 {
@@ -33,6 +36,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 {
@@ -59,6 +63,7 @@ struct typec_port {
 	struct mutex			port_list_lock; /* Port list lock */
 
 	void				*pld;
+	ANDROID_KABI_RESERVE(1);
 };
 
 #define to_typec_port(_dev_) container_of(_dev_, struct typec_port, dev)
diff --git a/drivers/usb/typec/mux.h b/drivers/usb/typec/mux.h
index b1d6e837cb74..a15b926edfc5 100644
--- a/drivers/usb/typec/mux.h
+++ b/drivers/usb/typec/mux.h
@@ -4,15 +4,18 @@
 #define __USB_TYPEC_MUX__
 
 #include <linux/usb/typec_mux.h>
+#include <linux/android_kabi.h>
 
 struct typec_switch {
 	struct device dev;
 	typec_switch_set_fn_t set;
+	ANDROID_KABI_RESERVE(1);
 };
 
 struct typec_mux {
 	struct device dev;
 	typec_mux_set_fn_t set;
+	ANDROID_KABI_RESERVE(1);
 };
 
 #define to_typec_switch(_dev_) container_of(_dev_, struct typec_switch, dev)
diff --git a/include/linux/amba/bus.h b/include/linux/amba/bus.h
index c68d87b87283..5970a430e2ae 100644
--- a/include/linux/amba/bus.h
+++ b/include/linux/amba/bus.h
@@ -17,6 +17,7 @@
 #include <linux/err.h>
 #include <linux/resource.h>
 #include <linux/regulator/consumer.h>
+#include <linux/android_kabi.h>
 
 #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 33207004cfde..b298388bc3b6 100644
--- a/include/linux/backing-dev-defs.h
+++ b/include/linux/backing-dev-defs.h
@@ -13,6 +13,7 @@
 #include <linux/workqueue.h>
 #include <linux/kref.h>
 #include <linux/refcount.h>
+#include <linux/android_kabi.h>
 
 struct page;
 struct device;
@@ -164,6 +165,9 @@ struct bdi_writeback {
 		struct rcu_head rcu;
 	};
 #endif
+
+	ANDROID_KABI_RESERVE(1);
+	ANDROID_KABI_RESERVE(2);
 };
 
 struct backing_dev_info {
@@ -202,6 +206,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 413c0148c0ce..3ce44f640567 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -24,6 +24,7 @@
 #include <linux/blkzoned.h>
 #include <linux/pm.h>
 #include <linux/sbitmap.h>
+#include <linux/android_kabi.h>
 
 struct module;
 struct request_queue;
@@ -233,6 +234,8 @@ struct request {
 	 */
 	rq_end_io_fn *end_io;
 	void *end_io_data;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 static inline int blk_validate_block_size(unsigned int bsize)
@@ -331,6 +334,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,
@@ -561,6 +566,11 @@ 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);
 };
 
 /* Keep blk_queue_flag_name[] in sync with the definitions below */
@@ -1863,6 +1873,9 @@ struct block_device_operations {
 	 * driver.
 	 */
 	int (*alternative_gpt_sector)(struct gendisk *disk, sector_t *sector);
+
+	ANDROID_KABI_RESERVE(1);
+	ANDROID_KABI_RESERVE(2);
 };
 
 #ifdef CONFIG_COMPAT
diff --git a/include/linux/bpf.h b/include/linux/bpf.h
index 15b690a0cecb..b342a42802fe 100644
--- a/include/linux/bpf.h
+++ b/include/linux/bpf.h
@@ -23,6 +23,7 @@
 #include <linux/slab.h>
 #include <linux/percpu-refcount.h>
 #include <linux/bpfptr.h>
+#include <linux/android_kabi.h>
 
 struct bpf_verifier_env;
 struct bpf_verifier_log;
@@ -151,6 +152,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 {
@@ -257,6 +261,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 {
@@ -511,6 +517,7 @@ struct bpf_verifier_ops {
 				 enum bpf_access_type atype,
 				 u32 *next_btf_id);
 	bool (*check_kfunc_call)(u32 kfunc_btf_id);
+	ANDROID_KABI_RESERVE(1);
 };
 
 struct bpf_prog_offload_ops {
@@ -526,6 +533,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 {
@@ -538,6 +546,7 @@ struct bpf_prog_offload {
 	bool			opt_failed;
 	void			*jited_image;
 	u32			jited_len;
+	ANDROID_KABI_RESERVE(1);
 };
 
 enum bpf_cgroup_storage_type {
@@ -921,6 +930,7 @@ struct bpf_prog_aux {
 		struct work_struct work;
 		struct rcu_head	rcu;
 	};
+	ANDROID_KABI_RESERVE(1);
 };
 
 struct bpf_array_aux {
@@ -959,6 +969,7 @@ struct bpf_link_ops {
 	void (*show_fdinfo)(const struct bpf_link *link, struct seq_file *seq);
 	int (*fill_link_info)(const struct bpf_link *link,
 			      struct bpf_link_info *info);
+	ANDROID_KABI_RESERVE(1);
 };
 
 struct bpf_link_primer {
@@ -988,6 +999,7 @@ struct bpf_struct_ops {
 	struct btf_func_model func_models[BPF_STRUCT_OPS_MAX_NR_MEMBERS];
 	u32 type_id;
 	u32 value_id;
+	ANDROID_KABI_RESERVE(1);
 };
 
 #if defined(CONFIG_BPF_JIT) && defined(CONFIG_BPF_SYSCALL)
diff --git a/include/linux/bpf_verifier.h b/include/linux/bpf_verifier.h
index 364550dd19c4..adeeedae6227 100644
--- a/include/linux/bpf_verifier.h
+++ b/include/linux/bpf_verifier.h
@@ -8,6 +8,7 @@
 #include <linux/btf.h> /* for struct btf and btf_id() */
 #include <linux/filter.h> /* for MAX_BPF_STACK */
 #include <linux/tnum.h>
+#include <linux/android_kabi.h>
 
 /* Maximum variable offset umax_value permitted when resolving memory accesses.
  * In practice this is far bigger than any realistic pointer offset; this limit
@@ -414,6 +415,8 @@ struct bpf_subprog_info {
 	bool tail_call_reachable;
 	bool has_ld_abs;
 	bool is_async_cb;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /* single container for all structs
@@ -474,6 +477,9 @@ struct bpf_verifier_env {
 	/* longest register parentage chain walked for liveness marking */
 	u32 longest_mark_read_walk;
 	bpfptr_t fd_array;
+
+	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 b145025f3eac..173aacde9170 100644
--- a/include/linux/cgroup.h
+++ b/include/linux/cgroup.h
@@ -24,6 +24,7 @@
 #include <linux/user_namespace.h>
 #include <linux/refcount.h>
 #include <linux/kernel_stat.h>
+#include <linux/android_kabi.h>
 
 #include <linux/cgroup-defs.h>
 
@@ -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 991911048857..74ce8ddf718a 100644
--- a/include/linux/cpuhotplug.h
+++ b/include/linux/cpuhotplug.h
@@ -248,6 +248,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 fce476275e16..1035cb423fc1 100644
--- a/include/linux/cpuidle.h
+++ b/include/linux/cpuidle.h
@@ -14,6 +14,7 @@
 #include <linux/percpu.h>
 #include <linux/list.h>
 #include <linux/hrtimer.h>
+#include <linux/android_kabi.h>
 
 #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 114553b487ef..b335ec35f718 100644
--- a/include/linux/device-mapper.h
+++ b/include/linux/device-mapper.h
@@ -13,6 +13,7 @@
 #include <linux/dm-ioctl.h>
 #include <linux/math64.h>
 #include <linux/ratelimit.h>
+#include <linux/android_kabi.h>
 
 struct dm_dev;
 struct dm_target;
@@ -204,6 +205,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;
 };
@@ -366,6 +370,9 @@ struct dm_target {
 	 * zone append operations using regular writes.
 	 */
 	bool emulate_zone_append: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 90cca05e73cc..c539f4a86728 100644
--- a/include/linux/dma-buf.h
+++ b/include/linux/dma-buf.h
@@ -22,6 +22,7 @@
 #include <linux/fs.h>
 #include <linux/dma-fence.h>
 #include <linux/wait.h>
+#include <linux/android_kabi.h>
 
 struct device;
 struct dma_buf;
@@ -356,6 +357,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);
 };
 
 /**
@@ -517,6 +521,9 @@ struct dma_buf {
 		struct dma_buf *dmabuf;
 	} *sysfs_entry;
 #endif
+
+	ANDROID_KABI_RESERVE(1);
+	ANDROID_KABI_RESERVE(2);
 };
 
 /**
@@ -552,6 +559,7 @@ struct dma_buf_attach_ops {
 	 * point to the new location of the DMA-buf.
 	 */
 	void (*move_notify)(struct dma_buf_attachment *attach);
+	ANDROID_KABI_RESERVE(1);
 };
 
 /**
@@ -589,6 +597,9 @@ struct dma_buf_attachment {
 	void *importer_priv;
 	void *priv;
 	unsigned long dma_map_attrs;
+
+	ANDROID_KABI_RESERVE(1);
+	ANDROID_KABI_RESERVE(2);
 };
 
 /**
@@ -612,6 +623,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 9000f3ffce8b..ba37dfc6105a 100644
--- a/include/linux/dmaengine.h
+++ b/include/linux/dmaengine.h
@@ -12,6 +12,7 @@
 #include <linux/scatterlist.h>
 #include <linux/bitmap.h>
 #include <linux/types.h>
+#include <linux/android_kabi.h>
 #include <asm/page.h>
 
 /**
@@ -621,6 +622,11 @@ struct dma_async_tx_descriptor {
 	struct dma_async_tx_descriptor *parent;
 	spinlock_t lock;
 #endif
+
+	ANDROID_KABI_RESERVE(1);
+	ANDROID_KABI_RESERVE(2);
+	ANDROID_KABI_RESERVE(3);
+	ANDROID_KABI_RESERVE(4);
 };
 
 #ifdef CONFIG_DMA_ENGINE
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 30611711cef9..24b72ba69f7b 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1014,6 +1014,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 e3c29d2e6826..fc757fdeabf8 100644
--- a/include/linux/gpio/driver.h
+++ b/include/linux/gpio/driver.h
@@ -10,6 +10,7 @@
 #include <linux/lockdep.h>
 #include <linux/pinctrl/pinctrl.h>
 #include <linux/pinctrl/pinconf-generic.h>
+#include <linux/android_kabi.h>
 
 struct gpio_desc;
 struct of_phandle_args;
@@ -275,6 +276,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);
 };
 
 /**
@@ -482,6 +486,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 0354b298d874..dbf4ba68e477 100644
--- a/include/linux/input.h
+++ b/include/linux/input.h
@@ -7,6 +7,7 @@
 
 #include <linux/time.h>
 #include <linux/list.h>
+#include <linux/android_kabi.h>
 #include <uapi/linux/input.h>
 /* Implementation details, userspace should not care about these */
 #define ABS_MT_FIRST		ABS_MT_TOUCH_MAJOR
@@ -209,6 +210,11 @@ struct input_dev {
 	ktime_t timestamp[INPUT_CLK_MAX];
 
 	bool inhibited;
+
+	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)
 
@@ -328,6 +334,8 @@ struct input_handler {
 
 	struct list_head	h_list;
 	struct list_head	node;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /**
@@ -354,6 +362,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);
@@ -560,6 +570,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 5f21f34983fc..374c868afc2c 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 iomap_sector(const struct iomap *iomap, loff_t pos)
diff --git a/include/linux/kernfs.h b/include/linux/kernfs.h
index 1093abf7c28c..946321d02e3a 100644
--- a/include/linux/kernfs.h
+++ b/include/linux/kernfs.h
@@ -161,6 +161,8 @@ struct kernfs_node {
 	unsigned short		flags;
 	umode_t			mode;
 	struct kernfs_iattrs	*iattr;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /*
@@ -197,6 +199,8 @@ struct kernfs_root {
 	struct list_head	supers;
 
 	wait_queue_head_t	deactivate_waitq;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 struct kernfs_open_file {
@@ -217,6 +221,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 7d985a1dfe4a..106f8d097002 100644
--- a/include/linux/key-type.h
+++ b/include/linux/key-type.h
@@ -10,6 +10,7 @@
 
 #include <linux/key.h>
 #include <linux/errno.h>
+#include <linux/android_kabi.h>
 
 #ifdef CONFIG_KEYS
 
@@ -156,6 +157,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 34828f5d42f2..07f25e502078 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -636,6 +636,8 @@ struct mm_struct {
 			nodemask_t nodes;
 		} lru_gen;
 #endif /* CONFIG_LRU_GEN */
+
+		ANDROID_KABI_RESERVE(1);
 	} __randomize_layout;
 
 	/*
diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
index 37f975875102..06c8cb205021 100644
--- a/include/linux/mmc/card.h
+++ b/include/linux/mmc/card.h
@@ -9,6 +9,7 @@
 
 #include <linux/device.h>
 #include <linux/mod_devicetable.h>
+#include <linux/android_kabi.h>
 
 struct mmc_cid {
 	unsigned int		manfid;
@@ -258,6 +259,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);
 };
 
 /*
@@ -336,6 +339,9 @@ struct mmc_card {
 	unsigned int    nr_parts;
 
 	struct workqueue_struct *complete_wq;	/* Private workqueue */
+
+	ANDROID_KABI_RESERVE(1);
+	ANDROID_KABI_RESERVE(2);
 };
 
 static inline bool mmc_large_sector(struct mmc_card *card)
diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h
index 0c0c9a0fdf57..faddab9f0448 100644
--- a/include/linux/mmc/host.h
+++ b/include/linux/mmc/host.h
@@ -16,6 +16,7 @@
 #include <linux/mmc/pm.h>
 #include <linux/dma-direction.h>
 #include <linux/keyslot-manager.h>
+#include <linux/android_kabi.h>
 
 struct mmc_ios {
 	unsigned int	clock;			/* clock rate */
@@ -190,6 +191,9 @@ struct mmc_host_ops {
 
 	/* Initialize an SD express card, mandatory for MMC_CAP2_SD_EXP. */
 	int	(*init_sd_express)(struct mmc_host *host, struct mmc_ios *ios);
+
+	ANDROID_KABI_RESERVE(1);
+	ANDROID_KABI_RESERVE(2);
 };
 
 struct mmc_cqe_ops {
@@ -234,6 +238,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 {
@@ -498,6 +505,9 @@ struct mmc_host {
 	/* Host Software Queue support */
 	bool			hsq_enabled;
 
+	ANDROID_KABI_RESERVE(1);
+	ANDROID_KABI_RESERVE(2);
+
 	unsigned long		private[] ____cacheline_aligned;
 };
 
diff --git a/include/linux/netfilter.h b/include/linux/netfilter.h
index 3fda1a508733..b79cb3de242c 100644
--- a/include/linux/netfilter.h
+++ b/include/linux/netfilter.h
@@ -14,6 +14,7 @@
 #include <linux/netfilter_defs.h>
 #include <linux/netdevice.h>
 #include <linux/sockptr.h>
+#include <linux/android_kabi.h>
 #include <net/net_namespace.h>
 
 static inline int NF_DROP_GETERR(int verdict)
@@ -177,6 +178,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. */
@@ -379,6 +382,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;
@@ -463,6 +468,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;
 
@@ -478,6 +485,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 ada1296c87d5..b29e0d334f6e 100644
--- a/include/linux/netfilter/ipset/ip_set.h
+++ b/include/linux/netfilter/ipset/ip_set.h
@@ -14,6 +14,7 @@
 #include <linux/netfilter/x_tables.h>
 #include <linux/stringify.h>
 #include <linux/vmalloc.h>
+#include <linux/android_kabi.h>
 #include <net/netlink.h>
 #include <uapi/linux/netfilter/ipset/ip_set.h>
 
@@ -188,6 +189,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 {
@@ -234,6 +237,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 */
@@ -276,6 +281,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 241e005f290a..e9dd51997ca5 100644
--- a/include/linux/netfilter/nfnetlink.h
+++ b/include/linux/netfilter/nfnetlink.h
@@ -4,6 +4,7 @@
 
 #include <linux/netlink.h>
 #include <linux/capability.h>
+#include <linux/android_kabi.h>
 #include <net/netlink.h>
 #include <uapi/linux/netfilter/nfnetlink.h>
 
@@ -28,6 +29,8 @@ struct nfnl_callback {
 	const struct nla_policy	*policy;
 	enum nfnl_callback_type	type;
 	__u16			attr_count;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 enum nfnl_abort_action {
@@ -47,6 +50,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 <linux/android_kabi.h>
 #include <uapi/linux/netfilter_ipv6.h>
 #include <net/tcp.h>
 
@@ -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 9d6e75222868..91a58c41c217 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -573,6 +573,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;
 };
 
@@ -755,6 +759,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);
 };
 
 /*
@@ -830,6 +836,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 7c96f169d274..dcc1744503e4 100644
--- a/include/linux/platform_device.h
+++ b/include/linux/platform_device.h
@@ -11,6 +11,7 @@
 #define _PLATFORM_DEVICE_H_
 
 #include <linux/device.h>
+#include <linux/android_kabi.h>
 
 #define PLATFORM_DEVID_NONE	(-1)
 #define PLATFORM_DEVID_AUTO	(-2)
@@ -38,6 +39,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)
@@ -100,6 +104,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);
@@ -210,6 +216,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 1d8209c09686..81b017b94c45 100644
--- a/include/linux/pm.h
+++ b/include/linux/pm.h
@@ -15,6 +15,7 @@
 #include <linux/timer.h>
 #include <linux/hrtimer.h>
 #include <linux/completion.h>
+#include <linux/android_kabi.h>
 
 /*
  * Callbacks for platform drivers to implement.
@@ -298,6 +299,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
@@ -622,6 +625,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);
@@ -648,6 +654,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 ccd34f9dc299..ee457436060d 100644
--- a/include/linux/power_supply.h
+++ b/include/linux/power_supply.h
@@ -17,6 +17,7 @@
 #include <linux/leds.h>
 #include <linux/spinlock.h>
 #include <linux/notifier.h>
+#include <linux/android_kabi.h>
 
 /*
  * 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);
 };
 
 /*
@@ -383,6 +390,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 725c9b784e60..7261b89d3cf7 100644
--- a/include/linux/pwm.h
+++ b/include/linux/pwm.h
@@ -5,6 +5,7 @@
 #include <linux/err.h>
 #include <linux/mutex.h>
 #include <linux/of.h>
+#include <linux/android_kabi.h>
 
 struct pwm_capture;
 struct seq_file;
@@ -90,6 +91,8 @@ struct pwm_device {
 	struct pwm_args args;
 	struct pwm_state state;
 	struct pwm_state last;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /**
@@ -284,6 +287,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);
 };
 
 /**
@@ -310,6 +315,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 e3c9a25a853a..a543ce9a1611 100644
--- a/include/linux/regmap.h
+++ b/include/linux/regmap.h
@@ -19,6 +19,7 @@
 #include <linux/lockdep.h>
 #include <linux/iopoll.h>
 #include <linux/fwnode.h>
+#include <linux/android_kabi.h>
 
 struct module;
 struct clk;
@@ -409,6 +410,8 @@ struct regmap_config {
 	unsigned int hwlock_mode;
 
 	bool can_sleep;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /**
@@ -446,6 +449,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;
@@ -524,6 +529,8 @@ struct regmap_bus {
 	size_t max_raw_read;
 	size_t max_raw_write;
 	bool free_on_exit;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /*
diff --git a/include/linux/regulator/driver.h b/include/linux/regulator/driver.h
index bd7a73db2e66..2a6ca85363a8 100644
--- a/include/linux/regulator/driver.h
+++ b/include/linux/regulator/driver.h
@@ -17,6 +17,7 @@
 #include <linux/notifier.h>
 #include <linux/regulator/consumer.h>
 #include <linux/ww_mutex.h>
+#include <linux/android_kabi.h>
 
 struct gpio_desc;
 struct regmap;
@@ -235,6 +236,8 @@ struct regulator_ops {
 	int (*resume)(struct regulator_dev *rdev);
 
 	int (*set_pull_down) (struct regulator_dev *);
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /*
@@ -424,6 +427,8 @@ struct regulator_desc {
 	unsigned int poll_enabled_time;
 
 	unsigned int (*of_map_mode)(unsigned int mode);
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /**
@@ -642,6 +647,8 @@ struct regulator_dev {
 	int cached_err;
 	bool use_cached_err;
 	spinlock_t err_lock;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 struct regulator_dev *
diff --git a/include/linux/rtc.h b/include/linux/rtc.h
index bd611e26291d..3c384fe9be22 100644
--- a/include/linux/rtc.h
+++ b/include/linux/rtc.h
@@ -16,6 +16,7 @@
 #include <linux/types.h>
 #include <linux/interrupt.h>
 #include <linux/nvmem-provider.h>
+#include <linux/android_kabi.h>
 #include <uapi/linux/rtc.h>
 
 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;
@@ -159,6 +162,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 80e781c51ddc..48089bfdc01f 100644
--- a/include/linux/scmi_protocol.h
+++ b/include/linux/scmi_protocol.h
@@ -12,6 +12,7 @@
 #include <linux/device.h>
 #include <linux/notifier.h>
 #include <linux/types.h>
+#include <linux/android_kabi.h>
 
 #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);
 };
 
 /**
@@ -129,6 +132,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);
 };
 
 /**
@@ -154,6 +159,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);
 };
 
 /**
@@ -330,6 +337,8 @@ struct scmi_sensor_info {
 	unsigned int resolution;
 	int exponent;
 	struct scmi_range_attrs scalar_attrs;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /*
@@ -465,6 +474,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);
 };
 
 /**
@@ -485,6 +496,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);
 };
 
 /**
@@ -624,6 +637,8 @@ struct scmi_handle {
 	void (*devm_protocol_put)(struct scmi_device *sdev, u8 proto);
 
 	const struct scmi_notify_ops *notify_ops;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 enum scmi_std_protocol {
@@ -652,6 +667,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 8c32935e1059..572f3f604f49 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -17,6 +17,7 @@
 #include <linux/tty.h>
 #include <linux/mutex.h>
 #include <linux/sysrq.h>
+#include <linux/android_kabi.h>
 #include <uapi/linux/serial_core.h>
 
 #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 <linux/mutex.h>
 #include <linux/device.h>
 #include <linux/mod_devicetable.h>
+#include <linux/android_kabi.h>
 #include <uapi/linux/serio.h>
 
 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 6b0b686f6f90..04c72d9f0835 100644
--- a/include/linux/spi/spi.h
+++ b/include/linux/spi/spi.h
@@ -15,6 +15,7 @@
 #include <linux/scatterlist.h>
 #include <linux/gpio/consumer.h>
 #include <linux/ptp_clock_kernel.h>
+#include <linux/android_kabi.h>
 
 #include <uapi/linux/spi/spi.h>
 
@@ -200,6 +201,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:
@@ -287,6 +291,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)
@@ -672,6 +678,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)
@@ -967,6 +976,8 @@ struct spi_transfer {
 
 #define SPI_TRANS_FAIL_NO_START	BIT(0)
 	u16		error;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /**
@@ -1033,6 +1044,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)
@@ -1457,6 +1470,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 729bcbf9f5ad..743f08cc9bd9 100644
--- a/include/linux/spmi.h
+++ b/include/linux/spmi.h
@@ -7,6 +7,7 @@
 #include <linux/types.h>
 #include <linux/device.h>
 #include <linux/mod_devicetable.h>
+#include <linux/android_kabi.h>
 
 /* 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)
@@ -139,6 +141,7 @@ struct spmi_driver {
 	int	(*probe)(struct spmi_device *sdev);
 	void	(*remove)(struct spmi_device *sdev);
 	void	(*shutdown)(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 f3d9da6310ae..27321d5d01df 100644
--- a/include/linux/suspend.h
+++ b/include/linux/suspend.h
@@ -8,6 +8,7 @@
 #include <linux/pm.h>
 #include <linux/mm.h>
 #include <linux/freezer.h>
+#include <linux/android_kabi.h>
 #include <asm/errno.h>
 
 #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 48d8a363319e..bb9762967926 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -16,6 +16,7 @@
 
 #include <linux/skbuff.h>
 #include <linux/win_minmax.h>
+#include <linux/android_kabi.h>
 #include <net/sock.h>
 #include <net/inet_connection_sock.h>
 #include <net/inet_timewait_sock.h>
@@ -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 c314893970b3..22d16d193799 100644
--- a/include/linux/thermal.h
+++ b/include/linux/thermal.h
@@ -15,6 +15,7 @@
 #include <linux/device.h>
 #include <linux/sysfs.h>
 #include <linux/workqueue.h>
+#include <linux/android_kabi.h>
 #include <uapi/linux/thermal.h>
 
 #define THERMAL_MAX_TRIPS	12
@@ -78,6 +79,8 @@ struct thermal_zone_device_ops {
 			  enum thermal_trend *);
 	void (*hot)(struct thermal_zone_device *);
 	void (*critical)(struct thermal_zone_device *);
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 struct thermal_cooling_device_ops {
@@ -87,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 {
@@ -101,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);
 };
 
 /**
@@ -174,6 +181,8 @@ struct thermal_zone_device {
 	struct list_head node;
 	struct delayed_work poll_queue;
 	enum thermal_notify_event notify_event;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /**
@@ -194,6 +203,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 */
@@ -229,6 +240,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 */
@@ -282,6 +295,8 @@ struct thermal_zone_params {
 	 * 		Used by thermal zone drivers (default 0).
 	 */
 	int offset;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /**
@@ -306,6 +321,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 168e57e40bbb..b41d8dfc7005 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -15,6 +15,7 @@
 #include <uapi/linux/tty.h>
 #include <linux/rwsem.h>
 #include <linux/llist.h>
+#include <linux/android_kabi.h>
 
 
 /*
@@ -202,6 +203,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 c20431d8def8..8ae79ad51278 100644
--- a/include/linux/tty_driver.h
+++ b/include/linux/tty_driver.h
@@ -238,6 +238,7 @@
 #include <linux/cdev.h>
 #include <linux/termios.h>
 #include <linux/seq_file.h>
+#include <linux/android_kabi.h>
 
 struct tty_struct;
 struct tty_driver;
@@ -289,6 +290,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 {
@@ -323,6 +327,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 b1d812e902aa..c0aa3a6c5f1c 100644
--- a/include/linux/tty_ldisc.h
+++ b/include/linux/tty_ldisc.h
@@ -131,6 +131,7 @@ struct tty_struct;
 #include <linux/list.h>
 #include <linux/lockdep.h>
 #include <linux/seq_file.h>
+#include <linux/android_kabi.h>
 
 /*
  * the semaphore definition
@@ -213,6 +214,9 @@ struct tty_ldisc_ops {
 				const char *fp, int count);
 
 	struct  module *owner;
+
+	ANDROID_KABI_RESERVE(1);
+	ANDROID_KABI_RESERVE(2);
 };
 
 struct tty_ldisc {
diff --git a/include/linux/tty_port.h b/include/linux/tty_port.h
index 6e86e9e118b6..8737f899b85c 100644
--- a/include/linux/tty_port.h
+++ b/include/linux/tty_port.h
@@ -6,6 +6,7 @@
 #include <linux/mutex.h>
 #include <linux/tty_buffer.h>
 #include <linux/wait.h>
+#include <linux/android_kabi.h>
 
 /*
  * Port level information. Each device keeps its own port level information
@@ -39,6 +40,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 {
@@ -72,6 +75,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 */
diff --git a/include/linux/uio_driver.h b/include/linux/uio_driver.h
index 47c5962b876b..7f4e6c71c5d5 100644
--- a/include/linux/uio_driver.h
+++ b/include/linux/uio_driver.h
@@ -16,6 +16,7 @@
 #include <linux/device.h>
 #include <linux/fs.h>
 #include <linux/interrupt.h>
+#include <linux/android_kabi.h>
 
 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 10fe57cf40be..a0fd828b2080 100644
--- a/include/linux/usb/gadget.h
+++ b/include/linux/usb/gadget.h
@@ -122,6 +122,8 @@ struct usb_request {
 
 	int			status;
 	unsigned		actual;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /*-------------------------------------------------------------------------*/
@@ -152,6 +154,8 @@ struct usb_ep_ops {
 
 	int (*fifo_status) (struct usb_ep *ep);
 	void (*fifo_flush) (struct usb_ep *ep);
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /**
@@ -240,6 +244,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);
 };
 
 /*-------------------------------------------------------------------------*/
@@ -330,6 +336,11 @@ struct usb_gadget_ops {
 			struct usb_endpoint_descriptor *,
 			struct usb_ss_ep_comp_descriptor *);
 	int	(*check_config)(struct usb_gadget *gadget);
+
+	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 6475f880be37..9a1b417dfd58 100644
--- a/include/linux/usb/otg.h
+++ b/include/linux/usb/otg.h
@@ -12,6 +12,7 @@
 
 #include <linux/phy/phy.h>
 #include <linux/usb/phy.h>
+#include <linux/android_kabi.h>
 
 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 ec03fa27be97..fd0f13ba9e65 100644
--- a/include/linux/usb/phy.h
+++ b/include/linux/usb/phy.h
@@ -14,6 +14,7 @@
 #include <linux/extcon.h>
 #include <linux/notifier.h>
 #include <linux/usb.h>
+#include <linux/android_kabi.h>
 #include <uapi/linux/usb/charger.h>
 
 enum usb_phy_interface {
@@ -158,6 +159,7 @@ struct usb_phy {
 	enum usb_charger_type (*charger_detect)(struct usb_phy *x);
 
 	ANDROID_VENDOR_DATA(1);
+	ANDROID_KABI_RESERVE(1);
 };
 
 /* for board-specific init logic */
diff --git a/include/linux/usb/typec.h b/include/linux/usb/typec.h
index e2e44bb1dad8..4a2e767026ac 100644
--- a/include/linux/usb/typec.h
+++ b/include/linux/usb/typec.h
@@ -4,6 +4,7 @@
 #define __LINUX_USB_TYPEC_H
 
 #include <linux/types.h>
+#include <linux/android_kabi.h>
 
 /* USB Type-C Specification releases */
 #define USB_TYPEC_REV_1_0	0x100 /* 1.0 */
@@ -221,6 +222,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 {
@@ -258,6 +260,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 575b59fbac77..dc8a59b90c0c 100644
--- a/include/media/v4l2-ctrls.h
+++ b/include/media/v4l2-ctrls.h
@@ -11,6 +11,7 @@
 #include <linux/list.h>
 #include <linux/mutex.h>
 #include <linux/videodev2.h>
+#include <linux/android_kabi.h>
 #include <media/media-request.h>
 
 /*
@@ -85,6 +86,9 @@ union v4l2_ctrl_ptr {
 	struct v4l2_area *p_area;
 	void *p;
 	const void *p_const;
+
+	ANDROID_KABI_RESERVE(1);
+	ANDROID_KABI_RESERVE(2);
 };
 
 /**
@@ -117,6 +121,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);
 };
 
 /**
@@ -138,6 +144,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);
 };
 
 /**
@@ -288,6 +296,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);
 };
 
 /**
@@ -327,6 +337,8 @@ struct v4l2_ctrl_ref {
 	bool req_done;
 	bool valid_p_req;
 	union v4l2_ctrl_ptr p_req;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /**
@@ -377,6 +389,8 @@ struct v4l2_ctrl_handler {
 	struct list_head requests;
 	struct list_head requests_queued;
 	struct media_request_object req_obj;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /**
@@ -428,6 +442,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 6a4afd4a7df2..72e6c26cf024 100644
--- a/include/media/v4l2-dev.h
+++ b/include/media/v4l2-dev.h
@@ -16,6 +16,7 @@
 #include <linux/cdev.h>
 #include <linux/mutex.h>
 #include <linux/videodev2.h>
+#include <linux/android_kabi.h>
 
 #include <media/media-entity.h>
 
@@ -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 b66585e304e2..0055b0791068 100644
--- a/include/media/videobuf2-v4l2.h
+++ b/include/media/videobuf2-v4l2.h
@@ -13,6 +13,7 @@
 #define _MEDIA_VIDEOBUF2_V4L2_H
 
 #include <linux/videodev2.h>
+#include <linux/android_kabi.h>
 #include <media/videobuf2-core.h>
 
 #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 a7360c8c72f8..cd35ea0ae6b6 100644
--- a/include/net/bluetooth/hci_core.h
+++ b/include/net/bluetooth/hci_core.h
@@ -28,6 +28,7 @@
 #include <linux/idr.h>
 #include <linux/leds.h>
 #include <linux/rculist.h>
+#include <linux/android_kabi.h>
 
 #include <net/bluetooth/hci.h>
 #include <net/bluetooth/hci_sock.h>
@@ -606,6 +607,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)
@@ -703,6 +709,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 {
@@ -713,6 +724,8 @@ struct hci_chan {
 	unsigned int	sent;
 	__u8		state;
 	bool		amp;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 struct hci_conn_params {
@@ -739,6 +752,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;
@@ -1491,6 +1506,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)
@@ -1751,6 +1768,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 3c4f550e5a8b..19bb6ed535f6 100644
--- a/include/net/bluetooth/l2cap.h
+++ b/include/net/bluetooth/l2cap.h
@@ -29,6 +29,7 @@
 
 #include <asm/unaligned.h>
 #include <linux/atomic.h>
+#include <linux/android_kabi.h>
 
 /* L2CAP defaults */
 #define L2CAP_DEFAULT_MTU		672
@@ -645,6 +646,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 {
@@ -669,6 +673,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 {
@@ -704,6 +711,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 <linux/refcount.h>
+#include <linux/android_kabi.h>
 
 #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 fe12dcedd026..09e3f1e955da 100644
--- a/include/net/cfg80211.h
+++ b/include/net/cfg80211.h
@@ -23,6 +23,7 @@
 #include <linux/ieee80211.h>
 #include <linux/net.h>
 #include <linux/rfkill.h>
+#include <linux/android_kabi.h>
 #include <net/regulatory.h>
 
 /**
@@ -1124,6 +1125,8 @@ struct cfg80211_crypto_settings {
 	const u8 *sae_pwd;
 	u8 sae_pwd_len;
 	enum nl80211_sae_pwe_mechanism sae_pwe;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /**
@@ -1202,6 +1205,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 {
@@ -1330,6 +1335,8 @@ struct cfg80211_ap_settings {
 	struct cfg80211_fils_discovery fils_discovery;
 	struct cfg80211_unsol_bcast_probe_resp unsol_bcast_probe_resp;
 	struct cfg80211_mbssid_config mbssid_config;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /**
@@ -1359,6 +1366,8 @@ struct cfg80211_csa_settings {
 	bool radar_required;
 	bool block_tx;
 	u8 count;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /**
@@ -1524,6 +1533,8 @@ struct station_parameters {
 	const struct ieee80211_he_6ghz_capa *he_6ghz_capa;
 	const struct ieee80211_eht_cap_elem *eht_capa;
 	u8 eht_capa_len;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /**
@@ -1883,6 +1894,8 @@ struct station_info {
 	u32 airtime_link_metric;
 
 	u8 connected_to_as;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /**
@@ -2185,6 +2198,8 @@ struct mesh_config {
 	u16 dot11MeshAwakeWindowDuration;
 	u32 plink_timeout;
 	bool dot11MeshNolearn;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /**
@@ -2234,6 +2249,8 @@ struct mesh_setup {
 	struct cfg80211_bitrate_mask beacon_rate;
 	bool userspace_handles_dfs;
 	bool control_port_over_nl80211;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /**
@@ -2395,6 +2412,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[];
 };
@@ -2541,6 +2560,8 @@ struct cfg80211_sched_scan_request {
 	bool nl_owner_dead;
 	struct list_head list;
 
+	ANDROID_KABI_RESERVE(1);
+
 	/* keep last */
 	struct ieee80211_channel *channels[];
 };
@@ -2664,6 +2685,8 @@ struct cfg80211_bss {
 	u8 bssid_index;
 	u8 max_bssid_indicator;
 
+	ANDROID_KABI_RESERVE(1);
+
 	u8 priv[] __aligned(sizeof(void *));
 };
 
@@ -2792,6 +2815,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);
 };
 
 /**
@@ -2890,6 +2915,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);
 };
 
 /**
@@ -3004,6 +3031,8 @@ struct cfg80211_connect_params {
 	size_t fils_erp_rrk_len;
 	bool want_1x;
 	struct ieee80211_edmg edmg;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /**
@@ -3461,6 +3490,8 @@ struct cfg80211_nan_func {
 	u8 num_rx_filters;
 	u8 instance_id;
 	u64 cookie;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /**
@@ -3621,6 +3652,8 @@ struct cfg80211_pmsr_ftm_result {
 	    dist_avg_valid:1,
 	    dist_variance_valid:1,
 	    dist_spread_valid:1;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /**
@@ -4489,6 +4522,11 @@ struct cfg80211_ops {
 				struct cfg80211_fils_aad *fils_aad);
 	int	(*set_radar_background)(struct wiphy *wiphy,
 					struct cfg80211_chan_def *chandef);
+
+	ANDROID_KABI_RESERVE(1);
+	ANDROID_KABI_RESERVE(2);
+	ANDROID_KABI_RESERVE(3);
+	ANDROID_KABI_RESERVE(4);
 };
 
 /*
@@ -4852,6 +4890,8 @@ struct wiphy_vendor_command {
 		      unsigned long *storage);
 	const struct nla_policy *policy;
 	unsigned int maxattr;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /**
@@ -5276,6 +5316,8 @@ struct wiphy {
 	u8 mbssid_max_interfaces;
 	u8 ema_max_profile_periodicity;
 
+	ANDROID_KABI_RESERVE(1);
+
 	char priv[] __aligned(NETDEV_ALIGN);
 };
 
@@ -5639,6 +5681,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 7cb3fa8310ed..a48feee47b2b 100644
--- a/include/net/genetlink.h
+++ b/include/net/genetlink.h
@@ -3,6 +3,7 @@
 #define __NET_GENERIC_NETLINK_H
 
 #include <linux/genetlink.h>
+#include <linux/android_kabi.h>
 #include <net/netlink.h>
 #include <net/net_namespace.h>
 
@@ -68,6 +69,8 @@ struct genl_family {
 	const struct genl_small_ops *small_ops;
 	const struct genl_multicast_group *mcgrps;
 	struct module		*module;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /**
@@ -159,6 +162,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 fa6a87246a7b..5eca9727d716 100644
--- a/include/net/inet_connection_sock.h
+++ b/include/net/inet_connection_sock.h
@@ -17,6 +17,7 @@
 #include <linux/poll.h>
 #include <linux/kernel.h>
 #include <linux/sockptr.h>
+#include <linux/android_kabi.h>
 
 #include <net/inet_sock.h>
 #include <net/request_sock.h>
@@ -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	  sizeof_field(struct inet_connection_sock, icsk_ca_priv)
 };
diff --git a/include/net/ip6_fib.h b/include/net/ip6_fib.h
index bbb27639f293..1b4d27e40d81 100644
--- a/include/net/ip6_fib.h
+++ b/include/net/ip6_fib.h
@@ -13,6 +13,7 @@
 #include <linux/rtnetlink.h>
 #include <linux/spinlock.h>
 #include <linux/notifier.h>
+#include <linux/android_kabi.h>
 #include <net/dst.h>
 #include <net/flow.h>
 #include <net/ip_fib.h>
@@ -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 {
@@ -202,6 +207,9 @@ struct fib6_info {
 
 	struct rcu_head			rcu;
 	struct nexthop			*nh;
+
+	ANDROID_KABI_RESERVE(1);
+
 	struct fib6_nh			fib6_nh[];
 };
 
@@ -221,6 +229,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 d44aac0e4a1c..8eac316e1dd4 100644
--- a/include/net/mac80211.h
+++ b/include/net/mac80211.h
@@ -18,6 +18,7 @@
 #include <linux/if_ether.h>
 #include <linux/skbuff.h>
 #include <linux/ieee80211.h>
+#include <linux/android_kabi.h>
 #include <net/cfg80211.h>
 #include <net/codel.h>
 #include <net/ieee80211_radiotap.h>
@@ -702,6 +703,8 @@ struct ieee80211_bss_conf {
 	u32 unsol_bcast_probe_resp_interval;
 	bool s1g;
 	struct cfg80211_bitrate_mask beacon_tx_rate;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /**
@@ -1102,6 +1105,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 *)];
 	};
@@ -1591,6 +1597,8 @@ struct ieee80211_conf {
 	struct cfg80211_chan_def chandef;
 	bool radar_enabled;
 	enum ieee80211_smps_mode smps_mode;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /**
@@ -1746,6 +1754,8 @@ struct ieee80211_vif {
 	bool color_change_active;
 	u8 color_change_color;
 
+	ANDROID_KABI_RESERVE(1);
+
 	/* must be last */
 	u8 drv_priv[] __aligned(sizeof(void *));
 };
@@ -2128,6 +2138,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 *));
 };
@@ -2633,6 +2645,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,
@@ -4271,6 +4285,11 @@ struct ieee80211_ops {
 				     struct ieee80211_sta *sta, u8 flowid);
 	int (*set_radar_background)(struct ieee80211_hw *hw,
 				    struct cfg80211_chan_def *chandef);
+
+	ANDROID_KABI_RESERVE(1);
+	ANDROID_KABI_RESERVE(2);
+	ANDROID_KABI_RESERVE(3);
+	ANDROID_KABI_RESERVE(4);
 };
 
 /**
@@ -6286,6 +6305,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 d5767e25509c..7750ef0fe0dd 100644
--- a/include/net/neighbour.h
+++ b/include/net/neighbour.h
@@ -28,6 +28,7 @@
 #include <linux/err.h>
 #include <linux/sysctl.h>
 #include <linux/workqueue.h>
+#include <linux/android_kabi.h>
 #include <net/rtnetlink.h>
 
 /*
@@ -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 <linux/spinlock.h>
+#include <linux/android_kabi.h>
 
 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 6c5b2efc4f17..2f972fccfdcd 100644
--- a/include/net/netns/ipv4.h
+++ b/include/net/netns/ipv4.h
@@ -10,6 +10,7 @@
 #include <net/inet_frag.h>
 #include <linux/rcupdate.h>
 #include <linux/siphash.h>
+#include <linux/android_kabi.h>
 
 struct ctl_table_header;
 struct ipv4_devconf;
@@ -223,5 +224,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 6bd7e5a85ce7..75a53d9cd3b1 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 <linux/android_kabi.h>
 #include <net/dst_ops.h>
 #include <uapi/linux/icmpv6.h>
 
@@ -55,6 +56,7 @@ struct netns_sysctl_ipv6 {
 	u64 ioam6_id_wide;
 	bool skip_notify_on_dev_down;
 	u8 fib_notify_on_flag_change;
+	ANDROID_KABI_RESERVE(1);
 };
 
 struct netns_ipv6 {
@@ -114,6 +116,8 @@ struct netns_ipv6 {
 		u32		seq;
 	} ip6addrlbl_table;
 	struct ioam6_pernet_data *ioam6_data;
+
+	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 b593f95e9991..bf983f025ad2 100644
--- a/include/net/netns/netfilter.h
+++ b/include/net/netns/netfilter.h
@@ -3,6 +3,7 @@
 #define __NETNS_NETFILTER_H
 
 #include <linux/netfilter_defs.h>
+#include <linux/android_kabi.h>
 
 struct proc_dir_entry;
 struct nf_logger;
@@ -33,5 +34,7 @@ struct netns_nf {
 #if IS_ENABLED(CONFIG_NF_DEFRAG_IPV6)
 	unsigned int defrag_ipv6_users;
 #endif
+
+	ANDROID_KABI_RESERVE(1);
 };
 #endif
diff --git a/include/net/netns/nftables.h b/include/net/netns/nftables.h
index 8c77832d0240..26930d6a2452 100644
--- a/include/net/netns/nftables.h
+++ b/include/net/netns/nftables.h
@@ -3,9 +3,11 @@
 #define _NETNS_NFTABLES_H_
 
 #include <linux/list.h>
+#include <linux/android_kabi.h>
 
 struct netns_nftables {
 	u8			gencursor;
+	ANDROID_KABI_RESERVE(1);
 };
 
 #endif
diff --git a/include/net/netns/xfrm.h b/include/net/netns/xfrm.h
index 947733a639a6..1340371f1cc3 100644
--- a/include/net/netns/xfrm.h
+++ b/include/net/netns/xfrm.h
@@ -7,6 +7,7 @@
 #include <linux/workqueue.h>
 #include <linux/rhashtable-types.h>
 #include <linux/xfrm.h>
+#include <linux/android_kabi.h>
 #include <net/dst_ops.h>
 
 struct ctl_table_header;
@@ -86,6 +87,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 a4082406a003..6c48d6c6ef53 100644
--- a/include/net/page_pool.h
+++ b/include/net/page_pool.h
@@ -33,6 +33,7 @@
 #include <linux/mm.h> /* Needed by ptr_ring */
 #include <linux/ptr_ring.h>
 #include <linux/dma-direction.h>
+#include <linux/android_kabi.h>
 
 #define PP_FLAG_DMA_MAP		BIT(0) /* Should page_pool do the DMA
 					* map/unmap
@@ -132,6 +133,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 4121ffd0faf8..34336fe6c38f 100644
--- a/include/net/sch_generic.h
+++ b/include/net/sch_generic.h
@@ -16,6 +16,7 @@
 #include <linux/rwsem.h>
 #include <linux/atomic.h>
 #include <linux/hashtable.h>
+#include <linux/android_kabi.h>
 #include <net/gen_stats.h>
 #include <net/rtnetlink.h>
 #include <net/flow_offload.h>
@@ -119,6 +120,8 @@ struct Qdisc {
 
 	struct rcu_head		rcu;
 
+	ANDROID_KABI_RESERVE(1);
+
 	/* private data */
 	long privdata[] ____cacheline_aligned;
 };
@@ -277,6 +280,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 */
@@ -322,6 +327,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 1fffb206f09f..43c50e64d818 100644
--- a/include/net/tls.h
+++ b/include/net/tls.h
@@ -113,6 +113,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[];
 };
 
@@ -141,6 +144,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 {
@@ -158,6 +163,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 05b45d60a980..ccb77598b6be 100644
--- a/include/scsi/scsi_host.h
+++ b/include/scsi/scsi_host.h
@@ -715,6 +715,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 d91289c6f00e..77d027f73f4a 100644
--- a/include/sound/compress_driver.h
+++ b/include/sound/compress_driver.h
@@ -12,6 +12,7 @@
 
 #include <linux/types.h>
 #include <linux/sched.h>
+#include <linux/android_kabi.h>
 #include <sound/core.h>
 #include <sound/compress_offload.h>
 #include <sound/asound.h>
@@ -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);
 };
 
 /**
@@ -84,6 +87,8 @@ struct snd_compr_stream {
 	bool pause_in_draining;
 	void *private_data;
 	struct snd_dma_buffer dma_buffer;
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 /**
@@ -132,6 +137,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);
 };
 
 /**
@@ -162,6 +169,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 6d4cc49584c6..aeb06543caa2 100644
--- a/include/sound/core.h
+++ b/include/sound/core.h
@@ -14,6 +14,7 @@
 #include <linux/pm.h>			/* pm_message_t */
 #include <linux/stringify.h>
 #include <linux/printk.h>
+#include <linux/android_kabi.h>
 
 /* 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)
@@ -139,6 +144,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)
@@ -214,6 +222,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 <sound/asound.h>
 #include <linux/poll.h>
+#include <linux/android_kabi.h>
 
 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 <linux/poll.h>
 #include <linux/seq_file.h>
+#include <linux/android_kabi.h>
 #include <sound/core.h>
 
 /* 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 1181f536557e..9e4299eafc02 100644
--- a/include/sound/jack.h
+++ b/include/sound/jack.h
@@ -9,6 +9,7 @@
  */
 
 #include <sound/core.h>
+#include <linux/android_kabi.h>
 
 struct input_dev;
 
@@ -70,6 +71,8 @@ struct snd_jack {
 	int hw_status_cache;
 	void *private_data;
 	void (*private_free)(struct snd_jack *);
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 #ifdef CONFIG_SND_JACK
diff --git a/include/sound/pcm.h b/include/sound/pcm.h
index e08bf475d02d..ecfa59b886d4 100644
--- a/include/sound/pcm.h
+++ b/include/sound/pcm.h
@@ -16,6 +16,7 @@
 #include <linux/bitops.h>
 #include <linux/pm_qos.h>
 #include <linux/refcount.h>
+#include <linux/android_kabi.h>
 
 #define snd_pcm_substream_chip(substream) ((substream)->private_data)
 #define snd_pcm_chip(pcm) ((pcm)->private_data)
@@ -77,6 +78,7 @@ struct snd_pcm_ops {
 			     unsigned long offset);
 	int (*mmap)(struct snd_pcm_substream *substream, struct vm_area_struct *vma);
 	int (*ack)(struct snd_pcm_substream *substream);
+	ANDROID_KABI_RESERVE(1);
 };
 
 /*
@@ -430,6 +432,8 @@ struct snd_pcm_runtime {
 	/* -- OSS things -- */
 	struct snd_pcm_oss_runtime oss;
 #endif
+	ANDROID_KABI_RESERVE(1);
+	ANDROID_KABI_RESERVE(2);
 };
 
 struct snd_pcm_group {		/* keep linked substreams */
@@ -482,6 +486,7 @@ struct snd_pcm_substream {
 	/* misc flags */
 	unsigned int hw_opened: 1;
 	unsigned int managed_buffer_alloc:1;
+	ANDROID_KABI_RESERVE(1);
 };
 
 #define SUBSTREAM_BUSY(substream) ((substream)->ref_count > 0)
@@ -506,6 +511,7 @@ struct snd_pcm_str {
 #endif
 	struct snd_kcontrol *chmap_kctl; /* channel-mapping controls */
 	struct device dev;
+	ANDROID_KABI_RESERVE(1);
 };
 
 struct snd_pcm {
@@ -528,6 +534,7 @@ struct snd_pcm {
 #if IS_ENABLED(CONFIG_SND_PCM_OSS)
 	struct snd_pcm_oss oss;
 #endif
+	ANDROID_KABI_RESERVE(1);
 };
 
 /*
diff --git a/include/sound/soc.h b/include/sound/soc.h
index 3c8323dc3787..65564830ea97 100644
--- a/include/sound/soc.h
+++ b/include/sound/soc.h
@@ -19,6 +19,7 @@
 #include <linux/kernel.h>
 #include <linux/regmap.h>
 #include <linux/log2.h>
+#include <linux/android_kabi.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/compress_driver.h>
@@ -731,6 +732,8 @@ struct snd_soc_dai_link {
 #ifdef CONFIG_SND_SOC_TOPOLOGY
 	struct snd_soc_dobj dobj; /* For topology */
 #endif
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 static inline struct snd_soc_dai_link_component*
@@ -1000,6 +1003,11 @@ struct snd_soc_card {
 	unsigned int component_chaining: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;							\
@@ -1084,6 +1092,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()  */
@@ -1123,6 +1134,8 @@ struct soc_mixer_control {
 #ifdef CONFIG_SND_SOC_TOPOLOGY
 	struct snd_soc_dobj dobj;
 #endif
+
+	ANDROID_KABI_RESERVE(1);
 };
 
 struct soc_bytes {
@@ -1167,6 +1180,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 <sound/asound.h>
 #include <linux/interrupt.h>
+#include <linux/android_kabi.h>
 
 #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 87f042d06ce0..907bd3e65c3e 100644
--- a/sound/usb/card.h
+++ b/sound/usb/card.h
@@ -142,6 +142,7 @@ struct snd_usb_endpoint {
 
 	spinlock_t lock;
 	struct list_head list;
+	ANDROID_KABI_RESERVE(1);
 };
 
 struct media_ctl;
@@ -193,6 +194,8 @@ struct snd_usb_substream {
 	bool trigger_tstamp_pending_update; /* trigger timestamp being updated from initial estimate */
 	bool lowlatency_playback;	/* low-latency playback mode */
 	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 167834133b9b..f1f12745612f 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 <linux/android_kabi.h>
+
 /*
  *
  */
@@ -59,6 +61,11 @@ struct snd_usb_audio {
 	struct usb_host_interface *ctrl_intf;	/* the audio control interface */
 	struct media_device *media_dev;
 	struct media_intf_devnode *ctl_intf_media_devnode;
+
+	ANDROID_KABI_RESERVE(1);
+	ANDROID_KABI_RESERVE(2);
+	ANDROID_KABI_RESERVE(3);
+	ANDROID_KABI_RESERVE(4);
 };
 
 #define USB_AUDIO_IFACE_UNUSED	((void *)-1L)