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

ANDROID: add kabi padding for structures for the android12 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.4.0..5.4.129 release (1 1/2 years).  Yes, past changes do not mean
that future changes will also be needed in the same area, but that is a
hint that those areas are both well maintained and looked after, and
there have been previous problems found in them.

Also the list of structures that are being required based on OEM usage
in the android/ symbol lists were consulted as that's a larger list than
what has been changed in the past.

Hopefully we caught everything we need to worry about, only time will
tell...

Bug: 151154716
Signed-off-by: Greg Kroah-Hartman <gregkh@google.com>
Change-Id: I880bbcda0628a7459988eeb49d18655522697664
This commit is contained in:
Greg Kroah-Hartman 2021-07-02 15:58:26 +02:00 committed by Todd Kjos
parent 429c78f9b0
commit 37485a3025
84 changed files with 606 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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>
@ -605,6 +606,8 @@ struct sdhci_host {
u64 data_timeout;
ANDROID_KABI_RESERVE(1);
unsigned long private[] ____cacheline_aligned;
};
@ -652,6 +655,8 @@ struct sdhci_ops {
void (*request_done)(struct sdhci_host *host,
struct mmc_request *mrq);
void (*dump_vendor_regs)(struct sdhci_host *host);
ANDROID_KABI_RESERVE(1);
};
#ifdef CONFIG_MMC_SDHCI_IO_ACCESSORS

2
drivers/scsi/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))
@ -594,6 +595,7 @@ struct ufs_dev_info {
u8 b_presrv_uspc_en;
/* UFS HPB related flag */
bool hpb_enabled;
ANDROID_KABI_RESERVE(1);
};
/**

6
drivers/scsi/ufs/ufshcd.h
View File

@ -218,6 +218,8 @@ struct ufshcd_lrb {
#endif
bool req_abort_skip;
ANDROID_KABI_RESERVE(1);
};
/**
@ -398,6 +400,8 @@ struct ufs_clk_gating {
bool is_initialized;
int active_reqs;
struct workqueue_struct *clk_gating_workq;
ANDROID_KABI_RESERVE(1);
};
struct ufs_saved_pwr_info {
@ -444,6 +448,8 @@ struct ufs_clk_scaling {
bool is_initialized;
bool is_busy_started;
bool is_suspended;
ANDROID_KABI_RESERVE(1);
};
#define UFS_EVENT_HIST_LENGTH 8

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

@ -12,6 +12,7 @@
#include <linux/property.h>
#include <linux/slab.h>
#include <linux/usb/pd_vdo.h>
#include <linux/android_kabi.h>
#include "bus.h"
@ -20,6 +21,7 @@ struct typec_plug {
enum typec_plug_index index;
struct ida mode_ids;
int num_altmodes;
ANDROID_KABI_RESERVE(1);
};
struct typec_cable {
@ -28,6 +30,7 @@ struct typec_cable {
struct usb_pd_identity *identity;
unsigned int active:1;
u16 pd_revision; /* 0300H = "3.0" */
ANDROID_KABI_RESERVE(1);
};
struct typec_partner {
@ -39,6 +42,7 @@ struct typec_partner {
int num_altmodes;
u16 pd_revision; /* 0300H = "3.0" */
enum usb_pd_svdm_ver svdm_version;
ANDROID_KABI_RESERVE(1);
};
struct typec_port {
@ -60,6 +64,7 @@ struct typec_port {
const struct typec_capability *cap;
const struct typec_operations *ops;
ANDROID_KABI_RESERVE(1);
};
#define to_typec_port(_dev_) container_of(_dev_, struct typec_port, dev)

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
@ -71,6 +72,8 @@ struct amba_device {
struct amba_cs_uci_id uci;
unsigned int irq[AMBA_NR_IRQS];
char *driver_override;
ANDROID_KABI_RESERVE(1);
};
struct amba_driver {
@ -79,6 +82,8 @@ struct amba_driver {
void (*remove)(struct amba_device *);
void (*shutdown)(struct amba_device *);
const struct amba_id *id_table;
ANDROID_KABI_RESERVE(1);
};
/*

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);
};
enum {

12
include/linux/blkdev.h
View File

@ -26,6 +26,7 @@
#include <linux/scatterlist.h>
#include <linux/blkzoned.h>
#include <linux/pm.h>
#include <linux/android_kabi.h>
struct module;
struct scsi_ioctl_command;
@ -242,6 +243,8 @@ struct request {
*/
rq_end_io_fn *end_io;
void *end_io_data;
ANDROID_KABI_RESERVE(1);
};
static inline bool blk_op_is_scsi(unsigned int op)
@ -346,6 +349,8 @@ struct queue_limits {
unsigned char discard_misaligned;
unsigned char raid_partial_stripes_expensive;
enum blk_zoned_model zoned;
ANDROID_KABI_RESERVE(1);
};
typedef int (*report_zones_cb)(struct blk_zone *zone, unsigned int idx,
@ -589,6 +594,10 @@ struct request_queue {
#define BLK_MAX_WRITE_HINTS 5
u64 write_hints[BLK_MAX_WRITE_HINTS];
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
ANDROID_OEM_DATA(1);
};
@ -1858,6 +1867,9 @@ struct block_device_operations {
char *(*devnode)(struct gendisk *disk, umode_t *mode);
struct module *owner;
const struct pr_ops *pr_ops;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
#ifdef CONFIG_COMPAT

9
include/linux/bpf.h
View File

@ -21,6 +21,7 @@
#include <linux/kallsyms.h>
#include <linux/capability.h>
#include <linux/percpu-refcount.h>
#include <linux/android_kabi.h>
struct bpf_verifier_env;
struct bpf_verifier_log;
@ -132,6 +133,9 @@ struct bpf_map_ops {
/* bpf_iter info used to open a seq_file */
const struct bpf_iter_seq_info *iter_seq_info;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
struct bpf_map_memory {
@ -218,6 +222,8 @@ struct bpf_map_dev_ops {
int (*map_update_elem)(struct bpf_offloaded_map *map,
void *key, void *value, u64 flags);
int (*map_delete_elem)(struct bpf_offloaded_map *map, void *key);
ANDROID_KABI_RESERVE(1);
};
struct bpf_offloaded_map {
@ -459,6 +465,7 @@ struct bpf_verifier_ops {
const struct btf_type *t, int off, int size,
enum bpf_access_type atype,
u32 *next_btf_id);
ANDROID_KABI_RESERVE(1);
};
struct bpf_prog_offload_ops {
@ -474,6 +481,7 @@ struct bpf_prog_offload_ops {
int (*prepare)(struct bpf_prog *prog);
int (*translate)(struct bpf_prog *prog);
void (*destroy)(struct bpf_prog *prog);
ANDROID_KABI_RESERVE(1);
};
struct bpf_prog_offload {
@ -851,6 +859,7 @@ struct bpf_prog_aux {
struct work_struct work;
struct rcu_head rcu;
};
ANDROID_KABI_RESERVE(1);
};
struct bpf_array_aux {

6
include/linux/bpf_verifier.h
View File

@ -7,6 +7,7 @@
#include <linux/bpf.h> /* for enum bpf_reg_type */
#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
@ -370,6 +371,8 @@ struct bpf_subprog_info {
bool has_tail_call;
bool tail_call_reachable;
bool has_ld_abs;
ANDROID_KABI_RESERVE(1);
};
/* single container for all structs
@ -425,6 +428,9 @@ struct bpf_verifier_env {
u32 peak_states;
/* longest register parentage chain walked for liveness marking */
u32 longest_mark_read_walk;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
__printf(2, 0) void bpf_verifier_vlog(struct bpf_verifier_log *log,

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 cgroup_root cgrp_dfl_root;

4
include/linux/cpuhotplug.h
View File

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

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;
@ -198,6 +199,9 @@ struct target_type {
dm_dax_copy_iter_fn dax_copy_to_iter;
dm_dax_zero_page_range_fn dax_zero_page_range;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
/* For internal device-mapper use. */
struct list_head list;
};
@ -349,6 +353,9 @@ struct dm_target {
* Set if we need to limit the number of in-flight bios when swapping.
*/
bool limit_swap_bios:1;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
void *dm_per_bio_data(struct bio *bio, size_t data_size);

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

@ -21,6 +21,7 @@
#include <linux/fs.h>
#include <linux/dma-fence.h>
#include <linux/wait.h>
#include <linux/android_kabi.h>
struct device;
struct dma_buf;
@ -353,6 +354,9 @@ struct dma_buf_ops {
* will be populated with the buffer's flags.
*/
int (*get_flags)(struct dma_buf *dmabuf, unsigned long *flags);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
/**
@ -425,6 +429,9 @@ struct dma_buf {
struct kset *attach_stats_kset;
} *sysfs_entry;
#endif
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
/**
@ -505,6 +512,9 @@ struct dma_buf_attachment {
unsigned int map_counter;
} *sysfs_entry;
#endif
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
/**
@ -528,6 +538,9 @@ struct dma_buf_export_info {
int flags;
struct dma_resv *resv;
void *priv;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
/**

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>
/**
@ -941,6 +942,11 @@ struct dma_device {
void (*dbg_summary_show)(struct seq_file *s, struct dma_device *dev);
struct dentry *dbg_dev_root;
#endif
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
static inline int dmaengine_slave_config(struct dma_chan *chan,

3
include/linux/fs.h
View File

@ -966,6 +966,9 @@ struct file {
struct address_space *f_mapping;
errseq_t f_wb_err;
errseq_t f_sb_err; /* for syncfs */
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
} __randomize_layout
__attribute__((aligned(4))); /* lest something weird decides that 2 is OK */

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

@ -10,6 +10,7 @@
#include <linux/lockdep.h>
#include <linux/pinctrl/pinctrl.h>
#include <linux/pinctrl/pinconf-generic.h>
#include <linux/android_kabi.h>
struct gpio_desc;
struct of_phandle_args;
@ -266,6 +267,9 @@ struct gpio_irq_chip {
* Store old irq_chip irq_mask callback
*/
void (*irq_mask)(struct irq_data *data);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
/**
@ -469,6 +473,9 @@ struct gpio_chip {
int (*of_xlate)(struct gpio_chip *gc,
const struct of_phandle_args *gpiospec, u32 *flags);
#endif /* CONFIG_OF_GPIO */
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
extern const char *gpiochip_is_requested(struct gpio_chip *gc,

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
@ -201,6 +202,11 @@ struct input_dev {
bool devres_managed;
ktime_t timestamp[INPUT_CLK_MAX];
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
#define to_input_dev(d) container_of(d, struct input_dev, dev)
@ -320,6 +326,8 @@ struct input_handler {
struct list_head h_list;
struct list_head node;
ANDROID_KABI_RESERVE(1);
};
/**
@ -346,6 +354,8 @@ struct input_handle {
struct list_head d_node;
struct list_head h_node;
ANDROID_KABI_RESERVE(1);
};
struct input_dev __must_check *input_allocate_device(void);
@ -550,6 +560,9 @@ struct ff_device {
int max_effects;
struct ff_effect *effects;
ANDROID_KABI_RESERVE(1);
struct file *effect_owners[];
};

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

6
include/linux/kernfs.h
View File

@ -157,6 +157,8 @@ struct kernfs_node {
unsigned short flags;
umode_t mode;
struct kernfs_iattrs *iattr;
ANDROID_KABI_RESERVE(1);
};
/*
@ -198,6 +200,8 @@ struct kernfs_root {
struct list_head supers;
wait_queue_head_t deactivate_waitq;
ANDROID_KABI_RESERVE(1);
};
struct kernfs_open_file {
@ -218,6 +222,8 @@ struct kernfs_open_file {
bool mmapped:1;
bool released:1;
const struct vm_operations_struct *vm_ops;
ANDROID_KABI_RESERVE(1);
};
struct kernfs_ops {

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
@ -155,6 +156,9 @@ struct key_type {
int (*asym_verify_signature)(struct kernel_pkey_params *params,
const void *in, const void *in2);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
/* internal fields */
struct list_head link; /* link in types list */
struct lock_class_key lock_class; /* key->sem lock class */

2
include/linux/mm_types.h
View File

@ -598,6 +598,8 @@ struct mm_struct {
#ifdef CONFIG_IOMMU_SUPPORT
u32 pasid;
#endif
ANDROID_KABI_RESERVE(1);
} __randomize_layout;
/*

5
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;
@ -236,6 +237,8 @@ struct mmc_part {
#define MMC_BLK_DATA_AREA_BOOT (1<<1)
#define MMC_BLK_DATA_AREA_GP (1<<2)
#define MMC_BLK_DATA_AREA_RPMB (1<<3)
ANDROID_KABI_RESERVE(1);
};
/*
@ -314,6 +317,8 @@ struct mmc_card {
unsigned int bouncesz; /* Bounce buffer size */
struct workqueue_struct *complete_wq; /* Private workqueue */
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_VENDOR_DATA(1);
};

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

@ -16,6 +16,7 @@
#include <linux/mmc/pm.h>
#include <linux/dma-direction.h>
#include <linux/keyslot-manager.h>
#include <linux/android_kabi.h>
#include <linux/android_vendor.h>
@ -176,6 +177,9 @@ struct mmc_host_ops {
*/
int (*multi_io_quirk)(struct mmc_card *card,
unsigned int direction, int blk_size);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
struct mmc_cqe_ops {
@ -220,6 +224,9 @@ struct mmc_cqe_ops {
* will have zero data bytes transferred.
*/
void (*cqe_recovery_finish)(struct mmc_host *host);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
struct mmc_async_req {
@ -485,6 +492,8 @@ struct mmc_host {
/* Host Software Queue support */
bool hsq_enabled;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_VENDOR_DATA(1);
ANDROID_OEM_DATA(1);

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)
@ -171,6 +172,8 @@ struct nf_sockopt_ops {
int (*get)(struct sock *sk, int optval, void __user *user, int *len);
/* Use the module struct to lock set/get code in place */
struct module *owner;
ANDROID_KABI_RESERVE(1);
};
/* Function to register/unregister hook points. */
@ -373,6 +376,8 @@ struct nf_nat_hook {
unsigned int (*manip_pkt)(struct sk_buff *skb, struct nf_conn *ct,
enum nf_nat_manip_type mtype,
enum ip_conntrack_dir dir);
ANDROID_KABI_RESERVE(1);
};
extern struct nf_nat_hook __rcu *nf_nat_hook;
@ -457,6 +462,8 @@ struct nf_ct_hook {
void (*destroy)(struct nf_conntrack *);
bool (*get_tuple_skb)(struct nf_conntrack_tuple *,
const struct sk_buff *);
ANDROID_KABI_RESERVE(1);
};
extern struct nf_ct_hook __rcu *nf_ct_hook;
@ -474,6 +481,8 @@ struct nfnl_ct_hook {
u32 portid, u32 report);
void (*seq_adjust)(struct sk_buff *skb, struct nf_conn *ct,
enum ip_conntrack_info ctinfo, s32 off);
ANDROID_KABI_RESERVE(1);
};
extern struct nfnl_ct_hook __rcu *nfnl_ct_hook;

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 {
bool (*same_set)(const struct ip_set *a, const struct ip_set *b);
/* Region-locking is used */
bool region_lock;
ANDROID_KABI_RESERVE(1);
};
struct ip_set_region {
@ -228,6 +231,8 @@ struct ip_set_type {
/* Set this to THIS_MODULE if you are a module, otherwise NULL */
struct module *me;
ANDROID_KABI_RESERVE(1);
};
/* register and unregister set type */
@ -270,6 +275,8 @@ struct ip_set {
size_t offset[IPSET_EXT_ID_MAX];
/* The type specific data */
void *data;
ANDROID_KABI_RESERVE(1);
};
static inline void

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>
@ -22,6 +23,8 @@ struct nfnl_callback {
struct netlink_ext_ack *extack);
const struct nla_policy *policy; /* netlink attribute policy */
const u_int16_t attr_count; /* number of nlattr's */
ANDROID_KABI_RESERVE(1);
};
enum nfnl_abort_action {
@ -41,6 +44,8 @@ struct nfnetlink_subsystem {
enum nfnl_abort_action action);
void (*cleanup)(struct net *net);
bool (*valid_genid)(struct net *net, u32 genid);
ANDROID_KABI_RESERVE(1);
};
int nfnetlink_subsys_register(const struct nfnetlink_subsystem *n);

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

@ -558,6 +558,10 @@ struct pci_host_bridge {
resource_size_t start,
resource_size_t size,
resource_size_t align);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
unsigned long private[] ____cacheline_aligned;
};
@ -745,6 +749,8 @@ struct pci_ops {
void __iomem *(*map_bus)(struct pci_bus *bus, unsigned int devfn, int where);
int (*read)(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 *val);
int (*write)(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 val);
ANDROID_KABI_RESERVE(1);
};
/*
@ -820,6 +826,8 @@ struct pci_error_handlers {
/* Device driver may resume normal operations */
void (*resume)(struct pci_dev *dev);
ANDROID_KABI_RESERVE(1);
};

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)
@ -37,6 +38,9 @@ struct platform_device {
/* arch specific additions */
struct pdev_archdata archdata;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
#define platform_get_device_id(pdev) ((pdev)->id_entry)
@ -94,6 +98,8 @@ struct platform_device_info {
u64 dma_mask;
const struct property_entry *properties;
ANDROID_KABI_RESERVE(1);
};
extern struct platform_device *platform_device_register_full(
const struct platform_device_info *pdevinfo);
@ -206,6 +212,8 @@ struct platform_driver {
struct device_driver driver;
const struct platform_device_id *id_table;
bool prevent_deferred_probe;
ANDROID_KABI_RESERVE(1);
};
#define to_platform_driver(drv) (container_of((drv), struct platform_driver, \

8
include/linux/pm.h
View File

@ -15,6 +15,7 @@
#include <linux/timer.h>
#include <linux/hrtimer.h>
#include <linux/completion.h>
#include <linux/android_kabi.h>
/*
* Callbacks for platform drivers to implement.
@ -299,6 +300,8 @@ struct dev_pm_ops {
int (*runtime_suspend)(struct device *dev);
int (*runtime_resume)(struct device *dev);
int (*runtime_idle)(struct device *dev);
ANDROID_KABI_RESERVE(1);
};
#ifdef CONFIG_PM_SLEEP
@ -621,6 +624,9 @@ struct dev_pm_info {
struct pm_subsys_data *subsys_data; /* Owned by the subsystem. */
void (*set_latency_tolerance)(struct device *, s32);
struct dev_pm_qos *qos;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
extern int dev_pm_get_subsys_data(struct device *dev);
@ -647,6 +653,8 @@ struct dev_pm_domain {
int (*activate)(struct device *dev);
void (*sync)(struct device *dev);
void (*dismiss)(struct device *dev);
ANDROID_KABI_RESERVE(1);
};
/*

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,
@ -233,6 +234,8 @@ struct power_supply_config {
char **supplied_to;
size_t num_supplicants;
ANDROID_KABI_RESERVE(1);
};
/* Description of power supply */
@ -274,6 +277,8 @@ struct power_supply_desc {
bool no_thermal;
/* For APM emulation, think legacy userspace. */
int use_for_apm;
ANDROID_KABI_RESERVE(1);
};
struct power_supply {
@ -315,6 +320,8 @@ struct power_supply {
struct led_trigger *charging_blink_full_solid_trig;
char *charging_blink_full_solid_trig_name;
#endif
ANDROID_KABI_RESERVE(1);
};
/*
@ -382,6 +389,8 @@ struct power_supply_battery_info {
int ocv_table_size[POWER_SUPPLY_OCV_TEMP_MAX];
struct power_supply_resistance_temp_table *resist_table;
int resist_table_size;
ANDROID_KABI_RESERVE(1);
};
extern struct atomic_notifier_head power_supply_notifier;

7
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_capture;
struct seq_file;
@ -97,6 +98,8 @@ struct pwm_device {
struct pwm_args args;
struct pwm_state state;
struct pwm_state last;
ANDROID_KABI_RESERVE(1);
};
/**
@ -298,6 +301,8 @@ struct pwm_ops {
enum pwm_polarity polarity);
int (*enable)(struct pwm_chip *chip, struct pwm_device *pwm);
void (*disable)(struct pwm_chip *chip, struct pwm_device *pwm);
ANDROID_KABI_RESERVE(1);
};
/**
@ -324,6 +329,8 @@ struct pwm_chip {
/* only used internally by the PWM framework */
struct list_head list;
struct pwm_device *pwms;
ANDROID_KABI_RESERVE(1);
};
/**

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;
@ -401,6 +402,8 @@ struct regmap_config {
unsigned int hwlock_mode;
bool can_sleep;
ANDROID_KABI_RESERVE(1);
};
/**
@ -438,6 +441,8 @@ struct regmap_range_cfg {
/* Data window (per each page) */
unsigned int window_start;
unsigned int window_len;
ANDROID_KABI_RESERVE(1);
};
struct regmap_async;
@ -514,6 +519,8 @@ struct regmap_bus {
enum regmap_endian val_format_endian_default;
size_t max_raw_read;
size_t max_raw_write;
ANDROID_KABI_RESERVE(1);
};
/*

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;
@ -202,6 +203,8 @@ struct regulator_ops {
int (*resume)(struct regulator_dev *rdev);
int (*set_pull_down) (struct regulator_dev *);
ANDROID_KABI_RESERVE(1);
};
/*
@ -381,6 +384,8 @@ struct regulator_desc {
unsigned int poll_enabled_time;
unsigned int (*of_map_mode)(unsigned int mode);
ANDROID_KABI_RESERVE(1);
};
/**
@ -473,6 +478,8 @@ struct regulator_dev {
/* time when this regulator was disabled last time */
unsigned long last_off_jiffy;
ANDROID_KABI_RESERVE(1);
};
struct regulator_dev *

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);
@ -66,6 +67,8 @@ struct rtc_class_ops {
int (*alarm_irq_enable)(struct device *, unsigned int enabled);
int (*read_offset)(struct device *, long *offset);
int (*set_offset)(struct device *, long offset);
ANDROID_KABI_RESERVE(1);
};
struct rtc_device;
@ -140,6 +143,8 @@ struct rtc_device {
unsigned int uie_task_active:1;
unsigned int uie_timer_active:1;
#endif
ANDROID_KABI_RESERVE(1);
};
#define to_rtc_device(d) container_of(d, struct rtc_device, dev)

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 16
#define SCMI_MAX_NUM_RATES 16
@ -82,6 +83,8 @@ struct scmi_clk_proto_ops {
u64 rate);
int (*enable)(const struct scmi_protocol_handle *ph, u32 clk_id);
int (*disable)(const struct scmi_protocol_handle *ph, u32 clk_id);
ANDROID_KABI_RESERVE(1);
};
/**
@ -125,6 +128,8 @@ struct scmi_perf_proto_ops {
bool (*fast_switch_possible)(const struct scmi_protocol_handle *ph,
struct device *dev);
bool (*power_scale_mw_get)(const struct scmi_protocol_handle *ph);
ANDROID_KABI_RESERVE(1);
};
/**
@ -150,6 +155,8 @@ struct scmi_power_proto_ops {
u32 state);
int (*state_get)(const struct scmi_protocol_handle *ph, u32 domain,
u32 *state);
ANDROID_KABI_RESERVE(1);
};
/**
@ -326,6 +333,8 @@ struct scmi_sensor_info {
unsigned int resolution;
int exponent;
struct scmi_range_attrs scalar_attrs;
ANDROID_KABI_RESERVE(1);
};
/*
@ -461,6 +470,8 @@ struct scmi_sensor_proto_ops {
u32 sensor_id, u32 *sensor_config);
int (*config_set)(const struct scmi_protocol_handle *ph,
u32 sensor_id, u32 sensor_config);
ANDROID_KABI_RESERVE(1);
};
/**
@ -481,6 +492,8 @@ struct scmi_reset_proto_ops {
int (*reset)(const struct scmi_protocol_handle *ph, u32 domain);
int (*assert)(const struct scmi_protocol_handle *ph, u32 domain);
int (*deassert)(const struct scmi_protocol_handle *ph, u32 domain);
ANDROID_KABI_RESERVE(1);
};
/**
@ -625,6 +638,8 @@ struct scmi_handle {
void (*devm_put_protocol)(struct scmi_device *sdev, u8 proto);
const struct scmi_notify_ops *notify_ops;
ANDROID_KABI_RESERVE(1);
};
enum scmi_std_protocol {
@ -653,6 +668,8 @@ struct scmi_device {
const char *name;
struct device dev;
struct scmi_handle *handle;
ANDROID_KABI_RESERVE(1);
};
#define to_scmi_dev(d) container_of(d, struct scmi_device, dev)

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
@ -80,6 +81,9 @@ struct uart_ops {
void (*poll_put_char)(struct uart_port *, unsigned char);
int (*poll_get_char)(struct uart_port *);
#endif
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
#define NO_POLL_CHAR 0x00ff0000
@ -256,6 +260,9 @@ struct uart_port {
struct gpio_desc *rs485_term_gpio; /* enable RS485 bus termination */
struct serial_iso7816 iso7816;
void *private_data; /* generic platform data pointer */
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
static inline int serial_port_in(struct uart_port *up, int offset)
@ -318,6 +325,8 @@ struct uart_driver {
*/
struct uart_state *state;
struct tty_driver *tty_driver;
ANDROID_KABI_RESERVE(1);
};
void uart_write_wakeup(struct uart_port *port);

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/scatterlist.h>
#include <linux/gpio/consumer.h>
#include <linux/ptp_clock_kernel.h>
#include <linux/android_kabi.h>
struct dma_chan;
struct property_entry;
@ -197,6 +198,9 @@ struct spi_device {
/* the statistics */
struct spi_statistics statistics;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
/*
* likely need more hooks for more protocol options affecting how
* the controller talks to each chip, like:
@ -281,6 +285,8 @@ struct spi_driver {
int (*remove)(struct spi_device *spi);
void (*shutdown)(struct spi_device *spi);
struct device_driver driver;
ANDROID_KABI_RESERVE(1);
};
static inline struct spi_driver *to_spi_driver(struct device_driver *drv)
@ -667,6 +673,9 @@ struct spi_controller {
/* Interrupt enable state during PTP system timestamping */
unsigned long irq_flags;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
static inline void *spi_controller_get_devdata(struct spi_controller *ctlr)
@ -964,6 +973,8 @@ struct spi_transfer {
#define SPI_TRANS_FAIL_NO_START BIT(0)
u16 error;
ANDROID_KABI_RESERVE(1);
};
/**
@ -1030,6 +1041,8 @@ struct spi_message {
/* list of spi_res reources when the spi message is processed */
struct list_head resources;
ANDROID_KABI_RESERVE(1);
};
static inline void spi_message_init_no_memset(struct spi_message *m)
@ -1468,6 +1481,8 @@ struct spi_board_info {
*/
u32 mode;
ANDROID_KABI_RESERVE(1);
/* ... may need additional spi_device chip config data here.
* avoid stuff protocol drivers can set; but include stuff
* needed to behave without being bound to a driver:

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)
@ -138,6 +140,7 @@ struct spmi_driver {
struct device_driver driver;
int (*probe)(struct spmi_device *sdev);
void (*remove)(struct spmi_device *sdev);
ANDROID_KABI_RESERVE(1);
};
static inline struct spmi_driver *to_spmi_driver(struct device_driver *d)

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

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

16
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>
#define THERMAL_TRIPS_NONE -1
@ -79,6 +80,7 @@ struct thermal_zone_device_ops {
enum thermal_trend *);
int (*notify) (struct thermal_zone_device *, int,
enum thermal_trip_type);
ANDROID_KABI_RESERVE(1);
};
struct thermal_cooling_device_ops {
@ -88,6 +90,8 @@ struct thermal_cooling_device_ops {
int (*get_requested_power)(struct thermal_cooling_device *, u32 *);
int (*state2power)(struct thermal_cooling_device *, unsigned long, u32 *);
int (*power2state)(struct thermal_cooling_device *, u32, unsigned long *);
ANDROID_KABI_RESERVE(1);
};
struct thermal_cooling_device {
@ -102,6 +106,8 @@ struct thermal_cooling_device {
struct mutex lock; /* protect thermal_instances list */
struct list_head thermal_instances;
struct list_head node;
ANDROID_KABI_RESERVE(1);
};
/**
@ -179,6 +185,8 @@ struct thermal_zone_device {
struct list_head node;
struct delayed_work poll_queue;
enum thermal_notify_event notify_event;
ANDROID_KABI_RESERVE(1);
};
/**
@ -199,6 +207,8 @@ struct thermal_governor {
void (*unbind_from_tz)(struct thermal_zone_device *tz);
int (*throttle)(struct thermal_zone_device *tz, int trip);
struct list_head governor_list;
ANDROID_KABI_RESERVE(1);
};
/* Structure that holds binding parameters for a zone */
@ -234,6 +244,8 @@ struct thermal_bind_params {
unsigned long *binding_limits;
int (*match) (struct thermal_zone_device *tz,
struct thermal_cooling_device *cdev);
ANDROID_KABI_RESERVE(1);
};
/* Structure to define Thermal Zone parameters */
@ -287,6 +299,8 @@ struct thermal_zone_params {
* Used by thermal zone drivers (default 0).
*/
int offset;
ANDROID_KABI_RESERVE(1);
};
/**
@ -311,6 +325,8 @@ struct thermal_zone_of_device_ops {
int (*set_trips)(void *, int, int);
int (*set_emul_temp)(void *, int);
int (*set_trip_temp)(void *, int, int);
ANDROID_KABI_RESERVE(1);
};
/* Function declarations */

8
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>
/*
@ -218,6 +219,8 @@ struct tty_port_operations {
int (*activate)(struct tty_port *port, struct tty_struct *tty);
/* Called on the final put of a port */
void (*destruct)(struct tty_port *port);
ANDROID_KABI_RESERVE(1);
};
struct tty_port_client_operations {
@ -252,6 +255,8 @@ struct tty_port {
set to size of fifo */
struct kref kref; /* Ref counter */
void *client_data;
ANDROID_KABI_RESERVE(1);
};
/* tty_port::iflags bits -- use atomic bit ops */
@ -345,6 +350,9 @@ struct tty_struct {
/* If the tty has a pending do_SAK, queue it here - akpm */
struct work_struct SAK_work;
struct tty_port *port;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
} __randomize_layout;
/* Each of a tty's open files has private_data pointing to tty_file_private */

7
include/linux/tty_driver.h
View File

@ -237,6 +237,7 @@
#include <linux/cdev.h>
#include <linux/termios.h>
#include <linux/seq_file.h>
#include <linux/android_kabi.h>
struct tty_struct;
struct tty_driver;
@ -292,6 +293,9 @@ struct tty_operations {
void (*poll_put_char)(struct tty_driver *driver, int line, char ch);
#endif
int (*proc_show)(struct seq_file *, void *);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
} __randomize_layout;
struct tty_driver {
@ -326,6 +330,9 @@ struct tty_driver {
const struct tty_operations *ops;
struct list_head tty_drivers;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
} __randomize_layout;
extern struct list_head tty_drivers;

4
include/linux/tty_ldisc.h
View File

@ -126,6 +126,7 @@
#include <linux/fs.h>
#include <linux/wait.h>
#include <linux/atomic.h>
#include <linux/android_kabi.h>
/*
* the semaphore definition
@ -211,6 +212,9 @@ struct tty_ldisc_ops {
struct module *owner;
int refcount;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
struct tty_ldisc {

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

@ -123,6 +123,8 @@ struct usb_request {
int status;
unsigned actual;
ANDROID_KABI_RESERVE(1);
};
/*-------------------------------------------------------------------------*/
@ -153,6 +155,8 @@ struct usb_ep_ops {
int (*fifo_status) (struct usb_ep *ep);
void (*fifo_flush) (struct usb_ep *ep);
ANDROID_KABI_RESERVE(1);
};
/**
@ -241,6 +245,8 @@ struct usb_ep {
u8 address;
const struct usb_endpoint_descriptor *desc;
const struct usb_ss_ep_comp_descriptor *comp_desc;
ANDROID_KABI_RESERVE(1);
};
/*-------------------------------------------------------------------------*/
@ -329,6 +335,11 @@ struct usb_gadget_ops {
struct usb_ep *(*match_ep)(struct usb_gadget *,
struct usb_endpoint_descriptor *,
struct usb_ss_ep_comp_descriptor *);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
/**

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

3
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 */
@ -215,6 +216,7 @@ struct typec_operations {
int (*vconn_set)(struct typec_port *port, enum typec_role role);
int (*port_type_set)(struct typec_port *port,
enum typec_port_type type);
ANDROID_KABI_RESERVE(1);
};
enum usb_pd_svdm_ver {
@ -252,6 +254,7 @@ struct typec_capability {
void *driver_data;
const struct typec_operations *ops;
ANDROID_KABI_RESERVE(1);
};
/* Specific to try_role(). Indicates the user want's to clear the preference. */

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>
/*
@ -87,6 +88,9 @@ union v4l2_ctrl_ptr {
struct v4l2_area *p_area;
void *p;
const void *p_const;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
/**
@ -119,6 +123,8 @@ struct v4l2_ctrl_ops {
int (*g_volatile_ctrl)(struct v4l2_ctrl *ctrl);
int (*try_ctrl)(struct v4l2_ctrl *ctrl);
int (*s_ctrl)(struct v4l2_ctrl *ctrl);
ANDROID_KABI_RESERVE(1);
};
/**
@ -140,6 +146,8 @@ struct v4l2_ctrl_type_ops {
void (*log)(const struct v4l2_ctrl *ctrl);
int (*validate)(const struct v4l2_ctrl *ctrl, u32 idx,
union v4l2_ctrl_ptr ptr);
ANDROID_KABI_RESERVE(1);
};
/**
@ -290,6 +298,8 @@ struct v4l2_ctrl {
union v4l2_ctrl_ptr p_def;
union v4l2_ctrl_ptr p_new;
union v4l2_ctrl_ptr p_cur;
ANDROID_KABI_RESERVE(1);
};
/**
@ -329,6 +339,8 @@ struct v4l2_ctrl_ref {
bool req_done;
bool valid_p_req;
union v4l2_ctrl_ptr p_req;
ANDROID_KABI_RESERVE(1);
};
/**
@ -379,6 +391,8 @@ struct v4l2_ctrl_handler {
struct list_head requests;
struct list_head requests_queued;
struct media_request_object req_obj;
ANDROID_KABI_RESERVE(1);
};
/**
@ -430,6 +444,8 @@ struct v4l2_ctrl_config {
const char * const *qmenu;
const s64 *qmenu_int;
unsigned int is_private:1;
ANDROID_KABI_RESERVE(1);
};
/**

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

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_sock.h>
@ -564,6 +565,11 @@ struct hci_dev {
int (*set_bdaddr)(struct hci_dev *hdev, const bdaddr_t *bdaddr);
void (*cmd_timeout)(struct hci_dev *hdev);
bool (*prevent_wake)(struct hci_dev *hdev);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
#define HCI_PHY_HANDLE(handle) (handle & 0xff)
@ -660,6 +666,11 @@ struct hci_conn {
void (*connect_cfm_cb) (struct hci_conn *conn, u8 status);
void (*security_cfm_cb) (struct hci_conn *conn, u8 status);
void (*disconn_cfm_cb) (struct hci_conn *conn, u8 reason);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
struct hci_chan {
@ -670,6 +681,8 @@ struct hci_chan {
unsigned int sent;
__u8 state;
bool amp;
ANDROID_KABI_RESERVE(1);
};
struct hci_conn_params {
@ -696,6 +709,8 @@ struct hci_conn_params {
struct hci_conn *conn;
bool explicit_connect;
u32 current_flags;
ANDROID_KABI_RESERVE(1);
};
extern struct list_head hci_dev_list;
@ -1415,6 +1430,8 @@ struct hci_cb {
__u8 encrypt);
void (*key_change_cfm) (struct hci_conn *conn, __u8 status);
void (*role_switch_cfm) (struct hci_conn *conn, __u8 status, __u8 role);
ANDROID_KABI_RESERVE(1);
};
static inline void hci_connect_cfm(struct hci_conn *conn, __u8 status)
@ -1675,6 +1692,8 @@ struct hci_mgmt_chan {
size_t handler_count;
const struct hci_mgmt_handler *handlers;
void (*hdev_init) (struct sock *sk, struct hci_dev *hdev);
ANDROID_KABI_RESERVE(1);
};
int hci_mgmt_chan_register(struct hci_mgmt_chan *c);

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
@ -643,6 +644,9 @@ struct l2cap_chan {
void *data;
const struct l2cap_ops *ops;
struct mutex lock;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
struct l2cap_ops {
@ -667,6 +671,9 @@ struct l2cap_ops {
unsigned long len, int nb);
int (*filter) (struct l2cap_chan * chan,
struct sk_buff *skb);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
struct l2cap_conn {
@ -702,6 +709,9 @@ struct l2cap_conn {
struct mutex chan_lock;
struct kref ref;
struct list_head users;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
struct l2cap_user {

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

44
include/net/cfg80211.h
View File

@ -20,6 +20,7 @@
#include <linux/if_ether.h>
#include <linux/ieee80211.h>
#include <linux/net.h>
#include <linux/android_kabi.h>
#include <net/regulatory.h>
/**
@ -1042,6 +1043,8 @@ struct cfg80211_crypto_settings {
const u8 *sae_pwd;
u8 sae_pwd_len;
enum nl80211_sae_pwe_mechanism sae_pwe;
ANDROID_KABI_RESERVE(1);
};
/**
@ -1088,6 +1091,8 @@ struct cfg80211_beacon_data {
size_t probe_resp_len;
size_t lci_len;
size_t civicloc_len;
ANDROID_KABI_RESERVE(1);
};
struct mac_address {
@ -1224,6 +1229,8 @@ struct cfg80211_ap_settings {
struct cfg80211_he_bss_color he_bss_color;
struct cfg80211_fils_discovery fils_discovery;
struct cfg80211_unsol_bcast_probe_resp unsol_bcast_probe_resp;
ANDROID_KABI_RESERVE(1);
};
/**
@ -1253,6 +1260,8 @@ struct cfg80211_csa_settings {
bool radar_required;
bool block_tx;
u8 count;
ANDROID_KABI_RESERVE(1);
};
#define CFG80211_MAX_NUM_DIFFERENT_CHANNELS 10
@ -1395,6 +1404,8 @@ struct station_parameters {
u16 airtime_weight;
struct sta_txpwr txpwr;
const struct ieee80211_he_6ghz_capa *he_6ghz_capa;
ANDROID_KABI_RESERVE(1);
};
/**
@ -1741,6 +1752,8 @@ struct station_info {
u32 airtime_link_metric;
u8 connected_to_as;
ANDROID_KABI_RESERVE(1);
};
#if IS_ENABLED(CONFIG_CFG80211)
@ -1995,6 +2008,8 @@ struct mesh_config {
u16 dot11MeshAwakeWindowDuration;
u32 plink_timeout;
bool dot11MeshNolearn;
ANDROID_KABI_RESERVE(1);
};
/**
@ -2044,6 +2059,8 @@ struct mesh_setup {
struct cfg80211_bitrate_mask beacon_rate;
bool userspace_handles_dfs;
bool control_port_over_nl80211;
ANDROID_KABI_RESERVE(1);
};
/**
@ -2205,6 +2222,8 @@ struct cfg80211_scan_request {
u32 n_6ghz_params;
struct cfg80211_scan_6ghz_params *scan_6ghz_params;
ANDROID_KABI_RESERVE(1);
/* keep last */
struct ieee80211_channel *channels[];
};
@ -2351,6 +2370,8 @@ struct cfg80211_sched_scan_request {
bool nl_owner_dead;
struct list_head list;
ANDROID_KABI_RESERVE(1);
/* keep last */
struct ieee80211_channel *channels[];
};
@ -2474,6 +2495,8 @@ struct cfg80211_bss {
u8 bssid_index;
u8 max_bssid_indicator;
ANDROID_KABI_RESERVE(1);
u8 priv[] __aligned(sizeof(void *));
};
@ -2600,6 +2623,8 @@ struct cfg80211_assoc_request {
size_t fils_kek_len;
const u8 *fils_nonces;
struct ieee80211_s1g_cap s1g_capa, s1g_capa_mask;
ANDROID_KABI_RESERVE(1);
};
/**
@ -2698,6 +2723,8 @@ struct cfg80211_ibss_params {
struct ieee80211_ht_cap ht_capa_mask;
struct key_params *wep_keys;
int wep_tx_key;
ANDROID_KABI_RESERVE(1);
};
/**
@ -2812,6 +2839,8 @@ struct cfg80211_connect_params {
size_t fils_erp_rrk_len;
bool want_1x;
struct ieee80211_edmg edmg;
ANDROID_KABI_RESERVE(1);
};
/**
@ -3269,6 +3298,8 @@ struct cfg80211_nan_func {
u8 num_rx_filters;
u8 instance_id;
u64 cookie;
ANDROID_KABI_RESERVE(1);
};
/**
@ -3429,6 +3460,8 @@ struct cfg80211_pmsr_ftm_result {
dist_avg_valid:1,
dist_variance_valid:1,
dist_spread_valid:1;
ANDROID_KABI_RESERVE(1);
};
/**
@ -4265,6 +4298,10 @@ struct cfg80211_ops {
struct cfg80211_tid_config *tid_conf);
int (*reset_tid_config)(struct wiphy *wiphy, struct net_device *dev,
const u8 *peer, u8 tids);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
/*
@ -4628,6 +4665,8 @@ struct wiphy_vendor_command {
unsigned long *storage);
const struct nla_policy *policy;
unsigned int maxattr;
ANDROID_KABI_RESERVE(1);
};
/**
@ -5033,6 +5072,8 @@ struct wiphy {
u8 max_data_retry_count;
ANDROID_KABI_RESERVE(1);
char priv[] __aligned(NETDEV_ALIGN);
};
@ -5332,6 +5373,9 @@ struct wireless_dev {
struct work_struct pmsr_free_wk;
unsigned long unprot_beacon_reported;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
static inline u8 *wdev_address(struct wireless_dev *wdev)

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

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>
@ -51,6 +52,8 @@ struct inet_connection_sock_af_ops {
char __user *optval, int __user *optlen);
void (*addr2sockaddr)(struct sock *sk, struct sockaddr *);
void (*mtu_reduced)(struct sock *sk);
ANDROID_KABI_RESERVE(1);
};
/** inet_connection_sock - INET connection oriented sock
@ -134,6 +137,8 @@ struct inet_connection_sock {
u32 icsk_probes_tstamp;
u32 icsk_user_timeout;
ANDROID_KABI_RESERVE(1);
u64 icsk_ca_priv[104 / sizeof(u64)];
#define ICSK_CA_PRIV_SIZE (13 * sizeof(u64))
};

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>
@ -67,6 +68,8 @@ struct fib6_config {
struct nlattr *fc_encap;
u16 fc_encap_type;
bool fc_is_fdb;
ANDROID_KABI_RESERVE(1);
};
struct fib6_node {
@ -83,6 +86,8 @@ struct fib6_node {
int fn_sernum;
struct fib6_info __rcu *rr_ptr;
struct rcu_head rcu;
ANDROID_KABI_RESERVE(1);
};
struct fib6_gc_args {
@ -199,6 +204,9 @@ struct fib6_info {
struct rcu_head rcu;
struct nexthop *nh;
ANDROID_KABI_RESERVE(1);
struct fib6_nh fib6_nh[];
};
@ -218,6 +226,8 @@ struct rt6_info {
/* more non-fragment space at head required */
unsigned short rt6i_nfheader_len;
ANDROID_KABI_RESERVE(1);
};
struct fib6_result {

24
include/net/mac80211.h
View File

@ -18,6 +18,7 @@
#include <linux/if_ether.h>
#include <linux/skbuff.h>
#include <linux/ieee80211.h>
#include <linux/android_kabi.h>
#include <net/cfg80211.h>
#include <net/codel.h>
#include <net/ieee80211_radiotap.h>
@ -701,6 +702,8 @@ struct ieee80211_bss_conf {
u32 unsol_bcast_probe_resp_interval;
bool s1g;
struct cfg80211_bitrate_mask beacon_tx_rate;
ANDROID_KABI_RESERVE(1);
};
/**
@ -1097,6 +1100,9 @@ struct ieee80211_tx_info {
void *rate_driver_data[
IEEE80211_TX_INFO_RATE_DRIVER_DATA_SIZE / sizeof(void *)];
};
ANDROID_KABI_RESERVE(1);
void *driver_data[
IEEE80211_TX_INFO_DRIVER_DATA_SIZE / sizeof(void *)];
};
@ -1583,6 +1589,8 @@ struct ieee80211_conf {
struct cfg80211_chan_def chandef;
bool radar_enabled;
enum ieee80211_smps_mode smps_mode;
ANDROID_KABI_RESERVE(1);
};
/**
@ -1727,6 +1735,8 @@ struct ieee80211_vif {
bool txqs_stopped[IEEE80211_NUM_ACS];
ANDROID_KABI_RESERVE(1);
/* must be last */
u8 drv_priv[] __aligned(sizeof(void *));
};
@ -2112,6 +2122,8 @@ struct ieee80211_sta {
struct ieee80211_txq *txq[IEEE80211_NUM_TIDS + 1];
ANDROID_KABI_RESERVE(1);
/* must be last */
u8 drv_priv[] __aligned(sizeof(void *));
};
@ -2606,6 +2618,8 @@ struct ieee80211_hw {
u8 tx_sk_pacing_shift;
u8 weight_multiplier;
u32 max_mtu;
ANDROID_KABI_RESERVE(1);
};
static inline bool _ieee80211_hw_check(struct ieee80211_hw *hw,
@ -4192,6 +4206,11 @@ struct ieee80211_ops {
struct ieee80211_vif *vif);
void (*sta_set_4addr)(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
struct ieee80211_sta *sta, bool enabled);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
/**
@ -6161,6 +6180,11 @@ struct rate_control_ops {
struct dentry *dir);
u32 (*get_expected_throughput)(void *priv_sta);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
static inline int rate_supported(struct ieee80211_sta *sta,

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>
/*
@ -83,6 +84,8 @@ struct neigh_parms {
int reachable_time;
int data[NEIGH_VAR_DATA_MAX];
DECLARE_BITMAP(data_state, NEIGH_VAR_DATA_MAX);
ANDROID_KABI_RESERVE(1);
};
static inline void neigh_var_set(struct neigh_parms *p, int index, int val)
@ -157,6 +160,9 @@ struct neighbour {
struct list_head gc_list;
struct rcu_head rcu;
struct net_device *dev;
ANDROID_KABI_RESERVE(1);
u8 primary_key[0];
} __randomize_layout;
@ -226,6 +232,8 @@ struct neigh_table {
struct neigh_statistics __percpu *stats;
struct neigh_hash_table __rcu *nht;
struct pneigh_entry **phash_buckets;
ANDROID_KABI_RESERVE(1);
};
enum {

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

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

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

@ -10,6 +10,7 @@
#include <net/inet_frag.h>
#include <linux/rcupdate.h>
#include <linux/siphash.h>
#include <linux/android_kabi.h>
struct tcpm_hash_bucket;
struct ctl_table_header;
@ -228,5 +229,7 @@ struct netns_ipv4 {
atomic_t rt_genid;
siphash_key_t ip_id_key;
ANDROID_KABI_RESERVE(1);
};
#endif

3
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>
@ -115,6 +116,8 @@ struct netns_ipv6 {
spinlock_t lock;
u32 seq;
} ip6addrlbl_table;
ANDROID_KABI_RESERVE(1);
};
#if IS_ENABLED(CONFIG_NF_DEFRAG_IPV6)

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;
@ -34,5 +35,7 @@ struct netns_nf {
#if IS_ENABLED(CONFIG_NF_DEFRAG_IPV6)
bool defrag_ipv6;
#endif
ANDROID_KABI_RESERVE(1);
};
#endif

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

@ -3,6 +3,7 @@
#define _NETNS_NFTABLES_H_
#include <linux/list.h>
#include <linux/android_kabi.h>
struct netns_nftables {
struct list_head tables;
@ -13,6 +14,8 @@ struct netns_nftables {
unsigned int base_seq;
u8 gencursor;
u8 validate_state;
ANDROID_KABI_RESERVE(1);
};
#endif

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;
@ -77,6 +78,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
@ -126,6 +127,8 @@ struct page_pool {
refcount_t user_cnt;
u64 destroy_cnt;
ANDROID_KABI_RESERVE(1);
};
struct page *page_pool_alloc_pages(struct page_pool *pool, gfp_t gfp);

7
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>
@ -114,6 +115,8 @@ struct Qdisc {
bool empty;
struct rcu_head rcu;
ANDROID_KABI_RESERVE(1);
/* private data */
long privdata[] ____cacheline_aligned;
};
@ -259,6 +262,8 @@ struct Qdisc_class_ops {
struct sk_buff *skb, struct tcmsg*);
int (*dump_stats)(struct Qdisc *, unsigned long,
struct gnet_dump *);
ANDROID_KABI_RESERVE(1);
};
/* Qdisc_class_ops flag values */
@ -302,6 +307,8 @@ struct Qdisc_ops {
u32 (*egress_block_get)(struct Qdisc *sch);
struct module *owner;
ANDROID_KABI_RESERVE(1);
};

7
include/net/tls.h
View File

@ -116,6 +116,9 @@ struct tls_rec {
char aad_space[TLS_AAD_SPACE_SIZE];
u8 iv_data[MAX_IV_SIZE];
struct aead_request aead_req;
ANDROID_KABI_RESERVE(1);
u8 aead_req_ctx[];
};
@ -144,6 +147,8 @@ struct tls_sw_context_tx {
#define BIT_TX_SCHEDULED 0
#define BIT_TX_CLOSING 1
unsigned long tx_bitmask;
ANDROID_KABI_RESERVE(1);
};
struct tls_sw_context_rx {
@ -161,6 +166,8 @@ struct tls_sw_context_rx {
/* protect crypto_wait with decrypt_pending*/
spinlock_t decrypt_compl_lock;
bool async_notify;
ANDROID_KABI_RESERVE(1);
};
struct tls_record_info {

2
include/scsi/scsi_host.h
View File

@ -698,6 +698,8 @@ struct Scsi_Host {
*/
struct device *dma_dev;
ANDROID_KABI_RESERVE(1);
/*
* We should ensure that this is aligned, both for better performance
* and also because some compilers (m68k) don't automatically force

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);
};
/**
@ -82,6 +85,8 @@ struct snd_compr_stream {
bool partial_drain;
void *private_data;
struct snd_dma_buffer dma_buffer;
ANDROID_KABI_RESERVE(1);
};
/**
@ -130,6 +135,8 @@ struct snd_compr_ops {
struct snd_compr_caps *caps);
int (*get_codec_caps) (struct snd_compr_stream *stream,
struct snd_compr_codec_caps *codec);
ANDROID_KABI_RESERVE(1);
};
/**
@ -158,6 +165,7 @@ struct snd_compr {
struct snd_info_entry *proc_root;
struct snd_info_entry *proc_info_entry;
#endif
ANDROID_KABI_RESERVE(1);
};
/* compress device register APIs */

10
include/sound/core.h
View File

@ -14,6 +14,7 @@
#include <linux/pm.h> /* pm_message_t */
#include <linux/stringify.h>
#include <linux/printk.h>
#include <linux/android_kabi.h>
/* number of supported soundcards */
#ifdef CONFIG_SND_DYNAMIC_MINORS
@ -61,6 +62,8 @@ struct snd_device_ops {
int (*dev_free)(struct snd_device *dev);
int (*dev_register)(struct snd_device *dev);
int (*dev_disconnect)(struct snd_device *dev);
ANDROID_KABI_RESERVE(1);
};
struct snd_device {
@ -70,6 +73,8 @@ struct snd_device {
enum snd_device_type type; /* device type */
void *device_data; /* device structure */
const struct snd_device_ops *ops; /* operations */
ANDROID_KABI_RESERVE(1);
};
#define snd_device(n) list_entry(n, struct snd_device, list)
@ -132,6 +137,9 @@ struct snd_card {
struct snd_mixer_oss *mixer_oss;
int mixer_oss_change_count;
#endif
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
#define dev_to_snd_card(p) container_of(p, struct snd_card, card_dev)
@ -167,6 +175,8 @@ struct snd_minor {
void *private_data; /* private data for f_ops->open */
struct device *dev; /* device for sysfs */
struct snd_card *card_ptr; /* assigned card instance */
ANDROID_KABI_RESERVE(1);
};
/* return a device pointer linked to each sound device as a parent */

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;
@ -69,6 +70,8 @@ struct snd_jack {
#endif /* CONFIG_SND_JACK_INPUT_DEV */
void *private_data;
void (*private_free)(struct snd_jack *);
ANDROID_KABI_RESERVE(1);
};
#ifdef CONFIG_SND_JACK

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>
@ -846,6 +847,8 @@ struct snd_soc_dai_link {
#ifdef CONFIG_SND_SOC_TOPOLOGY
struct snd_soc_dobj dobj; /* For topology */
#endif
ANDROID_KABI_RESERVE(1);
};
#define for_each_link_codecs(link, i, codec) \
for ((i) = 0; \
@ -1096,6 +1099,11 @@ struct snd_soc_card {
unsigned int probed:1;
void *drvdata;
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
#define for_each_card_prelinks(card, i, link) \
for ((i) = 0; \
@ -1177,6 +1185,9 @@ struct snd_soc_pcm_runtime {
unsigned int fe_compr:1; /* for Dynamic PCM */
int num_components;
ANDROID_KABI_RESERVE(1);
struct snd_soc_component *components[]; /* CPU/Codec/Platform */
};
/* see soc_new_pcm_runtime() */
@ -1222,6 +1233,8 @@ struct soc_mixer_control {
#ifdef CONFIG_SND_SOC_TOPOLOGY
struct snd_soc_dobj dobj;
#endif
ANDROID_KABI_RESERVE(1);
};
struct soc_bytes {
@ -1266,6 +1279,8 @@ struct soc_enum {
#ifdef CONFIG_SND_SOC_TOPOLOGY
struct snd_soc_dobj dobj;
#endif
ANDROID_KABI_RESERVE(1);
};
static inline bool snd_soc_volsw_is_stereo(struct soc_mixer_control *mc)

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
sound/usb/card.h
View File

@ -178,6 +178,8 @@ struct snd_usb_substream {
bool trigger_tstamp_pending_update; /* trigger timestamp being updated from initial estimate */
struct media_ctl *media_ctl;
ANDROID_KABI_RESERVE(1);
};
struct snd_usb_stream {

10
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>
/*
*
*/
@ -64,6 +66,11 @@ struct snd_usb_audio {
struct mutex dev_lock; /* to protect any race with disconnect */
int card_num; /* cache pcm card number to use upon disconnect */
void (*disconnect_cb)(struct snd_usb_audio *chip);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
ANDROID_KABI_RESERVE(3);
ANDROID_KABI_RESERVE(4);
};
#define USB_AUDIO_IFACE_UNUSED ((void *)-1L)
@ -176,6 +183,9 @@ struct snd_usb_audio_vendor_ops {
struct audioformat *found,
int *cur_attr, int *attr);
int (*usb_add_ctls)(struct snd_usb_audio *chip);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
#endif /* __USBAUDIO_H */