UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

kabi: add paddings (part 1) 

Upstream: no

These padding are added using CentOS 9 as reference.

Signed-off-by: Kairui Song <kasong@tencent.com>
This commit is contained in:
Kairui Song 2023-11-16 17:31:54 +08:00
parent 4d53646471
commit f6ba444c8e
42 changed files with 378 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
arch/x86/include/asm/processor.h
View File

@ -38,6 +38,8 @@ struct vm86;
#include <linux/irqflags.h>
#include <linux/mem_encrypt.h>
#include <linux/kabi.h>
/*
* We handle most unaligned accesses in hardware. On the other hand
* unaligned DMA can be quite expensive on some Nehalem processors.
@ -146,6 +148,11 @@ struct cpuinfo_x86 {
/* Address space bits used by the cache internally */
u8 x86_cache_bits;
unsigned initialized : 1;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
} __randomize_layout;
#define X86_VENDOR_INTEL 0

11
block/elevator.h
View File

@ -5,6 +5,7 @@
#include <linux/percpu.h>
#include <linux/hashtable.h>
#include "blk-mq.h"
#include <linux/kabi.h>
struct io_cq;
struct elevator_type;
@ -48,6 +49,11 @@ struct elevator_mq_ops {
struct request *(*next_request)(struct request_queue *, struct request *);
void (*init_icq)(struct io_cq *);
void (*exit_icq)(struct io_cq *);
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
#define ELV_NAME_MAX (16)
@ -84,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);
};
static inline bool elevator_tryget(struct elevator_type *e)

3
drivers/char/ipmi/ipmi_si.h
View File

@ -66,6 +66,9 @@ struct si_sm_io {
u8 slave_addr;
enum si_type si_type;
struct device *dev;
KABI_RESERVE(1);
KABI_RESERVE(2);
};
int ipmi_si_add_smi(struct si_sm_io *io);

3
drivers/char/ipmi/ipmi_si_sm.h
View File

@ -94,6 +94,9 @@ struct si_sm_handlers {
/* Return the size of the SMI structure in bytes. */
int (*size)(void);
KABI_RESERVE(1);
KABI_RESERVE(2);
};
/* Current state machines that we can use. */

6
drivers/char/ipmi/kcs_bmc_client.h
View File

@ -11,6 +11,9 @@
struct kcs_bmc_driver_ops {
int (*add_device)(struct kcs_bmc_device *kcs_bmc);
int (*remove_device)(struct kcs_bmc_device *kcs_bmc);
KABI_RESERVE(1);
KABI_RESERVE(2);
};
struct kcs_bmc_driver {
@ -21,6 +24,9 @@ struct kcs_bmc_driver {
struct kcs_bmc_client_ops {
irqreturn_t (*event)(struct kcs_bmc_client *client);
KABI_RESERVE(1);
KABI_RESERVE(2);
};
struct kcs_bmc_client {

3
drivers/char/ipmi/kcs_bmc_device.h
View File

@ -13,6 +13,9 @@ struct kcs_bmc_device_ops {
u8 (*io_inputb)(struct kcs_bmc_device *kcs_bmc, u32 reg);
void (*io_outputb)(struct kcs_bmc_device *kcs_bmc, u32 reg, u8 b);
void (*io_updateb)(struct kcs_bmc_device *kcs_bmc, u32 reg, u8 mask, u8 b);
KABI_RESERVE(1);
KABI_RESERVE(2);
};
irqreturn_t kcs_bmc_handle_event(struct kcs_bmc_device *kcs_bmc);

9
drivers/pci/pci.h
View File

@ -310,6 +310,15 @@ 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);
KABI_RESERVE(5);
KABI_RESERVE(6);
KABI_RESERVE(7);
KABI_RESERVE(8);
};
#ifdef CONFIG_PCI_DOE

7
drivers/scsi/sd.h
View File

@ -2,6 +2,8 @@
#ifndef _SCSI_DISK_H
#define _SCSI_DISK_H
#include <linux/kabi.h>
/*
* More than enough for everybody ;) The huge number of majors
* is a leftover from 16bit dev_t days, we don't really need that
@ -151,6 +153,11 @@ struct scsi_disk {
unsigned urswrz : 1;
unsigned security : 1;
unsigned ignore_medium_access_errors : 1;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
#define to_scsi_disk(obj) container_of(obj, struct scsi_disk, disk_dev)

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

@ -160,6 +160,11 @@ struct bdi_writeback {
struct rcu_head rcu;
};
#endif
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
struct backing_dev_info {

9
include/linux/bio.h
View File

@ -343,6 +343,10 @@ struct bio_integrity_payload {
struct work_struct bip_work; /* I/O completion */
struct bio_vec *bip_vec;
KABI_RESERVE(1);
KABI_RESERVE(2);
struct bio_vec bip_inline_vecs[];/* embedded bvec array */
};
@ -702,6 +706,11 @@ struct bio_set {
* Hot un-plug notifier for the per-cpu cache, if used
*/
struct hlist_node cpuhp_dead;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
static inline bool bioset_initialized(struct bio_set *bs)

3
include/linux/blk-integrity.h
View File

@ -33,6 +33,9 @@ struct blk_integrity_profile {
integrity_prepare_fn *prepare_fn;
integrity_complete_fn *complete_fn;
const char *name;
KABI_RESERVE(1);
KABI_RESERVE(2);
};
#ifdef CONFIG_BLK_DEV_INTEGRITY

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

@ -429,6 +429,15 @@ struct blk_mq_hw_ctx {
* q->unused_hctx_list.
*/
struct list_head hctx_list;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
KABI_RESERVE(5);
KABI_RESERVE(6);
KABI_RESERVE(7);
KABI_RESERVE(8);
};
/**
@ -460,6 +469,7 @@ enum hctx_type {
HCTX_TYPE_POLL,
HCTX_MAX_TYPES,
HCTX_MAX_TYPES_KABI = 6, /* KABI extend for reserving space*/
};
/**
@ -515,6 +525,11 @@ struct blk_mq_tag_set {
struct mutex tag_list_lock;
struct list_head tag_list;
struct srcu_struct *srcu;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
/**
@ -526,6 +541,8 @@ struct blk_mq_tag_set {
struct blk_mq_queue_data {
struct request *rq;
bool last;
KABI_RESERVE(1);
};
typedef bool (busy_tag_iter_fn)(struct request *, void *);
@ -645,6 +662,15 @@ 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);
KABI_RESERVE(5);
KABI_RESERVE(6);
KABI_RESERVE(7);
KABI_RESERVE(8);
};
enum {

4
include/linux/blk_types.h
View File

@ -10,6 +10,7 @@
#include <linux/bvec.h>
#include <linux/device.h>
#include <linux/ktime.h>
#include <linux/kabi.h>
struct bio_set;
struct bio;
@ -315,6 +316,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

17
include/linux/blkdev.h
View File

@ -110,6 +110,9 @@ struct blk_integrity {
unsigned char tuple_size;
unsigned char interval_exp;
unsigned char tag_size;
KABI_RESERVE(1);
KABI_RESERVE(2);
};
typedef unsigned int __bitwise blk_mode_t;
@ -324,6 +327,15 @@ struct queue_limits {
* due to possible offsets.
*/
unsigned int dma_alignment;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
KABI_RESERVE(5);
KABI_RESERVE(6);
KABI_RESERVE(7);
KABI_RESERVE(8);
};
typedef int (*report_zones_cb)(struct blk_zone *zone, unsigned int idx,
@ -1405,6 +1417,11 @@ struct block_device_operations {
* driver.
*/
int (*alternative_gpt_sector)(struct gendisk *disk, sector_t *sector);
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
#ifdef CONFIG_COMPAT

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

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

5
include/linux/fs.h
View File

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

7
include/linux/fwnode.h
View File

@ -14,6 +14,8 @@
#include <linux/bits.h>
#include <linux/err.h>
#include <linux/kabi.h>
struct fwnode_operations;
struct device;
@ -45,6 +47,11 @@ struct fwnode_handle {
struct list_head suppliers;
struct list_head consumers;
u8 flags;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
/*

5
include/linux/hrtimer.h
View File

@ -21,6 +21,8 @@
#include <linux/timer.h>
#include <linux/timerqueue.h>
#include <linux/kabi.h>
struct hrtimer_clock_base;
struct hrtimer_cpu_base;
@ -124,6 +126,9 @@ struct hrtimer {
u8 is_rel;
u8 is_soft;
u8 is_hard;
KABI_RESERVE(1);
KABI_RESERVE(2);
};
/**

6
include/linux/ipmi.h
View File

@ -70,6 +70,9 @@ struct ipmi_recv_msg {
* the size or existence of this, since it may change.
*/
unsigned char msg_data[IPMI_MAX_MSG_LENGTH];
KABI_RESERVE(1);
KABI_RESERVE(2);
};
#define INIT_IPMI_RECV_MSG(done_handler) \
@ -110,6 +113,9 @@ struct ipmi_user_hndl {
* if it is not usable.
*/
void (*shutdown)(void *handler_data);
KABI_RESERVE(1);
KABI_RESERVE(2);
};
/* Create a new user of the IPMI layer on the given interface number. */

8
include/linux/ipmi_smi.h
View File

@ -123,6 +123,9 @@ struct ipmi_smi_msg {
* (presumably to free it).
*/
void (*done)(struct ipmi_smi_msg *msg);
KABI_RESERVE(1);
KABI_RESERVE(2);
};
#define INIT_IPMI_SMI_MSG(done_handler) \
@ -218,6 +221,11 @@ struct ipmi_smi_handlers {
* block.
*/
void (*set_maintenance_mode)(void *send_info, bool enable);
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
struct ipmi_device_id {

7
include/linux/irq.h
View File

@ -24,6 +24,8 @@
#include <asm/ptrace.h>
#include <asm/irq_regs.h>
#include <linux/kabi.h>
struct seq_file;
struct module;
struct msi_msg;
@ -187,6 +189,11 @@ struct irq_data {
struct irq_data *parent_data;
#endif
void *chip_data;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
/*

7
include/linux/irq_work.h
View File

@ -5,6 +5,8 @@
#include <linux/smp_types.h>
#include <linux/rcuwait.h>
#include <linux/kabi.h>
/*
* An entry can be in one of four states:
*
@ -18,6 +20,11 @@ struct irq_work {
struct __call_single_node node;
void (*func)(struct irq_work *);
struct rcuwait irqwait;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
#define __IRQ_WORK_INIT(_func, _flags) (struct irq_work){ \

7
include/linux/irqdesc.h
View File

@ -6,6 +6,8 @@
#include <linux/kobject.h>
#include <linux/mutex.h>
#include <linux/kabi.h>
/*
* Core internal functions to deal with irq descriptors
*/
@ -105,6 +107,11 @@ struct irq_desc {
#ifdef CONFIG_HARDIRQS_SW_RESEND
struct hlist_node resend_node;
#endif
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
} ____cacheline_internodealigned_in_smp;
#ifdef CONFIG_SPARSE_IRQ

7
include/linux/irqdomain.h
View File

@ -37,6 +37,8 @@
#include <linux/mutex.h>
#include <linux/radix-tree.h>
#include <linux/kabi.h>
struct device_node;
struct fwnode_handle;
struct irq_domain;
@ -170,6 +172,11 @@ struct irq_domain {
const struct msi_parent_ops *msi_parent_ops;
#endif
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
/* reverse map data. The linear map gets appended to the irq_domain */
irq_hw_number_t hwirq_max;
unsigned int revmap_size;

4
include/linux/mempolicy.h
View File

@ -52,6 +52,10 @@ struct mempolicy {
nodemask_t cpuset_mems_allowed; /* relative to these nodes */
nodemask_t user_nodemask; /* nodemask passed by user */
} w;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
};
/*

6
include/linux/mempool.h
View File

@ -7,7 +7,7 @@
#include <linux/wait.h>
#include <linux/compiler.h>
#include <linux/kabi.h>
struct kmem_cache;
typedef void * (mempool_alloc_t)(gfp_t gfp_mask, void *pool_data);
@ -23,6 +23,10 @@ typedef struct mempool_s {
mempool_alloc_t *alloc;
mempool_free_t *free;
wait_queue_head_t wait;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
} mempool_t;
static inline bool mempool_initialized(mempool_t *pool)

11
include/linux/memremap.h
View File

@ -25,6 +25,9 @@ struct vmem_altmap {
unsigned long free;
unsigned long align;
unsigned long alloc;
KABI_RESERVE(1);
KABI_RESERVE(2);
};
/*
@ -99,6 +102,9 @@ struct dev_pagemap_ops {
*/
int (*memory_failure)(struct dev_pagemap *pgmap, unsigned long pfn,
unsigned long nr_pages, int mf_flags);
KABI_RESERVE(1);
KABI_RESERVE(2);
};
#define PGMAP_ALTMAP_VALID (1 << 0)
@ -133,6 +139,11 @@ struct dev_pagemap {
const struct dev_pagemap_ops *ops;
void *owner;
int nr_range;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
KABI_RESERVE(5);
union {
struct range range;
DECLARE_FLEX_ARRAY(struct range, ranges);

7
include/linux/mm.h
View File

@ -549,6 +549,9 @@ struct vm_fault {
* page table to avoid allocation from
* atomic context.
*/
KABI_RESERVE(1);
KABI_RESERVE(2);
};
/*
@ -628,6 +631,10 @@ struct vm_operations_struct {
*/
struct page *(*find_special_page)(struct vm_area_struct *vma,
unsigned long addr);
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
#ifdef CONFIG_NUMA_BALANCING

11
include/linux/mm_types.h
View File

@ -660,6 +660,11 @@ struct vm_area_struct {
struct vma_numab_state *numab_state; /* NUMA Balancing state */
#endif
struct vm_userfaultfd_ctx vm_userfaultfd_ctx;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
} __randomize_layout;
#ifdef CONFIG_SCHED_MM_CID
@ -919,6 +924,12 @@ struct mm_struct {
#endif /* CONFIG_LRU_GEN */
} __randomize_layout;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
KABI_RESERVE(5);
/*
* The mm_cpumask needs to be at the end of mm_struct, because it
* is dynamically sized based on nr_cpu_ids.

5
include/linux/pagemap.h
View File

@ -1262,6 +1262,11 @@ struct readahead_control {
struct file *file;
struct address_space *mapping;
struct file_ra_state *ra;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
/* private: use the readahead_* accessors instead */
pgoff_t _index;
unsigned int _nr_pages;

47
include/linux/pci.h
View File

@ -43,6 +43,8 @@
#include <linux/pci_ids.h>
#include <linux/kabi.h>
#define PCI_STATUS_ERROR_BITS (PCI_STATUS_DETECTED_PARITY | \
PCI_STATUS_SIG_SYSTEM_ERROR | \
PCI_STATUS_REC_MASTER_ABORT | \
@ -529,6 +531,31 @@ struct pci_dev {
/* These methods index pci_reset_fn_methods[] */
u8 reset_methods[PCI_NUM_RESET_METHODS]; /* In priority order */
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
KABI_RESERVE(5);
KABI_RESERVE(6);
KABI_RESERVE(7);
KABI_RESERVE(8);
KABI_RESERVE(9);
KABI_RESERVE(10);
KABI_RESERVE(11);
KABI_RESERVE(12);
KABI_RESERVE(13);
KABI_RESERVE(14);
KABI_RESERVE(15);
KABI_RESERVE(16);
KABI_RESERVE(17);
KABI_RESERVE(18);
KABI_RESERVE(19);
KABI_RESERVE(20);
KABI_RESERVE(21);
KABI_RESERVE(22);
KABI_RESERVE(23);
KABI_RESERVE(24);
};
static inline struct pci_dev *pci_physfn(struct pci_dev *dev)
@ -678,6 +705,15 @@ struct pci_bus {
struct bin_attribute *legacy_mem; /* Legacy mem */
unsigned int is_added:1;
unsigned int unsafe_warn:1; /* warned about RW1C config write */
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
KABI_RESERVE(5);
KABI_RESERVE(6);
KABI_RESERVE(7);
KABI_RESERVE(8);
};
#define to_pci_bus(n) container_of(n, struct pci_bus, dev)
@ -927,12 +963,23 @@ struct pci_driver {
int (*sriov_configure)(struct pci_dev *dev, int num_vfs); /* On PF */
int (*sriov_set_msix_vec_count)(struct pci_dev *vf, int msix_vec_count); /* On PF */
u32 (*sriov_get_vf_total_msix)(struct pci_dev *pf);
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
const struct pci_error_handlers *err_handler;
const struct attribute_group **groups;
const struct attribute_group **dev_groups;
struct device_driver driver;
struct pci_dynids dynids;
bool driver_managed_dma;
KABI_RESERVE(5);
KABI_RESERVE(6);
KABI_RESERVE(7);
KABI_RESERVE(8);
};
static inline struct pci_driver *to_pci_driver(struct device_driver *drv)

16
include/linux/sched.h
View File

@ -39,6 +39,8 @@
#include <linux/livepatch_sched.h>
#include <asm/kmap_size.h>
#include <linux/kabi.h>
/* task_struct member predeclarations (sorted alphabetically): */
struct audit_context;
struct bio_list;
@ -501,6 +503,9 @@ struct sched_avg {
unsigned long runnable_avg;
unsigned long util_avg;
struct util_est util_est;
KABI_RESERVE(1);
KABI_RESERVE(2);
} ____cacheline_aligned;
struct sched_statistics {
@ -584,6 +589,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 {
@ -602,6 +612,8 @@ struct sched_rt_entity {
/* rq "owned" by this entity/group: */
struct rt_rq *my_q;
#endif
KABI_RESERVE(1);
KABI_RESERVE(2);
} __randomize_layout;
struct sched_dl_entity {
@ -675,6 +687,10 @@ struct sched_dl_entity {
*/
struct sched_dl_entity *pi_se;
#endif
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
#ifdef CONFIG_UCLAMP_TASK

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

@ -245,6 +245,16 @@ struct signal_struct {
* and may have inconsistent
* permissions.
*/
/*
* signal_struct is always dynamically allocated at process
* creation time and not embedded directly into other structure.
* So it is also safe to extend the size of the structure.
*/
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
} __randomize_layout;
/*

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

@ -151,6 +151,10 @@ struct sched_domain {
};
struct sched_domain_shared *shared;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
unsigned int span_weight;
/*
* Span of all CPUs in this domain.

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

@ -8,6 +8,8 @@
#include <linux/refcount.h>
#include <linux/ratelimit.h>
#include <linux/kabi.h>
/*
* Some day this will be a full-fledged user tracking system..
*/
@ -34,6 +36,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);

4
include/linux/shrinker.h
View File

@ -4,6 +4,7 @@
#include <linux/atomic.h>
#include <linux/types.h>
#include <linux/kabi.h>
/*
* This struct is used to pass information from page reclaim to the shrinkers.
@ -83,6 +84,9 @@ struct shrinker {
#endif
/* objs pending delete, per node */
atomic_long_t *nr_deferred;
KABI_RESERVE(1);
KABI_RESERVE(2);
};
#define DEFAULT_SEEKS 2 /* A good number if you don't know better. */

5
include/linux/swap.h
View File

@ -321,6 +321,11 @@ 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);
KABI_RESERVE(3);
struct plist_node avail_lists[]; /*
* entries in swap_avail_heads, one
* entry per node.

5
include/linux/timer.h
View File

@ -8,6 +8,8 @@
#include <linux/debugobjects.h>
#include <linux/stringify.h>
#include <linux/kabi.h>
struct timer_list {
/*
* All fields that change during normal runtime grouped to the
@ -21,6 +23,9 @@ struct timer_list {
#ifdef CONFIG_LOCKDEP
struct lockdep_map lockdep_map;
#endif
KABI_RESERVE(1);
KABI_RESERVE(2);
};
#ifdef CONFIG_LOCKDEP

5
include/scsi/scsi_cmnd.h
View File

@ -141,6 +141,11 @@ struct scsi_cmnd {
* to be at an address < 16Mb). */
int result; /* Status code from lower level driver */
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
/* Variant of blk_mq_rq_from_pdu() that verifies the type of its argument. */

16
include/scsi/scsi_device.h
View File

@ -10,6 +10,8 @@
#include <linux/atomic.h>
#include <linux/sbitmap.h>
#include <linux/kabi.h>
struct bsg_device;
struct device;
struct request_queue;
@ -284,6 +286,14 @@ 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);
KABI_RESERVE(5);
KABI_RESERVE(6);
unsigned long sdev_data[];
} __attribute__((aligned(sizeof(unsigned long))));
@ -370,6 +380,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[]; /* for the transport */
/* starget_data must be the last element!!!! */
} __attribute__((aligned(sizeof(unsigned long))));

13
include/scsi/scsi_host.h
View File

@ -497,6 +497,11 @@ struct scsi_host_template {
/* Delay for runtime autosuspend */
int rpm_autosuspend_delay;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
/*
@ -710,6 +715,14 @@ struct Scsi_Host {
*/
struct device *dma_dev;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
KABI_RESERVE(5);
KABI_RESERVE(6);
/*
* We should ensure that this is aligned, both for better performance
* and also because some compilers (m68k) don't automatically force

30
kernel/sched/sched.h
View File

@ -282,6 +282,9 @@ struct rt_bandwidth {
u64 rt_runtime;
struct hrtimer rt_period_timer;
unsigned int rt_period_active;
KABI_RESERVE(1);
KABI_RESERVE(2);
};
void __dl_clear_params(struct task_struct *p);
@ -313,6 +316,8 @@ struct dl_bw {
raw_spinlock_t lock;
u64 bw;
u64 total_bw;
KABI_RESERVE(1);
KABI_RESERVE(2);
};
extern void init_dl_bw(struct dl_bw *dl_b);
@ -357,6 +362,9 @@ struct cfs_bandwidth {
u64 throttled_time;
u64 burst_time;
#endif
KABI_RESERVE(1);
KABI_RESERVE(2);
};
/* Task group related information */
@ -412,6 +420,8 @@ struct task_group {
struct uclamp_se uclamp[UCLAMP_CNT];
#endif
KABI_RESERVE(1);
KABI_RESERVE(2);
};
#ifdef CONFIG_FAIR_GROUP_SCHED
@ -649,6 +659,11 @@ struct cfs_rq {
#endif
#endif /* CONFIG_CFS_BANDWIDTH */
#endif /* CONFIG_FAIR_GROUP_SCHED */
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
static inline int rt_bandwidth_enabled(void)
@ -695,6 +710,9 @@ struct rt_rq {
struct rq *rq;
struct task_group *tg;
#endif
KABI_RESERVE(1);
KABI_RESERVE(2);
};
static inline bool rt_rq_is_runnable(struct rt_rq *rt_rq)
@ -763,6 +781,9 @@ struct dl_rq {
* by the GRUB algorithm.
*/
u64 bw_ratio;
KABI_RESERVE(1);
KABI_RESERVE(2);
};
#ifdef CONFIG_FAIR_GROUP_SCHED
@ -889,6 +910,10 @@ struct root_domain {
* CPUs of the rd. Protected by RCU.
*/
struct perf_domain __rcu *pd;
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
};
extern void init_defrootdomain(void);
@ -1166,6 +1191,11 @@ struct rq {
call_single_data_t cfsb_csd;
struct list_head cfsb_csd_list;
#endif
KABI_RESERVE(1);
KABI_RESERVE(2);
KABI_RESERVE(3);
KABI_RESERVE(4);
};
#ifdef CONFIG_FAIR_GROUP_SCHED