tmakin/ack-tegra
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ANDROID: GKI: the "reusachtig" padding sync with android16-6.12

Browse Source 
Add the initial set of ABI padding fields in android16-6.12 based on what
is in the android15-6.6 branch.

Bug: 151154716
Change-Id: Icdb394863b2911389bfdced0fd1ea20236ca4ce1
Signed-off-by: Greg Kroah-Hartman <gregkh@google.com>
Signed-off-by: Carlos Llamas <cmllamas@google.com>
This commit is contained in:
Greg Kroah-Hartman
2024-02-29 10:29:40 +00:00
committed by Carlos Llamas
parent 20159aa0ac
commit 75adb09e2f
140 changed files with 1149 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
arch/arm64/tools/cpucaps
View File

@@ -107,3 +107,23 @@ WORKAROUND_REPEAT_TLBI
WORKAROUND_SPECULATIVE_AT
WORKAROUND_SPECULATIVE_SSBS
WORKAROUND_SPECULATIVE_UNPRIV_LOAD
ANDROID_KABI_RESERVE_01
ANDROID_KABI_RESERVE_02
ANDROID_KABI_RESERVE_03
ANDROID_KABI_RESERVE_04
ANDROID_KABI_RESERVE_05
ANDROID_KABI_RESERVE_06
ANDROID_KABI_RESERVE_07
ANDROID_KABI_RESERVE_08
ANDROID_KABI_RESERVE_09
ANDROID_KABI_RESERVE_10
ANDROID_KABI_RESERVE_11
ANDROID_KABI_RESERVE_12
ANDROID_KABI_RESERVE_13
ANDROID_KABI_RESERVE_14
ANDROID_KABI_RESERVE_15
ANDROID_KABI_RESERVE_16
ANDROID_KABI_RESERVE_17
ANDROID_KABI_RESERVE_18
ANDROID_KABI_RESERVE_19
ANDROID_KABI_RESERVE_20

9
block/elevator.h
View File

@@ -4,6 +4,7 @@
#include <linux/percpu.h>
#include <linux/hashtable.h>
#include <linux/android_kabi.h>
#include "blk-mq.h"
struct io_cq;
@@ -48,6 +49,11 @@ struct elevator_mq_ops {
struct request *(*next_request)(struct request_queue *, struct request *);
void (*init_icq)(struct io_cq *);
void (*exit_icq)(struct io_cq *);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
#define ELV_NAME_MAX (16)
@@ -83,6 +89,9 @@ struct elevator_type
/* managed by elevator core */
char icq_cache_name[ELV_NAME_MAX + 6]; /* elvname + "_io_cq" */
struct list_head list;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
static inline bool elevator_tryget(struct elevator_type *e)

4
drivers/gpio/gpiolib.h
View File

@@ -17,6 +17,7 @@
#include <linux/module.h>
#include <linux/notifier.h>
#include <linux/srcu.h>
#include <linux/android_kabi.h>
#define GPIOCHIP_NAME "gpiochip"
@@ -82,6 +83,7 @@ struct gpio_device {
*/
struct list_head pin_ranges;
#endif
ANDROID_KABI_RESERVE(1);
};
static inline struct gpio_device *to_gpio_device(struct device *dev)
@@ -125,6 +127,7 @@ struct gpio_array {
struct gpio_chip *chip;
unsigned long *get_mask;
unsigned long *set_mask;
ANDROID_KABI_RESERVE(1);
unsigned long invert_mask[];
};
@@ -202,6 +205,7 @@ struct gpio_desc {
#ifdef CONFIG_OF_DYNAMIC
struct device_node *hog;
#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>
@@ -620,6 +621,8 @@ struct sdhci_host {
u64 data_timeout;
ANDROID_KABI_RESERVE(1);
unsigned long private[] ____cacheline_aligned;
};
@@ -667,6 +670,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

6
drivers/pci/pci.h
View File

@@ -3,6 +3,7 @@
#define DRIVERS_PCI_H
#include <linux/pci.h>
#include <linux/android_kabi.h>
/* Number of possible devfns: 0.0 to 1f.7 inclusive */
#define MAX_NR_DEVFNS 256
@@ -421,6 +422,11 @@ struct pci_sriov {
u16 subsystem_device; /* VF subsystem device */
resource_size_t barsz[PCI_SRIOV_NUM_BARS]; /* VF BAR size */
bool drivers_autoprobe; /* Auto probing of VFs by driver */
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
#ifdef CONFIG_PCI_DOE

3
drivers/scsi/sd.h
View File

@@ -156,6 +156,9 @@ struct scsi_disk {
unsigned ignore_medium_access_errors : 1;
unsigned rscs : 1; /* reduced stream control support */
unsigned use_atomic_write_boundary : 1;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
#define to_scsi_disk(obj) container_of(obj, struct scsi_disk, disk_dev)

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

@@ -22,6 +22,7 @@
#include <linux/debugfs.h>
#include <linux/wait.h>
#include <linux/workqueue.h>
#include <linux/android_kabi.h>
#include <linux/usb/ch9.h>
#include <linux/usb/gadget.h>
@@ -703,6 +704,8 @@ struct dwc3_event_buffer {
dma_addr_t dma;
struct dwc3 *dwc;
ANDROID_KABI_RESERVE(1);
};
#define DWC3_EP_FLAG_STALLED BIT(0)
@@ -799,6 +802,9 @@ 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 {
@@ -910,6 +916,9 @@ struct dwc3_hwparams {
u32 hwparams7;
u32 hwparams8;
u32 hwparams9;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
/* HWPARAMS0 */
@@ -986,6 +995,9 @@ struct dwc3_request {
unsigned int needs_extra_trb:1;
unsigned int direction:1;
unsigned int mapped:1;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
/*
@@ -1400,6 +1412,11 @@ struct dwc3 {
int num_ep_resized;
struct dentry *debug_root;
u32 gsbuscfg0_reqinfo;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
#define INCRX_BURST_MODE 0

21
drivers/usb/host/xhci.h
View File

@@ -18,6 +18,7 @@
#include <linux/usb/hcd.h>
#include <linux/io-64-nonatomic-lo-hi.h>
#include <linux/io-64-nonatomic-hi-lo.h>
#include <linux/android_kabi.h>
/* Code sharing between pci-quirks and xhci hcd */
#include "xhci-ext-caps.h"
@@ -538,6 +539,9 @@ struct xhci_command {
struct list_head cmd_list;
/* xHCI command response timeout in milliseconds */
unsigned int timeout_ms;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
/* drop context bitmasks */
@@ -1278,6 +1282,8 @@ struct xhci_segment {
void *bounce_buf;
unsigned int bounce_offs;
unsigned int bounce_len;
ANDROID_KABI_RESERVE(1);
};
enum xhci_cancelled_td_status {
@@ -1369,6 +1375,9 @@ struct xhci_ring {
enum xhci_ring_type type;
bool last_td_was_short;
struct radix_tree_root *trb_address_map;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
struct xhci_erst_entry {
@@ -1384,6 +1393,7 @@ struct xhci_erst {
unsigned int num_entries;
/* xhci->event_ring keeps track of segment dma addresses */
dma_addr_t erst_dma_addr;
ANDROID_KABI_RESERVE(1);
};
struct xhci_scratchpad {
@@ -1660,6 +1670,12 @@ struct xhci_hcd {
struct list_head regset_list;
void *dbc;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
/* platform-specific data -- must come last */
unsigned long priv[] __aligned(sizeof(s64));
};
@@ -1679,6 +1695,11 @@ struct xhci_driver_overrides {
struct usb_tt *tt, gfp_t mem_flags);
int (*hub_control)(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
u16 wIndex, char *buf, u16 wLength);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
#define XHCI_CFC_DELAY 10

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;
@@ -24,6 +25,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;
@@ -15,6 +16,7 @@ struct typec_plug {
enum typec_plug_index index;
struct ida mode_ids;
int num_altmodes;
ANDROID_KABI_RESERVE(1);
};
struct typec_cable {
@@ -24,6 +26,7 @@ struct typec_cable {
unsigned int active:1;
u16 pd_revision; /* 0300H = "3.0" */
enum usb_pd_svdm_ver svdm_version;
ANDROID_KABI_RESERVE(1);
};
struct typec_partner {
@@ -40,6 +43,7 @@ struct typec_partner {
void (*attach)(struct typec_partner *partner, struct device *dev);
void (*deattach)(struct typec_partner *partner, struct device *dev);
ANDROID_KABI_RESERVE(1);
};
struct typec_port {
@@ -76,6 +80,7 @@ struct typec_port {
*/
struct device *usb2_dev;
struct device *usb3_dev;
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;
@@ -158,6 +159,9 @@ struct bdi_writeback {
struct rcu_head rcu;
};
#endif
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_OEM_DATA_ARRAY(1, 2);
};
@@ -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);
};
struct wb_lock_cookie {

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

@@ -9,6 +9,7 @@
#include <linux/prefetch.h>
#include <linux/srcu.h>
#include <linux/rw_hint.h>
#include <linux/android_kabi.h>
struct blk_mq_tags;
struct blk_flush_queue;
@@ -209,6 +210,7 @@ struct request {
rq_end_io_fn *end_io;
void *end_io_data;
ANDROID_KABI_RESERVE(1);
ANDROID_OEM_DATA(1);
};
@@ -452,6 +454,8 @@ struct blk_mq_hw_ctx {
* q->unused_hctx_list.
*/
struct list_head hctx_list;
ANDROID_KABI_RESERVE(1);
};
/**
@@ -538,6 +542,8 @@ struct blk_mq_tag_set {
struct mutex tag_list_lock;
struct list_head tag_list;
struct srcu_struct *srcu;
ANDROID_KABI_RESERVE(1);
};
/**
@@ -668,6 +674,8 @@ struct blk_mq_ops {
*/
void (*show_rq)(struct seq_file *m, struct request *rq);
#endif
ANDROID_KABI_RESERVE(1);
};
/* Keep hctx_flag_name[] in sync with the definitions below */

4
include/linux/blk_types.h
View File

@@ -11,6 +11,7 @@
#include <linux/device.h>
#include <linux/ktime.h>
#include <linux/rw_hint.h>
#include <linux/android_kabi.h>
struct bio_set;
struct bio;
@@ -272,6 +273,9 @@ struct bio {
struct bio_set *bi_pool;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
/*
* We can inline a number of vecs at the end of the bio, to avoid
* double allocations for a small number of bio_vecs. This member

19
include/linux/blkdev.h
View File

@@ -27,6 +27,7 @@
#include <linux/file.h>
#include <linux/lockdep.h>
#include <linux/android_vendor.h>
#include <linux/android_kabi.h>
struct module;
struct request_queue;
@@ -121,6 +122,9 @@ struct blk_integrity {
unsigned char pi_offset;
unsigned char interval_exp;
unsigned char tag_size;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
typedef unsigned int __bitwise blk_mode_t;
@@ -220,6 +224,11 @@ struct gendisk {
*/
struct blk_independent_access_ranges *ia_ranges;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
ANDROID_OEM_DATA(1);
};
@@ -406,6 +415,8 @@ struct queue_limits {
unsigned int dma_pad_mask;
struct blk_integrity integrity;
ANDROID_KABI_RESERVE(1);
};
typedef int (*report_zones_cb)(struct blk_zone *zone, unsigned int idx,
@@ -598,6 +609,11 @@ struct request_queue {
struct mutex debugfs_mutex;
bool mq_sysfs_init_done;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
ANDROID_OEM_DATA(1);
};
@@ -1516,6 +1532,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

@@ -30,6 +30,7 @@
#include <linux/static_call.h>
#include <linux/memcontrol.h>
#include <linux/cfi.h>
#include <linux/android_kabi.h>
struct bpf_verifier_env;
struct bpf_verifier_log;
@@ -181,6 +182,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 {
@@ -555,6 +559,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 {
@@ -996,6 +1002,7 @@ struct bpf_verifier_ops {
int (*btf_struct_access)(struct bpf_verifier_log *log,
const struct bpf_reg_state *reg,
int off, int size);
ANDROID_KABI_RESERVE(1);
};
struct bpf_prog_offload_ops {
@@ -1011,6 +1018,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 {
@@ -1023,6 +1031,7 @@ struct bpf_prog_offload {
bool opt_failed;
void *jited_image;
u32 jited_len;
ANDROID_KABI_RESERVE(1);
};
enum bpf_cgroup_storage_type {
@@ -1220,6 +1229,7 @@ struct bpf_trampoline {
int progs_cnt[BPF_TRAMP_MAX];
/* Executable image of trampoline */
struct bpf_tramp_image *cur_image;
ANDROID_KABI_RESERVE(1);
};
struct bpf_attach_target_info {
@@ -1251,6 +1261,7 @@ struct bpf_dispatcher {
struct static_call_key *sc_key;
void *sc_tramp;
#endif
ANDROID_KABI_RESERVE(1);
};
#ifndef __bpfcall
@@ -1565,6 +1576,7 @@ struct bpf_prog_aux {
struct work_struct work;
struct rcu_head rcu;
};
ANDROID_KABI_RESERVE(1);
};
struct bpf_prog {
@@ -1595,6 +1607,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);
@@ -1645,6 +1658,7 @@ struct bpf_link_ops {
int (*update_map)(struct bpf_link *link, struct bpf_map *new_map,
struct bpf_map *old_map);
__poll_t (*poll)(struct file *file, struct poll_table_struct *pts);
ANDROID_KABI_RESERVE(1);
};
struct bpf_tramp_link {
@@ -1796,6 +1810,7 @@ struct bpf_struct_ops_desc {
/* Collection of argument information for each member */
struct bpf_struct_ops_arg_info *arg_info;
ANDROID_KABI_RESERVE(1);
};
enum bpf_struct_ops_state {

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
@@ -671,6 +672,8 @@ struct bpf_subprog_info {
u8 arg_cnt;
struct bpf_subprog_arg_info args[MAX_BPF_FUNC_REG_ARGS];
ANDROID_KABI_RESERVE(1);
};
struct bpf_verifier_env;
@@ -784,6 +787,9 @@ struct bpf_verifier_env {
char tmp_str_buf[TMP_STR_BUF_LEN];
struct bpf_insn insn_buf[INSN_BUF_SIZE];
struct bpf_insn epilogue_buf[INSN_BUF_SIZE];
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
static inline struct bpf_func_info_aux *subprog_aux(struct bpf_verifier_env *env, int subprog)

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>
@@ -64,6 +65,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;

10
include/linux/coresight.h
View File

@@ -13,6 +13,7 @@
#include <linux/perf_event.h>
#include <linux/sched.h>
#include <linux/platform_device.h>
#include <linux/android_kabi.h>
/* Peripheral id registers (0xFD0-0xFEC) */
#define CORESIGHT_PERIPHIDR4 0xfd0
@@ -162,6 +163,7 @@ struct coresight_desc {
const struct attribute_group **groups;
const char *name;
struct csdev_access access;
ANDROID_KABI_RESERVE(1);
};
/**
@@ -202,6 +204,8 @@ struct coresight_connection {
struct coresight_device *src_dev;
atomic_t src_refcnt;
atomic_t dest_refcnt;
ANDROID_KABI_RESERVE(1);
};
/**
@@ -298,6 +302,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);
};
/*
@@ -356,6 +362,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);
};
/**
@@ -387,6 +394,7 @@ struct coresight_ops_source {
enum cs_mode mode, struct coresight_trace_id_map *id_map);
void (*disable)(struct coresight_device *csdev,
struct perf_event *event);
ANDROID_KABI_RESERVE(1);
};
/**
@@ -409,6 +417,8 @@ struct coresight_ops {
const struct coresight_ops_link *link_ops;
const struct coresight_ops_source *source_ops;
const struct coresight_ops_helper *helper_ops;
ANDROID_KABI_RESERVE(1);
};
static inline u32 csdev_access_relaxed_read32(struct csdev_access *csa,

5
include/linux/cpuidle.h
View File

@@ -15,6 +15,7 @@
#include <linux/list.h>
#include <linux/hrtimer.h>
#include <linux/context_tracking.h>
#include <linux/android_kabi.h>
#define CPUIDLE_STATE_MAX 10
#define CPUIDLE_NAME_LEN 16
@@ -111,6 +112,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);
@@ -165,6 +168,8 @@ struct cpuidle_driver {
/* preferred governor to switch at register time */
const char *governor;
ANDROID_KABI_RESERVE(1);
};
#ifdef CONFIG_CPU_IDLE

9
include/linux/dcache.h
View File

@@ -14,6 +14,7 @@
#include <linux/lockref.h>
#include <linux/stringhash.h>
#include <linux/wait.h>
#include <linux/android_kabi.h>
struct path;
struct file;
@@ -116,6 +117,9 @@ struct dentry {
struct hlist_bl_node d_in_lookup_hash; /* only for in-lookup ones */
struct rcu_head d_rcu;
} d_u;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
/*
@@ -151,6 +155,11 @@ struct dentry_operations {
int (*d_manage)(const struct path *, bool);
struct dentry *(*d_real)(struct dentry *, enum d_real_type type);
int (*d_canonical_path)(const struct path *, struct path *);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
} ____cacheline_aligned;
/*

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

@@ -14,6 +14,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;
@@ -216,6 +217,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;
};
@@ -418,6 +422,8 @@ struct dm_target {
* in the map method.
*/
bool mempool_needs_integrity:1;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
void *dm_per_bio_data(struct bio *bio, size_t data_size);

11
include/linux/device.h
View File

@@ -31,6 +31,7 @@
#include <linux/device/class.h>
#include <linux/device/driver.h>
#include <linux/cleanup.h>
#include <linux/android_kabi.h>
#include <asm/device.h>
struct device;
@@ -827,6 +828,14 @@ struct device {
#ifdef CONFIG_IOMMU_DMA
bool dma_iommu:1;
#endif
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
ANDROID_KABI_RESERVE(5);
ANDROID_KABI_RESERVE(6);
ANDROID_KABI_RESERVE(7);
ANDROID_KABI_RESERVE(8);
};
/**
@@ -855,6 +864,8 @@ struct device_link {
struct kref kref;
struct work_struct rm_work;
bool supplier_preactivated; /* Owned by consumer probe. */
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
#define kobj_to_dev(__kobj) container_of_const(__kobj, struct device, kobj)

6
include/linux/device/bus.h
View File

@@ -17,6 +17,7 @@
#include <linux/kobject.h>
#include <linux/klist.h>
#include <linux/pm.h>
#include <linux/android_kabi.h>
struct device_driver;
struct fwnode_handle;
@@ -102,6 +103,11 @@ struct bus_type {
const struct dev_pm_ops *pm;
bool need_parent_lock;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
int __must_check bus_register(const struct bus_type *bus);

6
include/linux/device/class.h
View File

@@ -18,6 +18,7 @@
#include <linux/klist.h>
#include <linux/pm.h>
#include <linux/device/bus.h>
#include <linux/android_kabi.h>
struct device;
struct fwnode_handle;
@@ -67,6 +68,11 @@ struct class {
void (*get_ownership)(const struct device *dev, kuid_t *uid, kgid_t *gid);
const struct dev_pm_ops *pm;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
struct class_dev_iter {

5
include/linux/device/driver.h
View File

@@ -119,6 +119,11 @@ struct device_driver {
void (*coredump) (struct device *dev);
struct driver_private *p;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};

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

@@ -23,6 +23,7 @@
#include <linux/dma-fence.h>
#include <linux/wait.h>
#include <linux/workqueue.h>
#include <linux/android_kabi.h>
struct device;
struct dma_buf;
@@ -357,6 +358,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);
};
/**
@@ -531,6 +535,9 @@ struct dma_buf {
struct dma_buf *dmabuf;
} *sysfs_entry;
#endif
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
/**
@@ -566,6 +573,8 @@ 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);
};
/**
@@ -603,6 +612,9 @@ struct dma_buf_attachment {
void *importer_priv;
void *priv;
unsigned long dma_map_attrs;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
/**
@@ -626,6 +638,9 @@ struct dma_buf_export_info {
int flags;
struct dma_resv *resv;
void *priv;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
#if IS_ENABLED(CONFIG_DEBUG_FS)

6
include/linux/dma-map-ops.h
View File

@@ -9,6 +9,7 @@
#include <linux/dma-mapping.h>
#include <linux/pgtable.h>
#include <linux/slab.h>
#include <linux/android_kabi.h>
struct cma;
struct iommu_ops;
@@ -68,6 +69,11 @@ struct dma_map_ops {
size_t (*max_mapping_size)(struct device *dev);
size_t (*opt_mapping_size)(void);
unsigned long (*get_merge_boundary)(struct device *dev);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
#ifdef CONFIG_ARCH_HAS_DMA_OPS

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

6
include/linux/ethtool.h
View File

@@ -17,6 +17,7 @@
#include <linux/compat.h>
#include <linux/if_ether.h>
#include <linux/netlink.h>
#include <linux/android_kabi.h>
#include <uapi/linux/ethtool.h>
#include <uapi/linux/net_tstamp.h>
@@ -1125,6 +1126,11 @@ struct ethtool_ops {
int (*set_mm)(struct net_device *dev, struct ethtool_mm_cfg *cfg,
struct netlink_ext_ack *extack);
void (*get_mm_stats)(struct net_device *dev, struct ethtool_mm_stats *stats);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
int ethtool_check_ops(const struct ethtool_ops *ops);

3
include/linux/fs.h
View File

@@ -1066,6 +1066,9 @@ struct file {
freeptr_t f_freeptr;
};
/* --- cacheline 3 boundary (192 bytes) --- */
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
} __randomize_layout
__attribute__((aligned(4))); /* lest something weird decides that 2 is OK */

6
include/linux/fscrypt.h
View File

@@ -17,6 +17,7 @@
#include <linux/mm.h>
#include <linux/slab.h>
#include <uapi/linux/fscrypt.h>
#include <linux/android_kabi.h>
/*
* The lengths of all file contents blocks must be divisible by this value.
@@ -191,6 +192,11 @@ struct fscrypt_operations {
struct block_device **(*get_devices)(struct super_block *sb,
unsigned int *num_devs);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
ANDROID_OEM_DATA_ARRAY(1, 4);
};

5
include/linux/fwnode.h
View File

@@ -13,6 +13,7 @@
#include <linux/err.h>
#include <linux/list.h>
#include <linux/types.h>
#include <linux/android_kabi.h>
enum dev_dma_attr {
DEV_DMA_NOT_SUPPORTED,
@@ -53,6 +54,7 @@ struct fwnode_handle {
struct list_head suppliers;
struct list_head consumers;
u8 flags;
ANDROID_KABI_RESERVE(1);
};
/*
@@ -70,6 +72,9 @@ struct fwnode_link {
struct fwnode_handle *consumer;
struct list_head c_hook;
u8 flags;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
};
/**

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

@@ -14,6 +14,7 @@
#include <linux/property.h>
#include <linux/spinlock_types.h>
#include <linux/types.h>
#include <linux/android_kabi.h>
#ifdef CONFIG_GENERIC_MSI_IRQ
#include <asm/msi.h>
@@ -317,6 +318,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);
};
/**
@@ -529,6 +533,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);
};
char *gpiochip_dup_line_label(struct gpio_chip *gc, unsigned int offset);

14
include/linux/hid.h
View File

@@ -27,6 +27,7 @@
#include <linux/power_supply.h>
#include <uapi/linux/hid.h>
#include <linux/hid_bpf.h>
#include <linux/android_kabi.h>
/*
* We parse each description item into this structure. Short items data
@@ -541,6 +542,7 @@ struct hid_report {
/* tool related state */
bool tool_active; /* whether the current tool is active */
unsigned int tool; /* BTN_TOOL_* */
ANDROID_KABI_RESERVE(1);
};
#define HID_MAX_IDS 256
@@ -585,6 +587,8 @@ struct hid_input {
struct list_head reports; /* the list of reports */
unsigned int application; /* application usage for this input */
bool registered;
ANDROID_KABI_RESERVE(1);
};
enum hid_type {
@@ -689,6 +693,9 @@ struct hid_device { /* device report descriptor */
#ifdef CONFIG_HID_BPF
struct hid_bpf bpf; /* hid-bpf data */
#endif /* CONFIG_HID_BPF */
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
void hiddev_free(struct kref *ref);
@@ -723,6 +730,7 @@ struct hid_parser {
unsigned int collection_stack_size;
struct hid_device *device;
unsigned int scan_flags;
ANDROID_KABI_RESERVE(1);
};
struct hid_class_descriptor {
@@ -844,6 +852,9 @@ struct hid_driver {
int (*resume)(struct hid_device *hdev);
int (*reset_resume)(struct hid_device *hdev);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
/* private: */
struct device_driver driver;
};
@@ -894,6 +905,9 @@ struct hid_ll_driver {
bool (*may_wakeup)(struct hid_device *hdev);
unsigned int max_buffer_size;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
extern bool hid_is_usb(const struct hid_device *hdev);

1
include/linux/hrtimer.h
View File

@@ -19,6 +19,7 @@
#include <linux/percpu-defs.h>
#include <linux/rbtree.h>
#include <linux/timer.h>
#include <linux/android_kabi.h>
/*
* Mode arguments of xxx_hrtimer functions:

11
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)
@@ -329,6 +335,8 @@ struct input_handler {
struct list_head h_list;
struct list_head node;
ANDROID_KABI_RESERVE(1);
};
/**
@@ -363,6 +371,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);
@@ -571,6 +581,7 @@ struct ff_device {
int max_effects;
struct ff_effect *effects;
ANDROID_KABI_RESERVE(1);
struct file *effect_owners[] __counted_by(max_effects);
};

6
include/linux/iomap.h
View File

@@ -9,6 +9,7 @@
#include <linux/types.h>
#include <linux/mm_types.h>
#include <linux/blkdev.h>
#include <linux/android_kabi.h>
struct address_space;
struct fiemap_extent_info;
@@ -103,6 +104,8 @@ struct iomap {
void *private; /* filesystem private */
const struct iomap_folio_ops *folio_ops;
u64 validity_cookie; /* used with .iomap_valid() */
ANDROID_KABI_RESERVE(1);
};
static inline sector_t iomap_sector(const struct iomap *iomap, loff_t pos)
@@ -197,6 +200,9 @@ struct iomap_ops {
*/
int (*iomap_end)(struct inode *inode, loff_t pos, loff_t length,
ssize_t written, unsigned flags, struct iomap *iomap);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
/**

6
include/linux/ioport.h
View File

@@ -14,6 +14,7 @@
#include <linux/compiler.h>
#include <linux/minmax.h>
#include <linux/types.h>
#include <linux/android_kabi.h>
/*
* Resources are tree-like, allowing
* nesting etc..
@@ -25,6 +26,11 @@ struct resource {
unsigned long flags;
unsigned long desc;
struct resource *parent, *sibling, *child;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
/*

6
include/linux/ipv6.h
View File

@@ -4,6 +4,7 @@
#include <uapi/linux/ipv6.h>
#include <linux/cache.h>
#include <linux/android_kabi.h>
#define ipv6_optlen(p) (((p)->hdrlen+1) << 3)
#define ipv6_authlen(p) (((p)->hdrlen+2) << 2)
@@ -93,6 +94,11 @@ struct ipv6_devconf {
__u8 ra_honor_pio_pflag;
struct ctl_table_header *sysctl_header;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
struct ipv6_params {

6
include/linux/irqdomain.h
View File

@@ -36,6 +36,7 @@
#include <linux/of.h>
#include <linux/mutex.h>
#include <linux/radix-tree.h>
#include <linux/android_kabi.h>
struct device_node;
struct fwnode_handle;
@@ -190,6 +191,11 @@ struct irq_domain {
#endif
void (*exit)(struct irq_domain *d);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
/* reverse map data. The linear map gets appended to the irq_domain */
irq_hw_number_t hwirq_max;
unsigned int revmap_size;

12
include/linux/kernfs.h
View File

@@ -19,6 +19,7 @@
#include <linux/wait.h>
#include <linux/rwsem.h>
#include <linux/cache.h>
#include <linux/android_kabi.h>
struct file;
struct dentry;
@@ -225,6 +226,7 @@ struct kernfs_node {
struct kernfs_iattrs *iattr;
struct rcu_head rcu;
ANDROID_KABI_RESERVE(1);
};
/*
@@ -244,6 +246,11 @@ struct kernfs_syscall_ops {
const char *new_name);
int (*show_path)(struct seq_file *sf, struct kernfs_node *kn,
struct kernfs_root *root);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
struct kernfs_node *kernfs_root_to_node(struct kernfs_root *root);
@@ -266,6 +273,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 {
@@ -319,6 +328,9 @@ struct kernfs_ops {
int (*mmap)(struct kernfs_open_file *of, struct vm_area_struct *vma);
loff_t (*llseek)(struct kernfs_open_file *of, loff_t offset, int whence);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
/*

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

16
include/linux/kobject.h
View File

@@ -27,6 +27,7 @@
#include <linux/atomic.h>
#include <linux/workqueue.h>
#include <linux/uidgid.h>
#include <linux/android_kabi.h>
#define UEVENT_HELPER_PATH_LEN 256
#define UEVENT_NUM_ENVP 64 /* number of env pointers */
@@ -79,6 +80,11 @@ struct kobject {
#ifdef CONFIG_DEBUG_KOBJECT_RELEASE
struct delayed_work release;
#endif
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
__printf(2, 3) int kobject_set_name(struct kobject *kobj, const char *name, ...);
@@ -120,6 +126,11 @@ struct kobj_type {
const struct kobj_ns_type_operations *(*child_ns_type)(const struct kobject *kobj);
const void *(*namespace)(const struct kobject *kobj);
void (*get_ownership)(const struct kobject *kobj, kuid_t *uid, kgid_t *gid);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
struct kobj_uevent_env {
@@ -170,6 +181,11 @@ struct kset {
spinlock_t list_lock;
struct kobject kobj;
const struct kset_uevent_ops *uevent_ops;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
} __randomize_layout;
void kset_init(struct kset *kset);

6
include/linux/mm.h
View File

@@ -33,6 +33,7 @@
#include <linux/memremap.h>
#include <linux/slab.h>
#include <linux/rcuwait.h>
#include <linux/android_kabi.h>
struct mempolicy;
struct anon_vma;
@@ -667,6 +668,11 @@ struct vm_operations_struct {
*/
struct page *(*find_special_page)(struct vm_area_struct *vma,
unsigned long addr);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
#ifdef CONFIG_NUMA_BALANCING

8
include/linux/mm_types.h
View File

@@ -20,6 +20,7 @@
#include <linux/seqlock.h>
#include <linux/percpu_counter.h>
#include <linux/types.h>
#include <linux/android_kabi.h>
#include <asm/mmu.h>
@@ -804,6 +805,11 @@ struct vm_area_struct {
struct anon_vma_name *anon_name;
#endif
struct vm_userfaultfd_ctx vm_userfaultfd_ctx;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
} __randomize_layout;
#ifdef CONFIG_NUMA
@@ -1068,6 +1074,8 @@ struct mm_struct {
#endif
} lru_gen;
#endif /* CONFIG_LRU_GEN_WALKS_MMU */
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;
@@ -257,6 +258,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);
};
/*
@@ -341,6 +344,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

@@ -17,6 +17,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 */
@@ -219,6 +220,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 {
@@ -263,6 +267,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);
};
/**
@@ -506,6 +513,10 @@ struct mmc_host {
int hsq_depth;
u32 err_stats[MMC_ERR_MAX];
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
unsigned long private[] ____cacheline_aligned;
};

9
include/linux/mmu_notifier.h
View File

@@ -8,6 +8,7 @@
#include <linux/mmap_lock.h>
#include <linux/srcu.h>
#include <linux/interval_tree.h>
#include <linux/android_kabi.h>
struct mmu_notifier_subscriptions;
struct mmu_notifier;
@@ -212,6 +213,11 @@ struct mmu_notifier_ops {
*/
struct mmu_notifier *(*alloc_notifier)(struct mm_struct *mm);
void (*free_notifier)(struct mmu_notifier *subscription);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
/*
@@ -231,6 +237,9 @@ struct mmu_notifier {
struct mm_struct *mm;
struct rcu_head rcu;
unsigned int users;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
/**

9
include/linux/mmzone.h
View File

@@ -23,6 +23,7 @@
#include <linux/page-flags.h>
#include <linux/local_lock.h>
#include <linux/zswap.h>
#include <linux/android_kabi.h>
#include <asm/page.h>
/* Free memory management - zoned buddy allocator. */
@@ -481,6 +482,8 @@ struct lru_gen_folio {
/* per-node lru_gen_folio list for global reclaim */
struct hlist_nulls_node list;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_OEM_DATA_ARRAY(1, 6);
};
@@ -506,6 +509,8 @@ struct lru_gen_mm_state {
unsigned long *filters[NR_BLOOM_FILTERS];
/* the mm stats for debugging */
unsigned long stats[NR_HIST_GENS][NR_MM_STATS];
ANDROID_KABI_RESERVE(1);
};
struct lru_gen_mm_walk {
@@ -523,6 +528,8 @@ struct lru_gen_mm_walk {
int batched;
int swappiness;
bool force_scan;
ANDROID_KABI_RESERVE(1);
};
/*
@@ -1463,6 +1470,8 @@ typedef struct pglist_data {
#ifdef CONFIG_MEMORY_FAILURE
struct memory_failure_stats mf_stats;
#endif
ANDROID_KABI_RESERVE(1);
} pg_data_t;
#define node_present_pages(nid) (NODE_DATA(nid)->node_present_pages)

6
include/linux/module.h
View File

@@ -28,6 +28,7 @@
#include <linux/srcu.h>
#include <linux/static_call_types.h>
#include <linux/dynamic_debug.h>
#include <linux/android_kabi.h>
#include <linux/percpu.h>
#include <asm/module.h>
@@ -596,6 +597,11 @@ struct module {
#ifdef CONFIG_DYNAMIC_DEBUG_CORE
struct _ddebug_info dyndbg_info;
#endif
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
} ____cacheline_aligned __randomize_layout;
#ifndef MODULE_ARCH_INIT
#define MODULE_ARCH_INIT {}

6
include/linux/mount.h
View File

@@ -11,6 +11,7 @@
#define _LINUX_MOUNT_H
#include <linux/types.h>
#include <linux/android_kabi.h>
#include <asm/barrier.h>
struct super_block;
@@ -70,6 +71,11 @@ struct vfsmount {
struct super_block *mnt_sb; /* pointer to superblock */
int mnt_flags;
struct mnt_idmap *mnt_idmap;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
} __randomize_layout;
static inline struct mnt_idmap *mnt_idmap(const struct vfsmount *mnt)

6
include/linux/net.h
View File

@@ -23,6 +23,7 @@
#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/sockptr.h>
#include <linux/android_kabi.h>
#include <uapi/linux/net.h>
@@ -225,6 +226,11 @@ struct proto_ops {
int (*sendmsg_locked)(struct sock *sk, struct msghdr *msg,
size_t size);
int (*set_rcvlowat)(struct sock *sk, int val);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
#define DECLARE_SOCKADDR(type, dst, src) \

41
include/linux/netdevice.h
View File

@@ -52,6 +52,7 @@
#include <net/net_trackers.h>
#include <net/net_debug.h>
#include <net/dropreason-core.h>
#include <linux/android_kabi.h>
struct netpoll_info;
struct device;
@@ -315,6 +316,9 @@ struct header_ops {
const unsigned char *haddr);
bool (*validate)(const char *ll_header, unsigned int len);
__be16 (*parse_protocol)(const struct sk_buff *skb);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
/* These flag bits are private to the generic network queueing
@@ -377,6 +381,11 @@ struct napi_struct {
struct list_head dev_list;
struct hlist_node napi_hash_node;
int irq;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
enum {
@@ -684,6 +693,11 @@ struct netdev_queue {
#if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
int numa_node;
#endif
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
} ____cacheline_aligned_in_smp;
extern int sysctl_fb_tunnels_only_for_init_net;
@@ -989,6 +1003,11 @@ struct xfrmdev_ops {
int (*xdo_dev_policy_add) (struct xfrm_policy *x, struct netlink_ext_ack *extack);
void (*xdo_dev_policy_delete) (struct xfrm_policy *x);
void (*xdo_dev_policy_free) (struct xfrm_policy *x);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
#endif
@@ -1603,6 +1622,14 @@ struct net_device_ops {
int (*ndo_hwtstamp_set)(struct net_device *dev,
struct kernel_hwtstamp_config *kernel_config,
struct netlink_ext_ack *extack);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
ANDROID_KABI_RESERVE(5);
ANDROID_KABI_RESERVE(6);
ANDROID_KABI_RESERVE(7);
ANDROID_KABI_RESERVE(8);
};
/**
@@ -2397,6 +2424,15 @@ struct net_device {
/** @irq_moder: dim parameters used if IS_ENABLED(CONFIG_DIMLIB). */
struct dim_irq_moder *irq_moder;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
ANDROID_KABI_RESERVE(5);
ANDROID_KABI_RESERVE(6);
ANDROID_KABI_RESERVE(7);
ANDROID_KABI_RESERVE(8);
u8 priv[] ____cacheline_aligned
__counted_by(priv_len);
} ____cacheline_aligned;
@@ -2708,6 +2744,11 @@ struct packet_type {
struct net *af_packet_net;
void *af_packet_priv;
struct list_head list;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
struct offload_callbacks {

7
include/linux/netfilter.h
View File

@@ -15,6 +15,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)
@@ -189,6 +190,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. */
@@ -382,6 +385,8 @@ struct nf_nat_hook {
const struct nlattr *attr);
void (*decode_session)(struct sk_buff *skb, struct flowi *fl);
void (*remove_nat_bysrc)(struct nf_conn *ct);
ANDROID_KABI_RESERVE(1);
};
extern const struct nf_nat_hook __rcu *nf_nat_hook;
@@ -485,6 +490,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>
@@ -190,6 +191,8 @@ struct ip_set_type_variant {
void (*cancel_gc)(struct ip_set *set);
/* Region-locking is used */
bool region_lock;
ANDROID_KABI_RESERVE(1);
};
struct ip_set_region {
@@ -236,6 +239,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 */
@@ -280,6 +285,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 {
@@ -46,6 +49,8 @@ struct nfnetlink_subsystem {
int (*abort)(struct net *net, struct sk_buff *skb,
enum nfnl_abort_action action);
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

24
include/linux/pci.h
View File

@@ -42,6 +42,7 @@
#include <uapi/linux/pci.h>
#include <linux/pci_ids.h>
#include <linux/android_kabi.h>
#define PCI_STATUS_ERROR_BITS (PCI_STATUS_DETECTED_PARITY | \
PCI_STATUS_SIG_SYSTEM_ERROR | \
@@ -535,6 +536,11 @@ struct pci_dev {
/* These methods index pci_reset_fn_methods[] */
u8 reset_methods[PCI_NUM_RESET_METHODS]; /* In priority order */
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
static inline struct pci_dev *pci_physfn(struct pci_dev *dev)
@@ -600,6 +606,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;
};
@@ -684,6 +694,11 @@ struct pci_bus {
struct bin_attribute *legacy_mem; /* Legacy mem */
unsigned int is_added:1;
unsigned int unsafe_warn:1; /* warned about RW1C config write */
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
#define to_pci_bus(n) container_of(n, struct pci_bus, dev)
@@ -807,6 +822,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);
};
/*
@@ -885,6 +902,8 @@ struct pci_error_handlers {
/* Allow device driver to record more details of a correctable error */
void (*cor_error_detected)(struct pci_dev *dev);
ANDROID_KABI_RESERVE(1);
};
@@ -962,6 +981,11 @@ struct pci_driver {
struct device_driver driver;
struct pci_dynids dynids;
bool driver_managed_dma;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
#define to_pci_driver(__drv) \

9
include/linux/phy.h
View File

@@ -28,6 +28,7 @@
#include <linux/irqreturn.h>
#include <linux/iopoll.h>
#include <linux/refcount.h>
#include <linux/android_kabi.h>
#include <linux/atomic.h>
#include <net/eee.h>
@@ -786,6 +787,11 @@ struct phy_device {
/* MACsec management functions */
const struct macsec_ops *macsec_ops;
#endif
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
/* Generic phy_device::dev_flags */
@@ -1219,6 +1225,9 @@ struct phy_driver {
*/
int (*led_polarity_set)(struct phy_device *dev, int index,
unsigned long modes);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
#define to_phy_driver(d) container_of_const(to_mdio_common_driver(d), \
struct phy_driver, mdiodrv)

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)
@@ -132,6 +136,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);
@@ -260,6 +266,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) \
@@ -721,6 +724,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);
@@ -749,6 +755,8 @@ struct dev_pm_domain {
void (*sync)(struct device *dev);
void (*dismiss)(struct device *dev);
int (*set_performance_state)(struct device *dev, unsigned int state);
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 {
@@ -320,6 +325,8 @@ struct power_supply {
struct led_trigger *charging_blink_full_solid_trig;
struct led_trigger *charging_orange_full_green_trig;
#endif
ANDROID_KABI_RESERVE(1);
};
/*
@@ -339,6 +346,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 {
@@ -766,6 +774,7 @@ struct power_supply_battery_info {
int vbat2ri_charging_size;
int bti_resistance_ohm;
int bti_resistance_tolerance;
ANDROID_KABI_RESERVE(1);
};
extern int power_supply_reg_notifier(struct notifier_block *nb);

5
include/linux/pwm.h
View File

@@ -7,6 +7,7 @@
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/of.h>
#include <linux/android_kabi.h>
MODULE_IMPORT_NS(PWM);
@@ -87,6 +88,8 @@ struct pwm_device {
struct pwm_args args;
struct pwm_state state;
struct pwm_state last;
ANDROID_KABI_RESERVE(1);
};
/**
@@ -263,6 +266,7 @@ struct pwm_ops {
const struct pwm_state *state);
int (*get_state)(struct pwm_chip *chip, struct pwm_device *pwm,
struct pwm_state *state);
ANDROID_KABI_RESERVE(1);
};
/**
@@ -290,6 +294,7 @@ struct pwm_chip {
/* only used internally by the PWM framework */
bool uses_pwmchip_alloc;
ANDROID_KABI_RESERVE(1);
struct pwm_device pwms[] __counted_by(npwm);
};

9
include/linux/quota.h
View File

@@ -318,6 +318,9 @@ struct quota_format_ops {
int (*commit_dqblk)(struct dquot *dquot); /* Write structure for one user */
int (*release_dqblk)(struct dquot *dquot); /* Called when last reference to dquot is being dropped */
int (*get_next_id)(struct super_block *sb, struct kqid *qid); /* Get next ID with existing structure in the quota file */
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
/* Operations working with dquots */
@@ -337,6 +340,9 @@ struct dquot_operations {
int (*get_inode_usage) (struct inode *, qsize_t *);
/* Get next ID with active quota structure */
int (*get_next_id) (struct super_block *sb, struct kqid *qid);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
struct path;
@@ -440,6 +446,9 @@ struct quotactl_ops {
int (*set_dqblk)(struct super_block *, struct kqid, struct qc_dqblk *);
int (*get_state)(struct super_block *, struct qc_state *);
int (*rm_xquota)(struct super_block *, unsigned int);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
struct quota_format_type {

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;
@@ -460,6 +461,8 @@ struct regmap_config {
const struct regmap_range_cfg *ranges;
unsigned int num_ranges;
ANDROID_KABI_RESERVE(1);
};
/**
@@ -497,6 +500,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;
@@ -583,6 +588,8 @@ struct regmap_bus {
enum regmap_endian val_format_endian_default;
size_t max_raw_read;
size_t max_raw_write;
ANDROID_KABI_RESERVE(1);
};
/*

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;
@@ -236,6 +237,8 @@ struct regulator_ops {
int (*resume)(struct regulator_dev *rdev);
int (*set_pull_down) (struct regulator_dev *);
ANDROID_KABI_RESERVE(1);
};
/*
@@ -430,6 +433,8 @@ struct regulator_desc {
unsigned int poll_enabled_time;
unsigned int (*of_map_mode)(unsigned int mode);
ANDROID_KABI_RESERVE(1);
};
/**
@@ -649,6 +654,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;
@@ -161,6 +164,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)

19
include/linux/sched.h
View File

@@ -48,6 +48,7 @@
#include <linux/livepatch_sched.h>
#include <linux/uidgid_types.h>
#include <linux/android_vendor.h>
#include <linux/android_kabi.h>
#include <asm/kmap_size.h>
/* task_struct member predeclarations (sorted alphabetically): */
@@ -586,6 +587,11 @@ struct sched_entity {
*/
struct sched_avg avg;
#endif
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
struct sched_rt_entity {
@@ -604,6 +610,11 @@ struct sched_rt_entity {
/* rq "owned" by this entity/group: */
struct rt_rq *my_q;
#endif
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
} __randomize_layout;
typedef bool (*dl_server_has_tasks_f)(struct sched_dl_entity *);
@@ -1610,6 +1621,14 @@ struct task_struct {
*/
struct callback_head l1d_flush_kill;
#endif
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
ANDROID_KABI_RESERVE(5);
ANDROID_KABI_RESERVE(6);
ANDROID_KABI_RESERVE(7);
ANDROID_KABI_RESERVE(8);
#ifdef CONFIG_RV
/*

5
include/linux/sched/signal.h
View File

@@ -13,6 +13,7 @@
#include <linux/posix-timers.h>
#include <linux/mm_types.h>
#include <asm/ptrace.h>
#include <linux/android_kabi.h>
/*
* Types defining task->signal and task->sighand and APIs using them:
@@ -246,6 +247,10 @@ struct signal_struct {
* and may have inconsistent
* permissions.
*/
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
ANDROID_OEM_DATA(1);
} __randomize_layout;

5
include/linux/sched/topology.h
View File

@@ -3,6 +3,7 @@
#define _LINUX_SCHED_TOPOLOGY_H
#include <linux/topology.h>
#include <linux/android_kabi.h>
#include <linux/sched/idle.h>
@@ -150,6 +151,10 @@ struct sched_domain {
struct sched_domain_shared *shared;
unsigned int span_weight;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
/*
* Span of all CPUs in this domain.
*

4
include/linux/sched/user.h
View File

@@ -7,6 +7,7 @@
#include <linux/percpu_counter.h>
#include <linux/refcount.h>
#include <linux/ratelimit.h>
#include <linux/android_kabi.h>
/*
* Some day this will be a full-fledged user tracking system..
@@ -34,6 +35,9 @@ struct user_struct {
/* Miscellaneous per-user rate limit */
struct ratelimit_state ratelimit;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
extern int uids_sysfs_init(void);

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
@@ -122,6 +123,8 @@ struct scmi_clk_proto_ops {
u32 oem_val, bool atomic);
int (*parent_get)(const struct scmi_protocol_handle *ph, u32 clk_id, u32 *parent_id);
int (*parent_set)(const struct scmi_protocol_handle *ph, u32 clk_id, u32 parent_id);
ANDROID_KABI_RESERVE(1);
};
struct scmi_perf_domain_info {
@@ -185,6 +188,8 @@ struct scmi_perf_proto_ops {
int (*fast_switch_rate_limit)(const struct scmi_protocol_handle *ph,
u32 domain, u32 *rate_limit);
enum scmi_power_scale (*power_scale_get)(const struct scmi_protocol_handle *ph);
ANDROID_KABI_RESERVE(1);
};
/**
@@ -211,6 +216,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);
};
/**
@@ -387,6 +394,8 @@ struct scmi_sensor_info {
unsigned int resolution;
int exponent;
struct scmi_range_attrs scalar_attrs;
ANDROID_KABI_RESERVE(1);
};
/*
@@ -522,6 +531,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);
};
/**
@@ -543,6 +554,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 {
@@ -913,6 +926,8 @@ struct scmi_handle {
unsigned int *atomic_threshold);
const struct scmi_notify_ops *notify_ops;
ANDROID_KABI_RESERVE(1);
};
enum scmi_std_protocol {
@@ -943,6 +958,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_const(d, struct scmi_device, dev)

9
include/linux/serial_core.h
View File

@@ -18,6 +18,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
@@ -404,6 +405,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
@@ -590,6 +594,9 @@ struct uart_port {
struct gpio_desc *rs485_rx_during_tx_gpio; /* Output GPIO that sets the state of RS485 RX during TX */
struct serial_iso7816 iso7816;
void *private_data; /* generic platform data pointer */
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
/*
@@ -881,6 +888,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

@@ -14,6 +14,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 const struct bus_type serio_bus;
@@ -62,6 +63,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)
@@ -80,6 +83,8 @@ struct serio_driver {
void (*cleanup)(struct serio *);
struct device_driver driver;
ANDROID_KABI_RESERVE(1);
};
#define to_serio_driver(d) container_of_const(d, struct serio_driver, driver)

6
include/linux/skbuff.h
View File

@@ -39,6 +39,7 @@
#include <net/dropreason-core.h>
#include <net/netmem.h>
#include <linux/android_vendor.h>
#include <linux/android_kabi.h>
/**
* DOC: skb checksums
@@ -614,6 +615,8 @@ struct skb_shared_info {
* remains valid until skb destructor */
void * destructor_arg;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_OEM_DATA_ARRAY(1, 3);
/* must be last field, see pskb_expand_head() */
@@ -1070,6 +1073,9 @@ struct sk_buff {
u64 kcov_handle;
#endif
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
); /* end headers group */
/* These elements must be at the end, see alloc_skb() for details. */

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

@@ -17,6 +17,7 @@
#include <linux/scatterlist.h>
#include <linux/slab.h>
#include <linux/u64_stats_sync.h>
#include <linux/android_kabi.h>
#include <uapi/linux/spi/spi.h>
@@ -232,6 +233,8 @@ struct spi_device {
* then more than one bit need to be set in cs_index_mask.
*/
u32 cs_index_mask : SPI_CS_CNT_MAX;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
/*
* Likely need more hooks for more protocol options affecting how
@@ -349,6 +352,8 @@ struct spi_driver {
void (*remove)(struct spi_device *spi);
void (*shutdown)(struct spi_device *spi);
struct device_driver driver;
ANDROID_KABI_RESERVE(1);
};
#define to_spi_driver(__drv) \
@@ -772,6 +777,9 @@ struct spi_controller {
bool queue_empty;
bool must_async;
bool defer_optimize_message;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
static inline void *spi_controller_get_devdata(struct spi_controller *ctlr)
@@ -1119,6 +1127,8 @@ struct spi_transfer {
struct ptp_system_timestamp *ptp_sts;
struct list_head transfer_list;
ANDROID_KABI_RESERVE(1);
};
/**
@@ -1200,6 +1210,8 @@ struct spi_message {
/* List of spi_res resources 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)
@@ -1648,6 +1660,8 @@ struct spi_board_info {
* needed to behave without being bound to a driver:
* - quirks like clock rate mattering when not selected
*/
ANDROID_KABI_RESERVE(1);
};
#ifdef CONFIG_SPI

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)
@@ -142,6 +144,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

2
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>
@@ -502,6 +503,7 @@ struct tcp_sock {
struct request_sock __rcu *fastopen_rsk;
struct saved_syn *saved_syn;
ANDROID_KABI_RESERVE(1);
ANDROID_OEM_DATA(1);
};

9
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 */
@@ -109,6 +110,8 @@ struct thermal_zone_device_ops {
const struct thermal_trip *, enum thermal_trend *);
void (*hot)(struct thermal_zone_device *);
void (*critical)(struct thermal_zone_device *);
ANDROID_KABI_RESERVE(1);
};
struct thermal_cooling_device_ops {
@@ -118,6 +121,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 {
@@ -136,6 +141,8 @@ struct thermal_cooling_device {
#ifdef CONFIG_THERMAL_DEBUGFS
struct thermal_debugfs *debugfs;
#endif
ANDROID_KABI_RESERVE(1);
};
/* Structure to define Thermal Zone parameters */
@@ -186,6 +193,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

@@ -14,6 +14,7 @@
#include <uapi/linux/tty.h>
#include <linux/rwsem.h>
#include <linux/llist.h>
#include <linux/android_kabi.h>
/*
@@ -241,6 +242,9 @@ struct tty_struct {
#define N_TTY_BUF_SIZE 4096
struct work_struct SAK_work;
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;
@@ -398,6 +399,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;
/**
@@ -468,6 +472,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
@@ -264,6 +265,9 @@ struct tty_ldisc_ops {
const u8 *fp, size_t 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 {
@@ -121,6 +124,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;
@@ -84,6 +85,8 @@ struct uio_device {
struct mutex info_lock;
struct kobject *map_dir;
struct kobject *portio_dir;
ANDROID_KABI_RESERVE(1);
};
/**
@@ -116,6 +119,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

32
include/linux/usb.h
View File

@@ -22,6 +22,7 @@
#include <linux/sched.h> /* for current && schedule_timeout */
#include <linux/mutex.h> /* for struct mutex */
#include <linux/pm_runtime.h> /* for runtime PM */
#include <linux/android_kabi.h>
struct usb_device;
struct usb_driver;
@@ -268,6 +269,11 @@ struct usb_interface {
struct device dev; /* interface specific device info */
struct device *usb_dev;
struct work_struct reset_ws; /* for resets in atomic context */
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
#define to_usb_interface(__dev) container_of_const(__dev, struct usb_interface, dev)
@@ -429,6 +435,11 @@ struct usb_host_bos {
struct usb_ssp_cap_descriptor *ssp_cap;
struct usb_ss_container_id_descriptor *ss_id;
struct usb_ptm_cap_descriptor *ptm_cap;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
int __usb_get_extra_descriptor(char *buffer, unsigned size,
@@ -487,6 +498,11 @@ struct usb_bus {
struct mon_bus *mon_bus; /* non-null when associated */
int monitored; /* non-zero when monitored */
#endif
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
struct usb_dev_state;
@@ -731,6 +747,11 @@ struct usb_device {
u16 hub_delay;
unsigned use_generic_driver:1;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
#define to_usb_device(__dev) container_of_const(__dev, struct usb_device, dev)
@@ -1242,6 +1263,11 @@ struct usb_driver {
unsigned int supports_autosuspend:1;
unsigned int disable_hub_initiated_lpm:1;
unsigned int soft_unbind:1;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
#define to_usb_driver(d) container_of(d, struct usb_driver, driver)
@@ -1631,6 +1657,12 @@ struct urb {
int error_count; /* (return) number of ISO errors */
void *context; /* (in) context for completion */
usb_complete_t complete; /* (in) completion routine */
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
struct usb_iso_packet_descriptor iso_frame_desc[];
/* (in) ISO ONLY */
};

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

@@ -123,6 +123,8 @@ struct usb_request {
int status;
unsigned actual;
ANDROID_KABI_RESERVE(1);
};
/*-------------------------------------------------------------------------*/
@@ -153,6 +155,8 @@ struct usb_ep_ops {
int (*fifo_status) (struct usb_ep *ep);
void (*fifo_flush) (struct usb_ep *ep);
ANDROID_KABI_RESERVE(1);
};
/**
@@ -241,6 +245,8 @@ struct usb_ep {
u16 maxpacket;
u16 maxpacket_limit;
u16 max_streams;
ANDROID_KABI_RESERVE(1);
};
/*-------------------------------------------------------------------------*/
@@ -333,6 +339,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);
};
/**

16
include/linux/usb/hcd.h
View File

@@ -11,6 +11,7 @@
#include <linux/rwsem.h>
#include <linux/interrupt.h>
#include <linux/idr.h>
#include <linux/android_kabi.h>
#define MAX_TOPO_LEVEL 6
@@ -213,6 +214,11 @@ struct usb_hcd {
* (ohci 32, uhci 1024, ehci 256/512/1024).
*/
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
/* The HC driver's private data is stored at the end of
* this structure.
*/
@@ -404,6 +410,11 @@ struct hc_driver {
#define EHSET_TEST_SINGLE_STEP_SET_FEATURE 0x06
int (*submit_single_step_set_feature)(struct usb_hcd *,
struct urb *, int);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
static inline int hcd_giveback_urb_in_bh(struct usb_hcd *hcd)
@@ -582,6 +593,11 @@ struct usb_tt {
spinlock_t lock;
struct list_head clear_list; /* of usb_tt_clear */
struct work_struct clear_work;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
struct usb_tt_clear {

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

6
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,11 @@ struct usb_phy {
* manually detect the charger type.
*/
enum usb_charger_type (*charger_detect)(struct usb_phy *x);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
/* 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 */
@@ -250,6 +251,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 {
@@ -290,6 +294,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

@@ -32,6 +32,7 @@ struct typec_altmode {
char *desc;
const struct typec_altmode_ops *ops;
const struct typec_cable_ops *cable_ops;
ANDROID_KABI_RESERVE(1);
};
#define to_typec_altmode(d) container_of(d, struct typec_altmode, dev)
@@ -65,6 +66,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);

9
include/linux/usb/usbnet.h
View File

@@ -14,6 +14,7 @@
#include <linux/skbuff.h>
#include <linux/types.h>
#include <linux/usb.h>
#include <linux/android_kabi.h>
/* interface from usbnet core to each USB networking link we handle */
struct usbnet {
@@ -81,6 +82,11 @@ struct usbnet {
* that must be broken
*/
# define EVENT_UNPLUG 31
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
static inline bool usbnet_going_away(struct usbnet *ubn)
@@ -180,6 +186,9 @@ struct driver_info {
int out; /* tx endpoint */
unsigned long data; /* Misc driver specific data */
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
/* Minidrivers are just drivers using the "usbnet" core as a powerful

3
include/linux/user_namespace.h
View File

@@ -10,6 +10,7 @@
#include <linux/rwsem.h>
#include <linux/sysctl.h>
#include <linux/err.h>
#include <linux/android_kabi.h>
#define UID_GID_MAP_MAX_BASE_EXTENTS 5
#define UID_GID_MAP_MAX_EXTENTS 340
@@ -112,6 +113,8 @@ struct user_namespace {
#if IS_ENABLED(CONFIG_BINFMT_MISC)
struct binfmt_misc *binfmt_misc;
#endif
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
} __randomize_layout;
struct ucounts {

4
include/linux/workqueue.h
View File

@@ -15,6 +15,7 @@
#include <linux/cpumask_types.h>
#include <linux/rcupdate.h>
#include <linux/workqueue_types.h>
#include <linux/android_kabi.h>
/*
* The first word is the work queue pointer and the flags rolled into
@@ -117,6 +118,9 @@ struct delayed_work {
/* target workqueue and CPU ->timer uses to queue ->work */
struct workqueue_struct *wq;
int cpu;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
struct rcu_work {

7
include/linux/wwan.h
View File

@@ -7,6 +7,7 @@
#include <linux/poll.h>
#include <linux/netdevice.h>
#include <linux/types.h>
#include <linux/android_kabi.h>
/**
* enum wwan_port_type - WWAN port types
@@ -64,6 +65,9 @@ struct wwan_port_ops {
int (*tx_blocking)(struct wwan_port *port, struct sk_buff *skb);
__poll_t (*tx_poll)(struct wwan_port *port, struct file *filp,
poll_table *wait);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
/** struct wwan_port_caps - The WWAN port capbilities
@@ -180,6 +184,9 @@ struct wwan_ops {
u32 if_id, struct netlink_ext_ack *extack);
void (*dellink)(void *ctxt, struct net_device *dev,
struct list_head *head);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
int wwan_register_ops(struct device *parent, const struct wwan_ops *ops,

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 */
@@ -93,6 +94,9 @@ union v4l2_ctrl_ptr {
struct v4l2_rect *p_rect;
void *p;
const void *p_const;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
/**
@@ -125,6 +129,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);
};
/**
@@ -150,6 +156,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);
};
/**
@@ -322,6 +330,8 @@ struct v4l2_ctrl {
union v4l2_ctrl_ptr p_max;
union v4l2_ctrl_ptr p_new;
union v4l2_ctrl_ptr p_cur;
ANDROID_KABI_RESERVE(1);
};
/**
@@ -374,6 +384,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);
};
/**
@@ -424,6 +436,8 @@ struct v4l2_ctrl_handler {
struct list_head requests;
struct list_head requests_queued;
struct media_request_object req_obj;
ANDROID_KABI_RESERVE(1);
};
/**
@@ -479,6 +493,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);
};
/**

Some files were not shown because too many files have changed in this diff Show More