TencentOS
/
TencentOS-kernel
mirror of https://github.com/Tencent/TencentOS-kernel
0
0
Fork 4
Code Issues Projects Releases Wiki Activity

kabi: reserve space for kabi 

Signed-off-by: denisecheng <denisecheng@tencent.com>
Signed-off-by: denisecheng <denisecheng@tencent.com>
This commit is contained in:
denisecheng 2021-06-10 15:44:54 +08:00 committed by kaixuxiakx
parent 41c8ed76f7
commit 320a3efd01
64 changed files with 532 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
drivers/pci/pci.h
View File

@ -339,6 +339,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 */
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
/**

3
drivers/scsi/sd.h
View File

@ -116,6 +116,9 @@ struct scsi_disk {
unsigned urswrz : 1;
unsigned security : 1;
unsigned ignore_medium_access_errors : 1;
KABI_RESERVE(1);
KABI_RESERVE(2);
};
#define to_scsi_disk(obj) container_of(obj,struct scsi_disk,dev)

10
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/kabi.h>
struct page;
struct device;
@ -183,6 +184,10 @@ struct bdi_writeback {
struct rcu_head rcu;
};
#endif
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
struct backing_dev_info {
@ -228,6 +233,11 @@ struct backing_dev_info {
#ifdef CONFIG_DEBUG_FS
struct dentry *debug_dir;
#endif
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
enum {

9
include/linux/bio.h
View File

@ -8,6 +8,7 @@
#include <linux/highmem.h>
#include <linux/mempool.h>
#include <linux/ioprio.h>
#include <linux/kabi.h>
#ifdef CONFIG_BLOCK
/* struct bio, bio_vec and BIO_* flags are defined in blk_types.h */
@ -320,6 +321,9 @@ struct bio_integrity_payload {
struct bio_vec *bip_vec;
struct bio_vec bip_inline_vecs[0];/* embedded bvec array */
KABI_RESERVE(1);
KABI_RESERVE(2);
};
#if defined(CONFIG_BLK_DEV_INTEGRITY)
@ -719,6 +723,11 @@ struct bio_set {
struct bio_list rescue_list;
struct work_struct rescue_work;
struct workqueue_struct *rescue_workqueue;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
struct biovec_slab {

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

@ -22,6 +22,7 @@
#include <linux/atomic.h>
#include <linux/kthread.h>
#include <linux/fs.h>
#include <linux/kabi.h>
/* percpu_counter batch for blkg_[rw]stats, per-cpu drift doesn't matter */
#define BLKG_STAT_CPU_BATCH (INT_MAX / 2)
@ -75,6 +76,11 @@ struct blkcg {
unsigned int dkstats_on;
struct list_head dkstats_list;
struct blkcg_dkstats *dkstats_hint;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
/*
@ -194,6 +200,9 @@ struct blkcg_policy {
blkcg_pol_free_pd_fn *pd_free_fn;
blkcg_pol_reset_pd_stats_fn *pd_reset_stats_fn;
blkcg_pol_stat_pd_fn *pd_stat_fn;
KABI_RESERVE(1);
KABI_RESERVE(2);
};
extern struct blkcg blkcg_root;

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

@ -5,6 +5,7 @@
#include <linux/blkdev.h>
#include <linux/sbitmap.h>
#include <linux/srcu.h>
#include <linux/kabi.h>
struct blk_mq_tags;
struct blk_flush_queue;
@ -72,6 +73,11 @@ struct blk_mq_hw_ctx {
struct list_head hctx_list;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
/* Must be the last member - see also blk_mq_hw_ctx_size(). */
struct srcu_struct srcu[0];
};
@ -113,11 +119,18 @@ struct blk_mq_tag_set {
struct mutex tag_list_lock;
struct list_head tag_list;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
struct blk_mq_queue_data {
struct request *rq;
bool last;
KABI_RESERVE(1);
};
typedef blk_status_t (queue_rq_fn)(struct blk_mq_hw_ctx *,
@ -221,6 +234,10 @@ struct blk_mq_ops {
*/
void (*show_rq)(struct seq_file *m, struct request *rq);
#endif
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
enum {

4
include/linux/blk_types.h
View File

@ -9,6 +9,7 @@
#include <linux/types.h>
#include <linux/bvec.h>
#include <linux/ktime.h>
#include <linux/kabi.h>
struct bio_set;
struct bio;
@ -193,6 +194,9 @@ struct bio {
struct bio_set *bi_pool;
KABI_RESERVE(1);
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

11
include/linux/blkdev.h
View File

@ -27,6 +27,7 @@
#include <linux/percpu-refcount.h>
#include <linux/scatterlist.h>
#include <linux/blkzoned.h>
#include <linux/kabi.h>
struct module;
struct scsi_ioctl_command;
@ -348,6 +349,10 @@ struct queue_limits {
unsigned char discard_misaligned;
unsigned char raid_partial_stripes_expensive;
enum blk_zoned_model zoned;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
};
#ifdef CONFIG_BLK_DEV_ZONED
@ -1535,6 +1540,9 @@ struct blk_integrity_profile {
integrity_prepare_fn *prepare_fn;
integrity_complete_fn *complete_fn;
const char *name;
KABI_RESERVE(1);
KABI_RESERVE(2);
};
extern void blk_integrity_register(struct gendisk *, struct blk_integrity *);
@ -1714,6 +1722,9 @@ struct block_device_operations {
struct blk_zone *zones, unsigned int *nr_zones);
struct module *owner;
const struct pr_ops *pr_ops;
KABI_RESERVE(1);
KABI_RESERVE(2);
};
extern int __blkdev_driver_ioctl(struct block_device *, fmode_t, unsigned int,

4
include/linux/bsg-lib.h
View File

@ -11,6 +11,7 @@
#include <linux/blkdev.h>
#include <scsi/scsi_request.h>
#include <linux/kabi.h>
struct request;
struct device;
@ -60,6 +61,9 @@ struct bsg_job {
struct bio *bidi_bio;
void *dd_data; /* Used for driver-specific storage */
KABI_RESERVE(1);
KABI_RESERVE(2);
};
void bsg_job_done(struct bsg_job *job, int result,

7
include/linux/bsg.h
View File

@ -3,6 +3,7 @@
#define _LINUX_BSG_H
#include <uapi/linux/bsg.h>
#include <linux/kabi.h>
struct request;
@ -13,6 +14,9 @@ struct bsg_ops {
fmode_t mode);
int (*complete_rq)(struct request *rq, struct sg_io_v4 *hdr);
void (*free_rq)(struct request *rq);
KABI_RESERVE(1);
KABI_RESERVE(2);
};
struct bsg_class_device {
@ -20,6 +24,9 @@ struct bsg_class_device {
int minor;
struct request_queue *queue;
const struct bsg_ops *ops;
KABI_RESERVE(1);
KABI_RESERVE(2);
};
int bsg_register_queue(struct request_queue *q, struct device *parent,

11
include/linux/dcache.h
View File

@ -13,6 +13,7 @@
#include <linux/lockref.h>
#include <linux/stringhash.h>
#include <linux/wait.h>
#include <linux/kabi.h>
struct path;
struct vfsmount;
@ -118,6 +119,11 @@ struct dentry {
struct hlist_bl_node d_in_lookup_hash; /* only for in-lookup ones */
struct rcu_head d_rcu;
} d_u;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
} __randomize_layout;
/*
@ -147,6 +153,11 @@ struct dentry_operations {
struct vfsmount *(*d_automount)(struct path *);
int (*d_manage)(const struct path *, bool);
struct dentry *(*d_real)(struct dentry *, const struct inode *);
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
} ____cacheline_aligned;
/*

3
include/linux/device.h
View File

@ -27,6 +27,7 @@
#include <linux/gfp.h>
#include <linux/overflow.h>
#include <asm/device.h>
#include <linux/kabi.h>
struct device;
struct device_private;
@ -594,6 +595,8 @@ struct class {
const struct dev_pm_ops *pm;
struct subsys_private *p;
KABI_RESERVE(1);
};
struct class_dev_iter {

6
include/linux/dma-mapping.h
View File

@ -11,6 +11,7 @@
#include <linux/scatterlist.h>
#include <linux/bug.h>
#include <linux/mem_encrypt.h>
#include <linux/kabi.h>
/**
* List of possible attributes associated with a DMA mapping. The semantics
@ -132,6 +133,11 @@ struct dma_map_ops {
u64 (*get_required_mask)(struct device *dev);
size_t (*max_mapping_size)(struct device *dev);
unsigned long (*get_merge_boundary)(struct device *dev);
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
#define DMA_MAPPING_ERROR (~(dma_addr_t)0)

9
include/linux/elevator.h
View File

@ -4,6 +4,7 @@
#include <linux/percpu.h>
#include <linux/hashtable.h>
#include <linux/kabi.h>
#ifdef CONFIG_BLOCK
@ -50,6 +51,9 @@ 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 *);
KABI_RESERVE(1);
KABI_RESERVE(2);
};
#define ELV_NAME_MAX (16)
@ -86,6 +90,11 @@ struct elevator_type
/* managed by elevator core */
char icq_cache_name[ELV_NAME_MAX + 6]; /* elvname + "_io_cq" */
struct list_head list;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
#define ELV_HASH_BITS 6

6
include/linux/ethtool.h
View File

@ -16,6 +16,7 @@
#include <linux/bitmap.h>
#include <linux/compat.h>
#include <uapi/linux/ethtool.h>
#include <linux/kabi.h>
#ifdef CONFIG_COMPAT
@ -404,6 +405,11 @@ struct ethtool_ops {
struct ethtool_fecparam *);
void (*get_ethtool_phy_stats)(struct net_device *,
struct ethtool_stats *, u64 *);
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
struct ethtool_rx_flow_rule {

41
include/linux/fs.h
View File

@ -40,6 +40,7 @@
#include <linux/fs_types.h>
#include <linux/build_bug.h>
#include <linux/stddef.h>
#include <linux/kabi.h>
#include <asm/byteorder.h>
#include <uapi/linux/fs.h>
@ -408,6 +409,9 @@ struct address_space_operations {
int (*swap_activate)(struct swap_info_struct *sis, struct file *file,
sector_t *span);
void (*swap_deactivate)(struct file *file);
KABI_RESERVE(1);
KABI_RESERVE(2);
};
extern const struct address_space_operations empty_aops;
@ -463,6 +467,11 @@ struct address_space {
spinlock_t private_lock;
struct list_head private_list;
void *private_data;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
} __attribute__((aligned(sizeof(long)))) __randomize_layout;
/*
* On most architectures that alignment is already the case; but
@ -507,6 +516,11 @@ struct block_device {
int bd_fsfreeze_count;
/* Mutex for freeze */
struct mutex bd_fsfreeze_mutex;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
} __randomize_layout;
/* XArray tags, for tagging dirty and writeback pages in the pagecache. */
@ -736,6 +750,9 @@ struct inode {
struct fsverity_info *i_verity_info;
#endif
KABI_RESERVE(1);
KABI_RESERVE(2);
void *i_private; /* fs or device private pointer */
} __randomize_layout;
@ -1031,6 +1048,9 @@ struct file_lock;
struct file_lock_operations {
void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
void (*fl_release_private)(struct file_lock *);
KABI_RESERVE(1);
KABI_RESERVE(2);
};
struct lock_manager_operations {
@ -1041,6 +1061,8 @@ struct lock_manager_operations {
bool (*lm_break)(struct file_lock *);
int (*lm_change)(struct file_lock *, int, struct list_head *);
void (*lm_setup)(struct file_lock *, void **);
KABI_RESERVE(1);
};
struct lock_manager {
@ -1860,6 +1882,11 @@ struct file_operations {
struct file *file_out, loff_t pos_out,
loff_t len, unsigned int remap_flags);
int (*fadvise)(struct file *, loff_t, loff_t, int);
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
} __randomize_layout;
struct inode_operations {
@ -1890,6 +1917,11 @@ struct inode_operations {
umode_t create_mode);
int (*tmpfile) (struct inode *, struct dentry *, umode_t);
int (*set_acl)(struct inode *, struct posix_acl *, int);
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
} ____cacheline_aligned;
static inline ssize_t call_read_iter(struct file *file, struct kiocb *kio,
@ -1974,6 +2006,11 @@ struct super_operations {
struct shrink_control *);
long (*free_cached_objects)(struct super_block *,
struct shrink_control *);
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
/*
@ -2245,6 +2282,10 @@ struct file_system_type {
struct lock_class_key i_lock_key;
struct lock_class_key i_mutex_key;
struct lock_class_key i_mutex_dir_key;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
};
#define MODULE_ALIAS_FS(NAME) MODULE_ALIAS("fs-" NAME)

6
include/linux/fsnotify_backend.h
View File

@ -19,6 +19,7 @@
#include <linux/atomic.h>
#include <linux/user_namespace.h>
#include <linux/refcount.h>
#include <linux/kabi.h>
/*
* IN_* from inotfy.h lines up EXACTLY with FS_*, this is so we can easily
@ -210,6 +211,11 @@ struct fsnotify_group {
} fanotify_data;
#endif /* CONFIG_FANOTIFY */
};
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
/* when calling fsnotify tell it if the data is a path or inode */

14
include/linux/genhd.h
View File

@ -18,6 +18,7 @@
#include <linux/uuid.h>
#include <linux/blk_types.h>
#include <asm/local.h>
#include <linux/kabi.h>
#ifdef CONFIG_BLOCK
@ -132,6 +133,11 @@ struct hd_struct {
#endif
struct percpu_ref ref;
struct rcu_work rcu_work;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
#define GENHD_FL_REMOVABLE 1
@ -176,6 +182,9 @@ struct blk_integrity {
unsigned char tuple_size;
unsigned char interval_exp;
unsigned char tag_size;
KABI_RESERVE(1);
KABI_RESERVE(2);
};
#endif /* CONFIG_BLK_DEV_INTEGRITY */
@ -220,6 +229,11 @@ struct gendisk {
int node_id;
struct badblocks *bb;
struct lockdep_map lockdep_map;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
static inline struct gendisk *part_to_disk(struct hd_struct *part)

7
include/linux/ioport.h
View File

@ -13,6 +13,8 @@
#include <linux/compiler.h>
#include <linux/types.h>
#include <linux/bits.h>
#include <linux/kabi.h>
/*
* Resources are tree-like, allowing
* nesting etc..
@ -24,6 +26,11 @@ struct resource {
unsigned long flags;
unsigned long desc;
struct resource *parent, *sibling, *child;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
/*

6
include/linux/ipv6.h
View File

@ -3,6 +3,7 @@
#define _IPV6_H
#include <uapi/linux/ipv6.h>
#include <linux/kabi.h>
#define ipv6_optlen(p) (((p)->hdrlen+1) << 3)
#define ipv6_authlen(p) (((p)->hdrlen+2) << 2)
@ -75,6 +76,11 @@ struct ipv6_devconf {
__s32 disable_policy;
__s32 ndisc_tclass;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
struct ctl_table_header *sysctl_header;
};

7
include/linux/irqdomain.h
View File

@ -35,6 +35,7 @@
#include <linux/of.h>
#include <linux/mutex.h>
#include <linux/radix-tree.h>
#include <linux/kabi.h>
struct device_node;
struct irq_domain;
@ -182,6 +183,12 @@ struct irq_domain {
unsigned int revmap_size;
struct radix_tree_root revmap_tree;
struct mutex revmap_tree_mutex;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
unsigned int linear_revmap[];
};

12
include/linux/kabi.h Normal file
View File

@ -0,0 +1,12 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* kabi.h
*
*/
#ifndef _LINUX_KABI_H
#define _LINUX_KABI_H
#define KABI_RESERVE(n) unsigned long kabi_reserved##n
#endif /* _LINUX_KABI_H */

6
include/linux/kernfs.h
View File

@ -16,6 +16,7 @@
#include <linux/atomic.h>
#include <linux/uidgid.h>
#include <linux/wait.h>
#include <linux/kabi.h>
struct file;
struct dentry;
@ -178,6 +179,9 @@ struct kernfs_syscall_ops {
const char *new_name);
int (*show_path)(struct seq_file *sf, struct kernfs_node *kn,
struct kernfs_root *root);
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
};
struct kernfs_root {
@ -271,6 +275,8 @@ struct kernfs_ops {
#ifdef CONFIG_DEBUG_LOCK_ALLOC
struct lock_class_key lockdep_key;
#endif
KABI_RESERVE(1);
KABI_RESERVE(2);
};
/*

9
include/linux/kobject.h
View File

@ -27,6 +27,7 @@
#include <linux/atomic.h>
#include <linux/workqueue.h>
#include <linux/uidgid.h>
#include <linux/kabi.h>
#define UEVENT_HELPER_PATH_LEN 256
#define UEVENT_NUM_ENVP 32 /* number of env pointers */
@ -78,6 +79,9 @@ struct kobject {
unsigned int state_add_uevent_sent:1;
unsigned int state_remove_uevent_sent:1;
unsigned int uevent_suppress:1;
KABI_RESERVE(1);
KABI_RESERVE(2);
};
extern __printf(2, 3)
@ -144,6 +148,8 @@ struct kobj_type {
const struct kobj_ns_type_operations *(*child_ns_type)(struct kobject *kobj);
const void *(*namespace)(struct kobject *kobj);
void (*get_ownership)(struct kobject *kobj, kuid_t *uid, kgid_t *gid);
KABI_RESERVE(1);
};
struct kobj_uevent_env {
@ -195,6 +201,9 @@ struct kset {
spinlock_t list_lock;
struct kobject kobj;
const struct kset_uevent_ops *uevent_ops;
KABI_RESERVE(1);
KABI_RESERVE(2);
} __randomize_layout;
extern void kset_init(struct kset *kset);

2
include/linux/mm.h
View File

@ -27,6 +27,7 @@
#include <linux/memremap.h>
#include <linux/overflow.h>
#include <linux/sizes.h>
#include <linux/kabi.h>
struct mempolicy;
struct anon_vma;
@ -525,6 +526,7 @@ struct vm_operations_struct {
*/
struct page *(*find_special_page)(struct vm_area_struct *vma,
unsigned long addr);
KABI_RESERVE(1);
};
static inline void vma_init(struct vm_area_struct *vma, struct mm_struct *mm)

11
include/linux/mm_types.h
View File

@ -14,6 +14,7 @@
#include <linux/uprobes.h>
#include <linux/page-flags-layout.h>
#include <linux/workqueue.h>
#include <linux/kabi.h>
#include <asm/mmu.h>
@ -353,6 +354,11 @@ struct vm_area_struct {
struct mempolicy *vm_policy; /* NUMA policy for the VMA */
#endif
struct vm_userfaultfd_ctx vm_userfaultfd_ctx;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
} __randomize_layout;
struct core_thread {
@ -526,6 +532,11 @@ struct mm_struct {
struct work_struct async_put_work;
} __randomize_layout;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
/*
* The mm_cpumask needs to be at the end of mm_struct, because it
* is dynamically sized based on nr_cpu_ids.

6
include/linux/mmu_notifier.h
View File

@ -6,6 +6,7 @@
#include <linux/spinlock.h>
#include <linux/mm_types.h>
#include <linux/srcu.h>
#include <linux/kabi.h>
struct mmu_notifier;
struct mmu_notifier_ops;
@ -228,6 +229,9 @@ struct mmu_notifier_ops {
*/
struct mmu_notifier *(*alloc_notifier)(struct mm_struct *mm);
void (*free_notifier)(struct mmu_notifier *mn);
KABI_RESERVE(1);
KABI_RESERVE(2);
};
/*
@ -247,6 +251,8 @@ struct mmu_notifier {
struct mm_struct *mm;
struct rcu_head rcu;
unsigned int users;
KABI_RESERVE(1);
};
static inline int mm_has_notifiers(struct mm_struct *mm)

7
include/linux/mmzone.h
View File

@ -21,6 +21,7 @@
#include <linux/mm_types.h>
#include <linux/page-flags.h>
#include <asm/page.h>
#include <linux/kabi.h>
/* Free memory management - zoned buddy allocator. */
#ifndef CONFIG_FORCE_MAX_ZONEORDER
@ -569,6 +570,9 @@ struct zone {
/* Zone statistics */
atomic_long_t vm_stat[NR_VM_ZONE_STAT_ITEMS];
atomic_long_t vm_numa_stat[NR_VM_NUMA_STAT_ITEMS];
KABI_RESERVE(1);
KABI_RESERVE(2);
} ____cacheline_internodealigned_in_smp;
enum pgdat_flags {
@ -788,6 +792,9 @@ typedef struct pglist_data {
/* Per-node vmstats */
struct per_cpu_nodestat __percpu *per_cpu_nodestats;
atomic_long_t vm_stat[NR_VM_NODE_STAT_ITEMS];
KABI_RESERVE(1);
KABI_RESERVE(2);
} pg_data_t;
#define node_present_pages(nid) (NODE_DATA(nid)->node_present_pages)

6
include/linux/module.h
View File

@ -22,6 +22,7 @@
#include <linux/error-injection.h>
#include <linux/tracepoint-defs.h>
#include <linux/srcu.h>
#include <linux/kabi.h>
#include <linux/percpu.h>
#include <asm/module.h>
@ -519,6 +520,11 @@ struct module {
struct error_injection_entry *ei_funcs;
unsigned int num_ei_funcs;
#endif
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
} ____cacheline_aligned __randomize_layout;
#ifndef MODULE_ARCH_INIT
#define MODULE_ARCH_INIT {}

5
include/linux/net.h
View File

@ -22,6 +22,7 @@
#include <linux/once.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/kabi.h>
#include <uapi/linux/net.h>
@ -203,6 +204,10 @@ struct proto_ops {
int (*sendmsg_locked)(struct sock *sk, struct msghdr *msg,
size_t size);
int (*set_rcvlowat)(struct sock *sk, int val);
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
};
#define DECLARE_SOCKADDR(type, dst, src) \

36
include/linux/netdevice.h
View File

@ -48,6 +48,7 @@
#include <uapi/linux/if_bonding.h>
#include <uapi/linux/pkt_cls.h>
#include <linux/hashtable.h>
#include <linux/kabi.h>
struct netpoll_info;
struct device;
@ -274,6 +275,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);
KABI_RESERVE(1);
KABI_RESERVE(2);
};
/* These flag bits are private to the generic network queueing
@ -341,6 +345,11 @@ struct napi_struct {
struct list_head dev_list;
struct hlist_node napi_hash_node;
unsigned int napi_id;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
enum {
@ -629,6 +638,10 @@ struct netdev_queue {
#ifdef CONFIG_BQL
struct dql dql;
#endif
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
} ____cacheline_aligned_in_smp;
extern int sysctl_fb_tunnels_only_for_init_net;
@ -747,6 +760,10 @@ struct netdev_rx_queue {
#ifdef CONFIG_XDP_SOCKETS
struct xdp_umem *umem;
#endif
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
} ____cacheline_aligned_in_smp;
/*
@ -917,6 +934,10 @@ struct xfrmdev_ops {
bool (*xdo_dev_offload_ok) (struct sk_buff *skb,
struct xfrm_state *x);
void (*xdo_dev_state_advance_esn) (struct xfrm_state *x);
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
};
#endif
@ -1443,6 +1464,11 @@ struct net_device_ops {
int (*ndo_xsk_wakeup)(struct net_device *dev,
u32 queue_id, u32 flags);
struct devlink_port * (*ndo_get_devlink_port)(struct net_device *dev);
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
#define DEV_MIB_MAX __DEV_MIB_MAX
@ -2086,6 +2112,11 @@ struct net_device {
struct lock_class_key addr_list_lock_key;
bool proto_down;
unsigned wol_enabled:1;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
#define to_net_dev(d) container_of(d, struct net_device, dev)
@ -2410,6 +2441,11 @@ struct packet_type {
struct sock *sk);
void *af_packet_priv;
struct list_head list;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
struct offload_callbacks {

15
include/linux/pci.h
View File

@ -39,6 +39,7 @@
#include <linux/io.h>
#include <linux/resource_ext.h>
#include <uapi/linux/pci.h>
#include <linux/kabi.h>
#include <linux/pci_ids.h>
@ -468,6 +469,11 @@ struct pci_dev {
size_t romlen; /* Length if not from BAR */
char *driver_override; /* Driver name to force a match */
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
unsigned long priv_flags; /* Private flags for the PCI driver */
};
@ -602,6 +608,11 @@ struct pci_bus {
struct bin_attribute *legacy_io; /* Legacy I/O for this bus */
struct bin_attribute *legacy_mem; /* Legacy mem */
unsigned int is_added:1;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
#define to_pci_bus(n) container_of(n, struct pci_bus, dev)
@ -839,6 +850,10 @@ struct pci_driver {
const struct attribute_group **groups;
struct device_driver driver;
struct pci_dynids dynids;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
};
#define to_pci_driver(drv) container_of(drv, struct pci_driver, driver)

8
include/linux/pci_hotplug.h
View File

@ -13,6 +13,7 @@
*/
#ifndef _PCI_HOTPLUG_H
#define _PCI_HOTPLUG_H
#include <linux/kabi.h>
/**
* struct hotplug_slot_ops -the callbacks that the hotplug pci core can use
@ -45,6 +46,10 @@ struct hotplug_slot_ops {
int (*get_latch_status) (struct hotplug_slot *slot, u8 *value);
int (*get_adapter_status) (struct hotplug_slot *slot, u8 *value);
int (*reset_slot) (struct hotplug_slot *slot, int probe);
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
};
/**
@ -61,6 +66,9 @@ struct hotplug_slot {
struct pci_slot *pci_slot;
struct module *owner;
const char *mod_name;
KABI_RESERVE(1);
KABI_RESERVE(2);
};
static inline const char *hotplug_slot_name(const struct hotplug_slot *slot)

15
include/linux/quota.h
View File

@ -47,6 +47,7 @@
#include <linux/uidgid.h>
#include <linux/projid.h>
#include <uapi/linux/quota.h>
#include <linux/kabi.h>
#undef USRQUOTA
#undef GRPQUOTA
@ -304,6 +305,11 @@ struct dquot {
loff_t dq_off; /* Offset of dquot on disk [dq_lock, stable once set] */
unsigned long dq_flags; /* See DQ_* */
struct mem_dqblk dq_dqb; /* Diskquota usage [dq_dqb_lock] */
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
/* Operations which must be implemented by each quota format */
@ -316,6 +322,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 */
KABI_RESERVE(1);
KABI_RESERVE(2);
};
/* Operations working with dquots */
@ -335,6 +344,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);
KABI_RESERVE(1);
KABI_RESERVE(2);
};
struct path;
@ -438,6 +450,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);
KABI_RESERVE(1);
KABI_RESERVE(2);
};
struct quota_format_type {

12
include/linux/sched.h
View File

@ -31,6 +31,7 @@
#include <linux/task_io_accounting.h>
#include <linux/posix-timers.h>
#include <linux/rseq.h>
#include <linux/kabi.h>
/* task_struct member predeclarations (sorted alphabetically): */
struct audit_context;
@ -476,6 +477,11 @@ struct sched_entity {
*/
struct sched_avg avg;
#endif
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
struct sched_rt_entity {
@ -563,6 +569,7 @@ struct sched_dl_entity {
* time.
*/
struct hrtimer inactive_timer;
};
#ifdef CONFIG_UCLAMP_TASK
@ -1285,6 +1292,11 @@ struct task_struct {
*/
randomized_struct_fields_end
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
/* CPU-specific state of this task: */
struct thread_struct thread;

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

@ -10,6 +10,7 @@
#include <linux/cred.h>
#include <linux/refcount.h>
#include <linux/posix-timers.h>
#include <linux/kabi.h>
/*
* Types defining task->signal and task->sighand and APIs using them:
@ -233,6 +234,10 @@ struct signal_struct {
* and may have inconsistent
* permissions.
*/
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
} __randomize_layout;
/*

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

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

2
include/linux/stacktrace.h
View File

@ -4,6 +4,7 @@
#include <linux/types.h>
#include <asm/errno.h>
#include <linux/kabi.h>
struct task_struct;
struct pt_regs;
@ -65,6 +66,7 @@ struct stack_trace {
unsigned int nr_entries, max_entries;
unsigned long *entries;
int skip; /* input argument: How many entries to skip */
KABI_RESERVE(1);
};
extern void save_stack_trace(struct stack_trace *trace);

5
include/linux/swap.h
View File

@ -13,6 +13,7 @@
#include <linux/atomic.h>
#include <linux/page-flags.h>
#include <asm/page.h>
#include <linux/kabi.h>
struct notifier_block;
@ -275,6 +276,10 @@ struct swap_info_struct {
*/
struct work_struct discard_work; /* discard worker */
struct swap_cluster_list discard_clusters; /* discard clusters list */
KABI_RESERVE(1);
KABI_RESERVE(2);
struct plist_node avail_lists[0]; /*
* entries in swap_avail_heads, one
* entry per node.

4
include/linux/timer.h
View File

@ -7,6 +7,7 @@
#include <linux/stddef.h>
#include <linux/debugobjects.h>
#include <linux/stringify.h>
#include <linux/kabi.h>
struct timer_list {
/*
@ -21,6 +22,9 @@ struct timer_list {
#ifdef CONFIG_LOCKDEP
struct lockdep_map lockdep_map;
#endif
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
};
#ifdef CONFIG_LOCKDEP

7
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/kabi.h>
#define UID_GID_MAP_MAX_BASE_EXTENTS 5
#define UID_GID_MAP_MAX_EXTENTS 340
@ -85,7 +86,13 @@ struct user_namespace {
struct ctl_table_header *sysctls;
#endif
struct ucounts *ucounts;
int ucount_max[UCOUNT_COUNTS];
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
} __randomize_layout;
struct ucounts {

5
include/linux/workqueue.h
View File

@ -14,6 +14,7 @@
#include <linux/atomic.h>
#include <linux/cpumask.h>
#include <linux/rcupdate.h>
#include <linux/kabi.h>
struct workqueue_struct;
@ -106,6 +107,8 @@ struct work_struct {
#ifdef CONFIG_LOCKDEP
struct lockdep_map lockdep_map;
#endif
KABI_RESERVE(1);
KABI_RESERVE(2);
};
#define WORK_DATA_INIT() ATOMIC_LONG_INIT((unsigned long)WORK_STRUCT_NO_POOL)
@ -119,6 +122,8 @@ struct delayed_work {
/* target workqueue and CPU ->timer uses to queue ->work */
struct workqueue_struct *wq;
int cpu;
KABI_RESERVE(1);
};
struct rcu_work {

5
include/linux/writeback.h
View File

@ -12,6 +12,7 @@
#include <linux/backing-dev-defs.h>
#include <linux/blk_types.h>
#include <linux/blk-cgroup.h>
#include <linux/kabi.h>
struct bio;
@ -92,6 +93,10 @@ struct writeback_control {
size_t wb_lcand_bytes; /* bytes written by last candidate */
size_t wb_tcand_bytes; /* bytes written by this candidate */
#endif
KABI_RESERVE(1);
KABI_RESERVE(2);
};
static inline int wbc_to_write_flags(struct writeback_control *wbc)

6
include/net/bond_3ad.h
View File

@ -10,6 +10,7 @@
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/if_ether.h>
#include <linux/kabi.h>
/* General definitions */
#define PKT_TYPE_LACPDU cpu_to_be16(ETH_P_SLOW)
@ -243,6 +244,11 @@ typedef struct port {
struct port *next_port_in_aggregator; /* Next port on the linked list of the parent aggregator */
u32 transaction_id; /* continuous number for identification of Marker PDU's; */
struct lacpdu lacpdu; /* the lacpdu that will be sent for this port */
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
} port_t;
/* system structure */

4
include/net/bonding.h
View File

@ -25,6 +25,7 @@
#include <linux/etherdevice.h>
#include <linux/reciprocal_div.h>
#include <linux/if_link.h>
#include <linux/kabi.h>
#include <net/bond_3ad.h>
#include <net/bond_alb.h>
@ -147,6 +148,9 @@ struct bond_params {
/* 2 bytes of padding : see ether_addr_equal_64bits() */
u8 ad_actor_system[ETH_ALEN + 2];
KABI_RESERVE(1);
KABI_RESERVE(2);
};
struct bond_parm_tbl {

6
include/net/dcbnl.h
View File

@ -9,6 +9,7 @@
#define __NET_DCBNL_H__
#include <linux/dcbnl.h>
#include <linux/kabi.h>
struct dcb_app_type {
int ifindex;
@ -107,6 +108,11 @@ struct dcbnl_rtnl_ops {
/* buffer settings */
int (*dcbnl_getbuffer)(struct net_device *, struct dcbnl_buffer *);
int (*dcbnl_setbuffer)(struct net_device *, struct dcbnl_buffer *);
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
#endif /* __NET_DCBNL_H__ */

3
include/net/dst.h
View File

@ -18,6 +18,7 @@
#include <linux/refcount.h>
#include <net/neighbour.h>
#include <asm/processor.h>
#include <linux/kabi.h>
struct sk_buff;
@ -77,6 +78,8 @@ struct dst_entry {
#ifndef CONFIG_64BIT
atomic_t __refcnt; /* 32-bit offset 64 */
#endif
KABI_RESERVE(1);
KABI_RESERVE(2);
};
struct dst_metrics {

6
include/net/dst_ops.h
View File

@ -4,6 +4,7 @@
#include <linux/types.h>
#include <linux/percpu_counter.h>
#include <linux/cache.h>
#include <linux/kabi.h>
struct dst_entry;
struct kmem_cachep;
@ -40,6 +41,11 @@ struct dst_ops {
struct kmem_cache *kmem_cachep;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
struct percpu_counter pcpuc_entries ____cacheline_aligned_in_smp;
};

6
include/net/fib_rules.h
View File

@ -10,6 +10,7 @@
#include <net/flow.h>
#include <net/rtnetlink.h>
#include <net/fib_notifier.h>
#include <linux/kabi.h>
struct fib_kuid_range {
kuid_t start;
@ -43,6 +44,11 @@ struct fib_rule {
struct fib_rule_port_range sport_range;
struct fib_rule_port_range dport_range;
struct rcu_head rcu;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
struct fib_lookup_arg {

8
include/net/flow.h
View File

@ -13,6 +13,7 @@
#include <linux/atomic.h>
#include <net/flow_dissector.h>
#include <linux/uidgid.h>
#include <linux/kabi.h>
/*
* ifindex generation is per-net namespace, and loopback is
@ -41,6 +42,9 @@ struct flowi_common {
kuid_t flowic_uid;
struct flowi_tunnel flowic_tun_key;
__u32 flowic_multipath_hash;
KABI_RESERVE(1);
KABI_RESERVE(2);
};
union flowi_uli {
@ -93,6 +97,8 @@ struct flowi4 {
#define fl4_ipsec_spi uli.spi
#define fl4_mh_type uli.mht.type
#define fl4_gre_key uli.gre_key
KABI_RESERVE(1);
} __attribute__((__aligned__(BITS_PER_LONG/8)));
static inline void flowi4_init_output(struct flowi4 *fl4, int oif,
@ -154,6 +160,8 @@ struct flowi6 {
#define fl6_mh_type uli.mht.type
#define fl6_gre_key uli.gre_key
__u32 mp_hash;
KABI_RESERVE(1);
} __attribute__((__aligned__(BITS_PER_LONG/8)));
struct flowidn {

8
include/net/genetlink.h
View File

@ -5,6 +5,7 @@
#include <linux/genetlink.h>
#include <net/netlink.h>
#include <net/net_namespace.h>
#include <linux/kabi.h>
#define GENLMSG_DEFAULT_SIZE (NLMSG_DEFAULT_SIZE - GENL_HDRLEN)
@ -65,6 +66,9 @@ struct genl_family {
unsigned int n_mcgrps;
unsigned int mcgrp_offset; /* private */
struct module *module;
KABI_RESERVE(1);
KABI_RESERVE(2);
};
struct nlattr **genl_family_attrbuf(const struct genl_family *family);
@ -140,6 +144,10 @@ struct genl_ops {
u8 internal_flags;
u8 flags;
u8 validate;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
};
int genl_register_family(struct genl_family *family);

6
include/net/l3mdev.h
View File

@ -9,6 +9,7 @@
#include <net/dst.h>
#include <net/fib_rules.h>
#include <linux/kabi.h>
/**
* struct l3mdev_ops - l3mdev operations
@ -33,6 +34,11 @@ struct l3mdev_ops {
/* IPv6 ops */
struct dst_entry * (*l3mdev_link_scope_lookup)(const struct net_device *dev,
struct flowi6 *fl6);
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
#ifdef CONFIG_NET_L3_MASTER_DEV

5
include/net/lwtunnel.h
View File

@ -7,6 +7,7 @@
#include <linux/skbuff.h>
#include <linux/types.h>
#include <net/route.h>
#include <linux/kabi.h>
#define LWTUNNEL_HASH_BITS 7
#define LWTUNNEL_HASH_SIZE (1 << LWTUNNEL_HASH_BITS)
@ -30,6 +31,10 @@ struct lwtunnel_state {
int (*orig_output)(struct net *net, struct sock *sk, struct sk_buff *skb);
int (*orig_input)(struct sk_buff *);
struct rcu_head rcu;
KABI_RESERVE(1);
KABI_RESERVE(2);
__u8 data[0];
};

5
include/net/neighbour.h
View File

@ -24,6 +24,7 @@
#include <linux/rcupdate.h>
#include <linux/seq_file.h>
#include <linux/bitmap.h>
#include <linux/kabi.h>
#include <linux/err.h>
#include <linux/sysctl.h>
@ -157,6 +158,10 @@ struct neighbour {
struct list_head gc_list;
struct rcu_head rcu;
struct net_device *dev;
KABI_RESERVE(1);
KABI_RESERVE(2);
u8 primary_key[0];
} __randomize_layout;

5
include/net/rtnetlink.h
View File

@ -4,6 +4,7 @@
#include <linux/rtnetlink.h>
#include <net/netlink.h>
#include <linux/kabi.h>
typedef int (*rtnl_doit_func)(struct sk_buff *, struct nlmsghdr *,
struct netlink_ext_ack *);
@ -112,6 +113,10 @@ struct rtnl_link_ops {
int (*fill_linkxstats)(struct sk_buff *skb,
const struct net_device *dev,
int *prividx, int attr);
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
int __rtnl_link_register(struct rtnl_link_ops *ops);

11
include/net/sock.h
View File

@ -59,6 +59,7 @@
#include <linux/filter.h>
#include <linux/rculist_nulls.h>
#include <linux/poll.h>
#include <linux/kabi.h>
#include <linux/atomic.h>
#include <linux/refcount.h>
@ -511,6 +512,11 @@ struct sock {
struct bpf_sk_storage __rcu *sk_bpf_storage;
#endif
struct rcu_head sk_rcu;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
enum sk_pacing {
@ -1188,6 +1194,11 @@ struct proto {
atomic_t socks;
#endif
int (*diag_destroy)(struct sock *sk, int err);
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
} __randomize_layout;
int proto_register(struct proto *prot, int alloc_slab);

6
include/net/switchdev.h
View File

@ -11,6 +11,7 @@
#include <linux/notifier.h>
#include <linux/list.h>
#include <net/ip_fib.h>
#include <linux/kabi.h>
#define SWITCHDEV_F_NO_RECURSE BIT(0)
#define SWITCHDEV_F_SKIP_EOPNOTSUPP BIT(1)
@ -71,6 +72,11 @@ struct switchdev_obj {
u32 flags;
void *complete_priv;
void (*complete)(struct net_device *dev, int err, void *priv);
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
/* SWITCHDEV_OBJ_ID_PORT_VLAN */

4
include/net/tls.h
View File

@ -43,6 +43,7 @@
#include <linux/mutex.h>
#include <linux/netdevice.h>
#include <linux/rcupdate.h>
#include <linux/kabi.h>
#include <net/tcp.h>
#include <net/strparser.h>
@ -232,6 +233,9 @@ enum tls_context_flags {
struct cipher_context {
char *iv;
char *rec_seq;
KABI_RESERVE(1);
KABI_RESERVE(2);
};
union tls_crypto_context {

7
include/net/xdp.h
View File

@ -6,6 +6,8 @@
#ifndef __LINUX_NET_XDP_H__
#define __LINUX_NET_XDP_H__
#include <linux/kabi.h>
/**
* DOC: XDP RX-queue information
*
@ -61,6 +63,11 @@ struct xdp_rxq_info {
u32 queue_index;
u32 reg_state;
struct xdp_mem_info mem;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
} ____cacheline_aligned; /* perf critical, avoid false-sharing */
struct xdp_buff {

5
include/net/xfrm.h
View File

@ -24,6 +24,7 @@
#include <net/ip6_fib.h>
#include <net/flow.h>
#include <net/gro_cells.h>
#include <linux/kabi.h>
#include <linux/interrupt.h>
@ -123,6 +124,8 @@ struct xfrm_state_walk {
u8 proto;
u32 seq;
struct xfrm_address_filter *filter;
KABI_RESERVE(1);
};
struct xfrm_state_offload {
@ -130,6 +133,8 @@ struct xfrm_state_offload {
unsigned long offload_handle;
unsigned int num_exthdrs;
u8 flags;
KABI_RESERVE(1);
};
struct xfrm_mode {

6
include/scsi/scsi_cmnd.h
View File

@ -11,6 +11,7 @@
#include <linux/scatterlist.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi_request.h>
#include <linux/kabi.h>
struct Scsi_Host;
struct scsi_driver;
@ -141,6 +142,11 @@ struct scsi_cmnd {
unsigned long state; /* Command completion state */
unsigned char tag; /* SCSI-II queued command tag */
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
/*

13
include/scsi/scsi_device.h
View File

@ -8,6 +8,7 @@
#include <linux/blkdev.h>
#include <scsi/scsi.h>
#include <linux/atomic.h>
#include <linux/kabi.h>
struct device;
struct request_queue;
@ -227,6 +228,12 @@ struct scsi_device {
struct mutex state_mutex;
enum scsi_device_state sdev_state;
struct task_struct *quiesced_by;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
unsigned long sdev_data[0];
} __attribute__((aligned(sizeof(unsigned long))));
@ -311,6 +318,12 @@ struct scsi_target {
char scsi_level;
enum scsi_target_state state;
void *hostdata; /* available to low-level driver */
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
unsigned long starget_data[0]; /* for the transport */
/* starget_data must be the last element!!!! */
} __attribute__((aligned(sizeof(unsigned long))));

11
include/scsi/scsi_host.h
View File

@ -10,6 +10,7 @@
#include <linux/seq_file.h>
#include <linux/blk-mq.h>
#include <scsi/scsi.h>
#include <linux/kabi.h>
struct block_device;
struct completion;
@ -486,6 +487,11 @@ struct scsi_host_template {
*/
unsigned int cmd_size;
struct scsi_host_cmd_pool *cmd_pool;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
/*
@ -691,6 +697,11 @@ struct Scsi_Host {
*/
struct device *dma_dev;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
/*
* We should ensure that this is aligned, both for better performance
* and also because some compilers (m68k) don't automatically force

19
kernel/sched/sched.h
View File

@ -401,6 +401,8 @@ struct task_group {
struct uclamp_se uclamp[UCLAMP_CNT];
#endif
KABI_RESERVE(1);
KABI_RESERVE(2);
};
#ifdef CONFIG_FAIR_GROUP_SCHED
@ -575,6 +577,8 @@ struct cfs_rq {
struct list_head throttled_list;
#endif /* CONFIG_CFS_BANDWIDTH */
#endif /* CONFIG_FAIR_GROUP_SCHED */
KABI_RESERVE(1);
KABI_RESERVE(2);
};
static inline int rt_bandwidth_enabled(void)
@ -782,6 +786,11 @@ struct root_domain {
* CPUs of the rd. Protected by RCU.
*/
struct perf_domain __rcu *pd;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
extern void init_defrootdomain(void);
@ -1002,6 +1011,9 @@ struct rq {
/* Must be inspected within a rcu lock section */
struct cpuidle_state *idle_state;
#endif
KABI_RESERVE(1);
KABI_RESERVE(2);
};
#ifdef CONFIG_FAIR_GROUP_SCHED
@ -1412,6 +1424,9 @@ struct sched_group {
struct sched_group_capacity *sgc;
int asym_prefer_cpu; /* CPU of highest priority in group */
KABI_RESERVE(1);
KABI_RESERVE(2);
/*
* The CPUs this group covers.
*
@ -1779,6 +1794,10 @@ struct sched_class {
#ifdef CONFIG_FAIR_GROUP_SCHED
void (*task_change_group)(struct task_struct *p, int type);
#endif
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
static inline void put_prev_task(struct rq *rq, struct task_struct *prev)