android/android_kernel_samsung_sm8650
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ANDROID: GKI: add kabi padding for structures for the android14 release

Browse Source 
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.10.0..5.10.110 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
Change-Id: I880bbcda0628a7459988eeb49d18655522697664
Signed-off-by: Greg Kroah-Hartman <gregkh@google.com>
This commit is contained in:
Greg Kroah-Hartman 2021-07-02 15:58:26 +02:00 committed by Carlos Llamas
parent 1d39b94f8c
commit 97752aa71c
94 changed files with 661 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
drivers/gpio/gpiolib.h
View File

@ -16,6 +16,7 @@
#include <linux/module.h>
#include <linux/cdev.h>
#include <linux/rwsem.h>
#include <linux/android_kabi.h>
#define GPIOCHIP_NAME "gpiochip"
@ -75,6 +76,7 @@ struct gpio_device {
*/
struct list_head pin_ranges;
#endif
ANDROID_KABI_RESERVE(1);
};
/* gpio suffixes used for ACPI and device tree lookup */
@ -100,6 +102,7 @@ struct gpio_array {
struct gpio_chip *chip;
unsigned long *get_mask;
unsigned long *set_mask;
ANDROID_KABI_RESERVE(1);
unsigned long invert_mask[];
};
@ -179,6 +182,7 @@ struct gpio_desc {
/* debounce period in microseconds */
unsigned int debounce_period_us;
#endif
ANDROID_KABI_RESERVE(1);
};
#define gpiod_not_found(desc) (IS_ERR(desc) && PTR_ERR(desc) == -ENOENT)

5
drivers/mmc/host/sdhci.h
View File

@ -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>
@ -616,6 +617,8 @@ struct sdhci_host {
u64 data_timeout;
ANDROID_KABI_RESERVE(1);
unsigned long private[] ____cacheline_aligned;
};
@ -663,6 +666,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

9
drivers/usb/dwc3/core.h
View File

@ -33,6 +33,8 @@
#include <linux/power_supply.h>
#include <linux/android_kabi.h>
#define DWC3_MSG_MAX 500
/* Global constants */
@ -771,6 +773,8 @@ struct dwc3_ep {
/* For isochronous START TRANSFER workaround only */
u8 combo_num;
int start_cmd_status;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
enum dwc3_phy {
@ -954,6 +958,7 @@ struct dwc3_request {
unsigned int needs_extra_trb:1;
unsigned int direction:1;
unsigned int mapped:1;
ANDROID_KABI_RESERVE(1);
};
/*
@ -1336,6 +1341,10 @@ struct dwc3 {
int last_fifo_depth;
int num_ep_resized;
struct dentry *debug_root;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
#define INCRX_BURST_MODE 0

2
drivers/usb/typec/bus.h
View File

@ -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)

5
drivers/usb/typec/class.h
View File

@ -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 {
@ -35,6 +38,7 @@ struct typec_partner {
enum usb_pd_svdm_ver svdm_version;
struct usb_power_delivery *pd;
ANDROID_KABI_RESERVE(1);
};
struct typec_port {
@ -59,6 +63,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)

3
drivers/usb/typec/mux.h
View File

@ -4,15 +4,18 @@
#define __USB_TYPEC_MUX__
#include <linux/usb/typec_mux.h>
#include <linux/android_kabi.h>
struct typec_switch_dev {
struct device dev;
typec_switch_set_fn_t set;
ANDROID_KABI_RESERVE(1);
};
struct typec_mux_dev {
struct device dev;
typec_mux_set_fn_t set;
ANDROID_KABI_RESERVE(1);
};
#define to_typec_switch_dev(_dev_) container_of(_dev_, struct typec_switch_dev, dev)

5
include/linux/amba/bus.h
View File

@ -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
@ -76,6 +77,8 @@ struct amba_device {
* frees it. Use driver_set_override() to set or clear it.
*/
const char *driver_override;
ANDROID_KABI_RESERVE(1);
};
struct amba_driver {
@ -92,6 +95,8 @@ struct amba_driver {
* to setup and manage their own I/O address space.
*/
bool driver_managed_dma;
ANDROID_KABI_RESERVE(1);
};
/*

7
include/linux/backing-dev-defs.h
View File

@ -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;
@ -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);
};
struct wb_lock_cookie {

9
include/linux/blk-mq.h
View File

@ -7,6 +7,7 @@
#include <linux/lockdep.h>
#include <linux/scatterlist.h>
#include <linux/prefetch.h>
#include <linux/android_kabi.h>
struct blk_mq_tags;
struct blk_flush_queue;
@ -197,6 +198,8 @@ struct request {
*/
rq_end_io_fn *end_io;
void *end_io_data;
ANDROID_KABI_RESERVE(1);
};
static inline enum req_op req_op(const struct request *req)
@ -440,6 +443,8 @@ struct blk_mq_hw_ctx {
* q->unused_hctx_list.
*/
struct list_head hctx_list;
ANDROID_KABI_RESERVE(1);
};
/**
@ -523,6 +528,8 @@ struct blk_mq_tag_set {
struct mutex tag_list_lock;
struct list_head tag_list;
ANDROID_KABI_RESERVE(1);
};
/**
@ -653,6 +660,8 @@ struct blk_mq_ops {
*/
void (*show_rq)(struct seq_file *m, struct request *rq);
#endif
ANDROID_KABI_RESERVE(1);
};
enum {

11
include/linux/blkdev.h
View File

@ -25,6 +25,7 @@
#include <linux/srcu.h>
#include <linux/uuid.h>
#include <linux/xarray.h>
#include <linux/android_kabi.h>
struct module;
struct request_queue;
@ -318,6 +319,8 @@ struct queue_limits {
* due to possible offsets.
*/
unsigned int dma_alignment;
ANDROID_KABI_RESERVE(1);
};
typedef int (*report_zones_cb)(struct blk_zone *zone, unsigned int idx,
@ -545,6 +548,11 @@ struct request_queue {
bool mq_sysfs_init_done;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
/**
* @srcu: Sleepable RCU. Use as lock when type of the request queue
* is blocking (BLK_MQ_F_BLOCKING). Must be the last member
@ -1426,6 +1434,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

15
include/linux/bpf.h
View File

@ -28,6 +28,7 @@
#include <linux/btf.h>
#include <linux/rcupdate_trace.h>
#include <linux/static_call.h>
#include <linux/android_kabi.h>
struct bpf_verifier_env;
struct bpf_verifier_log;
@ -162,6 +163,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);
};
enum {
@ -372,6 +376,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 {
@ -738,6 +744,7 @@ struct bpf_verifier_ops {
const struct btf_type *t, int off, int size,
enum bpf_access_type atype,
u32 *next_btf_id, enum bpf_type_flag *flag);
ANDROID_KABI_RESERVE(1);
};
struct bpf_prog_offload_ops {
@ -753,6 +760,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 {
@ -765,6 +773,7 @@ struct bpf_prog_offload {
bool opt_failed;
void *jited_image;
u32 jited_len;
ANDROID_KABI_RESERVE(1);
};
enum bpf_cgroup_storage_type {
@ -935,6 +944,7 @@ struct bpf_trampoline {
struct bpf_tramp_image *cur_image;
u64 selector;
struct module *mod;
ANDROID_KABI_RESERVE(1);
};
struct bpf_attach_target_info {
@ -965,6 +975,7 @@ struct bpf_dispatcher {
struct static_call_key *sc_key;
void *sc_tramp;
#endif
ANDROID_KABI_RESERVE(1);
};
static __always_inline __nocfi unsigned int bpf_dispatcher_nop_func(
@ -1217,6 +1228,7 @@ struct bpf_prog_aux {
struct work_struct work;
struct rcu_head rcu;
};
ANDROID_KABI_RESERVE(1);
};
struct bpf_prog {
@ -1246,6 +1258,7 @@ struct bpf_prog {
const struct bpf_insn *insn);
struct bpf_prog_aux *aux; /* Auxiliary fields */
struct sock_fprog_kern *orig_prog; /* Original BPF program */
ANDROID_KABI_RESERVE(1);
/* Instructions for interpreter */
union {
DECLARE_FLEX_ARRAY(struct sock_filter, insns);
@ -1279,6 +1292,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_tramp_link {
@ -1326,6 +1340,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)

6
include/linux/bpf_verifier.h
View File

@ -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
@ -483,6 +484,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
@ -553,6 +556,9 @@ struct bpf_verifier_env {
u32 prev_log_len, prev_insn_print_len;
/* buffer used in reg_type_str() to generate reg_type string */
char type_str_buf[TYPE_STR_BUF_LEN];
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
__printf(2, 0) void bpf_verifier_vlog(struct bpf_verifier_log *log,

3
include/linux/cgroup.h
View File

@ -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 file_system_type cgroup_fs_type;

8
include/linux/coresight.h
View File

@ -10,6 +10,7 @@
#include <linux/io.h>
#include <linux/perf_event.h>
#include <linux/sched.h>
#include <linux/android_kabi.h>
/* Peripheral id registers (0xFD0-0xFEC) */
#define CORESIGHT_PERIPHIDR4 0xfd0
@ -159,6 +160,7 @@ struct coresight_desc {
const struct attribute_group **groups;
const char *name;
struct csdev_access access;
ANDROID_KABI_RESERVE(1);
};
/**
@ -176,6 +178,7 @@ struct coresight_connection {
struct fwnode_handle *child_fwnode;
struct coresight_device *child_dev;
struct coresight_sysfs_link *link;
ANDROID_KABI_RESERVE(1);
};
/**
@ -245,6 +248,8 @@ struct coresight_device {
struct list_head config_csdev_list;
spinlock_t cscfg_csdev_lock;
void *active_cscfg_ctxt;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
/*
@ -296,6 +301,7 @@ struct coresight_ops_sink {
unsigned long (*update_buffer)(struct coresight_device *csdev,
struct perf_output_handle *handle,
void *sink_config);
ANDROID_KABI_RESERVE(1);
};
/**
@ -326,6 +332,7 @@ struct coresight_ops_source {
struct perf_event *event, u32 mode);
void (*disable)(struct coresight_device *csdev,
struct perf_event *event);
ANDROID_KABI_RESERVE(1);
};
/**
@ -359,6 +366,7 @@ struct coresight_ops {
const struct coresight_ops_source *source_ops;
const struct coresight_ops_helper *helper_ops;
const struct coresight_ops_ect *ect_ops;
ANDROID_KABI_RESERVE(1);
};
#if IS_ENABLED(CONFIG_CORESIGHT)

4
include/linux/cpuhotplug.h
View File

@ -256,6 +256,10 @@ enum cpuhp_state {
CPUHP_AP_X86_HPET_ONLINE,
CPUHP_AP_X86_KVM_CLK_ONLINE,
CPUHP_AP_ACTIVE,
CPUHP_ANDROID_RESERVED_1,
CPUHP_ANDROID_RESERVED_2,
CPUHP_ANDROID_RESERVED_3,
CPUHP_ANDROID_RESERVED_4,
CPUHP_ONLINE,
};

5
include/linux/cpuidle.h
View File

@ -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

7
include/linux/device-mapper.h
View File

@ -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;
@ -211,6 +212,9 @@ struct target_type {
dm_dax_zero_page_range_fn dax_zero_page_range;
dm_dax_recovery_write_fn dax_recovery_write;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
/* For internal device-mapper use. */
struct list_head list;
};
@ -379,6 +383,9 @@ struct dm_target {
* bio_set_dev(). NOTE: ideally a target should _not_ need this.
*/
bool needs_bio_set_dev:1;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
void *dm_per_bio_data(struct bio *bio, size_t data_size);

14
include/linux/dma-buf.h
View File

@ -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);
};
/**
@ -526,6 +530,9 @@ struct dma_buf {
struct dma_buf *dmabuf;
} *sysfs_entry;
#endif
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
/**
@ -561,6 +568,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);
};
/**
@ -598,6 +606,9 @@ struct dma_buf_attachment {
void *importer_priv;
void *priv;
unsigned long dma_map_attrs;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
/**
@ -621,6 +632,9 @@ struct dma_buf_export_info {
int flags;
struct dma_resv *resv;
void *priv;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
/**

6
include/linux/dmaengine.h
View File

@ -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>
/**
@ -617,6 +618,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

3
include/linux/fs.h
View File

@ -977,6 +977,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 */

7
include/linux/gpio/driver.h
View File

@ -11,6 +11,7 @@
#include <linux/pinctrl/pinconf-generic.h>
#include <linux/property.h>
#include <linux/types.h>
#include <linux/android_kabi.h>
#include <asm/msi.h>
@ -307,6 +308,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);
};
/**
@ -538,6 +542,9 @@ struct gpio_chip {
struct device_node *np);
#endif /* CONFIG_OF_GPIO */
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
extern const char *gpiochip_is_requested(struct gpio_chip *gc,

13
include/linux/input.h
View File

@ -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);
@ -562,6 +572,9 @@ struct ff_device {
int max_effects;
struct ff_effect *effects;
ANDROID_KABI_RESERVE(1);
struct file *effect_owners[];
};

2
include/linux/iomap.h
View File

@ -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)

4
include/linux/kernfs.h
View File

@ -223,6 +223,8 @@ struct kernfs_node {
unsigned short flags;
umode_t mode;
struct kernfs_iattrs *iattr;
ANDROID_KABI_RESERVE(1);
};
/*
@ -264,6 +266,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 {

4
include/linux/key-type.h
View File

@ -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 */

2
include/linux/mm_types.h
View File

@ -716,6 +716,8 @@ struct mm_struct {
#endif
} lru_gen;
#endif /* CONFIG_LRU_GEN */
ANDROID_KABI_RESERVE(1);
} __randomize_layout;
/*

6
include/linux/mmc/card.h
View File

@ -9,6 +9,7 @@
#include <linux/device.h>
#include <linux/mod_devicetable.h>
#include <linux/android_kabi.h>
struct mmc_cid {
unsigned int manfid;
@ -259,6 +260,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);
};
/*
@ -338,6 +341,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)

11
include/linux/mmc/host.h
View File

@ -16,6 +16,7 @@
#include <linux/mmc/pm.h>
#include <linux/dma-direction.h>
#include <linux/blk-crypto-profile.h>
#include <linux/android_kabi.h>
struct mmc_ios {
unsigned int clock; /* clock rate */
@ -212,6 +213,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 {
@ -256,6 +260,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 {
@ -521,6 +528,10 @@ struct mmc_host {
bool hsq_enabled;
u32 err_stats[MMC_ERR_MAX];
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
unsigned long private[] ____cacheline_aligned;
};

9
include/linux/netfilter.h
View File

@ -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. */
@ -375,6 +378,8 @@ struct nf_nat_hook {
enum nf_nat_manip_type mtype,
enum ip_conntrack_dir dir);
void (*remove_nat_bysrc)(struct nf_conn *ct);
ANDROID_KABI_RESERVE(1);
};
extern const struct nf_nat_hook __rcu *nf_nat_hook;
@ -459,6 +464,8 @@ struct nf_ct_hook {
bool (*get_tuple_skb)(struct nf_conntrack_tuple *,
const struct sk_buff *);
void (*attach)(struct sk_buff *nskb, const struct sk_buff *skb);
ANDROID_KABI_RESERVE(1);
};
extern const 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 const struct nfnl_ct_hook __rcu *nfnl_ct_hook;

7
include/linux/netfilter/ipset/ip_set.h
View File

@ -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

5
include/linux/netfilter/nfnetlink.h
View File

@ -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);

3
include/linux/netfilter_ipv6.h
View File

@ -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

8
include/linux/pci.h
View File

@ -587,6 +587,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;
};
@ -769,6 +773,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);
};
/*
@ -844,6 +850,8 @@ struct pci_error_handlers {
/* Device driver may resume normal operations */
void (*resume)(struct pci_dev *dev);
ANDROID_KABI_RESERVE(1);
};

8
include/linux/platform_device.h
View File

@ -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)
@ -42,6 +43,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)
@ -104,6 +108,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);
@ -222,6 +228,8 @@ struct platform_driver {
* to setup and manage their own I/O address space.
*/
bool driver_managed_dma;
ANDROID_KABI_RESERVE(1);
};
#define to_platform_driver(drv) (container_of((drv), struct platform_driver, \

8
include/linux/pm.h
View File

@ -16,6 +16,7 @@
#include <linux/timer.h>
#include <linux/hrtimer.h>
#include <linux/completion.h>
#include <linux/android_kabi.h>
/*
* Callbacks for platform drivers to implement.
@ -307,6 +308,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);
};
#define SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn) \
@ -692,6 +695,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);
@ -718,6 +724,8 @@ struct dev_pm_domain {
int (*activate)(struct device *dev);
void (*sync)(struct device *dev);
void (*dismiss)(struct device *dev);
ANDROID_KABI_RESERVE(1);
};
/*

9
include/linux/power_supply.h
View File

@ -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,
@ -242,6 +243,8 @@ struct power_supply_config {
char **supplied_to;
size_t num_supplicants;
ANDROID_KABI_RESERVE(1);
};
/* Description of power supply */
@ -283,6 +286,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 {
@ -324,6 +329,8 @@ struct power_supply {
struct led_trigger *charging_blink_full_solid_trig;
char *charging_blink_full_solid_trig_name;
#endif
ANDROID_KABI_RESERVE(1);
};
/*
@ -343,6 +350,7 @@ struct power_supply_info {
int energy_full_design;
int energy_empty_design;
int use_for_apm;
ANDROID_KABI_RESERVE(1);
};
struct power_supply_battery_ocv_table {
@ -770,6 +778,7 @@ struct power_supply_battery_info {
int vbat2ri_charging_size;
int bti_resistance_ohm;
int bti_resistance_tolerance;
ANDROID_KABI_RESERVE(1);
};
extern struct atomic_notifier_head power_supply_notifier;

6
include/linux/pwm.h
View File

@ -5,6 +5,7 @@
#include <linux/err.h>
#include <linux/mutex.h>
#include <linux/of.h>
#include <linux/android_kabi.h>
struct pwm_chip;
@ -87,6 +88,8 @@ struct pwm_device {
struct pwm_args args;
struct pwm_state state;
struct pwm_state last;
ANDROID_KABI_RESERVE(1);
};
/**
@ -279,6 +282,7 @@ struct pwm_ops {
int (*get_state)(struct pwm_chip *chip, struct pwm_device *pwm,
struct pwm_state *state);
struct module *owner;
ANDROID_KABI_RESERVE(1);
};
/**
@ -305,6 +309,8 @@ struct pwm_chip {
/* only used internally by the PWM framework */
struct list_head list;
struct pwm_device *pwms;
ANDROID_KABI_RESERVE(1);
};
#if IS_ENABLED(CONFIG_PWM)

7
include/linux/regmap.h
View File

@ -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;
@ -437,6 +438,8 @@ struct regmap_config {
unsigned int hwlock_mode;
bool can_sleep;
ANDROID_KABI_RESERVE(1);
};
/**
@ -474,6 +477,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;
@ -560,6 +565,8 @@ struct regmap_bus {
size_t max_raw_read;
size_t max_raw_write;
bool free_on_exit;
ANDROID_KABI_RESERVE(1);
};
/*

7
include/linux/regulator/driver.h
View File

@ -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;
@ -241,6 +242,8 @@ struct regulator_ops {
int (*resume)(struct regulator_dev *rdev);
int (*set_pull_down) (struct regulator_dev *);
ANDROID_KABI_RESERVE(1);
};
/*
@ -431,6 +434,8 @@ struct regulator_desc {
unsigned int poll_enabled_time;
unsigned int (*of_map_mode)(unsigned int mode);
ANDROID_KABI_RESERVE(1);
};
/**
@ -650,6 +655,8 @@ struct regulator_dev {
int cached_err;
bool use_cached_err;
spinlock_t err_lock;
ANDROID_KABI_RESERVE(1);
};
/*

5
include/linux/rtc.h
View File

@ -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);
@ -68,6 +69,8 @@ struct rtc_class_ops {
int (*set_offset)(struct device *, long offset);
int (*param_get)(struct device *, struct rtc_param *param);
int (*param_set)(struct device *, struct rtc_param *param);
ANDROID_KABI_RESERVE(1);
};
struct rtc_device;
@ -160,6 +163,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)

17
include/linux/scmi_protocol.h
View File

@ -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 64
#define SCMI_SHORT_NAME_MAX_SIZE 16
@ -95,6 +96,8 @@ struct scmi_clk_proto_ops {
int (*enable_atomic)(const struct scmi_protocol_handle *ph, u32 clk_id);
int (*disable_atomic)(const struct scmi_protocol_handle *ph,
u32 clk_id);
ANDROID_KABI_RESERVE(1);
};
/**
@ -142,6 +145,8 @@ struct scmi_perf_proto_ops {
bool (*fast_switch_possible)(const struct scmi_protocol_handle *ph,
struct device *dev);
enum scmi_power_scale (*power_scale_get)(const struct scmi_protocol_handle *ph);
ANDROID_KABI_RESERVE(1);
};
/**
@ -168,6 +173,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);
};
/**
@ -344,6 +351,8 @@ struct scmi_sensor_info {
unsigned int resolution;
int exponent;
struct scmi_range_attrs scalar_attrs;
ANDROID_KABI_RESERVE(1);
};
/*
@ -479,6 +488,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);
};
/**
@ -500,6 +511,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);
};
enum scmi_voltage_level_mode {
@ -771,6 +784,8 @@ struct scmi_handle {
unsigned int *atomic_threshold);
const struct scmi_notify_ops *notify_ops;
ANDROID_KABI_RESERVE(1);
};
enum scmi_std_protocol {
@ -800,6 +815,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)

9
include/linux/serial_core.h
View File

@ -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
@ -402,6 +403,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
@ -581,6 +585,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)
@ -660,6 +667,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);

5
include/linux/serio.h
View File

@ -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)

15
include/linux/spi/spi.h
View File

@ -14,6 +14,7 @@
#include <linux/completion.h>
#include <linux/scatterlist.h>
#include <linux/gpio/consumer.h>
#include <linux/android_kabi.h>
#include <uapi/linux/spi/spi.h>
#include <linux/acpi.h>
@ -209,6 +210,9 @@ struct spi_device {
/* The statistics */
struct spi_statistics __percpu *pcpu_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:
@ -296,6 +300,8 @@ struct spi_driver {
void (*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)
@ -696,6 +702,9 @@ struct spi_controller {
/* Flag for enabling opportunistic skipping of the queue in spi_sync */
bool queue_empty;
bool must_async;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
static inline void *spi_controller_get_devdata(struct spi_controller *ctlr)
@ -989,6 +998,8 @@ struct spi_transfer {
#define SPI_TRANS_FAIL_NO_START BIT(0)
u16 error;
ANDROID_KABI_RESERVE(1);
};
/**
@ -1059,6 +1070,8 @@ struct spi_message {
/* spi_prepare_message() was called for this message */
bool prepared;
ANDROID_KABI_RESERVE(1);
};
static inline void spi_message_init_no_memset(struct spi_message *m)
@ -1472,6 +1485,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:

3
include/linux/spmi.h
View File

@ -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)

7
include/linux/suspend.h
View File

@ -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 {
@ -196,6 +199,8 @@ struct platform_s2idle_ops {
void (*restore_early)(void);
void (*restore)(void);
void (*end)(void);
ANDROID_KABI_RESERVE(1);
};
#ifdef CONFIG_SUSPEND
@ -427,6 +432,8 @@ struct platform_hibernation_ops {
int (*pre_restore)(void);
void (*restore_cleanup)(void);
void (*recover)(void);
ANDROID_KABI_RESERVE(1);
};
#ifdef CONFIG_HIBERNATION

3
include/linux/tcp.h
View File

@ -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>
@ -449,6 +450,8 @@ struct tcp_sock {
*/
struct request_sock __rcu *fastopen_rsk;
struct saved_syn *saved_syn;
ANDROID_KABI_RESERVE(1);
};
enum tsq_enum {

15
include/linux/thermal.h
View File

@ -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>
/* invalid cooling state */
@ -74,6 +75,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);
};
/**
@ -95,6 +98,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 {
@ -110,6 +115,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);
};
/**
@ -185,6 +192,8 @@ struct thermal_zone_device {
struct list_head node;
struct delayed_work poll_queue;
enum thermal_notify_event notify_event;
ANDROID_KABI_RESERVE(1);
};
/**
@ -205,6 +214,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 */
@ -240,6 +251,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 */
@ -293,6 +306,8 @@ struct thermal_zone_params {
* Used by thermal zone drivers (default 0).
*/
int offset;
ANDROID_KABI_RESERVE(1);
};
/* Function declarations */

4
include/linux/tty.h
View File

@ -15,6 +15,7 @@
#include <uapi/linux/tty.h>
#include <linux/rwsem.h>
#include <linux/llist.h>
#include <linux/android_kabi.h>
/*
@ -248,6 +249,9 @@ struct tty_struct {
int write_cnt;
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 */

7
include/linux/tty_driver.h
View File

@ -10,6 +10,7 @@
#include <linux/uaccess.h>
#include <linux/termios.h>
#include <linux/seq_file.h>
#include <linux/android_kabi.h>
struct tty_struct;
struct tty_driver;
@ -392,6 +393,9 @@ struct tty_operations {
void (*poll_put_char)(struct tty_driver *driver, int line, char ch);
#endif
int (*proc_show)(struct seq_file *m, void *driver);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
} __randomize_layout;
/**
@ -462,6 +466,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;

4
include/linux/tty_ldisc.h
View File

@ -10,6 +10,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
@ -245,6 +246,9 @@ struct tty_ldisc_ops {
const unsigned char *fp, unsigned int count);
struct module *owner;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
struct tty_ldisc {

5
include/linux/tty_port.h
View File

@ -7,6 +7,7 @@
#include <linux/mutex.h>
#include <linux/tty_buffer.h>
#include <linux/wait.h>
#include <linux/android_kabi.h>
struct attribute_group;
struct tty_driver;
@ -36,6 +37,8 @@ struct tty_port_operations {
void (*shutdown)(struct tty_port *port);
int (*activate)(struct tty_port *port, struct tty_struct *tty);
void (*destruct)(struct tty_port *port);
ANDROID_KABI_RESERVE(1);
};
struct tty_port_client_operations {
@ -120,6 +123,8 @@ struct tty_port {
int drain_delay;
struct kref kref;
void *client_data;
ANDROID_KABI_RESERVE(1);
};
/* tty_port::iflags bits -- use atomic bit ops */

4
include/linux/uio_driver.h
View File

@ -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

11
include/linux/usb/gadget.h
View File

@ -120,6 +120,8 @@ struct usb_request {
int status;
unsigned actual;
ANDROID_KABI_RESERVE(1);
};
/*-------------------------------------------------------------------------*/
@ -150,6 +152,8 @@ struct usb_ep_ops {
int (*fifo_status) (struct usb_ep *ep);
void (*fifo_flush) (struct usb_ep *ep);
ANDROID_KABI_RESERVE(1);
};
/**
@ -238,6 +242,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);
};
/*-------------------------------------------------------------------------*/
@ -328,6 +334,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);
};
/**

2
include/linux/usb/otg.h
View File

@ -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);
};
/**

3
include/linux/usb/phy.h
View File

@ -13,6 +13,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 {
@ -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 */

7
include/linux/usb/typec.h
View File

@ -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 */
@ -237,6 +238,9 @@ struct typec_operations {
enum typec_port_type type);
struct usb_power_delivery **(*pd_get)(struct typec_port *port);
int (*pd_set)(struct typec_port *port, struct usb_power_delivery *pd);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
enum usb_pd_svdm_ver {
@ -277,6 +281,9 @@ struct typec_capability {
struct usb_power_delivery *pd;
const struct typec_operations *ops;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
/* Specific to try_role(). Indicates the user want's to clear the preference. */

2
include/linux/usb/typec_altmode.h
View File

@ -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);

16
include/media/v4l2-ctrls.h
View File

@ -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>
/* forward references */
@ -83,6 +84,9 @@ union v4l2_ctrl_ptr {
struct v4l2_area *p_area;
void *p;
const void *p_const;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
/**
@ -115,6 +119,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);
};
/**
@ -134,6 +140,8 @@ struct v4l2_ctrl_type_ops {
union v4l2_ctrl_ptr ptr);
void (*log)(const struct v4l2_ctrl *ctrl);
int (*validate)(const struct v4l2_ctrl *ctrl, union v4l2_ctrl_ptr ptr);
ANDROID_KABI_RESERVE(1);
};
/**
@ -298,6 +306,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);
};
/**
@ -350,6 +360,8 @@ struct v4l2_ctrl_ref {
u32 p_req_array_alloc_elems;
u32 p_req_elems;
union v4l2_ctrl_ptr p_req;
ANDROID_KABI_RESERVE(1);
};
/**
@ -400,6 +412,8 @@ struct v4l2_ctrl_handler {
struct list_head requests;
struct list_head requests_queued;
struct media_request_object req_obj;
ANDROID_KABI_RESERVE(1);
};
/**
@ -451,6 +465,8 @@ struct v4l2_ctrl_config {
const char * const *qmenu;
const s64 *qmenu_int;
unsigned int is_private:1;
ANDROID_KABI_RESERVE(1);
};
/**

6
include/media/v4l2-dev.h
View File

@ -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);
};
/*
@ -306,6 +309,9 @@ struct video_device {
DECLARE_BITMAP(valid_ioctls, BASE_VIDIOC_PRIVATE);
struct mutex *lock;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
/**

3
include/media/videobuf2-v4l2.h
View File

@ -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 */

19
include/net/bluetooth/hci_core.h
View File

@ -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_sync.h>
@ -665,6 +666,11 @@ struct hci_dev {
int (*get_codec_config_data)(struct hci_dev *hdev, __u8 type,
struct bt_codec *codec, __u8 *vnd_len,
__u8 **vnd_data);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
#define HCI_PHY_HANDLE(handle) (handle & 0xff)
@ -771,6 +777,11 @@ struct hci_conn {
void (*disconn_cfm_cb) (struct hci_conn *conn, u8 reason);
void (*cleanup)(struct hci_conn *conn);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
struct hci_chan {
@ -781,6 +792,8 @@ struct hci_chan {
unsigned int sent;
__u8 state;
bool amp;
ANDROID_KABI_RESERVE(1);
};
struct hci_conn_params {
@ -808,6 +821,8 @@ struct hci_conn_params {
bool explicit_connect;
hci_conn_flags_t flags;
u8 privacy_mode;
ANDROID_KABI_RESERVE(1);
};
extern struct list_head hci_dev_list;
@ -1766,6 +1781,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)
@ -1984,6 +2001,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);

10
include/net/bluetooth/l2cap.h
View File

@ -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 {

6
include/net/bluetooth/rfcomm.h
View File

@ -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 */

45
include/net/cfg80211.h
View File

@ -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>
/**
@ -1140,6 +1141,8 @@ struct cfg80211_crypto_settings {
const u8 *sae_pwd;
u8 sae_pwd_len;
enum nl80211_sae_pwe_mechanism sae_pwe;
ANDROID_KABI_RESERVE(1);
};
/**
@ -1226,6 +1229,8 @@ struct cfg80211_beacon_data {
size_t civicloc_len;
struct cfg80211_he_bss_color he_bss_color;
bool he_bss_color_valid;
ANDROID_KABI_RESERVE(1);
};
struct mac_address {
@ -1360,6 +1365,8 @@ struct cfg80211_ap_settings {
struct cfg80211_unsol_bcast_probe_resp unsol_bcast_probe_resp;
struct cfg80211_mbssid_config mbssid_config;
u16 punct_bitmap;
ANDROID_KABI_RESERVE(1);
};
/**
@ -1393,6 +1400,8 @@ struct cfg80211_csa_settings {
bool block_tx;
u8 count;
u16 punct_bitmap;
ANDROID_KABI_RESERVE(1);
};
/**
@ -1516,6 +1525,8 @@ struct link_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);
};
/**
@ -1973,6 +1984,8 @@ struct station_info {
u8 mld_addr[ETH_ALEN] __aligned(2);
const u8 *assoc_resp_ies;
size_t assoc_resp_ies_len;
ANDROID_KABI_RESERVE(1);
};
/**
@ -2280,6 +2293,8 @@ struct mesh_config {
u16 dot11MeshAwakeWindowDuration;
u32 plink_timeout;
bool dot11MeshNolearn;
ANDROID_KABI_RESERVE(1);
};
/**
@ -2329,6 +2344,8 @@ struct mesh_setup {
struct cfg80211_bitrate_mask beacon_rate;
bool userspace_handles_dfs;
bool control_port_over_nl80211;
ANDROID_KABI_RESERVE(1);
};
/**
@ -2492,6 +2509,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[];
};
@ -2638,6 +2657,8 @@ struct cfg80211_sched_scan_request {
bool nl_owner_dead;
struct list_head list;
ANDROID_KABI_RESERVE(1);
/* keep last */
struct ieee80211_channel *channels[];
};
@ -2761,6 +2782,8 @@ struct cfg80211_bss {
u8 bssid_index;
u8 max_bssid_indicator;
ANDROID_KABI_RESERVE(1);
u8 priv[] __aligned(sizeof(void *));
};
@ -2927,6 +2950,8 @@ struct cfg80211_assoc_request {
struct cfg80211_assoc_link links[IEEE80211_MLD_MAX_NUM_LINKS];
const u8 *ap_mld_addr;
s8 link_id;
ANDROID_KABI_RESERVE(1);
};
/**
@ -3025,6 +3050,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);
};
/**
@ -3139,6 +3166,8 @@ struct cfg80211_connect_params {
size_t fils_erp_rrk_len;
bool want_1x;
struct ieee80211_edmg edmg;
ANDROID_KABI_RESERVE(1);
};
/**
@ -3600,6 +3629,8 @@ struct cfg80211_nan_func {
u8 num_rx_filters;
u8 instance_id;
u64 cookie;
ANDROID_KABI_RESERVE(1);
};
/**
@ -3772,6 +3803,8 @@ struct cfg80211_pmsr_ftm_result {
dist_avg_valid:1,
dist_variance_valid:1,
dist_spread_valid:1;
ANDROID_KABI_RESERVE(1);
};
/**
@ -4689,6 +4722,11 @@ struct cfg80211_ops {
struct link_station_parameters *params);
int (*del_link_station)(struct wiphy *wiphy, struct net_device *dev,
struct link_station_del_parameters *params);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
/*
@ -5057,6 +5095,8 @@ struct wiphy_vendor_command {
unsigned long *storage);
const struct nla_policy *policy;
unsigned int maxattr;
ANDROID_KABI_RESERVE(1);
};
/**
@ -5502,6 +5542,8 @@ struct wiphy {
u8 ema_max_profile_periodicity;
u16 max_num_akm_suites;
ANDROID_KABI_RESERVE(1);
char priv[] __aligned(NETDEV_ALIGN);
};
@ -5895,6 +5937,9 @@ struct wireless_dev {
};
} links[IEEE80211_MLD_MAX_NUM_LINKS];
u16 valid_links;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
static inline const u8 *wdev_address(struct wireless_dev *wdev)

5
include/net/genetlink.h
View File

@ -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>
@ -81,6 +82,8 @@ struct genl_family {
const struct genl_small_ops *small_ops;
const struct genl_multicast_group *mcgrps;
struct module *module;
ANDROID_KABI_RESERVE(1);
};
/**
@ -179,6 +182,8 @@ struct genl_ops {
u8 internal_flags;
u8 flags;
u8 validate;
ANDROID_KABI_RESERVE(1);
};
/**

5
include/net/inet_connection_sock.h
View File

@ -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>
@ -52,6 +53,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
@ -135,6 +138,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)
};

4
include/net/inet_sock.h
View File

@ -17,6 +17,7 @@
#include <linux/types.h>
#include <linux/jhash.h>
#include <linux/netdevice.h>
#include <linux/android_kabi.h>
#include <net/flow.h>
#include <net/sock.h>
@ -253,6 +254,9 @@ struct inet_sock {
__u16 lo;
__u16 hi;
} local_port_range;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
#define IPCORK_OPT 1 /* ip-options has been held in ipcork.opt */

2
include/net/ip.h
View File

@ -25,6 +25,7 @@
#include <linux/jhash.h>
#include <linux/sockptr.h>
#include <linux/static_key.h>
#include <linux/android_kabi.h>
#include <net/inet_sock.h>
#include <net/route.h>
@ -81,6 +82,7 @@ struct ipcm_cookie {
__s16 tos;
char priority;
__u16 gso_size;
ANDROID_KABI_RESERVE(1);
};
static inline void ipcm_init(struct ipcm_cookie *ipcm)

10
include/net/ip6_fib.h
View File

@ -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>
@ -68,6 +69,8 @@ struct fib6_config {
struct nlattr *fc_encap;
u16 fc_encap_type;
bool fc_is_fdb;
ANDROID_KABI_RESERVE(1);
};
struct fib6_node {
@ -84,6 +87,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 {
@ -203,6 +208,9 @@ struct fib6_info {
struct rcu_head rcu;
struct nexthop *nh;
ANDROID_KABI_RESERVE(1);
struct fib6_nh fib6_nh[];
};
@ -222,6 +230,8 @@ struct rt6_info {
/* more non-fragment space at head required */
unsigned short rt6i_nfheader_len;
ANDROID_KABI_RESERVE(1);
};
struct fib6_result {

24
include/net/mac80211.h
View File

@ -19,6 +19,7 @@
#include <linux/skbuff.h>
#include <linux/ieee80211.h>
#include <linux/lockdep.h>
#include <linux/android_kabi.h>
#include <net/cfg80211.h>
#include <net/codel.h>
#include <net/ieee80211_radiotap.h>
@ -725,6 +726,8 @@ struct ieee80211_bss_conf {
bool color_change_active;
u8 color_change_color;
ANDROID_KABI_RESERVE(1);
};
/**
@ -1153,6 +1156,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 *)];
};
@ -1673,6 +1679,8 @@ struct ieee80211_conf {
struct cfg80211_chan_def chandef;
bool radar_enabled;
enum ieee80211_smps_mode smps_mode;
ANDROID_KABI_RESERVE(1);
};
/**
@ -1857,6 +1865,8 @@ struct ieee80211_vif {
struct ieee80211_vif *mbssid_tx_vif;
ANDROID_KABI_RESERVE(1);
/* must be last */
u8 drv_priv[] __aligned(sizeof(void *));
};
@ -2287,6 +2297,8 @@ struct ieee80211_sta {
struct ieee80211_link_sta deflink;
struct ieee80211_link_sta __rcu *link[IEEE80211_MLD_MAX_NUM_LINKS];
ANDROID_KABI_RESERVE(1);
/* must be last */
u8 drv_priv[] __aligned(sizeof(void *));
};
@ -2822,6 +2834,8 @@ struct ieee80211_hw {
u32 max_mtu;
const s8 *tx_power_levels;
u8 max_txpwr_levels_idx;
ANDROID_KABI_RESERVE(1);
};
static inline bool _ieee80211_hw_check(struct ieee80211_hw *hw,
@ -4515,6 +4529,11 @@ struct ieee80211_ops {
struct ieee80211_vif *vif,
struct ieee80211_sta *sta,
u16 old_links, u16 new_links);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
/**
@ -6614,6 +6633,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,

8
include/net/neighbour.h
View File

@ -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>
/*
@ -86,6 +87,8 @@ struct neigh_parms {
u32 qlen;
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)
@ -162,6 +165,9 @@ struct neighbour {
struct rcu_head rcu;
struct net_device *dev;
netdevice_tracker dev_tracker;
ANDROID_KABI_RESERVE(1);
u8 primary_key[0];
} __randomize_layout;
@ -234,6 +240,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 {

3
include/net/netns/can.h
View File

@ -8,6 +8,7 @@
#include <linux/spinlock.h>
#include <linux/timer.h>
#include <linux/android_kabi.h>
struct can_dev_rcv_lists;
struct can_pkg_stats;
@ -36,6 +37,8 @@ struct netns_can {
/* CAN GW per-net gateway jobs */
struct hlist_head cgw_list;
ANDROID_KABI_RESERVE(1);
};
#endif /* __NETNS_CAN_H__ */

3
include/net/netns/ipv4.h
View File

@ -11,6 +11,7 @@
#include <linux/rcupdate.h>
#include <linux/seqlock.h>
#include <linux/siphash.h>
#include <linux/android_kabi.h>
struct ctl_table_header;
struct ipv4_devconf;
@ -229,5 +230,7 @@ struct netns_ipv4 {
atomic_t rt_genid;
siphash_key_t ip_id_key;
ANDROID_KABI_RESERVE(1);
};
#endif

4
include/net/netns/ipv6.h
View File

@ -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 {
@ -118,6 +120,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)

3
include/net/netns/netfilter.h
View File

@ -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;
@ -30,5 +31,7 @@ struct netns_nf {
#if IS_ENABLED(CONFIG_NF_DEFRAG_IPV6)
unsigned int defrag_ipv6_users;
#endif
ANDROID_KABI_RESERVE(1);
};
#endif

2
include/net/netns/nftables.h
View File

@ -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

3
include/net/netns/xfrm.h
View File

@ -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;
@ -82,6 +83,8 @@ struct netns_xfrm {
spinlock_t xfrm_policy_lock;
struct mutex xfrm_cfg_mutex;
ANDROID_KABI_RESERVE(1);
};
#endif

3
include/net/page_pool.h
View File

@ -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
@ -207,6 +208,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);

8
include/net/sch_generic.h
View File

@ -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>
@ -126,6 +127,9 @@ struct Qdisc {
struct rcu_head rcu;
netdevice_tracker dev_tracker;
ANDROID_KABI_RESERVE(1);
/* private data */
long privdata[] ____cacheline_aligned;
};
@ -270,6 +274,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 */
@ -315,6 +321,8 @@ struct Qdisc_ops {
u32 (*egress_block_get)(struct Qdisc *sch);
struct module *owner;
ANDROID_KABI_RESERVE(1);
};

4
include/net/tls.h
View File

@ -116,6 +116,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_strparser {
@ -150,6 +152,8 @@ struct tls_sw_context_rx {
spinlock_t decrypt_compl_lock;
struct sk_buff_head async_hold;
struct wait_queue_head wq;
ANDROID_KABI_RESERVE(1);
};
struct tls_record_info {

2
include/scsi/scsi_host.h
View File

@ -716,6 +716,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

8
include/sound/compress_driver.h
View File

@ -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 */

10
include/sound/core.h
View File

@ -15,6 +15,7 @@
#include <linux/stringify.h>
#include <linux/printk.h>
#include <linux/xarray.h>
#include <linux/android_kabi.h>
/* number of supported soundcards */
#ifdef CONFIG_SND_DYNAMIC_MINORS
@ -62,6 +63,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 {
@ -71,6 +74,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)
@ -145,6 +150,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)
@ -220,6 +228,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 */

5
include/sound/hwdep.h
View File

@ -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,

5
include/sound/info.h
View File

@ -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)

3
include/sound/jack.h
View File

@ -9,6 +9,7 @@
*/
#include <sound/core.h>
#include <linux/android_kabi.h>
struct input_dev;
@ -71,6 +72,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

7
include/sound/pcm.h
View File

@ -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);
};
/*
@ -435,6 +437,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 */
@ -487,6 +491,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)
@ -511,6 +516,7 @@ struct snd_pcm_str {
#endif
struct snd_kcontrol *chmap_kctl; /* channel-mapping controls */
struct device dev;
ANDROID_KABI_RESERVE(1);
};
struct snd_pcm {
@ -533,6 +539,7 @@ struct snd_pcm {
#if IS_ENABLED(CONFIG_SND_PCM_OSS)
struct snd_pcm_oss oss;
#endif
ANDROID_KABI_RESERVE(1);
};
/*

15
include/sound/soc.h
View File

@ -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>
@ -762,6 +763,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*
@ -1030,6 +1033,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; \
@ -1110,6 +1118,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() */
@ -1149,6 +1160,8 @@ struct soc_mixer_control {
#ifdef CONFIG_SND_SOC_TOPOLOGY
struct snd_soc_dobj dobj;
#endif
ANDROID_KABI_RESERVE(1);
};
struct soc_bytes {
@ -1193,6 +1206,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)

7
include/sound/timer.h
View File

@ -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);
};
/*

2
include/ufs/ufs.h
View File

@ -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))
@ -636,6 +637,7 @@ struct ufs_dev_info {
/* UFS EXT_IID Enable */
bool b_ext_iid_en;
ANDROID_KABI_RESERVE(1);
};
/*

6
include/ufs/ufshcd.h
View File

@ -199,6 +199,8 @@ struct ufshcd_lrb {
#endif
bool req_abort_skip;
ANDROID_KABI_RESERVE(1);
};
/**
@ -392,6 +394,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 {
@ -438,6 +442,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

3
sound/usb/card.h
View File

@ -145,6 +145,7 @@ struct snd_usb_endpoint {
spinlock_t lock;
struct list_head list;
ANDROID_KABI_RESERVE(1);
};
struct media_ctl;
@ -196,6 +197,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 {

7
sound/usb/usbaudio.h
View File

@ -12,6 +12,8 @@
#define USB_ID_VENDOR(id) ((id) >> 16)
#define USB_ID_PRODUCT(id) ((u16)(id))
#include <linux/android_kabi.h>
/*
*
*/
@ -61,6 +63,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)